diff --git a/README.md b/README.md index 5008a98..c38d61f 100644 --- a/README.md +++ b/README.md @@ -240,6 +240,48 @@ spec: secretProviderClass: origination-aggregate ``` +### HelmReleaseV2 + +Definition can be found [here](./helm/crds/provisioning.totalsoft.ro_helmreleasev2s.yaml) + +`HelmReleaseV2` supports the same provisioning behavior as `HelmRelease`, but provisions Flux `HelmRelease` resources with `apiVersion: helm.toolkit.fluxcd.io/v2`. + +Example: + +```yaml +apiVersion: provisioning.totalsoft.ro/v1alpha1 +kind: HelmReleaseV2 +metadata: + name: my-helm-release-v2 + namespace: my-namespace +spec: + domainRef: origination + platformRef: radu.demo + release: + interval: 10m + releaseName: my-release + chart: + spec: + version: ">=0.1.0-0" + chart: my-chart + sourceRef: + kind: HelmRepository + name: my-helm-repo + namespace: my-namespace + upgrade: + remediation: + remediateLastFailure: false + values: + global: + vaultEnvironment: "false" + + runtimeConfiguration: + enabled: false + configMap: origination-aggregate + csi: + secretProviderClass: origination-aggregate +``` + > _Note_ You can skip provisioning for some tenant by adding the label `provisioning.totalsoft.ro/skip-tenant-SOME_TENANT_CODE`="true" ### AzureVirtualMachine diff --git a/helm/crds/provisioning.totalsoft.ro_helmreleasev2s.yaml b/helm/crds/provisioning.totalsoft.ro_helmreleasev2s.yaml new file mode 100644 index 0000000..a25bece --- /dev/null +++ b/helm/crds/provisioning.totalsoft.ro_helmreleasev2s.yaml @@ -0,0 +1,1239 @@ +--- +apiVersion: apiextensions.k8s.io/v1 +kind: CustomResourceDefinition +metadata: + annotations: + controller-gen.kubebuilder.io/version: v0.20.1 + name: helmreleasev2s.provisioning.totalsoft.ro +spec: + group: provisioning.totalsoft.ro + names: + kind: HelmReleaseV2 + listKind: HelmReleaseV2List + plural: helmreleasev2s + singular: helmreleasev2 + scope: Namespaced + versions: + - additionalPrinterColumns: + - jsonPath: .spec.platformRef + name: Platform + type: string + name: v1alpha1 + schema: + openAPIV3Schema: + properties: + apiVersion: + description: |- + 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 + type: string + kind: + description: |- + 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 + type: string + metadata: + type: object + spec: + properties: + dependsOn: + description: List of dependencies + items: + properties: + kind: + description: Kind is a string value representing the REST resource + this dependency represents. + type: string + name: + description: ' The name of the dependency.' + type: string + required: + - kind + - name + type: object + type: array + domainRef: + description: Business Domain that this resource is provision for. + type: string + exports: + items: + properties: + domain: + description: The domain or bounded-context for which HelmReleaseV2 + values are exported. + type: string + releaseName: + properties: + toConfigMap: + properties: + keyTemplate: + type: string + required: + - keyTemplate + type: object + toKubeSecret: + properties: + keyTemplate: + type: string + required: + - keyTemplate + type: object + toVault: + properties: + keyTemplate: + type: string + required: + - keyTemplate + type: object + type: object + required: + - domain + type: object + type: array + platformRef: + description: Target platform (custom resource name). + type: string + release: + description: helm release spec + properties: + chart: + description: |- + Chart defines the template of the v1.HelmChart that should be created + for this HelmRelease. + properties: + metadata: + description: ObjectMeta holds the template for metadata like + labels and annotations. + properties: + annotations: + additionalProperties: + type: string + description: |- + Annotations is an unstructured key value map stored with a resource that may be + set by external tools to store and retrieve arbitrary metadata. They are not + queryable and should be preserved when modifying objects. + More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations/ + type: object + labels: + additionalProperties: + type: string + description: |- + Map of string keys and values that can be used to organize and categorize + (scope and select) objects. + More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/ + type: object + type: object + spec: + description: Spec holds the template for the v1.HelmChartSpec + for this HelmRelease. + properties: + chart: + description: The name or path the Helm chart is available + at in the SourceRef. + maxLength: 2048 + minLength: 1 + type: string + ignoreMissingValuesFiles: + description: IgnoreMissingValuesFiles controls whether + to silently ignore missing values files rather than + failing. + type: boolean + interval: + description: |- + Interval at which to check the v1.Source for updates. Defaults to + 'HelmReleaseSpec.Interval'. + pattern: ^([0-9]+(\.[0-9]+)?(ms|s|m|h))+$ + type: string + reconcileStrategy: + default: ChartVersion + description: |- + Determines what enables the creation of a new artifact. Valid values are + ('ChartVersion', 'Revision'). + See the documentation of the values for an explanation on their behavior. + Defaults to ChartVersion when omitted. + enum: + - ChartVersion + - Revision + type: string + sourceRef: + description: The name and namespace of the v1.Source the + chart is available at. + properties: + apiVersion: + description: APIVersion of the referent. + type: string + kind: + description: Kind of the referent. + enum: + - HelmRepository + - GitRepository + - Bucket + type: string + name: + description: Name of the referent. + maxLength: 253 + minLength: 1 + type: string + namespace: + description: Namespace of the referent. + maxLength: 63 + minLength: 1 + type: string + required: + - kind + - name + type: object + valuesFiles: + description: |- + Alternative list of values files to use as the chart values (values.yaml + is not included by default), expected to be a relative path in the SourceRef. + Values files are merged in the order of this list with the last file overriding + the first. Ignored when omitted. + items: + type: string + type: array + verify: + description: |- + Verify contains the secret name containing the trusted public keys + used to verify the signature and specifies which provider to use to check + whether OCI image is authentic. + This field is only supported for OCI sources. + Chart dependencies, which are not bundled in the umbrella chart artifact, + are not verified. + properties: + provider: + default: cosign + description: Provider specifies the technology used + to sign the OCI Helm chart. + enum: + - cosign + - notation + type: string + secretRef: + description: |- + SecretRef specifies the Kubernetes Secret containing the + trusted public keys. + properties: + name: + description: Name of the referent. + type: string + required: + - name + type: object + required: + - provider + type: object + version: + default: '*' + description: |- + Version semver expression, ignored for charts from v1.GitRepository and + v1beta2.Bucket sources. Defaults to latest when omitted. + type: string + required: + - chart + - sourceRef + type: object + required: + - spec + type: object + chartRef: + description: |- + ChartRef holds a reference to a source controller resource containing the + Helm chart artifact. + properties: + apiVersion: + description: APIVersion of the referent. + type: string + kind: + description: Kind of the referent. + enum: + - OCIRepository + - HelmChart + - ExternalArtifact + type: string + name: + description: Name of the referent. + maxLength: 253 + minLength: 1 + type: string + namespace: + description: |- + Namespace of the referent, defaults to the namespace of the Kubernetes + resource object that contains the reference. + maxLength: 63 + minLength: 1 + type: string + required: + - kind + - name + type: object + commonMetadata: + description: |- + CommonMetadata specifies the common labels and annotations that are + applied to all resources. Any existing label or annotation will be + overridden if its key matches a common one. + properties: + annotations: + additionalProperties: + type: string + description: Annotations to be added to the object's metadata. + type: object + labels: + additionalProperties: + type: string + description: Labels to be added to the object's metadata. + type: object + type: object + dependsOn: + description: |- + DependsOn may contain a DependencyReference slice with + references to HelmRelease resources that must be ready before this HelmRelease + can be reconciled. + items: + description: DependencyReference defines a HelmRelease dependency + on another HelmRelease resource. + properties: + name: + description: Name of the referent. + type: string + namespace: + description: |- + Namespace of the referent, defaults to the namespace of the HelmRelease + resource object that contains the reference. + type: string + readyExpr: + description: |- + ReadyExpr is a CEL expression that can be used to assess the readiness + of a dependency. When specified, the built-in readiness check + is replaced by the logic defined in the CEL expression. + To make the CEL expression additive to the built-in readiness check, + the feature gate `AdditiveCELDependencyCheck` must be set to `true`. + type: string + required: + - name + type: object + type: array + driftDetection: + description: |- + DriftDetection holds the configuration for detecting and handling + differences between the manifest in the Helm storage and the resources + currently existing in the cluster. + properties: + ignore: + description: |- + Ignore contains a list of rules for specifying which changes to ignore + during diffing. + items: + description: |- + IgnoreRule defines a rule to selectively disregard specific changes during + the drift detection process. + properties: + paths: + description: |- + Paths is a list of JSON Pointer (RFC 6901) paths to be excluded from + consideration in a Kubernetes object. + items: + type: string + type: array + target: + description: |- + Target is a selector for specifying Kubernetes objects to which this + rule applies. + If Target is not set, the Paths will be ignored for all Kubernetes + objects within the manifest of the Helm release. + properties: + annotationSelector: + description: |- + AnnotationSelector is a string that follows the label selection expression + https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#api + It matches with the resource annotations. + type: string + group: + description: |- + Group is the API group to select resources from. + Together with Version and Kind it is capable of unambiguously identifying and/or selecting resources. + https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md + type: string + kind: + description: |- + Kind of the API Group to select resources from. + Together with Group and Version it is capable of unambiguously + identifying and/or selecting resources. + https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md + type: string + labelSelector: + description: |- + LabelSelector is a string that follows the label selection expression + https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#api + It matches with the resource labels. + type: string + name: + description: Name to match resources with. + type: string + namespace: + description: Namespace to select resources from. + type: string + version: + description: |- + Version of the API Group to select resources from. + Together with Group and Kind it is capable of unambiguously identifying and/or selecting resources. + https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md + type: string + type: object + required: + - paths + type: object + type: array + mode: + description: |- + Mode defines how differences should be handled between the Helm manifest + and the manifest currently applied to the cluster. + If not explicitly set, it defaults to DiffModeDisabled. + enum: + - enabled + - warn + - disabled + type: string + type: object + healthCheckExprs: + description: |- + HealthCheckExprs is a list of healthcheck expressions for evaluating the + health of custom resources using Common Expression Language (CEL). + The expressions are evaluated only when the specific Helm action + taking place has wait enabled, i.e. DisableWait is false, and the + 'poller' WaitStrategy is used. + items: + description: CustomHealthCheck defines the health check for + custom resources. + properties: + apiVersion: + description: APIVersion of the custom resource under evaluation. + type: string + current: + description: |- + Current is the CEL expression that determines if the status + of the custom resource has reached the desired state. + type: string + failed: + description: |- + Failed is the CEL expression that determines if the status + of the custom resource has failed to reach the desired state. + type: string + inProgress: + description: |- + InProgress is the CEL expression that determines if the status + of the custom resource has not yet reached the desired state. + type: string + kind: + description: Kind of the custom resource under evaluation. + type: string + required: + - apiVersion + - current + - kind + type: object + type: array + install: + description: Install holds the configuration for Helm install + actions for this HelmRelease. + properties: + crds: + description: |- + CRDs upgrade CRDs from the Helm Chart's crds directory according + to the CRD upgrade policy provided here. Valid values are `Skip`, + `Create` or `CreateReplace`. Default is `Create` and if omitted + CRDs are installed but not updated. + + Skip: do neither install nor replace (update) any CRDs. + + Create: new CRDs are created, existing CRDs are neither updated nor deleted. + + CreateReplace: new CRDs are created, existing CRDs are updated (replaced) + but not deleted. + + By default, CRDs are applied (installed) during Helm install action. + With this option users can opt in to CRD replace existing CRDs on Helm + install actions, which is not (yet) natively supported by Helm. + https://helm.sh/docs/chart_best_practices/custom_resource_definitions. + enum: + - Skip + - Create + - CreateReplace + type: string + createNamespace: + description: |- + CreateNamespace tells the Helm install action to create the + HelmReleaseSpec.TargetNamespace if it does not exist yet. + On uninstall, the namespace will not be garbage collected. + type: boolean + disableHooks: + description: DisableHooks prevents hooks from running during + the Helm install action. + type: boolean + disableOpenAPIValidation: + description: |- + DisableOpenAPIValidation prevents the Helm install action from validating + rendered templates against the Kubernetes OpenAPI Schema. + type: boolean + disableSchemaValidation: + description: |- + DisableSchemaValidation prevents the Helm install action from validating + the values against the JSON Schema. + type: boolean + disableTakeOwnership: + description: |- + DisableTakeOwnership disables taking ownership of existing resources + during the Helm install action. Defaults to false. + type: boolean + disableWait: + description: |- + DisableWait disables the waiting for resources to be ready after a Helm + install has been performed. + type: boolean + disableWaitForJobs: + description: |- + DisableWaitForJobs disables waiting for jobs to complete after a Helm + install has been performed. + type: boolean + remediation: + description: |- + Remediation holds the remediation configuration for when the Helm install + action for the HelmRelease fails. The default is to not perform any action. + properties: + ignoreTestFailures: + description: |- + IgnoreTestFailures tells the controller to skip remediation when the Helm + tests are run after an install action but fail. Defaults to + 'Test.IgnoreFailures'. + type: boolean + remediateLastFailure: + description: |- + RemediateLastFailure tells the controller to remediate the last failure, when + no retries remain. Defaults to 'false'. + type: boolean + retries: + description: |- + Retries is the number of retries that should be attempted on failures before + bailing. Remediation, using an uninstall, is performed between each attempt. + Defaults to '0', a negative integer equals to unlimited retries. + type: integer + type: object + replace: + description: |- + Replace tells the Helm install action to re-use the 'ReleaseName', but only + if that name is a deleted release which remains in the history. + type: boolean + serverSideApply: + description: |- + ServerSideApply enables server-side apply for resources during install. + Defaults to true (or false when UseHelm3Defaults feature gate is enabled). + type: boolean + skipCRDs: + description: |- + SkipCRDs tells the Helm install action to not install any CRDs. By default, + CRDs are installed if not already present. + + Deprecated use CRD policy (`crds`) attribute with value `Skip` instead. + type: boolean + strategy: + description: |- + Strategy defines the install strategy to use for this HelmRelease. + Defaults to 'RemediateOnFailure', or 'RetryOnFailure' when the + DefaultToRetryOnFailure feature gate is enabled. + properties: + name: + description: Name of the install strategy. + enum: + - RemediateOnFailure + - RetryOnFailure + type: string + retryInterval: + description: |- + RetryInterval is the interval at which to retry a failed install. + Can be used only when Name is set to RetryOnFailure. + Defaults to '5m'. + pattern: ^([0-9]+(\.[0-9]+)?(ms|s|m|h))+$ + type: string + required: + - name + type: object + x-kubernetes-validations: + - message: .retryInterval cannot be set when .name is 'RemediateOnFailure' + rule: '!has(self.retryInterval) || self.name != ''RemediateOnFailure''' + timeout: + description: |- + Timeout is the time to wait for any individual Kubernetes operation (like + Jobs for hooks) during the performance of a Helm install action. Defaults to + 'HelmReleaseSpec.Timeout'. + pattern: ^([0-9]+(\.[0-9]+)?(ms|s|m|h))+$ + type: string + type: object + interval: + description: Interval at which to reconcile the Helm release. + pattern: ^([0-9]+(\.[0-9]+)?(ms|s|m|h))+$ + type: string + kubeConfig: + description: |- + KubeConfig for reconciling the HelmRelease on a remote cluster. + When used in combination with HelmReleaseSpec.ServiceAccountName, + forces the controller to act on behalf of that Service Account at the + target cluster. + If the --default-service-account flag is set, its value will be used as + a controller level fallback for when HelmReleaseSpec.ServiceAccountName + is empty. + properties: + configMapRef: + description: |- + ConfigMapRef holds an optional name of a ConfigMap that contains + the following keys: + + - `provider`: the provider to use. One of `aws`, `azure`, `gcp`, or + `generic`. Required. + - `cluster`: the fully qualified resource name of the Kubernetes + cluster in the cloud provider API. Not used by the `generic` + provider. Required when one of `address` or `ca.crt` is not set. + - `address`: the address of the Kubernetes API server. Required + for `generic`. For the other providers, if not specified, the + first address in the cluster resource will be used, and if + specified, it must match one of the addresses in the cluster + resource. + If audiences is not set, will be used as the audience for the + `generic` provider. + - `ca.crt`: the optional PEM-encoded CA certificate for the + Kubernetes API server. If not set, the controller will use the + CA certificate from the cluster resource. + - `audiences`: the optional audiences as a list of + line-break-separated strings for the Kubernetes ServiceAccount + token. Defaults to the `address` for the `generic` provider, or + to specific values for the other providers depending on the + provider. + - `serviceAccountName`: the optional name of the Kubernetes + ServiceAccount in the same namespace that should be used + for authentication. If not specified, the controller + ServiceAccount will be used. + + Mutually exclusive with SecretRef. + properties: + name: + description: Name of the referent. + type: string + required: + - name + type: object + secretRef: + description: |- + SecretRef holds an optional name of a secret that contains a key with + the kubeconfig file as the value. If no key is set, the key will default + to 'value'. Mutually exclusive with ConfigMapRef. + It is recommended that the kubeconfig is self-contained, and the secret + is regularly updated if credentials such as a cloud-access-token expire. + Cloud specific `cmd-path` auth helpers will not function without adding + binaries and credentials to the Pod that is responsible for reconciling + Kubernetes resources. Supported only for the generic provider. + properties: + key: + description: Key in the Secret, when not specified an + implementation-specific default key is used. + type: string + name: + description: Name of the Secret. + type: string + required: + - name + type: object + type: object + x-kubernetes-validations: + - message: exactly one of spec.kubeConfig.configMapRef or spec.kubeConfig.secretRef + must be specified + rule: has(self.configMapRef) || has(self.secretRef) + - message: exactly one of spec.kubeConfig.configMapRef or spec.kubeConfig.secretRef + must be specified + rule: '!has(self.configMapRef) || !has(self.secretRef)' + maxHistory: + description: |- + MaxHistory is the number of revisions saved by Helm for this HelmRelease. + Use '0' for an unlimited number of revisions; defaults to '5'. + type: integer + persistentClient: + description: |- + PersistentClient tells the controller to use a persistent Kubernetes + client for this release. When enabled, the client will be reused for the + duration of the reconciliation, instead of being created and destroyed + for each (step of a) Helm action. + + This can improve performance, but may cause issues with some Helm charts + that for example do create Custom Resource Definitions during installation + outside Helm's CRD lifecycle hooks, which are then not observed to be + available by e.g. post-install hooks. + + If not set, it defaults to true. + type: boolean + postRenderers: + description: |- + PostRenderers holds an array of Helm PostRenderers, which will be applied in order + of their definition. + items: + description: PostRenderer contains a Helm PostRenderer specification. + properties: + kustomize: + description: Kustomization to apply as PostRenderer. + properties: + images: + description: |- + Images is a list of (image name, new name, new tag or digest) + for changing image names, tags or digests. This can also be achieved with a + patch, but this operator is simpler to specify. + items: + description: Image contains an image name, a new name, + a new tag or digest, which will replace the original + name and tag. + properties: + digest: + description: |- + Digest is the value used to replace the original image tag. + If digest is present NewTag value is ignored. + type: string + name: + description: Name is a tag-less image name. + type: string + newName: + description: NewName is the value used to replace + the original name. + type: string + newTag: + description: NewTag is the value used to replace + the original tag. + type: string + required: + - name + type: object + type: array + patches: + description: |- + Strategic merge and JSON patches, defined as inline YAML objects, + capable of targeting objects based on kind, label and annotation selectors. + items: + description: |- + Patch contains an inline StrategicMerge or JSON6902 patch, and the target the patch should + be applied to. + properties: + patch: + description: |- + Patch contains an inline StrategicMerge patch or an inline JSON6902 patch with + an array of operation objects. + type: string + target: + description: Target points to the resources that + the patch document should be applied to. + properties: + annotationSelector: + description: |- + AnnotationSelector is a string that follows the label selection expression + https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#api + It matches with the resource annotations. + type: string + group: + description: |- + Group is the API group to select resources from. + Together with Version and Kind it is capable of unambiguously identifying and/or selecting resources. + https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md + type: string + kind: + description: |- + Kind of the API Group to select resources from. + Together with Group and Version it is capable of unambiguously + identifying and/or selecting resources. + https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md + type: string + labelSelector: + description: |- + LabelSelector is a string that follows the label selection expression + https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#api + It matches with the resource labels. + type: string + name: + description: Name to match resources with. + type: string + namespace: + description: Namespace to select resources + from. + type: string + version: + description: |- + Version of the API Group to select resources from. + Together with Group and Kind it is capable of unambiguously identifying and/or selecting resources. + https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md + type: string + type: object + required: + - patch + type: object + type: array + type: object + type: object + type: array + releaseName: + description: |- + ReleaseName used for the Helm release. Defaults to a composition of + '[TargetNamespace-]Name'. + maxLength: 53 + minLength: 1 + type: string + rollback: + description: Rollback holds the configuration for Helm rollback + actions for this HelmRelease. + properties: + cleanupOnFail: + description: |- + CleanupOnFail allows deletion of new resources created during the Helm + rollback action when it fails. + type: boolean + disableHooks: + description: DisableHooks prevents hooks from running during + the Helm rollback action. + type: boolean + disableWait: + description: |- + DisableWait disables the waiting for resources to be ready after a Helm + rollback has been performed. + type: boolean + disableWaitForJobs: + description: |- + DisableWaitForJobs disables waiting for jobs to complete after a Helm + rollback has been performed. + type: boolean + force: + description: |- + Force forces resource updates through a replacement strategy + that avoids 3-way merge conflicts on client-side apply. + This field is ignored for server-side apply (which always + forces conflicts with other field managers). + type: boolean + recreate: + description: |- + Recreate performs pod restarts for any managed workloads. + + Deprecated: This behavior was deprecated in Helm 3: + - Deprecation: https://github.com/helm/helm/pull/6463 + - Removal: https://github.com/helm/helm/pull/31023 + After helm-controller was upgraded to the Helm 4 SDK, + this field is no longer functional and will print a + warning if set to true. It will also be removed in a + future release. + type: boolean + serverSideApply: + description: |- + ServerSideApply enables server-side apply for resources during rollback. + Can be "enabled", "disabled", or "auto". + When "auto", server-side apply usage will be based on the release's previous usage. + Defaults to "auto". + enum: + - enabled + - disabled + - auto + type: string + timeout: + description: |- + Timeout is the time to wait for any individual Kubernetes operation (like + Jobs for hooks) during the performance of a Helm rollback action. Defaults to + 'HelmReleaseSpec.Timeout'. + pattern: ^([0-9]+(\.[0-9]+)?(ms|s|m|h))+$ + type: string + type: object + serviceAccountName: + description: |- + The name of the Kubernetes service account to impersonate + when reconciling this HelmRelease. + maxLength: 253 + minLength: 1 + type: string + storageNamespace: + description: |- + StorageNamespace used for the Helm storage. + Defaults to the namespace of the HelmRelease. + maxLength: 63 + minLength: 1 + type: string + suspend: + description: |- + Suspend tells the controller to suspend reconciliation for this HelmRelease, + it does not apply to already started reconciliations. Defaults to false. + type: boolean + targetNamespace: + description: |- + TargetNamespace to target when performing operations for the HelmRelease. + Defaults to the namespace of the HelmRelease. + maxLength: 63 + minLength: 1 + type: string + test: + description: Test holds the configuration for Helm test actions + for this HelmRelease. + properties: + enable: + description: |- + Enable enables Helm test actions for this HelmRelease after an Helm install + or upgrade action has been performed. + type: boolean + filters: + description: Filters is a list of tests to run or exclude + from running. + items: + description: Filter holds the configuration for individual + Helm test filters. + properties: + exclude: + description: Exclude specifies whether the named test + should be excluded. + type: boolean + name: + description: Name is the name of the test. + maxLength: 253 + minLength: 1 + type: string + required: + - name + type: object + type: array + ignoreFailures: + description: |- + IgnoreFailures tells the controller to skip remediation when the Helm tests + are run but fail. Can be overwritten for tests run after install or upgrade + actions in 'Install.IgnoreTestFailures' and 'Upgrade.IgnoreTestFailures'. + type: boolean + timeout: + description: |- + Timeout is the time to wait for any individual Kubernetes operation during + the performance of a Helm test action. Defaults to 'HelmReleaseSpec.Timeout'. + pattern: ^([0-9]+(\.[0-9]+)?(ms|s|m|h))+$ + type: string + type: object + timeout: + description: |- + Timeout is the time to wait for any individual Kubernetes operation (like Jobs + for hooks) during the performance of a Helm action. Defaults to '5m0s'. + pattern: ^([0-9]+(\.[0-9]+)?(ms|s|m|h))+$ + type: string + uninstall: + description: Uninstall holds the configuration for Helm uninstall + actions for this HelmRelease. + properties: + deletionPropagation: + default: background + description: |- + DeletionPropagation specifies the deletion propagation policy when + a Helm uninstall is performed. + enum: + - background + - foreground + - orphan + type: string + disableHooks: + description: DisableHooks prevents hooks from running during + the Helm rollback action. + type: boolean + disableWait: + description: |- + DisableWait disables waiting for all the resources to be deleted after + a Helm uninstall is performed. + type: boolean + keepHistory: + description: |- + KeepHistory tells Helm to remove all associated resources and mark the + release as deleted, but retain the release history. + type: boolean + timeout: + description: |- + Timeout is the time to wait for any individual Kubernetes operation (like + Jobs for hooks) during the performance of a Helm uninstall action. Defaults + to 'HelmReleaseSpec.Timeout'. + pattern: ^([0-9]+(\.[0-9]+)?(ms|s|m|h))+$ + type: string + type: object + upgrade: + description: Upgrade holds the configuration for Helm upgrade + actions for this HelmRelease. + properties: + cleanupOnFail: + description: |- + CleanupOnFail allows deletion of new resources created during the Helm + upgrade action when it fails. + type: boolean + crds: + description: |- + CRDs upgrade CRDs from the Helm Chart's crds directory according + to the CRD upgrade policy provided here. Valid values are `Skip`, + `Create` or `CreateReplace`. Default is `Skip` and if omitted + CRDs are neither installed nor upgraded. + + Skip: do neither install nor replace (update) any CRDs. + + Create: new CRDs are created, existing CRDs are neither updated nor deleted. + + CreateReplace: new CRDs are created, existing CRDs are updated (replaced) + but not deleted. + + By default, CRDs are not applied during Helm upgrade action. With this + option users can opt-in to CRD upgrade, which is not (yet) natively supported by Helm. + https://helm.sh/docs/chart_best_practices/custom_resource_definitions. + enum: + - Skip + - Create + - CreateReplace + type: string + disableHooks: + description: DisableHooks prevents hooks from running during + the Helm upgrade action. + type: boolean + disableOpenAPIValidation: + description: |- + DisableOpenAPIValidation prevents the Helm upgrade action from validating + rendered templates against the Kubernetes OpenAPI Schema. + type: boolean + disableSchemaValidation: + description: |- + DisableSchemaValidation prevents the Helm upgrade action from validating + the values against the JSON Schema. + type: boolean + disableTakeOwnership: + description: |- + DisableTakeOwnership disables taking ownership of existing resources + during the Helm upgrade action. Defaults to false. + type: boolean + disableWait: + description: |- + DisableWait disables the waiting for resources to be ready after a Helm + upgrade has been performed. + type: boolean + disableWaitForJobs: + description: |- + DisableWaitForJobs disables waiting for jobs to complete after a Helm + upgrade has been performed. + type: boolean + force: + description: |- + Force forces resource updates through a replacement strategy + that avoids 3-way merge conflicts on client-side apply. + This field is ignored for server-side apply (which always + forces conflicts with other field managers). + type: boolean + preserveValues: + description: |- + PreserveValues will make Helm reuse the last release's values and merge in + overrides from 'Values'. Setting this flag makes the HelmRelease + non-declarative. + type: boolean + remediation: + description: |- + Remediation holds the remediation configuration for when the Helm upgrade + action for the HelmRelease fails. The default is to not perform any action. + properties: + ignoreTestFailures: + description: |- + IgnoreTestFailures tells the controller to skip remediation when the Helm + tests are run after an upgrade action but fail. + Defaults to 'Test.IgnoreFailures'. + type: boolean + remediateLastFailure: + description: |- + RemediateLastFailure tells the controller to remediate the last failure, when + no retries remain. Defaults to 'false' unless 'Retries' is greater than 0. + type: boolean + retries: + description: |- + Retries is the number of retries that should be attempted on failures before + bailing. Remediation, using 'Strategy', is performed between each attempt. + Defaults to '0', a negative integer equals to unlimited retries. + type: integer + strategy: + description: Strategy to use for failure remediation. + Defaults to 'rollback'. + enum: + - rollback + - uninstall + type: string + type: object + serverSideApply: + description: |- + ServerSideApply enables server-side apply for resources during upgrade. + Can be "enabled", "disabled", or "auto". + When "auto", server-side apply usage will be based on the release's previous usage. + Defaults to "auto". + enum: + - enabled + - disabled + - auto + type: string + strategy: + description: |- + Strategy defines the upgrade strategy to use for this HelmRelease. + Defaults to 'RemediateOnFailure', or 'RetryOnFailure' when the + DefaultToRetryOnFailure feature gate is enabled. + properties: + name: + description: Name of the upgrade strategy. + enum: + - RemediateOnFailure + - RetryOnFailure + type: string + retryInterval: + description: |- + RetryInterval is the interval at which to retry a failed upgrade. + Can be used only when Name is set to RetryOnFailure. + Defaults to '5m'. + pattern: ^([0-9]+(\.[0-9]+)?(ms|s|m|h))+$ + type: string + required: + - name + type: object + x-kubernetes-validations: + - message: .retryInterval can only be set when .name is 'RetryOnFailure' + rule: '!has(self.retryInterval) || self.name == ''RetryOnFailure''' + timeout: + description: |- + Timeout is the time to wait for any individual Kubernetes operation (like + Jobs for hooks) during the performance of a Helm upgrade action. Defaults to + 'HelmReleaseSpec.Timeout'. + pattern: ^([0-9]+(\.[0-9]+)?(ms|s|m|h))+$ + type: string + type: object + values: + description: Values holds the values for this Helm release. + x-kubernetes-preserve-unknown-fields: true + valuesFrom: + description: |- + ValuesFrom holds references to resources containing Helm values for this HelmRelease, + and information about how they should be merged. + items: + description: |- + ValuesReference contains a reference to a resource containing Helm values, + and optionally the key they can be found at. + properties: + kind: + description: Kind of the values referent, valid values are + ('Secret', 'ConfigMap'). + enum: + - Secret + - ConfigMap + type: string + name: + description: |- + Name of the values referent. Should reside in the same namespace as the + referring resource. + maxLength: 253 + minLength: 1 + type: string + optional: + description: |- + Optional marks this ValuesReference as optional. When set, a not found error + for the values reference is ignored, but any ValuesKey, TargetPath or + transient error will still result in a reconciliation failure. + type: boolean + targetPath: + description: |- + TargetPath is the YAML dot notation path the value should be merged at. When + set, the ValuesKey is expected to be a single flat value. Defaults to 'None', + which results in the values getting merged at the root. + maxLength: 250 + pattern: ^([a-zA-Z0-9_\-.\\\/]|\[[0-9]{1,5}\])+$ + type: string + valuesKey: + description: |- + ValuesKey is the data key where the values.yaml or a specific value can be + found at. Defaults to 'values.yaml'. + maxLength: 253 + pattern: ^[\-._a-zA-Z0-9]+$ + type: string + required: + - kind + - name + type: object + type: array + waitStrategy: + description: |- + WaitStrategy defines Helm's wait strategy for waiting for applied + resources to become ready. + properties: + name: + description: |- + Name is Helm's wait strategy for waiting for applied resources to + become ready. One of 'poller' or 'legacy'. The 'poller' strategy uses + kstatus to poll resource statuses, while the 'legacy' strategy uses + Helm v3's waiting logic. + Defaults to 'poller', or to 'legacy' when UseHelm3Defaults feature + gate is enabled. + enum: + - poller + - legacy + type: string + required: + - name + type: object + required: + - interval + type: object + x-kubernetes-validations: + - message: either chart or chartRef must be set + rule: (has(self.chart) && !has(self.chartRef)) || (!has(self.chart) + && has(self.chartRef)) + target: + default: + category: Tenant + description: The provisioning target. + properties: + category: + default: Tenant + description: 'Provisioning target type. Possible values: Tenant, + Platform' + enum: + - Tenant + - Platform + type: string + filter: + description: |- + Filter targets (applies for category "Tenant"). + If ommited all targets are selected. + properties: + kind: + default: Blacklist + description: 'Includes or excludes the speciffied targets. + Possibile values: Blacklist, Whitelist' + enum: + - Blacklist + - Whitelist + type: string + values: + description: A list of targets to include or exculde + items: + type: string + type: array + required: + - kind + type: object + required: + - category + type: object + tenantOverrides: + additionalProperties: + x-kubernetes-preserve-unknown-fields: true + description: |- + Overrides for tenants. Dictionary with tenant name as key, spec override as value. + The spec override has the same structure as Spec + type: object + required: + - domainRef + - platformRef + - release + - target + type: object + required: + - spec + type: object + served: true + storage: true + subresources: {} diff --git a/internal/controllers/provisioning/provisioners/pulumi/fluxcd/generate_pulumi_fluxcd_apis.mk b/internal/controllers/provisioning/provisioners/pulumi/fluxcd/generate_pulumi_fluxcd_apis.mk index 0eb9dbe..effd942 100644 --- a/internal/controllers/provisioning/provisioners/pulumi/fluxcd/generate_pulumi_fluxcd_apis.mk +++ b/internal/controllers/provisioning/provisioners/pulumi/fluxcd/generate_pulumi_fluxcd_apis.mk @@ -3,5 +3,5 @@ # go install github.com/pulumi/crd2pulumi@latest generate-pulumi-fluxcd-apis: crd2pulumi --goPath ./internal/controllers/provisioning/provisioners/pulumi/fluxcd/generated ./internal/controllers/provisioning/provisioners/pulumi/fluxcd/helm.toolkit.fluxcd.io_helmreleases.yaml --force - + crd2pulumi --goPath ./internal/controllers/provisioning/provisioners/pulumi/fluxcd/generated ./internal/controllers/provisioning/provisioners/pulumi/fluxcd/helm.toolkit.fluxcd.io_helmreleases_v2.yaml --force diff --git a/internal/controllers/provisioning/provisioners/pulumi/fluxcd/generated/kubernetes/helm/v2/helmRelease.go b/internal/controllers/provisioning/provisioners/pulumi/fluxcd/generated/kubernetes/helm/v2/helmRelease.go new file mode 100644 index 0000000..088c207 --- /dev/null +++ b/internal/controllers/provisioning/provisioners/pulumi/fluxcd/generated/kubernetes/helm/v2/helmRelease.go @@ -0,0 +1,248 @@ +// Code generated by crd2pulumi DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package v2 + +import ( + "context" + "reflect" + + metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" + "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/utilities" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// HelmRelease is the Schema for the helmreleases API +type HelmRelease struct { + pulumi.CustomResourceState + + // 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 + ApiVersion pulumi.StringOutput `pulumi:"apiVersion"` + // 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 + Kind pulumi.StringOutput `pulumi:"kind"` + // Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + Metadata metav1.ObjectMetaOutput `pulumi:"metadata"` + Spec HelmReleaseSpecOutput `pulumi:"spec"` + Status HelmReleaseStatusPtrOutput `pulumi:"status"` +} + +// NewHelmRelease registers a new resource with the given unique name, arguments, and options. +func NewHelmRelease(ctx *pulumi.Context, + name string, args *HelmReleaseArgs, opts ...pulumi.ResourceOption) (*HelmRelease, error) { + if args == nil { + args = &HelmReleaseArgs{} + } + + args.ApiVersion = pulumi.StringPtr("helm.toolkit.fluxcd.io/v2") + args.Kind = pulumi.StringPtr("HelmRelease") + opts = utilities.PkgResourceDefaultOpts(opts) + var resource HelmRelease + err := ctx.RegisterResource("kubernetes:helm.toolkit.fluxcd.io/v2:HelmRelease", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetHelmRelease gets an existing HelmRelease resource's state with the given name, ID, and optional +// state properties that are used to uniquely qualify the lookup (nil if not required). +func GetHelmRelease(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *HelmReleaseState, opts ...pulumi.ResourceOption) (*HelmRelease, error) { + var resource HelmRelease + err := ctx.ReadResource("kubernetes:helm.toolkit.fluxcd.io/v2:HelmRelease", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering HelmRelease resources. +type helmReleaseState struct { +} + +type HelmReleaseState struct { +} + +func (HelmReleaseState) ElementType() reflect.Type { + return reflect.TypeOf((*helmReleaseState)(nil)).Elem() +} + +type helmReleaseArgs struct { + // 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 + ApiVersion *string `pulumi:"apiVersion"` + // 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 + Kind *string `pulumi:"kind"` + // Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + Metadata *metav1.ObjectMeta `pulumi:"metadata"` + Spec *HelmReleaseSpec `pulumi:"spec"` +} + +// The set of arguments for constructing a HelmRelease resource. +type HelmReleaseArgs struct { + // 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 + ApiVersion pulumi.StringPtrInput + // 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 + Kind pulumi.StringPtrInput + // Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + Metadata metav1.ObjectMetaPtrInput + Spec HelmReleaseSpecPtrInput +} + +func (HelmReleaseArgs) ElementType() reflect.Type { + return reflect.TypeOf((*helmReleaseArgs)(nil)).Elem() +} + +type HelmReleaseInput interface { + pulumi.Input + + ToHelmReleaseOutput() HelmReleaseOutput + ToHelmReleaseOutputWithContext(ctx context.Context) HelmReleaseOutput +} + +func (*HelmRelease) ElementType() reflect.Type { + return reflect.TypeOf((**HelmRelease)(nil)).Elem() +} + +func (i *HelmRelease) ToHelmReleaseOutput() HelmReleaseOutput { + return i.ToHelmReleaseOutputWithContext(context.Background()) +} + +func (i *HelmRelease) ToHelmReleaseOutputWithContext(ctx context.Context) HelmReleaseOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseOutput) +} + +// HelmReleaseArrayInput is an input type that accepts HelmReleaseArray and HelmReleaseArrayOutput values. +// You can construct a concrete instance of `HelmReleaseArrayInput` via: +// +// HelmReleaseArray{ HelmReleaseArgs{...} } +type HelmReleaseArrayInput interface { + pulumi.Input + + ToHelmReleaseArrayOutput() HelmReleaseArrayOutput + ToHelmReleaseArrayOutputWithContext(context.Context) HelmReleaseArrayOutput +} + +type HelmReleaseArray []HelmReleaseInput + +func (HelmReleaseArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*HelmRelease)(nil)).Elem() +} + +func (i HelmReleaseArray) ToHelmReleaseArrayOutput() HelmReleaseArrayOutput { + return i.ToHelmReleaseArrayOutputWithContext(context.Background()) +} + +func (i HelmReleaseArray) ToHelmReleaseArrayOutputWithContext(ctx context.Context) HelmReleaseArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseArrayOutput) +} + +// HelmReleaseMapInput is an input type that accepts HelmReleaseMap and HelmReleaseMapOutput values. +// You can construct a concrete instance of `HelmReleaseMapInput` via: +// +// HelmReleaseMap{ "key": HelmReleaseArgs{...} } +type HelmReleaseMapInput interface { + pulumi.Input + + ToHelmReleaseMapOutput() HelmReleaseMapOutput + ToHelmReleaseMapOutputWithContext(context.Context) HelmReleaseMapOutput +} + +type HelmReleaseMap map[string]HelmReleaseInput + +func (HelmReleaseMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*HelmRelease)(nil)).Elem() +} + +func (i HelmReleaseMap) ToHelmReleaseMapOutput() HelmReleaseMapOutput { + return i.ToHelmReleaseMapOutputWithContext(context.Background()) +} + +func (i HelmReleaseMap) ToHelmReleaseMapOutputWithContext(ctx context.Context) HelmReleaseMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseMapOutput) +} + +type HelmReleaseOutput struct{ *pulumi.OutputState } + +func (HelmReleaseOutput) ElementType() reflect.Type { + return reflect.TypeOf((**HelmRelease)(nil)).Elem() +} + +func (o HelmReleaseOutput) ToHelmReleaseOutput() HelmReleaseOutput { + return o +} + +func (o HelmReleaseOutput) ToHelmReleaseOutputWithContext(ctx context.Context) HelmReleaseOutput { + return o +} + +// 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 +func (o HelmReleaseOutput) ApiVersion() pulumi.StringOutput { + return o.ApplyT(func(v *HelmRelease) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) +} + +// 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 +func (o HelmReleaseOutput) Kind() pulumi.StringOutput { + return o.ApplyT(func(v *HelmRelease) pulumi.StringOutput { return v.Kind }).(pulumi.StringOutput) +} + +// Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata +func (o HelmReleaseOutput) Metadata() metav1.ObjectMetaOutput { + return o.ApplyT(func(v *HelmRelease) metav1.ObjectMetaOutput { return v.Metadata }).(metav1.ObjectMetaOutput) +} + +func (o HelmReleaseOutput) Spec() HelmReleaseSpecOutput { + return o.ApplyT(func(v *HelmRelease) HelmReleaseSpecOutput { return v.Spec }).(HelmReleaseSpecOutput) +} + +func (o HelmReleaseOutput) Status() HelmReleaseStatusPtrOutput { + return o.ApplyT(func(v *HelmRelease) HelmReleaseStatusPtrOutput { return v.Status }).(HelmReleaseStatusPtrOutput) +} + +type HelmReleaseArrayOutput struct{ *pulumi.OutputState } + +func (HelmReleaseArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*HelmRelease)(nil)).Elem() +} + +func (o HelmReleaseArrayOutput) ToHelmReleaseArrayOutput() HelmReleaseArrayOutput { + return o +} + +func (o HelmReleaseArrayOutput) ToHelmReleaseArrayOutputWithContext(ctx context.Context) HelmReleaseArrayOutput { + return o +} + +func (o HelmReleaseArrayOutput) Index(i pulumi.IntInput) HelmReleaseOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *HelmRelease { + return vs[0].([]*HelmRelease)[vs[1].(int)] + }).(HelmReleaseOutput) +} + +type HelmReleaseMapOutput struct{ *pulumi.OutputState } + +func (HelmReleaseMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*HelmRelease)(nil)).Elem() +} + +func (o HelmReleaseMapOutput) ToHelmReleaseMapOutput() HelmReleaseMapOutput { + return o +} + +func (o HelmReleaseMapOutput) ToHelmReleaseMapOutputWithContext(ctx context.Context) HelmReleaseMapOutput { + return o +} + +func (o HelmReleaseMapOutput) MapIndex(k pulumi.StringInput) HelmReleaseOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *HelmRelease { + return vs[0].(map[string]*HelmRelease)[vs[1].(string)] + }).(HelmReleaseOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseInput)(nil)).Elem(), &HelmRelease{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseArrayInput)(nil)).Elem(), HelmReleaseArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseMapInput)(nil)).Elem(), HelmReleaseMap{}) + pulumi.RegisterOutputType(HelmReleaseOutput{}) + pulumi.RegisterOutputType(HelmReleaseArrayOutput{}) + pulumi.RegisterOutputType(HelmReleaseMapOutput{}) +} diff --git a/internal/controllers/provisioning/provisioners/pulumi/fluxcd/generated/kubernetes/helm/v2/helmReleaseList.go b/internal/controllers/provisioning/provisioners/pulumi/fluxcd/generated/kubernetes/helm/v2/helmReleaseList.go new file mode 100644 index 0000000..d7abf88 --- /dev/null +++ b/internal/controllers/provisioning/provisioners/pulumi/fluxcd/generated/kubernetes/helm/v2/helmReleaseList.go @@ -0,0 +1,251 @@ +// Code generated by crd2pulumi DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package v2 + +import ( + "context" + "reflect" + + "errors" + metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" + "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/utilities" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// HelmReleaseList is a list of HelmRelease +type HelmReleaseList struct { + pulumi.CustomResourceState + + // 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 + ApiVersion pulumi.StringOutput `pulumi:"apiVersion"` + // List of helmreleases. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md + Items HelmReleaseTypeArrayOutput `pulumi:"items"` + // 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 + Kind pulumi.StringOutput `pulumi:"kind"` + // Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds + Metadata metav1.ListMetaOutput `pulumi:"metadata"` +} + +// NewHelmReleaseList registers a new resource with the given unique name, arguments, and options. +func NewHelmReleaseList(ctx *pulumi.Context, + name string, args *HelmReleaseListArgs, opts ...pulumi.ResourceOption) (*HelmReleaseList, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.Items == nil { + return nil, errors.New("invalid value for required argument 'Items'") + } + args.ApiVersion = pulumi.StringPtr("helm.toolkit.fluxcd.io/v2") + args.Kind = pulumi.StringPtr("HelmReleaseList") + opts = utilities.PkgResourceDefaultOpts(opts) + var resource HelmReleaseList + err := ctx.RegisterResource("kubernetes:helm.toolkit.fluxcd.io/v2:HelmReleaseList", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetHelmReleaseList gets an existing HelmReleaseList resource's state with the given name, ID, and optional +// state properties that are used to uniquely qualify the lookup (nil if not required). +func GetHelmReleaseList(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *HelmReleaseListState, opts ...pulumi.ResourceOption) (*HelmReleaseList, error) { + var resource HelmReleaseList + err := ctx.ReadResource("kubernetes:helm.toolkit.fluxcd.io/v2:HelmReleaseList", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering HelmReleaseList resources. +type helmReleaseListState struct { +} + +type HelmReleaseListState struct { +} + +func (HelmReleaseListState) ElementType() reflect.Type { + return reflect.TypeOf((*helmReleaseListState)(nil)).Elem() +} + +type helmReleaseListArgs struct { + // 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 + ApiVersion *string `pulumi:"apiVersion"` + // List of helmreleases. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md + Items []HelmReleaseType `pulumi:"items"` + // 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 + Kind *string `pulumi:"kind"` + // Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds + Metadata *metav1.ListMeta `pulumi:"metadata"` +} + +// The set of arguments for constructing a HelmReleaseList resource. +type HelmReleaseListArgs struct { + // 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 + ApiVersion pulumi.StringPtrInput + // List of helmreleases. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md + Items HelmReleaseTypeArrayInput + // 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 + Kind pulumi.StringPtrInput + // Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds + Metadata metav1.ListMetaPtrInput +} + +func (HelmReleaseListArgs) ElementType() reflect.Type { + return reflect.TypeOf((*helmReleaseListArgs)(nil)).Elem() +} + +type HelmReleaseListInput interface { + pulumi.Input + + ToHelmReleaseListOutput() HelmReleaseListOutput + ToHelmReleaseListOutputWithContext(ctx context.Context) HelmReleaseListOutput +} + +func (*HelmReleaseList) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseList)(nil)).Elem() +} + +func (i *HelmReleaseList) ToHelmReleaseListOutput() HelmReleaseListOutput { + return i.ToHelmReleaseListOutputWithContext(context.Background()) +} + +func (i *HelmReleaseList) ToHelmReleaseListOutputWithContext(ctx context.Context) HelmReleaseListOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseListOutput) +} + +// HelmReleaseListArrayInput is an input type that accepts HelmReleaseListArray and HelmReleaseListArrayOutput values. +// You can construct a concrete instance of `HelmReleaseListArrayInput` via: +// +// HelmReleaseListArray{ HelmReleaseListArgs{...} } +type HelmReleaseListArrayInput interface { + pulumi.Input + + ToHelmReleaseListArrayOutput() HelmReleaseListArrayOutput + ToHelmReleaseListArrayOutputWithContext(context.Context) HelmReleaseListArrayOutput +} + +type HelmReleaseListArray []HelmReleaseListInput + +func (HelmReleaseListArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*HelmReleaseList)(nil)).Elem() +} + +func (i HelmReleaseListArray) ToHelmReleaseListArrayOutput() HelmReleaseListArrayOutput { + return i.ToHelmReleaseListArrayOutputWithContext(context.Background()) +} + +func (i HelmReleaseListArray) ToHelmReleaseListArrayOutputWithContext(ctx context.Context) HelmReleaseListArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseListArrayOutput) +} + +// HelmReleaseListMapInput is an input type that accepts HelmReleaseListMap and HelmReleaseListMapOutput values. +// You can construct a concrete instance of `HelmReleaseListMapInput` via: +// +// HelmReleaseListMap{ "key": HelmReleaseListArgs{...} } +type HelmReleaseListMapInput interface { + pulumi.Input + + ToHelmReleaseListMapOutput() HelmReleaseListMapOutput + ToHelmReleaseListMapOutputWithContext(context.Context) HelmReleaseListMapOutput +} + +type HelmReleaseListMap map[string]HelmReleaseListInput + +func (HelmReleaseListMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*HelmReleaseList)(nil)).Elem() +} + +func (i HelmReleaseListMap) ToHelmReleaseListMapOutput() HelmReleaseListMapOutput { + return i.ToHelmReleaseListMapOutputWithContext(context.Background()) +} + +func (i HelmReleaseListMap) ToHelmReleaseListMapOutputWithContext(ctx context.Context) HelmReleaseListMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseListMapOutput) +} + +type HelmReleaseListOutput struct{ *pulumi.OutputState } + +func (HelmReleaseListOutput) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseList)(nil)).Elem() +} + +func (o HelmReleaseListOutput) ToHelmReleaseListOutput() HelmReleaseListOutput { + return o +} + +func (o HelmReleaseListOutput) ToHelmReleaseListOutputWithContext(ctx context.Context) HelmReleaseListOutput { + return o +} + +// 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 +func (o HelmReleaseListOutput) ApiVersion() pulumi.StringOutput { + return o.ApplyT(func(v *HelmReleaseList) pulumi.StringOutput { return v.ApiVersion }).(pulumi.StringOutput) +} + +// List of helmreleases. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md +func (o HelmReleaseListOutput) Items() HelmReleaseTypeArrayOutput { + return o.ApplyT(func(v *HelmReleaseList) HelmReleaseTypeArrayOutput { return v.Items }).(HelmReleaseTypeArrayOutput) +} + +// 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 +func (o HelmReleaseListOutput) Kind() pulumi.StringOutput { + return o.ApplyT(func(v *HelmReleaseList) pulumi.StringOutput { return v.Kind }).(pulumi.StringOutput) +} + +// Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +func (o HelmReleaseListOutput) Metadata() metav1.ListMetaOutput { + return o.ApplyT(func(v *HelmReleaseList) metav1.ListMetaOutput { return v.Metadata }).(metav1.ListMetaOutput) +} + +type HelmReleaseListArrayOutput struct{ *pulumi.OutputState } + +func (HelmReleaseListArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*HelmReleaseList)(nil)).Elem() +} + +func (o HelmReleaseListArrayOutput) ToHelmReleaseListArrayOutput() HelmReleaseListArrayOutput { + return o +} + +func (o HelmReleaseListArrayOutput) ToHelmReleaseListArrayOutputWithContext(ctx context.Context) HelmReleaseListArrayOutput { + return o +} + +func (o HelmReleaseListArrayOutput) Index(i pulumi.IntInput) HelmReleaseListOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *HelmReleaseList { + return vs[0].([]*HelmReleaseList)[vs[1].(int)] + }).(HelmReleaseListOutput) +} + +type HelmReleaseListMapOutput struct{ *pulumi.OutputState } + +func (HelmReleaseListMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*HelmReleaseList)(nil)).Elem() +} + +func (o HelmReleaseListMapOutput) ToHelmReleaseListMapOutput() HelmReleaseListMapOutput { + return o +} + +func (o HelmReleaseListMapOutput) ToHelmReleaseListMapOutputWithContext(ctx context.Context) HelmReleaseListMapOutput { + return o +} + +func (o HelmReleaseListMapOutput) MapIndex(k pulumi.StringInput) HelmReleaseListOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *HelmReleaseList { + return vs[0].(map[string]*HelmReleaseList)[vs[1].(string)] + }).(HelmReleaseListOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseListInput)(nil)).Elem(), &HelmReleaseList{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseListArrayInput)(nil)).Elem(), HelmReleaseListArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseListMapInput)(nil)).Elem(), HelmReleaseListMap{}) + pulumi.RegisterOutputType(HelmReleaseListOutput{}) + pulumi.RegisterOutputType(HelmReleaseListArrayOutput{}) + pulumi.RegisterOutputType(HelmReleaseListMapOutput{}) +} diff --git a/internal/controllers/provisioning/provisioners/pulumi/fluxcd/generated/kubernetes/helm/v2/helmReleasePatch.go b/internal/controllers/provisioning/provisioners/pulumi/fluxcd/generated/kubernetes/helm/v2/helmReleasePatch.go new file mode 100644 index 0000000..7f1d5d4 --- /dev/null +++ b/internal/controllers/provisioning/provisioners/pulumi/fluxcd/generated/kubernetes/helm/v2/helmReleasePatch.go @@ -0,0 +1,254 @@ +// Code generated by crd2pulumi DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package v2 + +import ( + "context" + "reflect" + + metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" + "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/utilities" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Patch resources are used to modify existing Kubernetes resources by using +// Server-Side Apply updates. The name of the resource must be specified, but all other properties are optional. More than +// one patch may be applied to the same resource, and a random FieldManager name will be used for each Patch resource. +// Conflicts will result in an error by default, but can be forced using the "pulumi.com/patchForce" annotation. See the +// [Server-Side Apply Docs](https://www.pulumi.com/registry/packages/kubernetes/how-to-guides/managing-resources-with-server-side-apply/) for +// additional information about using Server-Side Apply to manage Kubernetes resources with Pulumi. +// HelmRelease is the Schema for the helmreleases API +type HelmReleasePatch struct { + pulumi.CustomResourceState + + // 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 + ApiVersion pulumi.StringPtrOutput `pulumi:"apiVersion"` + // 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 + Kind pulumi.StringPtrOutput `pulumi:"kind"` + // Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + Metadata metav1.ObjectMetaPatchPtrOutput `pulumi:"metadata"` + Spec HelmReleaseSpecPatchPtrOutput `pulumi:"spec"` + Status HelmReleaseStatusPatchPtrOutput `pulumi:"status"` +} + +// NewHelmReleasePatch registers a new resource with the given unique name, arguments, and options. +func NewHelmReleasePatch(ctx *pulumi.Context, + name string, args *HelmReleasePatchArgs, opts ...pulumi.ResourceOption) (*HelmReleasePatch, error) { + if args == nil { + args = &HelmReleasePatchArgs{} + } + + args.ApiVersion = pulumi.StringPtr("helm.toolkit.fluxcd.io/v2") + args.Kind = pulumi.StringPtr("HelmRelease") + opts = utilities.PkgResourceDefaultOpts(opts) + var resource HelmReleasePatch + err := ctx.RegisterResource("kubernetes:helm.toolkit.fluxcd.io/v2:HelmReleasePatch", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetHelmReleasePatch gets an existing HelmReleasePatch resource's state with the given name, ID, and optional +// state properties that are used to uniquely qualify the lookup (nil if not required). +func GetHelmReleasePatch(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *HelmReleasePatchState, opts ...pulumi.ResourceOption) (*HelmReleasePatch, error) { + var resource HelmReleasePatch + err := ctx.ReadResource("kubernetes:helm.toolkit.fluxcd.io/v2:HelmReleasePatch", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering HelmReleasePatch resources. +type helmReleasePatchState struct { +} + +type HelmReleasePatchState struct { +} + +func (HelmReleasePatchState) ElementType() reflect.Type { + return reflect.TypeOf((*helmReleasePatchState)(nil)).Elem() +} + +type helmReleasePatchArgs struct { + // 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 + ApiVersion *string `pulumi:"apiVersion"` + // 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 + Kind *string `pulumi:"kind"` + // Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + Metadata *metav1.ObjectMetaPatch `pulumi:"metadata"` + Spec *HelmReleaseSpecPatch `pulumi:"spec"` +} + +// The set of arguments for constructing a HelmReleasePatch resource. +type HelmReleasePatchArgs struct { + // 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 + ApiVersion pulumi.StringPtrInput + // 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 + Kind pulumi.StringPtrInput + // Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + Metadata metav1.ObjectMetaPatchPtrInput + Spec HelmReleaseSpecPatchPtrInput +} + +func (HelmReleasePatchArgs) ElementType() reflect.Type { + return reflect.TypeOf((*helmReleasePatchArgs)(nil)).Elem() +} + +type HelmReleasePatchInput interface { + pulumi.Input + + ToHelmReleasePatchOutput() HelmReleasePatchOutput + ToHelmReleasePatchOutputWithContext(ctx context.Context) HelmReleasePatchOutput +} + +func (*HelmReleasePatch) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleasePatch)(nil)).Elem() +} + +func (i *HelmReleasePatch) ToHelmReleasePatchOutput() HelmReleasePatchOutput { + return i.ToHelmReleasePatchOutputWithContext(context.Background()) +} + +func (i *HelmReleasePatch) ToHelmReleasePatchOutputWithContext(ctx context.Context) HelmReleasePatchOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleasePatchOutput) +} + +// HelmReleasePatchArrayInput is an input type that accepts HelmReleasePatchArray and HelmReleasePatchArrayOutput values. +// You can construct a concrete instance of `HelmReleasePatchArrayInput` via: +// +// HelmReleasePatchArray{ HelmReleasePatchArgs{...} } +type HelmReleasePatchArrayInput interface { + pulumi.Input + + ToHelmReleasePatchArrayOutput() HelmReleasePatchArrayOutput + ToHelmReleasePatchArrayOutputWithContext(context.Context) HelmReleasePatchArrayOutput +} + +type HelmReleasePatchArray []HelmReleasePatchInput + +func (HelmReleasePatchArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*HelmReleasePatch)(nil)).Elem() +} + +func (i HelmReleasePatchArray) ToHelmReleasePatchArrayOutput() HelmReleasePatchArrayOutput { + return i.ToHelmReleasePatchArrayOutputWithContext(context.Background()) +} + +func (i HelmReleasePatchArray) ToHelmReleasePatchArrayOutputWithContext(ctx context.Context) HelmReleasePatchArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleasePatchArrayOutput) +} + +// HelmReleasePatchMapInput is an input type that accepts HelmReleasePatchMap and HelmReleasePatchMapOutput values. +// You can construct a concrete instance of `HelmReleasePatchMapInput` via: +// +// HelmReleasePatchMap{ "key": HelmReleasePatchArgs{...} } +type HelmReleasePatchMapInput interface { + pulumi.Input + + ToHelmReleasePatchMapOutput() HelmReleasePatchMapOutput + ToHelmReleasePatchMapOutputWithContext(context.Context) HelmReleasePatchMapOutput +} + +type HelmReleasePatchMap map[string]HelmReleasePatchInput + +func (HelmReleasePatchMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*HelmReleasePatch)(nil)).Elem() +} + +func (i HelmReleasePatchMap) ToHelmReleasePatchMapOutput() HelmReleasePatchMapOutput { + return i.ToHelmReleasePatchMapOutputWithContext(context.Background()) +} + +func (i HelmReleasePatchMap) ToHelmReleasePatchMapOutputWithContext(ctx context.Context) HelmReleasePatchMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleasePatchMapOutput) +} + +type HelmReleasePatchOutput struct{ *pulumi.OutputState } + +func (HelmReleasePatchOutput) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleasePatch)(nil)).Elem() +} + +func (o HelmReleasePatchOutput) ToHelmReleasePatchOutput() HelmReleasePatchOutput { + return o +} + +func (o HelmReleasePatchOutput) ToHelmReleasePatchOutputWithContext(ctx context.Context) HelmReleasePatchOutput { + return o +} + +// 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 +func (o HelmReleasePatchOutput) ApiVersion() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleasePatch) pulumi.StringPtrOutput { return v.ApiVersion }).(pulumi.StringPtrOutput) +} + +// 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 +func (o HelmReleasePatchOutput) Kind() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleasePatch) pulumi.StringPtrOutput { return v.Kind }).(pulumi.StringPtrOutput) +} + +// Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata +func (o HelmReleasePatchOutput) Metadata() metav1.ObjectMetaPatchPtrOutput { + return o.ApplyT(func(v *HelmReleasePatch) metav1.ObjectMetaPatchPtrOutput { return v.Metadata }).(metav1.ObjectMetaPatchPtrOutput) +} + +func (o HelmReleasePatchOutput) Spec() HelmReleaseSpecPatchPtrOutput { + return o.ApplyT(func(v *HelmReleasePatch) HelmReleaseSpecPatchPtrOutput { return v.Spec }).(HelmReleaseSpecPatchPtrOutput) +} + +func (o HelmReleasePatchOutput) Status() HelmReleaseStatusPatchPtrOutput { + return o.ApplyT(func(v *HelmReleasePatch) HelmReleaseStatusPatchPtrOutput { return v.Status }).(HelmReleaseStatusPatchPtrOutput) +} + +type HelmReleasePatchArrayOutput struct{ *pulumi.OutputState } + +func (HelmReleasePatchArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*HelmReleasePatch)(nil)).Elem() +} + +func (o HelmReleasePatchArrayOutput) ToHelmReleasePatchArrayOutput() HelmReleasePatchArrayOutput { + return o +} + +func (o HelmReleasePatchArrayOutput) ToHelmReleasePatchArrayOutputWithContext(ctx context.Context) HelmReleasePatchArrayOutput { + return o +} + +func (o HelmReleasePatchArrayOutput) Index(i pulumi.IntInput) HelmReleasePatchOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *HelmReleasePatch { + return vs[0].([]*HelmReleasePatch)[vs[1].(int)] + }).(HelmReleasePatchOutput) +} + +type HelmReleasePatchMapOutput struct{ *pulumi.OutputState } + +func (HelmReleasePatchMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*HelmReleasePatch)(nil)).Elem() +} + +func (o HelmReleasePatchMapOutput) ToHelmReleasePatchMapOutput() HelmReleasePatchMapOutput { + return o +} + +func (o HelmReleasePatchMapOutput) ToHelmReleasePatchMapOutputWithContext(ctx context.Context) HelmReleasePatchMapOutput { + return o +} + +func (o HelmReleasePatchMapOutput) MapIndex(k pulumi.StringInput) HelmReleasePatchOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *HelmReleasePatch { + return vs[0].(map[string]*HelmReleasePatch)[vs[1].(string)] + }).(HelmReleasePatchOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleasePatchInput)(nil)).Elem(), &HelmReleasePatch{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleasePatchArrayInput)(nil)).Elem(), HelmReleasePatchArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleasePatchMapInput)(nil)).Elem(), HelmReleasePatchMap{}) + pulumi.RegisterOutputType(HelmReleasePatchOutput{}) + pulumi.RegisterOutputType(HelmReleasePatchArrayOutput{}) + pulumi.RegisterOutputType(HelmReleasePatchMapOutput{}) +} diff --git a/internal/controllers/provisioning/provisioners/pulumi/fluxcd/generated/kubernetes/helm/v2/init.go b/internal/controllers/provisioning/provisioners/pulumi/fluxcd/generated/kubernetes/helm/v2/init.go new file mode 100644 index 0000000..e1dde6c --- /dev/null +++ b/internal/controllers/provisioning/provisioners/pulumi/fluxcd/generated/kubernetes/helm/v2/init.go @@ -0,0 +1,48 @@ +// Code generated by crd2pulumi DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package v2 + +import ( + "fmt" + + "github.com/blang/semver" + "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/utilities" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +type module struct { + version semver.Version +} + +func (m *module) Version() semver.Version { + return m.version +} + +func (m *module) Construct(ctx *pulumi.Context, name, typ, urn string) (r pulumi.Resource, err error) { + switch typ { + case "kubernetes:helm.toolkit.fluxcd.io/v2:HelmRelease": + r = &HelmRelease{} + case "kubernetes:helm.toolkit.fluxcd.io/v2:HelmReleaseList": + r = &HelmReleaseList{} + case "kubernetes:helm.toolkit.fluxcd.io/v2:HelmReleasePatch": + r = &HelmReleasePatch{} + default: + return nil, fmt.Errorf("unknown resource type: %s", typ) + } + + err = ctx.RegisterResource(typ, name, nil, r, pulumi.URN_(urn)) + return +} + +func init() { + version, err := utilities.PkgVersion() + if err != nil { + version = semver.Version{Major: 1} + } + pulumi.RegisterResourceModule( + "crds", + "helm.toolkit.fluxcd.io/v2", + &module{version}, + ) +} diff --git a/internal/controllers/provisioning/provisioners/pulumi/fluxcd/generated/kubernetes/helm/v2/pulumiTypes.go b/internal/controllers/provisioning/provisioners/pulumi/fluxcd/generated/kubernetes/helm/v2/pulumiTypes.go new file mode 100644 index 0000000..f709ec3 --- /dev/null +++ b/internal/controllers/provisioning/provisioners/pulumi/fluxcd/generated/kubernetes/helm/v2/pulumiTypes.go @@ -0,0 +1,18109 @@ +// Code generated by crd2pulumi DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package v2 + +import ( + "context" + "reflect" + + metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" + "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/utilities" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +var _ = utilities.GetEnvOrDefault + +// HelmRelease is the Schema for the helmreleases API +type HelmReleaseType struct { + // 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 + ApiVersion *string `pulumi:"apiVersion"` + // 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 + Kind *string `pulumi:"kind"` + // Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + Metadata *metav1.ObjectMeta `pulumi:"metadata"` + Spec *HelmReleaseSpec `pulumi:"spec"` + Status *HelmReleaseStatus `pulumi:"status"` +} + +// HelmReleaseTypeInput is an input type that accepts HelmReleaseTypeArgs and HelmReleaseTypeOutput values. +// You can construct a concrete instance of `HelmReleaseTypeInput` via: +// +// HelmReleaseTypeArgs{...} +type HelmReleaseTypeInput interface { + pulumi.Input + + ToHelmReleaseTypeOutput() HelmReleaseTypeOutput + ToHelmReleaseTypeOutputWithContext(context.Context) HelmReleaseTypeOutput +} + +// HelmRelease is the Schema for the helmreleases API +type HelmReleaseTypeArgs struct { + // 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 + ApiVersion pulumi.StringPtrInput `pulumi:"apiVersion"` + // 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 + Kind pulumi.StringPtrInput `pulumi:"kind"` + // Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + Metadata metav1.ObjectMetaPtrInput `pulumi:"metadata"` + Spec HelmReleaseSpecPtrInput `pulumi:"spec"` + Status HelmReleaseStatusPtrInput `pulumi:"status"` +} + +func (HelmReleaseTypeArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseType)(nil)).Elem() +} + +func (i HelmReleaseTypeArgs) ToHelmReleaseTypeOutput() HelmReleaseTypeOutput { + return i.ToHelmReleaseTypeOutputWithContext(context.Background()) +} + +func (i HelmReleaseTypeArgs) ToHelmReleaseTypeOutputWithContext(ctx context.Context) HelmReleaseTypeOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseTypeOutput) +} + +// HelmReleaseTypeArrayInput is an input type that accepts HelmReleaseTypeArray and HelmReleaseTypeArrayOutput values. +// You can construct a concrete instance of `HelmReleaseTypeArrayInput` via: +// +// HelmReleaseTypeArray{ HelmReleaseTypeArgs{...} } +type HelmReleaseTypeArrayInput interface { + pulumi.Input + + ToHelmReleaseTypeArrayOutput() HelmReleaseTypeArrayOutput + ToHelmReleaseTypeArrayOutputWithContext(context.Context) HelmReleaseTypeArrayOutput +} + +type HelmReleaseTypeArray []HelmReleaseTypeInput + +func (HelmReleaseTypeArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]HelmReleaseType)(nil)).Elem() +} + +func (i HelmReleaseTypeArray) ToHelmReleaseTypeArrayOutput() HelmReleaseTypeArrayOutput { + return i.ToHelmReleaseTypeArrayOutputWithContext(context.Background()) +} + +func (i HelmReleaseTypeArray) ToHelmReleaseTypeArrayOutputWithContext(ctx context.Context) HelmReleaseTypeArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseTypeArrayOutput) +} + +// HelmRelease is the Schema for the helmreleases API +type HelmReleaseTypeOutput struct{ *pulumi.OutputState } + +func (HelmReleaseTypeOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseType)(nil)).Elem() +} + +func (o HelmReleaseTypeOutput) ToHelmReleaseTypeOutput() HelmReleaseTypeOutput { + return o +} + +func (o HelmReleaseTypeOutput) ToHelmReleaseTypeOutputWithContext(ctx context.Context) HelmReleaseTypeOutput { + return o +} + +// 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 +func (o HelmReleaseTypeOutput) ApiVersion() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) +} + +// 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 +func (o HelmReleaseTypeOutput) Kind() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseType) *string { return v.Kind }).(pulumi.StringPtrOutput) +} + +// Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata +func (o HelmReleaseTypeOutput) Metadata() metav1.ObjectMetaPtrOutput { + return o.ApplyT(func(v HelmReleaseType) *metav1.ObjectMeta { return v.Metadata }).(metav1.ObjectMetaPtrOutput) +} + +func (o HelmReleaseTypeOutput) Spec() HelmReleaseSpecPtrOutput { + return o.ApplyT(func(v HelmReleaseType) *HelmReleaseSpec { return v.Spec }).(HelmReleaseSpecPtrOutput) +} + +func (o HelmReleaseTypeOutput) Status() HelmReleaseStatusPtrOutput { + return o.ApplyT(func(v HelmReleaseType) *HelmReleaseStatus { return v.Status }).(HelmReleaseStatusPtrOutput) +} + +type HelmReleaseTypeArrayOutput struct{ *pulumi.OutputState } + +func (HelmReleaseTypeArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]HelmReleaseType)(nil)).Elem() +} + +func (o HelmReleaseTypeArrayOutput) ToHelmReleaseTypeArrayOutput() HelmReleaseTypeArrayOutput { + return o +} + +func (o HelmReleaseTypeArrayOutput) ToHelmReleaseTypeArrayOutputWithContext(ctx context.Context) HelmReleaseTypeArrayOutput { + return o +} + +func (o HelmReleaseTypeArrayOutput) Index(i pulumi.IntInput) HelmReleaseTypeOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) HelmReleaseType { + return vs[0].([]HelmReleaseType)[vs[1].(int)] + }).(HelmReleaseTypeOutput) +} + +// HelmReleaseList is a list of HelmRelease +type HelmReleaseListType struct { + // 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 + ApiVersion *string `pulumi:"apiVersion"` + // List of helmreleases. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md + Items []HelmReleaseType `pulumi:"items"` + // 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 + Kind *string `pulumi:"kind"` + // Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds + Metadata *metav1.ListMeta `pulumi:"metadata"` +} + +// HelmReleaseListTypeInput is an input type that accepts HelmReleaseListTypeArgs and HelmReleaseListTypeOutput values. +// You can construct a concrete instance of `HelmReleaseListTypeInput` via: +// +// HelmReleaseListTypeArgs{...} +type HelmReleaseListTypeInput interface { + pulumi.Input + + ToHelmReleaseListTypeOutput() HelmReleaseListTypeOutput + ToHelmReleaseListTypeOutputWithContext(context.Context) HelmReleaseListTypeOutput +} + +// HelmReleaseList is a list of HelmRelease +type HelmReleaseListTypeArgs struct { + // 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 + ApiVersion pulumi.StringPtrInput `pulumi:"apiVersion"` + // List of helmreleases. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md + Items HelmReleaseTypeArrayInput `pulumi:"items"` + // 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 + Kind pulumi.StringPtrInput `pulumi:"kind"` + // Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds + Metadata metav1.ListMetaPtrInput `pulumi:"metadata"` +} + +func (HelmReleaseListTypeArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseListType)(nil)).Elem() +} + +func (i HelmReleaseListTypeArgs) ToHelmReleaseListTypeOutput() HelmReleaseListTypeOutput { + return i.ToHelmReleaseListTypeOutputWithContext(context.Background()) +} + +func (i HelmReleaseListTypeArgs) ToHelmReleaseListTypeOutputWithContext(ctx context.Context) HelmReleaseListTypeOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseListTypeOutput) +} + +// HelmReleaseList is a list of HelmRelease +type HelmReleaseListTypeOutput struct{ *pulumi.OutputState } + +func (HelmReleaseListTypeOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseListType)(nil)).Elem() +} + +func (o HelmReleaseListTypeOutput) ToHelmReleaseListTypeOutput() HelmReleaseListTypeOutput { + return o +} + +func (o HelmReleaseListTypeOutput) ToHelmReleaseListTypeOutputWithContext(ctx context.Context) HelmReleaseListTypeOutput { + return o +} + +// 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 +func (o HelmReleaseListTypeOutput) ApiVersion() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) +} + +// List of helmreleases. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md +func (o HelmReleaseListTypeOutput) Items() HelmReleaseTypeArrayOutput { + return o.ApplyT(func(v HelmReleaseListType) []HelmReleaseType { return v.Items }).(HelmReleaseTypeArrayOutput) +} + +// 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 +func (o HelmReleaseListTypeOutput) Kind() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseListType) *string { return v.Kind }).(pulumi.StringPtrOutput) +} + +// Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +func (o HelmReleaseListTypeOutput) Metadata() metav1.ListMetaPtrOutput { + return o.ApplyT(func(v HelmReleaseListType) *metav1.ListMeta { return v.Metadata }).(metav1.ListMetaPtrOutput) +} + +// HelmRelease is the Schema for the helmreleases API +type HelmReleasePatchType struct { + // 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 + ApiVersion *string `pulumi:"apiVersion"` + // 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 + Kind *string `pulumi:"kind"` + // Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + Metadata *metav1.ObjectMetaPatch `pulumi:"metadata"` + Spec *HelmReleaseSpecPatch `pulumi:"spec"` + Status *HelmReleaseStatusPatch `pulumi:"status"` +} + +// HelmReleasePatchTypeInput is an input type that accepts HelmReleasePatchTypeArgs and HelmReleasePatchTypeOutput values. +// You can construct a concrete instance of `HelmReleasePatchTypeInput` via: +// +// HelmReleasePatchTypeArgs{...} +type HelmReleasePatchTypeInput interface { + pulumi.Input + + ToHelmReleasePatchTypeOutput() HelmReleasePatchTypeOutput + ToHelmReleasePatchTypeOutputWithContext(context.Context) HelmReleasePatchTypeOutput +} + +// HelmRelease is the Schema for the helmreleases API +type HelmReleasePatchTypeArgs struct { + // 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 + ApiVersion pulumi.StringPtrInput `pulumi:"apiVersion"` + // 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 + Kind pulumi.StringPtrInput `pulumi:"kind"` + // Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + Metadata metav1.ObjectMetaPatchPtrInput `pulumi:"metadata"` + Spec HelmReleaseSpecPatchPtrInput `pulumi:"spec"` + Status HelmReleaseStatusPatchPtrInput `pulumi:"status"` +} + +func (HelmReleasePatchTypeArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleasePatchType)(nil)).Elem() +} + +func (i HelmReleasePatchTypeArgs) ToHelmReleasePatchTypeOutput() HelmReleasePatchTypeOutput { + return i.ToHelmReleasePatchTypeOutputWithContext(context.Background()) +} + +func (i HelmReleasePatchTypeArgs) ToHelmReleasePatchTypeOutputWithContext(ctx context.Context) HelmReleasePatchTypeOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleasePatchTypeOutput) +} + +// HelmRelease is the Schema for the helmreleases API +type HelmReleasePatchTypeOutput struct{ *pulumi.OutputState } + +func (HelmReleasePatchTypeOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleasePatchType)(nil)).Elem() +} + +func (o HelmReleasePatchTypeOutput) ToHelmReleasePatchTypeOutput() HelmReleasePatchTypeOutput { + return o +} + +func (o HelmReleasePatchTypeOutput) ToHelmReleasePatchTypeOutputWithContext(ctx context.Context) HelmReleasePatchTypeOutput { + return o +} + +// 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 +func (o HelmReleasePatchTypeOutput) ApiVersion() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleasePatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) +} + +// 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 +func (o HelmReleasePatchTypeOutput) Kind() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleasePatchType) *string { return v.Kind }).(pulumi.StringPtrOutput) +} + +// Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata +func (o HelmReleasePatchTypeOutput) Metadata() metav1.ObjectMetaPatchPtrOutput { + return o.ApplyT(func(v HelmReleasePatchType) *metav1.ObjectMetaPatch { return v.Metadata }).(metav1.ObjectMetaPatchPtrOutput) +} + +func (o HelmReleasePatchTypeOutput) Spec() HelmReleaseSpecPatchPtrOutput { + return o.ApplyT(func(v HelmReleasePatchType) *HelmReleaseSpecPatch { return v.Spec }).(HelmReleaseSpecPatchPtrOutput) +} + +func (o HelmReleasePatchTypeOutput) Status() HelmReleaseStatusPatchPtrOutput { + return o.ApplyT(func(v HelmReleasePatchType) *HelmReleaseStatusPatch { return v.Status }).(HelmReleaseStatusPatchPtrOutput) +} + +// HelmReleaseSpec defines the desired state of a Helm release. +type HelmReleaseSpec struct { + Chart *HelmReleaseSpecChart `pulumi:"chart"` + ChartRef *HelmReleaseSpecChartRef `pulumi:"chartRef"` + CommonMetadata *HelmReleaseSpecCommonMetadata `pulumi:"commonMetadata"` + // DependsOn may contain a DependencyReference slice with + // references to HelmRelease resources that must be ready before this HelmRelease + // can be reconciled. + DependsOn []HelmReleaseSpecDependsOn `pulumi:"dependsOn"` + DriftDetection *HelmReleaseSpecDriftDetection `pulumi:"driftDetection"` + // HealthCheckExprs is a list of healthcheck expressions for evaluating the + // health of custom resources using Common Expression Language (CEL). + // The expressions are evaluated only when the specific Helm action + // taking place has wait enabled, i.e. DisableWait is false, and the + // 'poller' WaitStrategy is used. + HealthCheckExprs []HelmReleaseSpecHealthCheckExprs `pulumi:"healthCheckExprs"` + Install *HelmReleaseSpecInstall `pulumi:"install"` + // Interval at which to reconcile the Helm release. + Interval *string `pulumi:"interval"` + KubeConfig *HelmReleaseSpecKubeConfig `pulumi:"kubeConfig"` + // MaxHistory is the number of revisions saved by Helm for this HelmRelease. + // Use '0' for an unlimited number of revisions; defaults to '5'. + MaxHistory *int `pulumi:"maxHistory"` + // PersistentClient tells the controller to use a persistent Kubernetes + // client for this release. When enabled, the client will be reused for the + // duration of the reconciliation, instead of being created and destroyed + // for each (step of a) Helm action. + // + // This can improve performance, but may cause issues with some Helm charts + // that for example do create Custom Resource Definitions during installation + // outside Helm's CRD lifecycle hooks, which are then not observed to be + // available by e.g. post-install hooks. + // + // If not set, it defaults to true. + PersistentClient *bool `pulumi:"persistentClient"` + // PostRenderers holds an array of Helm PostRenderers, which will be applied in order + // of their definition. + PostRenderers []HelmReleaseSpecPostRenderers `pulumi:"postRenderers"` + // ReleaseName used for the Helm release. Defaults to a composition of + // '[TargetNamespace-]Name'. + ReleaseName *string `pulumi:"releaseName"` + Rollback *HelmReleaseSpecRollback `pulumi:"rollback"` + // The name of the Kubernetes service account to impersonate + // when reconciling this HelmRelease. + ServiceAccountName *string `pulumi:"serviceAccountName"` + // StorageNamespace used for the Helm storage. + // Defaults to the namespace of the HelmRelease. + StorageNamespace *string `pulumi:"storageNamespace"` + // Suspend tells the controller to suspend reconciliation for this HelmRelease, + // it does not apply to already started reconciliations. Defaults to false. + Suspend *bool `pulumi:"suspend"` + // TargetNamespace to target when performing operations for the HelmRelease. + // Defaults to the namespace of the HelmRelease. + TargetNamespace *string `pulumi:"targetNamespace"` + Test *HelmReleaseSpecTest `pulumi:"test"` + // Timeout is the time to wait for any individual Kubernetes operation (like Jobs + // for hooks) during the performance of a Helm action. Defaults to '5m0s'. + Timeout *string `pulumi:"timeout"` + Uninstall *HelmReleaseSpecUninstall `pulumi:"uninstall"` + Upgrade *HelmReleaseSpecUpgrade `pulumi:"upgrade"` + // Values holds the values for this Helm release. + Values map[string]interface{} `pulumi:"values"` + // ValuesFrom holds references to resources containing Helm values for this HelmRelease, + // and information about how they should be merged. + ValuesFrom []HelmReleaseSpecValuesFrom `pulumi:"valuesFrom"` + WaitStrategy *HelmReleaseSpecWaitStrategy `pulumi:"waitStrategy"` +} + +// HelmReleaseSpecInput is an input type that accepts HelmReleaseSpecArgs and HelmReleaseSpecOutput values. +// You can construct a concrete instance of `HelmReleaseSpecInput` via: +// +// HelmReleaseSpecArgs{...} +type HelmReleaseSpecInput interface { + pulumi.Input + + ToHelmReleaseSpecOutput() HelmReleaseSpecOutput + ToHelmReleaseSpecOutputWithContext(context.Context) HelmReleaseSpecOutput +} + +// HelmReleaseSpec defines the desired state of a Helm release. +type HelmReleaseSpecArgs struct { + Chart HelmReleaseSpecChartPtrInput `pulumi:"chart"` + ChartRef HelmReleaseSpecChartRefPtrInput `pulumi:"chartRef"` + CommonMetadata HelmReleaseSpecCommonMetadataPtrInput `pulumi:"commonMetadata"` + // DependsOn may contain a DependencyReference slice with + // references to HelmRelease resources that must be ready before this HelmRelease + // can be reconciled. + DependsOn HelmReleaseSpecDependsOnArrayInput `pulumi:"dependsOn"` + DriftDetection HelmReleaseSpecDriftDetectionPtrInput `pulumi:"driftDetection"` + // HealthCheckExprs is a list of healthcheck expressions for evaluating the + // health of custom resources using Common Expression Language (CEL). + // The expressions are evaluated only when the specific Helm action + // taking place has wait enabled, i.e. DisableWait is false, and the + // 'poller' WaitStrategy is used. + HealthCheckExprs HelmReleaseSpecHealthCheckExprsArrayInput `pulumi:"healthCheckExprs"` + Install HelmReleaseSpecInstallPtrInput `pulumi:"install"` + // Interval at which to reconcile the Helm release. + Interval pulumi.StringPtrInput `pulumi:"interval"` + KubeConfig HelmReleaseSpecKubeConfigPtrInput `pulumi:"kubeConfig"` + // MaxHistory is the number of revisions saved by Helm for this HelmRelease. + // Use '0' for an unlimited number of revisions; defaults to '5'. + MaxHistory pulumi.IntPtrInput `pulumi:"maxHistory"` + // PersistentClient tells the controller to use a persistent Kubernetes + // client for this release. When enabled, the client will be reused for the + // duration of the reconciliation, instead of being created and destroyed + // for each (step of a) Helm action. + // + // This can improve performance, but may cause issues with some Helm charts + // that for example do create Custom Resource Definitions during installation + // outside Helm's CRD lifecycle hooks, which are then not observed to be + // available by e.g. post-install hooks. + // + // If not set, it defaults to true. + PersistentClient pulumi.BoolPtrInput `pulumi:"persistentClient"` + // PostRenderers holds an array of Helm PostRenderers, which will be applied in order + // of their definition. + PostRenderers HelmReleaseSpecPostRenderersArrayInput `pulumi:"postRenderers"` + // ReleaseName used for the Helm release. Defaults to a composition of + // '[TargetNamespace-]Name'. + ReleaseName pulumi.StringPtrInput `pulumi:"releaseName"` + Rollback HelmReleaseSpecRollbackPtrInput `pulumi:"rollback"` + // The name of the Kubernetes service account to impersonate + // when reconciling this HelmRelease. + ServiceAccountName pulumi.StringPtrInput `pulumi:"serviceAccountName"` + // StorageNamespace used for the Helm storage. + // Defaults to the namespace of the HelmRelease. + StorageNamespace pulumi.StringPtrInput `pulumi:"storageNamespace"` + // Suspend tells the controller to suspend reconciliation for this HelmRelease, + // it does not apply to already started reconciliations. Defaults to false. + Suspend pulumi.BoolPtrInput `pulumi:"suspend"` + // TargetNamespace to target when performing operations for the HelmRelease. + // Defaults to the namespace of the HelmRelease. + TargetNamespace pulumi.StringPtrInput `pulumi:"targetNamespace"` + Test HelmReleaseSpecTestPtrInput `pulumi:"test"` + // Timeout is the time to wait for any individual Kubernetes operation (like Jobs + // for hooks) during the performance of a Helm action. Defaults to '5m0s'. + Timeout pulumi.StringPtrInput `pulumi:"timeout"` + Uninstall HelmReleaseSpecUninstallPtrInput `pulumi:"uninstall"` + Upgrade HelmReleaseSpecUpgradePtrInput `pulumi:"upgrade"` + // Values holds the values for this Helm release. + Values pulumi.MapInput `pulumi:"values"` + // ValuesFrom holds references to resources containing Helm values for this HelmRelease, + // and information about how they should be merged. + ValuesFrom HelmReleaseSpecValuesFromArrayInput `pulumi:"valuesFrom"` + WaitStrategy HelmReleaseSpecWaitStrategyPtrInput `pulumi:"waitStrategy"` +} + +func (HelmReleaseSpecArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpec)(nil)).Elem() +} + +func (i HelmReleaseSpecArgs) ToHelmReleaseSpecOutput() HelmReleaseSpecOutput { + return i.ToHelmReleaseSpecOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecArgs) ToHelmReleaseSpecOutputWithContext(ctx context.Context) HelmReleaseSpecOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecOutput) +} + +func (i HelmReleaseSpecArgs) ToHelmReleaseSpecPtrOutput() HelmReleaseSpecPtrOutput { + return i.ToHelmReleaseSpecPtrOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecArgs) ToHelmReleaseSpecPtrOutputWithContext(ctx context.Context) HelmReleaseSpecPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecOutput).ToHelmReleaseSpecPtrOutputWithContext(ctx) +} + +// HelmReleaseSpecPtrInput is an input type that accepts HelmReleaseSpecArgs, HelmReleaseSpecPtr and HelmReleaseSpecPtrOutput values. +// You can construct a concrete instance of `HelmReleaseSpecPtrInput` via: +// +// HelmReleaseSpecArgs{...} +// +// or: +// +// nil +type HelmReleaseSpecPtrInput interface { + pulumi.Input + + ToHelmReleaseSpecPtrOutput() HelmReleaseSpecPtrOutput + ToHelmReleaseSpecPtrOutputWithContext(context.Context) HelmReleaseSpecPtrOutput +} + +type helmReleaseSpecPtrType HelmReleaseSpecArgs + +func HelmReleaseSpecPtr(v *HelmReleaseSpecArgs) HelmReleaseSpecPtrInput { + return (*helmReleaseSpecPtrType)(v) +} + +func (*helmReleaseSpecPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpec)(nil)).Elem() +} + +func (i *helmReleaseSpecPtrType) ToHelmReleaseSpecPtrOutput() HelmReleaseSpecPtrOutput { + return i.ToHelmReleaseSpecPtrOutputWithContext(context.Background()) +} + +func (i *helmReleaseSpecPtrType) ToHelmReleaseSpecPtrOutputWithContext(ctx context.Context) HelmReleaseSpecPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecPtrOutput) +} + +// HelmReleaseSpec defines the desired state of a Helm release. +type HelmReleaseSpecOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpec)(nil)).Elem() +} + +func (o HelmReleaseSpecOutput) ToHelmReleaseSpecOutput() HelmReleaseSpecOutput { + return o +} + +func (o HelmReleaseSpecOutput) ToHelmReleaseSpecOutputWithContext(ctx context.Context) HelmReleaseSpecOutput { + return o +} + +func (o HelmReleaseSpecOutput) ToHelmReleaseSpecPtrOutput() HelmReleaseSpecPtrOutput { + return o.ToHelmReleaseSpecPtrOutputWithContext(context.Background()) +} + +func (o HelmReleaseSpecOutput) ToHelmReleaseSpecPtrOutputWithContext(ctx context.Context) HelmReleaseSpecPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v HelmReleaseSpec) *HelmReleaseSpec { + return &v + }).(HelmReleaseSpecPtrOutput) +} + +func (o HelmReleaseSpecOutput) Chart() HelmReleaseSpecChartPtrOutput { + return o.ApplyT(func(v HelmReleaseSpec) *HelmReleaseSpecChart { return v.Chart }).(HelmReleaseSpecChartPtrOutput) +} + +func (o HelmReleaseSpecOutput) ChartRef() HelmReleaseSpecChartRefPtrOutput { + return o.ApplyT(func(v HelmReleaseSpec) *HelmReleaseSpecChartRef { return v.ChartRef }).(HelmReleaseSpecChartRefPtrOutput) +} + +func (o HelmReleaseSpecOutput) CommonMetadata() HelmReleaseSpecCommonMetadataPtrOutput { + return o.ApplyT(func(v HelmReleaseSpec) *HelmReleaseSpecCommonMetadata { return v.CommonMetadata }).(HelmReleaseSpecCommonMetadataPtrOutput) +} + +// DependsOn may contain a DependencyReference slice with +// references to HelmRelease resources that must be ready before this HelmRelease +// can be reconciled. +func (o HelmReleaseSpecOutput) DependsOn() HelmReleaseSpecDependsOnArrayOutput { + return o.ApplyT(func(v HelmReleaseSpec) []HelmReleaseSpecDependsOn { return v.DependsOn }).(HelmReleaseSpecDependsOnArrayOutput) +} + +func (o HelmReleaseSpecOutput) DriftDetection() HelmReleaseSpecDriftDetectionPtrOutput { + return o.ApplyT(func(v HelmReleaseSpec) *HelmReleaseSpecDriftDetection { return v.DriftDetection }).(HelmReleaseSpecDriftDetectionPtrOutput) +} + +// HealthCheckExprs is a list of healthcheck expressions for evaluating the +// health of custom resources using Common Expression Language (CEL). +// The expressions are evaluated only when the specific Helm action +// taking place has wait enabled, i.e. DisableWait is false, and the +// 'poller' WaitStrategy is used. +func (o HelmReleaseSpecOutput) HealthCheckExprs() HelmReleaseSpecHealthCheckExprsArrayOutput { + return o.ApplyT(func(v HelmReleaseSpec) []HelmReleaseSpecHealthCheckExprs { return v.HealthCheckExprs }).(HelmReleaseSpecHealthCheckExprsArrayOutput) +} + +func (o HelmReleaseSpecOutput) Install() HelmReleaseSpecInstallPtrOutput { + return o.ApplyT(func(v HelmReleaseSpec) *HelmReleaseSpecInstall { return v.Install }).(HelmReleaseSpecInstallPtrOutput) +} + +// Interval at which to reconcile the Helm release. +func (o HelmReleaseSpecOutput) Interval() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpec) *string { return v.Interval }).(pulumi.StringPtrOutput) +} + +func (o HelmReleaseSpecOutput) KubeConfig() HelmReleaseSpecKubeConfigPtrOutput { + return o.ApplyT(func(v HelmReleaseSpec) *HelmReleaseSpecKubeConfig { return v.KubeConfig }).(HelmReleaseSpecKubeConfigPtrOutput) +} + +// MaxHistory is the number of revisions saved by Helm for this HelmRelease. +// Use '0' for an unlimited number of revisions; defaults to '5'. +func (o HelmReleaseSpecOutput) MaxHistory() pulumi.IntPtrOutput { + return o.ApplyT(func(v HelmReleaseSpec) *int { return v.MaxHistory }).(pulumi.IntPtrOutput) +} + +// PersistentClient tells the controller to use a persistent Kubernetes +// client for this release. When enabled, the client will be reused for the +// duration of the reconciliation, instead of being created and destroyed +// for each (step of a) Helm action. +// +// This can improve performance, but may cause issues with some Helm charts +// that for example do create Custom Resource Definitions during installation +// outside Helm's CRD lifecycle hooks, which are then not observed to be +// available by e.g. post-install hooks. +// +// If not set, it defaults to true. +func (o HelmReleaseSpecOutput) PersistentClient() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpec) *bool { return v.PersistentClient }).(pulumi.BoolPtrOutput) +} + +// PostRenderers holds an array of Helm PostRenderers, which will be applied in order +// of their definition. +func (o HelmReleaseSpecOutput) PostRenderers() HelmReleaseSpecPostRenderersArrayOutput { + return o.ApplyT(func(v HelmReleaseSpec) []HelmReleaseSpecPostRenderers { return v.PostRenderers }).(HelmReleaseSpecPostRenderersArrayOutput) +} + +// ReleaseName used for the Helm release. Defaults to a composition of +// '[TargetNamespace-]Name'. +func (o HelmReleaseSpecOutput) ReleaseName() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpec) *string { return v.ReleaseName }).(pulumi.StringPtrOutput) +} + +func (o HelmReleaseSpecOutput) Rollback() HelmReleaseSpecRollbackPtrOutput { + return o.ApplyT(func(v HelmReleaseSpec) *HelmReleaseSpecRollback { return v.Rollback }).(HelmReleaseSpecRollbackPtrOutput) +} + +// The name of the Kubernetes service account to impersonate +// when reconciling this HelmRelease. +func (o HelmReleaseSpecOutput) ServiceAccountName() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpec) *string { return v.ServiceAccountName }).(pulumi.StringPtrOutput) +} + +// StorageNamespace used for the Helm storage. +// Defaults to the namespace of the HelmRelease. +func (o HelmReleaseSpecOutput) StorageNamespace() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpec) *string { return v.StorageNamespace }).(pulumi.StringPtrOutput) +} + +// Suspend tells the controller to suspend reconciliation for this HelmRelease, +// it does not apply to already started reconciliations. Defaults to false. +func (o HelmReleaseSpecOutput) Suspend() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpec) *bool { return v.Suspend }).(pulumi.BoolPtrOutput) +} + +// TargetNamespace to target when performing operations for the HelmRelease. +// Defaults to the namespace of the HelmRelease. +func (o HelmReleaseSpecOutput) TargetNamespace() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpec) *string { return v.TargetNamespace }).(pulumi.StringPtrOutput) +} + +func (o HelmReleaseSpecOutput) Test() HelmReleaseSpecTestPtrOutput { + return o.ApplyT(func(v HelmReleaseSpec) *HelmReleaseSpecTest { return v.Test }).(HelmReleaseSpecTestPtrOutput) +} + +// Timeout is the time to wait for any individual Kubernetes operation (like Jobs +// for hooks) during the performance of a Helm action. Defaults to '5m0s'. +func (o HelmReleaseSpecOutput) Timeout() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpec) *string { return v.Timeout }).(pulumi.StringPtrOutput) +} + +func (o HelmReleaseSpecOutput) Uninstall() HelmReleaseSpecUninstallPtrOutput { + return o.ApplyT(func(v HelmReleaseSpec) *HelmReleaseSpecUninstall { return v.Uninstall }).(HelmReleaseSpecUninstallPtrOutput) +} + +func (o HelmReleaseSpecOutput) Upgrade() HelmReleaseSpecUpgradePtrOutput { + return o.ApplyT(func(v HelmReleaseSpec) *HelmReleaseSpecUpgrade { return v.Upgrade }).(HelmReleaseSpecUpgradePtrOutput) +} + +// Values holds the values for this Helm release. +func (o HelmReleaseSpecOutput) Values() pulumi.MapOutput { + return o.ApplyT(func(v HelmReleaseSpec) map[string]interface{} { return v.Values }).(pulumi.MapOutput) +} + +// ValuesFrom holds references to resources containing Helm values for this HelmRelease, +// and information about how they should be merged. +func (o HelmReleaseSpecOutput) ValuesFrom() HelmReleaseSpecValuesFromArrayOutput { + return o.ApplyT(func(v HelmReleaseSpec) []HelmReleaseSpecValuesFrom { return v.ValuesFrom }).(HelmReleaseSpecValuesFromArrayOutput) +} + +func (o HelmReleaseSpecOutput) WaitStrategy() HelmReleaseSpecWaitStrategyPtrOutput { + return o.ApplyT(func(v HelmReleaseSpec) *HelmReleaseSpecWaitStrategy { return v.WaitStrategy }).(HelmReleaseSpecWaitStrategyPtrOutput) +} + +type HelmReleaseSpecPtrOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpec)(nil)).Elem() +} + +func (o HelmReleaseSpecPtrOutput) ToHelmReleaseSpecPtrOutput() HelmReleaseSpecPtrOutput { + return o +} + +func (o HelmReleaseSpecPtrOutput) ToHelmReleaseSpecPtrOutputWithContext(ctx context.Context) HelmReleaseSpecPtrOutput { + return o +} + +func (o HelmReleaseSpecPtrOutput) Elem() HelmReleaseSpecOutput { + return o.ApplyT(func(v *HelmReleaseSpec) HelmReleaseSpec { + if v != nil { + return *v + } + var ret HelmReleaseSpec + return ret + }).(HelmReleaseSpecOutput) +} + +func (o HelmReleaseSpecPtrOutput) Chart() HelmReleaseSpecChartPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpec) *HelmReleaseSpecChart { + if v == nil { + return nil + } + return v.Chart + }).(HelmReleaseSpecChartPtrOutput) +} + +func (o HelmReleaseSpecPtrOutput) ChartRef() HelmReleaseSpecChartRefPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpec) *HelmReleaseSpecChartRef { + if v == nil { + return nil + } + return v.ChartRef + }).(HelmReleaseSpecChartRefPtrOutput) +} + +func (o HelmReleaseSpecPtrOutput) CommonMetadata() HelmReleaseSpecCommonMetadataPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpec) *HelmReleaseSpecCommonMetadata { + if v == nil { + return nil + } + return v.CommonMetadata + }).(HelmReleaseSpecCommonMetadataPtrOutput) +} + +// DependsOn may contain a DependencyReference slice with +// references to HelmRelease resources that must be ready before this HelmRelease +// can be reconciled. +func (o HelmReleaseSpecPtrOutput) DependsOn() HelmReleaseSpecDependsOnArrayOutput { + return o.ApplyT(func(v *HelmReleaseSpec) []HelmReleaseSpecDependsOn { + if v == nil { + return nil + } + return v.DependsOn + }).(HelmReleaseSpecDependsOnArrayOutput) +} + +func (o HelmReleaseSpecPtrOutput) DriftDetection() HelmReleaseSpecDriftDetectionPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpec) *HelmReleaseSpecDriftDetection { + if v == nil { + return nil + } + return v.DriftDetection + }).(HelmReleaseSpecDriftDetectionPtrOutput) +} + +// HealthCheckExprs is a list of healthcheck expressions for evaluating the +// health of custom resources using Common Expression Language (CEL). +// The expressions are evaluated only when the specific Helm action +// taking place has wait enabled, i.e. DisableWait is false, and the +// 'poller' WaitStrategy is used. +func (o HelmReleaseSpecPtrOutput) HealthCheckExprs() HelmReleaseSpecHealthCheckExprsArrayOutput { + return o.ApplyT(func(v *HelmReleaseSpec) []HelmReleaseSpecHealthCheckExprs { + if v == nil { + return nil + } + return v.HealthCheckExprs + }).(HelmReleaseSpecHealthCheckExprsArrayOutput) +} + +func (o HelmReleaseSpecPtrOutput) Install() HelmReleaseSpecInstallPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpec) *HelmReleaseSpecInstall { + if v == nil { + return nil + } + return v.Install + }).(HelmReleaseSpecInstallPtrOutput) +} + +// Interval at which to reconcile the Helm release. +func (o HelmReleaseSpecPtrOutput) Interval() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpec) *string { + if v == nil { + return nil + } + return v.Interval + }).(pulumi.StringPtrOutput) +} + +func (o HelmReleaseSpecPtrOutput) KubeConfig() HelmReleaseSpecKubeConfigPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpec) *HelmReleaseSpecKubeConfig { + if v == nil { + return nil + } + return v.KubeConfig + }).(HelmReleaseSpecKubeConfigPtrOutput) +} + +// MaxHistory is the number of revisions saved by Helm for this HelmRelease. +// Use '0' for an unlimited number of revisions; defaults to '5'. +func (o HelmReleaseSpecPtrOutput) MaxHistory() pulumi.IntPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpec) *int { + if v == nil { + return nil + } + return v.MaxHistory + }).(pulumi.IntPtrOutput) +} + +// PersistentClient tells the controller to use a persistent Kubernetes +// client for this release. When enabled, the client will be reused for the +// duration of the reconciliation, instead of being created and destroyed +// for each (step of a) Helm action. +// +// This can improve performance, but may cause issues with some Helm charts +// that for example do create Custom Resource Definitions during installation +// outside Helm's CRD lifecycle hooks, which are then not observed to be +// available by e.g. post-install hooks. +// +// If not set, it defaults to true. +func (o HelmReleaseSpecPtrOutput) PersistentClient() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpec) *bool { + if v == nil { + return nil + } + return v.PersistentClient + }).(pulumi.BoolPtrOutput) +} + +// PostRenderers holds an array of Helm PostRenderers, which will be applied in order +// of their definition. +func (o HelmReleaseSpecPtrOutput) PostRenderers() HelmReleaseSpecPostRenderersArrayOutput { + return o.ApplyT(func(v *HelmReleaseSpec) []HelmReleaseSpecPostRenderers { + if v == nil { + return nil + } + return v.PostRenderers + }).(HelmReleaseSpecPostRenderersArrayOutput) +} + +// ReleaseName used for the Helm release. Defaults to a composition of +// '[TargetNamespace-]Name'. +func (o HelmReleaseSpecPtrOutput) ReleaseName() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpec) *string { + if v == nil { + return nil + } + return v.ReleaseName + }).(pulumi.StringPtrOutput) +} + +func (o HelmReleaseSpecPtrOutput) Rollback() HelmReleaseSpecRollbackPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpec) *HelmReleaseSpecRollback { + if v == nil { + return nil + } + return v.Rollback + }).(HelmReleaseSpecRollbackPtrOutput) +} + +// The name of the Kubernetes service account to impersonate +// when reconciling this HelmRelease. +func (o HelmReleaseSpecPtrOutput) ServiceAccountName() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpec) *string { + if v == nil { + return nil + } + return v.ServiceAccountName + }).(pulumi.StringPtrOutput) +} + +// StorageNamespace used for the Helm storage. +// Defaults to the namespace of the HelmRelease. +func (o HelmReleaseSpecPtrOutput) StorageNamespace() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpec) *string { + if v == nil { + return nil + } + return v.StorageNamespace + }).(pulumi.StringPtrOutput) +} + +// Suspend tells the controller to suspend reconciliation for this HelmRelease, +// it does not apply to already started reconciliations. Defaults to false. +func (o HelmReleaseSpecPtrOutput) Suspend() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpec) *bool { + if v == nil { + return nil + } + return v.Suspend + }).(pulumi.BoolPtrOutput) +} + +// TargetNamespace to target when performing operations for the HelmRelease. +// Defaults to the namespace of the HelmRelease. +func (o HelmReleaseSpecPtrOutput) TargetNamespace() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpec) *string { + if v == nil { + return nil + } + return v.TargetNamespace + }).(pulumi.StringPtrOutput) +} + +func (o HelmReleaseSpecPtrOutput) Test() HelmReleaseSpecTestPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpec) *HelmReleaseSpecTest { + if v == nil { + return nil + } + return v.Test + }).(HelmReleaseSpecTestPtrOutput) +} + +// Timeout is the time to wait for any individual Kubernetes operation (like Jobs +// for hooks) during the performance of a Helm action. Defaults to '5m0s'. +func (o HelmReleaseSpecPtrOutput) Timeout() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpec) *string { + if v == nil { + return nil + } + return v.Timeout + }).(pulumi.StringPtrOutput) +} + +func (o HelmReleaseSpecPtrOutput) Uninstall() HelmReleaseSpecUninstallPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpec) *HelmReleaseSpecUninstall { + if v == nil { + return nil + } + return v.Uninstall + }).(HelmReleaseSpecUninstallPtrOutput) +} + +func (o HelmReleaseSpecPtrOutput) Upgrade() HelmReleaseSpecUpgradePtrOutput { + return o.ApplyT(func(v *HelmReleaseSpec) *HelmReleaseSpecUpgrade { + if v == nil { + return nil + } + return v.Upgrade + }).(HelmReleaseSpecUpgradePtrOutput) +} + +// Values holds the values for this Helm release. +func (o HelmReleaseSpecPtrOutput) Values() pulumi.MapOutput { + return o.ApplyT(func(v *HelmReleaseSpec) map[string]interface{} { + if v == nil { + return nil + } + return v.Values + }).(pulumi.MapOutput) +} + +// ValuesFrom holds references to resources containing Helm values for this HelmRelease, +// and information about how they should be merged. +func (o HelmReleaseSpecPtrOutput) ValuesFrom() HelmReleaseSpecValuesFromArrayOutput { + return o.ApplyT(func(v *HelmReleaseSpec) []HelmReleaseSpecValuesFrom { + if v == nil { + return nil + } + return v.ValuesFrom + }).(HelmReleaseSpecValuesFromArrayOutput) +} + +func (o HelmReleaseSpecPtrOutput) WaitStrategy() HelmReleaseSpecWaitStrategyPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpec) *HelmReleaseSpecWaitStrategy { + if v == nil { + return nil + } + return v.WaitStrategy + }).(HelmReleaseSpecWaitStrategyPtrOutput) +} + +// Chart defines the template of the v1.HelmChart that should be created +// for this HelmRelease. +type HelmReleaseSpecChart struct { + Metadata *HelmReleaseSpecChartMetadata `pulumi:"metadata"` + Spec *HelmReleaseSpecChartSpec `pulumi:"spec"` +} + +// HelmReleaseSpecChartInput is an input type that accepts HelmReleaseSpecChartArgs and HelmReleaseSpecChartOutput values. +// You can construct a concrete instance of `HelmReleaseSpecChartInput` via: +// +// HelmReleaseSpecChartArgs{...} +type HelmReleaseSpecChartInput interface { + pulumi.Input + + ToHelmReleaseSpecChartOutput() HelmReleaseSpecChartOutput + ToHelmReleaseSpecChartOutputWithContext(context.Context) HelmReleaseSpecChartOutput +} + +// Chart defines the template of the v1.HelmChart that should be created +// for this HelmRelease. +type HelmReleaseSpecChartArgs struct { + Metadata HelmReleaseSpecChartMetadataPtrInput `pulumi:"metadata"` + Spec HelmReleaseSpecChartSpecPtrInput `pulumi:"spec"` +} + +func (HelmReleaseSpecChartArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecChart)(nil)).Elem() +} + +func (i HelmReleaseSpecChartArgs) ToHelmReleaseSpecChartOutput() HelmReleaseSpecChartOutput { + return i.ToHelmReleaseSpecChartOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecChartArgs) ToHelmReleaseSpecChartOutputWithContext(ctx context.Context) HelmReleaseSpecChartOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecChartOutput) +} + +func (i HelmReleaseSpecChartArgs) ToHelmReleaseSpecChartPtrOutput() HelmReleaseSpecChartPtrOutput { + return i.ToHelmReleaseSpecChartPtrOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecChartArgs) ToHelmReleaseSpecChartPtrOutputWithContext(ctx context.Context) HelmReleaseSpecChartPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecChartOutput).ToHelmReleaseSpecChartPtrOutputWithContext(ctx) +} + +// HelmReleaseSpecChartPtrInput is an input type that accepts HelmReleaseSpecChartArgs, HelmReleaseSpecChartPtr and HelmReleaseSpecChartPtrOutput values. +// You can construct a concrete instance of `HelmReleaseSpecChartPtrInput` via: +// +// HelmReleaseSpecChartArgs{...} +// +// or: +// +// nil +type HelmReleaseSpecChartPtrInput interface { + pulumi.Input + + ToHelmReleaseSpecChartPtrOutput() HelmReleaseSpecChartPtrOutput + ToHelmReleaseSpecChartPtrOutputWithContext(context.Context) HelmReleaseSpecChartPtrOutput +} + +type helmReleaseSpecChartPtrType HelmReleaseSpecChartArgs + +func HelmReleaseSpecChartPtr(v *HelmReleaseSpecChartArgs) HelmReleaseSpecChartPtrInput { + return (*helmReleaseSpecChartPtrType)(v) +} + +func (*helmReleaseSpecChartPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecChart)(nil)).Elem() +} + +func (i *helmReleaseSpecChartPtrType) ToHelmReleaseSpecChartPtrOutput() HelmReleaseSpecChartPtrOutput { + return i.ToHelmReleaseSpecChartPtrOutputWithContext(context.Background()) +} + +func (i *helmReleaseSpecChartPtrType) ToHelmReleaseSpecChartPtrOutputWithContext(ctx context.Context) HelmReleaseSpecChartPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecChartPtrOutput) +} + +// Chart defines the template of the v1.HelmChart that should be created +// for this HelmRelease. +type HelmReleaseSpecChartOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecChartOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecChart)(nil)).Elem() +} + +func (o HelmReleaseSpecChartOutput) ToHelmReleaseSpecChartOutput() HelmReleaseSpecChartOutput { + return o +} + +func (o HelmReleaseSpecChartOutput) ToHelmReleaseSpecChartOutputWithContext(ctx context.Context) HelmReleaseSpecChartOutput { + return o +} + +func (o HelmReleaseSpecChartOutput) ToHelmReleaseSpecChartPtrOutput() HelmReleaseSpecChartPtrOutput { + return o.ToHelmReleaseSpecChartPtrOutputWithContext(context.Background()) +} + +func (o HelmReleaseSpecChartOutput) ToHelmReleaseSpecChartPtrOutputWithContext(ctx context.Context) HelmReleaseSpecChartPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v HelmReleaseSpecChart) *HelmReleaseSpecChart { + return &v + }).(HelmReleaseSpecChartPtrOutput) +} + +func (o HelmReleaseSpecChartOutput) Metadata() HelmReleaseSpecChartMetadataPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecChart) *HelmReleaseSpecChartMetadata { return v.Metadata }).(HelmReleaseSpecChartMetadataPtrOutput) +} + +func (o HelmReleaseSpecChartOutput) Spec() HelmReleaseSpecChartSpecPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecChart) *HelmReleaseSpecChartSpec { return v.Spec }).(HelmReleaseSpecChartSpecPtrOutput) +} + +type HelmReleaseSpecChartPtrOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecChartPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecChart)(nil)).Elem() +} + +func (o HelmReleaseSpecChartPtrOutput) ToHelmReleaseSpecChartPtrOutput() HelmReleaseSpecChartPtrOutput { + return o +} + +func (o HelmReleaseSpecChartPtrOutput) ToHelmReleaseSpecChartPtrOutputWithContext(ctx context.Context) HelmReleaseSpecChartPtrOutput { + return o +} + +func (o HelmReleaseSpecChartPtrOutput) Elem() HelmReleaseSpecChartOutput { + return o.ApplyT(func(v *HelmReleaseSpecChart) HelmReleaseSpecChart { + if v != nil { + return *v + } + var ret HelmReleaseSpecChart + return ret + }).(HelmReleaseSpecChartOutput) +} + +func (o HelmReleaseSpecChartPtrOutput) Metadata() HelmReleaseSpecChartMetadataPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecChart) *HelmReleaseSpecChartMetadata { + if v == nil { + return nil + } + return v.Metadata + }).(HelmReleaseSpecChartMetadataPtrOutput) +} + +func (o HelmReleaseSpecChartPtrOutput) Spec() HelmReleaseSpecChartSpecPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecChart) *HelmReleaseSpecChartSpec { + if v == nil { + return nil + } + return v.Spec + }).(HelmReleaseSpecChartSpecPtrOutput) +} + +// ObjectMeta holds the template for metadata like labels and annotations. +type HelmReleaseSpecChartMetadata struct { + // Annotations is an unstructured key value map stored with a resource that may be + // set by external tools to store and retrieve arbitrary metadata. They are not + // queryable and should be preserved when modifying objects. + // More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations/ + Annotations map[string]string `pulumi:"annotations"` + // Map of string keys and values that can be used to organize and categorize + // (scope and select) objects. + // More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/ + Labels map[string]string `pulumi:"labels"` +} + +// HelmReleaseSpecChartMetadataInput is an input type that accepts HelmReleaseSpecChartMetadataArgs and HelmReleaseSpecChartMetadataOutput values. +// You can construct a concrete instance of `HelmReleaseSpecChartMetadataInput` via: +// +// HelmReleaseSpecChartMetadataArgs{...} +type HelmReleaseSpecChartMetadataInput interface { + pulumi.Input + + ToHelmReleaseSpecChartMetadataOutput() HelmReleaseSpecChartMetadataOutput + ToHelmReleaseSpecChartMetadataOutputWithContext(context.Context) HelmReleaseSpecChartMetadataOutput +} + +// ObjectMeta holds the template for metadata like labels and annotations. +type HelmReleaseSpecChartMetadataArgs struct { + // Annotations is an unstructured key value map stored with a resource that may be + // set by external tools to store and retrieve arbitrary metadata. They are not + // queryable and should be preserved when modifying objects. + // More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations/ + Annotations pulumi.StringMapInput `pulumi:"annotations"` + // Map of string keys and values that can be used to organize and categorize + // (scope and select) objects. + // More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/ + Labels pulumi.StringMapInput `pulumi:"labels"` +} + +func (HelmReleaseSpecChartMetadataArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecChartMetadata)(nil)).Elem() +} + +func (i HelmReleaseSpecChartMetadataArgs) ToHelmReleaseSpecChartMetadataOutput() HelmReleaseSpecChartMetadataOutput { + return i.ToHelmReleaseSpecChartMetadataOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecChartMetadataArgs) ToHelmReleaseSpecChartMetadataOutputWithContext(ctx context.Context) HelmReleaseSpecChartMetadataOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecChartMetadataOutput) +} + +func (i HelmReleaseSpecChartMetadataArgs) ToHelmReleaseSpecChartMetadataPtrOutput() HelmReleaseSpecChartMetadataPtrOutput { + return i.ToHelmReleaseSpecChartMetadataPtrOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecChartMetadataArgs) ToHelmReleaseSpecChartMetadataPtrOutputWithContext(ctx context.Context) HelmReleaseSpecChartMetadataPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecChartMetadataOutput).ToHelmReleaseSpecChartMetadataPtrOutputWithContext(ctx) +} + +// HelmReleaseSpecChartMetadataPtrInput is an input type that accepts HelmReleaseSpecChartMetadataArgs, HelmReleaseSpecChartMetadataPtr and HelmReleaseSpecChartMetadataPtrOutput values. +// You can construct a concrete instance of `HelmReleaseSpecChartMetadataPtrInput` via: +// +// HelmReleaseSpecChartMetadataArgs{...} +// +// or: +// +// nil +type HelmReleaseSpecChartMetadataPtrInput interface { + pulumi.Input + + ToHelmReleaseSpecChartMetadataPtrOutput() HelmReleaseSpecChartMetadataPtrOutput + ToHelmReleaseSpecChartMetadataPtrOutputWithContext(context.Context) HelmReleaseSpecChartMetadataPtrOutput +} + +type helmReleaseSpecChartMetadataPtrType HelmReleaseSpecChartMetadataArgs + +func HelmReleaseSpecChartMetadataPtr(v *HelmReleaseSpecChartMetadataArgs) HelmReleaseSpecChartMetadataPtrInput { + return (*helmReleaseSpecChartMetadataPtrType)(v) +} + +func (*helmReleaseSpecChartMetadataPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecChartMetadata)(nil)).Elem() +} + +func (i *helmReleaseSpecChartMetadataPtrType) ToHelmReleaseSpecChartMetadataPtrOutput() HelmReleaseSpecChartMetadataPtrOutput { + return i.ToHelmReleaseSpecChartMetadataPtrOutputWithContext(context.Background()) +} + +func (i *helmReleaseSpecChartMetadataPtrType) ToHelmReleaseSpecChartMetadataPtrOutputWithContext(ctx context.Context) HelmReleaseSpecChartMetadataPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecChartMetadataPtrOutput) +} + +// ObjectMeta holds the template for metadata like labels and annotations. +type HelmReleaseSpecChartMetadataOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecChartMetadataOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecChartMetadata)(nil)).Elem() +} + +func (o HelmReleaseSpecChartMetadataOutput) ToHelmReleaseSpecChartMetadataOutput() HelmReleaseSpecChartMetadataOutput { + return o +} + +func (o HelmReleaseSpecChartMetadataOutput) ToHelmReleaseSpecChartMetadataOutputWithContext(ctx context.Context) HelmReleaseSpecChartMetadataOutput { + return o +} + +func (o HelmReleaseSpecChartMetadataOutput) ToHelmReleaseSpecChartMetadataPtrOutput() HelmReleaseSpecChartMetadataPtrOutput { + return o.ToHelmReleaseSpecChartMetadataPtrOutputWithContext(context.Background()) +} + +func (o HelmReleaseSpecChartMetadataOutput) ToHelmReleaseSpecChartMetadataPtrOutputWithContext(ctx context.Context) HelmReleaseSpecChartMetadataPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v HelmReleaseSpecChartMetadata) *HelmReleaseSpecChartMetadata { + return &v + }).(HelmReleaseSpecChartMetadataPtrOutput) +} + +// Annotations is an unstructured key value map stored with a resource that may be +// set by external tools to store and retrieve arbitrary metadata. They are not +// queryable and should be preserved when modifying objects. +// More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations/ +func (o HelmReleaseSpecChartMetadataOutput) Annotations() pulumi.StringMapOutput { + return o.ApplyT(func(v HelmReleaseSpecChartMetadata) map[string]string { return v.Annotations }).(pulumi.StringMapOutput) +} + +// Map of string keys and values that can be used to organize and categorize +// (scope and select) objects. +// More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/ +func (o HelmReleaseSpecChartMetadataOutput) Labels() pulumi.StringMapOutput { + return o.ApplyT(func(v HelmReleaseSpecChartMetadata) map[string]string { return v.Labels }).(pulumi.StringMapOutput) +} + +type HelmReleaseSpecChartMetadataPtrOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecChartMetadataPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecChartMetadata)(nil)).Elem() +} + +func (o HelmReleaseSpecChartMetadataPtrOutput) ToHelmReleaseSpecChartMetadataPtrOutput() HelmReleaseSpecChartMetadataPtrOutput { + return o +} + +func (o HelmReleaseSpecChartMetadataPtrOutput) ToHelmReleaseSpecChartMetadataPtrOutputWithContext(ctx context.Context) HelmReleaseSpecChartMetadataPtrOutput { + return o +} + +func (o HelmReleaseSpecChartMetadataPtrOutput) Elem() HelmReleaseSpecChartMetadataOutput { + return o.ApplyT(func(v *HelmReleaseSpecChartMetadata) HelmReleaseSpecChartMetadata { + if v != nil { + return *v + } + var ret HelmReleaseSpecChartMetadata + return ret + }).(HelmReleaseSpecChartMetadataOutput) +} + +// Annotations is an unstructured key value map stored with a resource that may be +// set by external tools to store and retrieve arbitrary metadata. They are not +// queryable and should be preserved when modifying objects. +// More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations/ +func (o HelmReleaseSpecChartMetadataPtrOutput) Annotations() pulumi.StringMapOutput { + return o.ApplyT(func(v *HelmReleaseSpecChartMetadata) map[string]string { + if v == nil { + return nil + } + return v.Annotations + }).(pulumi.StringMapOutput) +} + +// Map of string keys and values that can be used to organize and categorize +// (scope and select) objects. +// More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/ +func (o HelmReleaseSpecChartMetadataPtrOutput) Labels() pulumi.StringMapOutput { + return o.ApplyT(func(v *HelmReleaseSpecChartMetadata) map[string]string { + if v == nil { + return nil + } + return v.Labels + }).(pulumi.StringMapOutput) +} + +// ObjectMeta holds the template for metadata like labels and annotations. +type HelmReleaseSpecChartMetadataPatch struct { + // Annotations is an unstructured key value map stored with a resource that may be + // set by external tools to store and retrieve arbitrary metadata. They are not + // queryable and should be preserved when modifying objects. + // More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations/ + Annotations map[string]string `pulumi:"annotations"` + // Map of string keys and values that can be used to organize and categorize + // (scope and select) objects. + // More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/ + Labels map[string]string `pulumi:"labels"` +} + +// HelmReleaseSpecChartMetadataPatchInput is an input type that accepts HelmReleaseSpecChartMetadataPatchArgs and HelmReleaseSpecChartMetadataPatchOutput values. +// You can construct a concrete instance of `HelmReleaseSpecChartMetadataPatchInput` via: +// +// HelmReleaseSpecChartMetadataPatchArgs{...} +type HelmReleaseSpecChartMetadataPatchInput interface { + pulumi.Input + + ToHelmReleaseSpecChartMetadataPatchOutput() HelmReleaseSpecChartMetadataPatchOutput + ToHelmReleaseSpecChartMetadataPatchOutputWithContext(context.Context) HelmReleaseSpecChartMetadataPatchOutput +} + +// ObjectMeta holds the template for metadata like labels and annotations. +type HelmReleaseSpecChartMetadataPatchArgs struct { + // Annotations is an unstructured key value map stored with a resource that may be + // set by external tools to store and retrieve arbitrary metadata. They are not + // queryable and should be preserved when modifying objects. + // More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations/ + Annotations pulumi.StringMapInput `pulumi:"annotations"` + // Map of string keys and values that can be used to organize and categorize + // (scope and select) objects. + // More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/ + Labels pulumi.StringMapInput `pulumi:"labels"` +} + +func (HelmReleaseSpecChartMetadataPatchArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecChartMetadataPatch)(nil)).Elem() +} + +func (i HelmReleaseSpecChartMetadataPatchArgs) ToHelmReleaseSpecChartMetadataPatchOutput() HelmReleaseSpecChartMetadataPatchOutput { + return i.ToHelmReleaseSpecChartMetadataPatchOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecChartMetadataPatchArgs) ToHelmReleaseSpecChartMetadataPatchOutputWithContext(ctx context.Context) HelmReleaseSpecChartMetadataPatchOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecChartMetadataPatchOutput) +} + +func (i HelmReleaseSpecChartMetadataPatchArgs) ToHelmReleaseSpecChartMetadataPatchPtrOutput() HelmReleaseSpecChartMetadataPatchPtrOutput { + return i.ToHelmReleaseSpecChartMetadataPatchPtrOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecChartMetadataPatchArgs) ToHelmReleaseSpecChartMetadataPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecChartMetadataPatchPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecChartMetadataPatchOutput).ToHelmReleaseSpecChartMetadataPatchPtrOutputWithContext(ctx) +} + +// HelmReleaseSpecChartMetadataPatchPtrInput is an input type that accepts HelmReleaseSpecChartMetadataPatchArgs, HelmReleaseSpecChartMetadataPatchPtr and HelmReleaseSpecChartMetadataPatchPtrOutput values. +// You can construct a concrete instance of `HelmReleaseSpecChartMetadataPatchPtrInput` via: +// +// HelmReleaseSpecChartMetadataPatchArgs{...} +// +// or: +// +// nil +type HelmReleaseSpecChartMetadataPatchPtrInput interface { + pulumi.Input + + ToHelmReleaseSpecChartMetadataPatchPtrOutput() HelmReleaseSpecChartMetadataPatchPtrOutput + ToHelmReleaseSpecChartMetadataPatchPtrOutputWithContext(context.Context) HelmReleaseSpecChartMetadataPatchPtrOutput +} + +type helmReleaseSpecChartMetadataPatchPtrType HelmReleaseSpecChartMetadataPatchArgs + +func HelmReleaseSpecChartMetadataPatchPtr(v *HelmReleaseSpecChartMetadataPatchArgs) HelmReleaseSpecChartMetadataPatchPtrInput { + return (*helmReleaseSpecChartMetadataPatchPtrType)(v) +} + +func (*helmReleaseSpecChartMetadataPatchPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecChartMetadataPatch)(nil)).Elem() +} + +func (i *helmReleaseSpecChartMetadataPatchPtrType) ToHelmReleaseSpecChartMetadataPatchPtrOutput() HelmReleaseSpecChartMetadataPatchPtrOutput { + return i.ToHelmReleaseSpecChartMetadataPatchPtrOutputWithContext(context.Background()) +} + +func (i *helmReleaseSpecChartMetadataPatchPtrType) ToHelmReleaseSpecChartMetadataPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecChartMetadataPatchPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecChartMetadataPatchPtrOutput) +} + +// ObjectMeta holds the template for metadata like labels and annotations. +type HelmReleaseSpecChartMetadataPatchOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecChartMetadataPatchOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecChartMetadataPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecChartMetadataPatchOutput) ToHelmReleaseSpecChartMetadataPatchOutput() HelmReleaseSpecChartMetadataPatchOutput { + return o +} + +func (o HelmReleaseSpecChartMetadataPatchOutput) ToHelmReleaseSpecChartMetadataPatchOutputWithContext(ctx context.Context) HelmReleaseSpecChartMetadataPatchOutput { + return o +} + +func (o HelmReleaseSpecChartMetadataPatchOutput) ToHelmReleaseSpecChartMetadataPatchPtrOutput() HelmReleaseSpecChartMetadataPatchPtrOutput { + return o.ToHelmReleaseSpecChartMetadataPatchPtrOutputWithContext(context.Background()) +} + +func (o HelmReleaseSpecChartMetadataPatchOutput) ToHelmReleaseSpecChartMetadataPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecChartMetadataPatchPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v HelmReleaseSpecChartMetadataPatch) *HelmReleaseSpecChartMetadataPatch { + return &v + }).(HelmReleaseSpecChartMetadataPatchPtrOutput) +} + +// Annotations is an unstructured key value map stored with a resource that may be +// set by external tools to store and retrieve arbitrary metadata. They are not +// queryable and should be preserved when modifying objects. +// More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations/ +func (o HelmReleaseSpecChartMetadataPatchOutput) Annotations() pulumi.StringMapOutput { + return o.ApplyT(func(v HelmReleaseSpecChartMetadataPatch) map[string]string { return v.Annotations }).(pulumi.StringMapOutput) +} + +// Map of string keys and values that can be used to organize and categorize +// (scope and select) objects. +// More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/ +func (o HelmReleaseSpecChartMetadataPatchOutput) Labels() pulumi.StringMapOutput { + return o.ApplyT(func(v HelmReleaseSpecChartMetadataPatch) map[string]string { return v.Labels }).(pulumi.StringMapOutput) +} + +type HelmReleaseSpecChartMetadataPatchPtrOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecChartMetadataPatchPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecChartMetadataPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecChartMetadataPatchPtrOutput) ToHelmReleaseSpecChartMetadataPatchPtrOutput() HelmReleaseSpecChartMetadataPatchPtrOutput { + return o +} + +func (o HelmReleaseSpecChartMetadataPatchPtrOutput) ToHelmReleaseSpecChartMetadataPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecChartMetadataPatchPtrOutput { + return o +} + +func (o HelmReleaseSpecChartMetadataPatchPtrOutput) Elem() HelmReleaseSpecChartMetadataPatchOutput { + return o.ApplyT(func(v *HelmReleaseSpecChartMetadataPatch) HelmReleaseSpecChartMetadataPatch { + if v != nil { + return *v + } + var ret HelmReleaseSpecChartMetadataPatch + return ret + }).(HelmReleaseSpecChartMetadataPatchOutput) +} + +// Annotations is an unstructured key value map stored with a resource that may be +// set by external tools to store and retrieve arbitrary metadata. They are not +// queryable and should be preserved when modifying objects. +// More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations/ +func (o HelmReleaseSpecChartMetadataPatchPtrOutput) Annotations() pulumi.StringMapOutput { + return o.ApplyT(func(v *HelmReleaseSpecChartMetadataPatch) map[string]string { + if v == nil { + return nil + } + return v.Annotations + }).(pulumi.StringMapOutput) +} + +// Map of string keys and values that can be used to organize and categorize +// (scope and select) objects. +// More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/ +func (o HelmReleaseSpecChartMetadataPatchPtrOutput) Labels() pulumi.StringMapOutput { + return o.ApplyT(func(v *HelmReleaseSpecChartMetadataPatch) map[string]string { + if v == nil { + return nil + } + return v.Labels + }).(pulumi.StringMapOutput) +} + +// Chart defines the template of the v1.HelmChart that should be created +// for this HelmRelease. +type HelmReleaseSpecChartPatch struct { + Metadata *HelmReleaseSpecChartMetadataPatch `pulumi:"metadata"` + Spec *HelmReleaseSpecChartSpecPatch `pulumi:"spec"` +} + +// HelmReleaseSpecChartPatchInput is an input type that accepts HelmReleaseSpecChartPatchArgs and HelmReleaseSpecChartPatchOutput values. +// You can construct a concrete instance of `HelmReleaseSpecChartPatchInput` via: +// +// HelmReleaseSpecChartPatchArgs{...} +type HelmReleaseSpecChartPatchInput interface { + pulumi.Input + + ToHelmReleaseSpecChartPatchOutput() HelmReleaseSpecChartPatchOutput + ToHelmReleaseSpecChartPatchOutputWithContext(context.Context) HelmReleaseSpecChartPatchOutput +} + +// Chart defines the template of the v1.HelmChart that should be created +// for this HelmRelease. +type HelmReleaseSpecChartPatchArgs struct { + Metadata HelmReleaseSpecChartMetadataPatchPtrInput `pulumi:"metadata"` + Spec HelmReleaseSpecChartSpecPatchPtrInput `pulumi:"spec"` +} + +func (HelmReleaseSpecChartPatchArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecChartPatch)(nil)).Elem() +} + +func (i HelmReleaseSpecChartPatchArgs) ToHelmReleaseSpecChartPatchOutput() HelmReleaseSpecChartPatchOutput { + return i.ToHelmReleaseSpecChartPatchOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecChartPatchArgs) ToHelmReleaseSpecChartPatchOutputWithContext(ctx context.Context) HelmReleaseSpecChartPatchOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecChartPatchOutput) +} + +func (i HelmReleaseSpecChartPatchArgs) ToHelmReleaseSpecChartPatchPtrOutput() HelmReleaseSpecChartPatchPtrOutput { + return i.ToHelmReleaseSpecChartPatchPtrOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecChartPatchArgs) ToHelmReleaseSpecChartPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecChartPatchPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecChartPatchOutput).ToHelmReleaseSpecChartPatchPtrOutputWithContext(ctx) +} + +// HelmReleaseSpecChartPatchPtrInput is an input type that accepts HelmReleaseSpecChartPatchArgs, HelmReleaseSpecChartPatchPtr and HelmReleaseSpecChartPatchPtrOutput values. +// You can construct a concrete instance of `HelmReleaseSpecChartPatchPtrInput` via: +// +// HelmReleaseSpecChartPatchArgs{...} +// +// or: +// +// nil +type HelmReleaseSpecChartPatchPtrInput interface { + pulumi.Input + + ToHelmReleaseSpecChartPatchPtrOutput() HelmReleaseSpecChartPatchPtrOutput + ToHelmReleaseSpecChartPatchPtrOutputWithContext(context.Context) HelmReleaseSpecChartPatchPtrOutput +} + +type helmReleaseSpecChartPatchPtrType HelmReleaseSpecChartPatchArgs + +func HelmReleaseSpecChartPatchPtr(v *HelmReleaseSpecChartPatchArgs) HelmReleaseSpecChartPatchPtrInput { + return (*helmReleaseSpecChartPatchPtrType)(v) +} + +func (*helmReleaseSpecChartPatchPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecChartPatch)(nil)).Elem() +} + +func (i *helmReleaseSpecChartPatchPtrType) ToHelmReleaseSpecChartPatchPtrOutput() HelmReleaseSpecChartPatchPtrOutput { + return i.ToHelmReleaseSpecChartPatchPtrOutputWithContext(context.Background()) +} + +func (i *helmReleaseSpecChartPatchPtrType) ToHelmReleaseSpecChartPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecChartPatchPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecChartPatchPtrOutput) +} + +// Chart defines the template of the v1.HelmChart that should be created +// for this HelmRelease. +type HelmReleaseSpecChartPatchOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecChartPatchOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecChartPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecChartPatchOutput) ToHelmReleaseSpecChartPatchOutput() HelmReleaseSpecChartPatchOutput { + return o +} + +func (o HelmReleaseSpecChartPatchOutput) ToHelmReleaseSpecChartPatchOutputWithContext(ctx context.Context) HelmReleaseSpecChartPatchOutput { + return o +} + +func (o HelmReleaseSpecChartPatchOutput) ToHelmReleaseSpecChartPatchPtrOutput() HelmReleaseSpecChartPatchPtrOutput { + return o.ToHelmReleaseSpecChartPatchPtrOutputWithContext(context.Background()) +} + +func (o HelmReleaseSpecChartPatchOutput) ToHelmReleaseSpecChartPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecChartPatchPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v HelmReleaseSpecChartPatch) *HelmReleaseSpecChartPatch { + return &v + }).(HelmReleaseSpecChartPatchPtrOutput) +} + +func (o HelmReleaseSpecChartPatchOutput) Metadata() HelmReleaseSpecChartMetadataPatchPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecChartPatch) *HelmReleaseSpecChartMetadataPatch { return v.Metadata }).(HelmReleaseSpecChartMetadataPatchPtrOutput) +} + +func (o HelmReleaseSpecChartPatchOutput) Spec() HelmReleaseSpecChartSpecPatchPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecChartPatch) *HelmReleaseSpecChartSpecPatch { return v.Spec }).(HelmReleaseSpecChartSpecPatchPtrOutput) +} + +type HelmReleaseSpecChartPatchPtrOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecChartPatchPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecChartPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecChartPatchPtrOutput) ToHelmReleaseSpecChartPatchPtrOutput() HelmReleaseSpecChartPatchPtrOutput { + return o +} + +func (o HelmReleaseSpecChartPatchPtrOutput) ToHelmReleaseSpecChartPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecChartPatchPtrOutput { + return o +} + +func (o HelmReleaseSpecChartPatchPtrOutput) Elem() HelmReleaseSpecChartPatchOutput { + return o.ApplyT(func(v *HelmReleaseSpecChartPatch) HelmReleaseSpecChartPatch { + if v != nil { + return *v + } + var ret HelmReleaseSpecChartPatch + return ret + }).(HelmReleaseSpecChartPatchOutput) +} + +func (o HelmReleaseSpecChartPatchPtrOutput) Metadata() HelmReleaseSpecChartMetadataPatchPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecChartPatch) *HelmReleaseSpecChartMetadataPatch { + if v == nil { + return nil + } + return v.Metadata + }).(HelmReleaseSpecChartMetadataPatchPtrOutput) +} + +func (o HelmReleaseSpecChartPatchPtrOutput) Spec() HelmReleaseSpecChartSpecPatchPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecChartPatch) *HelmReleaseSpecChartSpecPatch { + if v == nil { + return nil + } + return v.Spec + }).(HelmReleaseSpecChartSpecPatchPtrOutput) +} + +// ChartRef holds a reference to a source controller resource containing the +// Helm chart artifact. +type HelmReleaseSpecChartRef struct { + // APIVersion of the referent. + ApiVersion *string `pulumi:"apiVersion"` + // Kind of the referent. + Kind *string `pulumi:"kind"` + // Name of the referent. + Name *string `pulumi:"name"` + // Namespace of the referent, defaults to the namespace of the Kubernetes + // resource object that contains the reference. + Namespace *string `pulumi:"namespace"` +} + +// HelmReleaseSpecChartRefInput is an input type that accepts HelmReleaseSpecChartRefArgs and HelmReleaseSpecChartRefOutput values. +// You can construct a concrete instance of `HelmReleaseSpecChartRefInput` via: +// +// HelmReleaseSpecChartRefArgs{...} +type HelmReleaseSpecChartRefInput interface { + pulumi.Input + + ToHelmReleaseSpecChartRefOutput() HelmReleaseSpecChartRefOutput + ToHelmReleaseSpecChartRefOutputWithContext(context.Context) HelmReleaseSpecChartRefOutput +} + +// ChartRef holds a reference to a source controller resource containing the +// Helm chart artifact. +type HelmReleaseSpecChartRefArgs struct { + // APIVersion of the referent. + ApiVersion pulumi.StringPtrInput `pulumi:"apiVersion"` + // Kind of the referent. + Kind pulumi.StringPtrInput `pulumi:"kind"` + // Name of the referent. + Name pulumi.StringPtrInput `pulumi:"name"` + // Namespace of the referent, defaults to the namespace of the Kubernetes + // resource object that contains the reference. + Namespace pulumi.StringPtrInput `pulumi:"namespace"` +} + +func (HelmReleaseSpecChartRefArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecChartRef)(nil)).Elem() +} + +func (i HelmReleaseSpecChartRefArgs) ToHelmReleaseSpecChartRefOutput() HelmReleaseSpecChartRefOutput { + return i.ToHelmReleaseSpecChartRefOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecChartRefArgs) ToHelmReleaseSpecChartRefOutputWithContext(ctx context.Context) HelmReleaseSpecChartRefOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecChartRefOutput) +} + +func (i HelmReleaseSpecChartRefArgs) ToHelmReleaseSpecChartRefPtrOutput() HelmReleaseSpecChartRefPtrOutput { + return i.ToHelmReleaseSpecChartRefPtrOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecChartRefArgs) ToHelmReleaseSpecChartRefPtrOutputWithContext(ctx context.Context) HelmReleaseSpecChartRefPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecChartRefOutput).ToHelmReleaseSpecChartRefPtrOutputWithContext(ctx) +} + +// HelmReleaseSpecChartRefPtrInput is an input type that accepts HelmReleaseSpecChartRefArgs, HelmReleaseSpecChartRefPtr and HelmReleaseSpecChartRefPtrOutput values. +// You can construct a concrete instance of `HelmReleaseSpecChartRefPtrInput` via: +// +// HelmReleaseSpecChartRefArgs{...} +// +// or: +// +// nil +type HelmReleaseSpecChartRefPtrInput interface { + pulumi.Input + + ToHelmReleaseSpecChartRefPtrOutput() HelmReleaseSpecChartRefPtrOutput + ToHelmReleaseSpecChartRefPtrOutputWithContext(context.Context) HelmReleaseSpecChartRefPtrOutput +} + +type helmReleaseSpecChartRefPtrType HelmReleaseSpecChartRefArgs + +func HelmReleaseSpecChartRefPtr(v *HelmReleaseSpecChartRefArgs) HelmReleaseSpecChartRefPtrInput { + return (*helmReleaseSpecChartRefPtrType)(v) +} + +func (*helmReleaseSpecChartRefPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecChartRef)(nil)).Elem() +} + +func (i *helmReleaseSpecChartRefPtrType) ToHelmReleaseSpecChartRefPtrOutput() HelmReleaseSpecChartRefPtrOutput { + return i.ToHelmReleaseSpecChartRefPtrOutputWithContext(context.Background()) +} + +func (i *helmReleaseSpecChartRefPtrType) ToHelmReleaseSpecChartRefPtrOutputWithContext(ctx context.Context) HelmReleaseSpecChartRefPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecChartRefPtrOutput) +} + +// ChartRef holds a reference to a source controller resource containing the +// Helm chart artifact. +type HelmReleaseSpecChartRefOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecChartRefOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecChartRef)(nil)).Elem() +} + +func (o HelmReleaseSpecChartRefOutput) ToHelmReleaseSpecChartRefOutput() HelmReleaseSpecChartRefOutput { + return o +} + +func (o HelmReleaseSpecChartRefOutput) ToHelmReleaseSpecChartRefOutputWithContext(ctx context.Context) HelmReleaseSpecChartRefOutput { + return o +} + +func (o HelmReleaseSpecChartRefOutput) ToHelmReleaseSpecChartRefPtrOutput() HelmReleaseSpecChartRefPtrOutput { + return o.ToHelmReleaseSpecChartRefPtrOutputWithContext(context.Background()) +} + +func (o HelmReleaseSpecChartRefOutput) ToHelmReleaseSpecChartRefPtrOutputWithContext(ctx context.Context) HelmReleaseSpecChartRefPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v HelmReleaseSpecChartRef) *HelmReleaseSpecChartRef { + return &v + }).(HelmReleaseSpecChartRefPtrOutput) +} + +// APIVersion of the referent. +func (o HelmReleaseSpecChartRefOutput) ApiVersion() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecChartRef) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) +} + +// Kind of the referent. +func (o HelmReleaseSpecChartRefOutput) Kind() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecChartRef) *string { return v.Kind }).(pulumi.StringPtrOutput) +} + +// Name of the referent. +func (o HelmReleaseSpecChartRefOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecChartRef) *string { return v.Name }).(pulumi.StringPtrOutput) +} + +// Namespace of the referent, defaults to the namespace of the Kubernetes +// resource object that contains the reference. +func (o HelmReleaseSpecChartRefOutput) Namespace() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecChartRef) *string { return v.Namespace }).(pulumi.StringPtrOutput) +} + +type HelmReleaseSpecChartRefPtrOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecChartRefPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecChartRef)(nil)).Elem() +} + +func (o HelmReleaseSpecChartRefPtrOutput) ToHelmReleaseSpecChartRefPtrOutput() HelmReleaseSpecChartRefPtrOutput { + return o +} + +func (o HelmReleaseSpecChartRefPtrOutput) ToHelmReleaseSpecChartRefPtrOutputWithContext(ctx context.Context) HelmReleaseSpecChartRefPtrOutput { + return o +} + +func (o HelmReleaseSpecChartRefPtrOutput) Elem() HelmReleaseSpecChartRefOutput { + return o.ApplyT(func(v *HelmReleaseSpecChartRef) HelmReleaseSpecChartRef { + if v != nil { + return *v + } + var ret HelmReleaseSpecChartRef + return ret + }).(HelmReleaseSpecChartRefOutput) +} + +// APIVersion of the referent. +func (o HelmReleaseSpecChartRefPtrOutput) ApiVersion() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecChartRef) *string { + if v == nil { + return nil + } + return v.ApiVersion + }).(pulumi.StringPtrOutput) +} + +// Kind of the referent. +func (o HelmReleaseSpecChartRefPtrOutput) Kind() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecChartRef) *string { + if v == nil { + return nil + } + return v.Kind + }).(pulumi.StringPtrOutput) +} + +// Name of the referent. +func (o HelmReleaseSpecChartRefPtrOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecChartRef) *string { + if v == nil { + return nil + } + return v.Name + }).(pulumi.StringPtrOutput) +} + +// Namespace of the referent, defaults to the namespace of the Kubernetes +// resource object that contains the reference. +func (o HelmReleaseSpecChartRefPtrOutput) Namespace() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecChartRef) *string { + if v == nil { + return nil + } + return v.Namespace + }).(pulumi.StringPtrOutput) +} + +// ChartRef holds a reference to a source controller resource containing the +// Helm chart artifact. +type HelmReleaseSpecChartRefPatch struct { + // APIVersion of the referent. + ApiVersion *string `pulumi:"apiVersion"` + // Kind of the referent. + Kind *string `pulumi:"kind"` + // Name of the referent. + Name *string `pulumi:"name"` + // Namespace of the referent, defaults to the namespace of the Kubernetes + // resource object that contains the reference. + Namespace *string `pulumi:"namespace"` +} + +// HelmReleaseSpecChartRefPatchInput is an input type that accepts HelmReleaseSpecChartRefPatchArgs and HelmReleaseSpecChartRefPatchOutput values. +// You can construct a concrete instance of `HelmReleaseSpecChartRefPatchInput` via: +// +// HelmReleaseSpecChartRefPatchArgs{...} +type HelmReleaseSpecChartRefPatchInput interface { + pulumi.Input + + ToHelmReleaseSpecChartRefPatchOutput() HelmReleaseSpecChartRefPatchOutput + ToHelmReleaseSpecChartRefPatchOutputWithContext(context.Context) HelmReleaseSpecChartRefPatchOutput +} + +// ChartRef holds a reference to a source controller resource containing the +// Helm chart artifact. +type HelmReleaseSpecChartRefPatchArgs struct { + // APIVersion of the referent. + ApiVersion pulumi.StringPtrInput `pulumi:"apiVersion"` + // Kind of the referent. + Kind pulumi.StringPtrInput `pulumi:"kind"` + // Name of the referent. + Name pulumi.StringPtrInput `pulumi:"name"` + // Namespace of the referent, defaults to the namespace of the Kubernetes + // resource object that contains the reference. + Namespace pulumi.StringPtrInput `pulumi:"namespace"` +} + +func (HelmReleaseSpecChartRefPatchArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecChartRefPatch)(nil)).Elem() +} + +func (i HelmReleaseSpecChartRefPatchArgs) ToHelmReleaseSpecChartRefPatchOutput() HelmReleaseSpecChartRefPatchOutput { + return i.ToHelmReleaseSpecChartRefPatchOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecChartRefPatchArgs) ToHelmReleaseSpecChartRefPatchOutputWithContext(ctx context.Context) HelmReleaseSpecChartRefPatchOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecChartRefPatchOutput) +} + +func (i HelmReleaseSpecChartRefPatchArgs) ToHelmReleaseSpecChartRefPatchPtrOutput() HelmReleaseSpecChartRefPatchPtrOutput { + return i.ToHelmReleaseSpecChartRefPatchPtrOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecChartRefPatchArgs) ToHelmReleaseSpecChartRefPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecChartRefPatchPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecChartRefPatchOutput).ToHelmReleaseSpecChartRefPatchPtrOutputWithContext(ctx) +} + +// HelmReleaseSpecChartRefPatchPtrInput is an input type that accepts HelmReleaseSpecChartRefPatchArgs, HelmReleaseSpecChartRefPatchPtr and HelmReleaseSpecChartRefPatchPtrOutput values. +// You can construct a concrete instance of `HelmReleaseSpecChartRefPatchPtrInput` via: +// +// HelmReleaseSpecChartRefPatchArgs{...} +// +// or: +// +// nil +type HelmReleaseSpecChartRefPatchPtrInput interface { + pulumi.Input + + ToHelmReleaseSpecChartRefPatchPtrOutput() HelmReleaseSpecChartRefPatchPtrOutput + ToHelmReleaseSpecChartRefPatchPtrOutputWithContext(context.Context) HelmReleaseSpecChartRefPatchPtrOutput +} + +type helmReleaseSpecChartRefPatchPtrType HelmReleaseSpecChartRefPatchArgs + +func HelmReleaseSpecChartRefPatchPtr(v *HelmReleaseSpecChartRefPatchArgs) HelmReleaseSpecChartRefPatchPtrInput { + return (*helmReleaseSpecChartRefPatchPtrType)(v) +} + +func (*helmReleaseSpecChartRefPatchPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecChartRefPatch)(nil)).Elem() +} + +func (i *helmReleaseSpecChartRefPatchPtrType) ToHelmReleaseSpecChartRefPatchPtrOutput() HelmReleaseSpecChartRefPatchPtrOutput { + return i.ToHelmReleaseSpecChartRefPatchPtrOutputWithContext(context.Background()) +} + +func (i *helmReleaseSpecChartRefPatchPtrType) ToHelmReleaseSpecChartRefPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecChartRefPatchPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecChartRefPatchPtrOutput) +} + +// ChartRef holds a reference to a source controller resource containing the +// Helm chart artifact. +type HelmReleaseSpecChartRefPatchOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecChartRefPatchOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecChartRefPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecChartRefPatchOutput) ToHelmReleaseSpecChartRefPatchOutput() HelmReleaseSpecChartRefPatchOutput { + return o +} + +func (o HelmReleaseSpecChartRefPatchOutput) ToHelmReleaseSpecChartRefPatchOutputWithContext(ctx context.Context) HelmReleaseSpecChartRefPatchOutput { + return o +} + +func (o HelmReleaseSpecChartRefPatchOutput) ToHelmReleaseSpecChartRefPatchPtrOutput() HelmReleaseSpecChartRefPatchPtrOutput { + return o.ToHelmReleaseSpecChartRefPatchPtrOutputWithContext(context.Background()) +} + +func (o HelmReleaseSpecChartRefPatchOutput) ToHelmReleaseSpecChartRefPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecChartRefPatchPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v HelmReleaseSpecChartRefPatch) *HelmReleaseSpecChartRefPatch { + return &v + }).(HelmReleaseSpecChartRefPatchPtrOutput) +} + +// APIVersion of the referent. +func (o HelmReleaseSpecChartRefPatchOutput) ApiVersion() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecChartRefPatch) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) +} + +// Kind of the referent. +func (o HelmReleaseSpecChartRefPatchOutput) Kind() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecChartRefPatch) *string { return v.Kind }).(pulumi.StringPtrOutput) +} + +// Name of the referent. +func (o HelmReleaseSpecChartRefPatchOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecChartRefPatch) *string { return v.Name }).(pulumi.StringPtrOutput) +} + +// Namespace of the referent, defaults to the namespace of the Kubernetes +// resource object that contains the reference. +func (o HelmReleaseSpecChartRefPatchOutput) Namespace() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecChartRefPatch) *string { return v.Namespace }).(pulumi.StringPtrOutput) +} + +type HelmReleaseSpecChartRefPatchPtrOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecChartRefPatchPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecChartRefPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecChartRefPatchPtrOutput) ToHelmReleaseSpecChartRefPatchPtrOutput() HelmReleaseSpecChartRefPatchPtrOutput { + return o +} + +func (o HelmReleaseSpecChartRefPatchPtrOutput) ToHelmReleaseSpecChartRefPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecChartRefPatchPtrOutput { + return o +} + +func (o HelmReleaseSpecChartRefPatchPtrOutput) Elem() HelmReleaseSpecChartRefPatchOutput { + return o.ApplyT(func(v *HelmReleaseSpecChartRefPatch) HelmReleaseSpecChartRefPatch { + if v != nil { + return *v + } + var ret HelmReleaseSpecChartRefPatch + return ret + }).(HelmReleaseSpecChartRefPatchOutput) +} + +// APIVersion of the referent. +func (o HelmReleaseSpecChartRefPatchPtrOutput) ApiVersion() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecChartRefPatch) *string { + if v == nil { + return nil + } + return v.ApiVersion + }).(pulumi.StringPtrOutput) +} + +// Kind of the referent. +func (o HelmReleaseSpecChartRefPatchPtrOutput) Kind() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecChartRefPatch) *string { + if v == nil { + return nil + } + return v.Kind + }).(pulumi.StringPtrOutput) +} + +// Name of the referent. +func (o HelmReleaseSpecChartRefPatchPtrOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecChartRefPatch) *string { + if v == nil { + return nil + } + return v.Name + }).(pulumi.StringPtrOutput) +} + +// Namespace of the referent, defaults to the namespace of the Kubernetes +// resource object that contains the reference. +func (o HelmReleaseSpecChartRefPatchPtrOutput) Namespace() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecChartRefPatch) *string { + if v == nil { + return nil + } + return v.Namespace + }).(pulumi.StringPtrOutput) +} + +// Spec holds the template for the v1.HelmChartSpec for this HelmRelease. +type HelmReleaseSpecChartSpec struct { + // The name or path the Helm chart is available at in the SourceRef. + Chart *string `pulumi:"chart"` + // IgnoreMissingValuesFiles controls whether to silently ignore missing values files rather than failing. + IgnoreMissingValuesFiles *bool `pulumi:"ignoreMissingValuesFiles"` + // Interval at which to check the v1.Source for updates. Defaults to + // 'HelmReleaseSpec.Interval'. + Interval *string `pulumi:"interval"` + // Determines what enables the creation of a new artifact. Valid values are + // ('ChartVersion', 'Revision'). + // See the documentation of the values for an explanation on their behavior. + // Defaults to ChartVersion when omitted. + ReconcileStrategy *string `pulumi:"reconcileStrategy"` + SourceRef *HelmReleaseSpecChartSpecSourceRef `pulumi:"sourceRef"` + // Alternative list of values files to use as the chart values (values.yaml + // is not included by default), expected to be a relative path in the SourceRef. + // Values files are merged in the order of this list with the last file overriding + // the first. Ignored when omitted. + ValuesFiles []string `pulumi:"valuesFiles"` + Verify *HelmReleaseSpecChartSpecVerify `pulumi:"verify"` + // Version semver expression, ignored for charts from v1.GitRepository and + // v1beta2.Bucket sources. Defaults to latest when omitted. + Version *string `pulumi:"version"` +} + +// HelmReleaseSpecChartSpecInput is an input type that accepts HelmReleaseSpecChartSpecArgs and HelmReleaseSpecChartSpecOutput values. +// You can construct a concrete instance of `HelmReleaseSpecChartSpecInput` via: +// +// HelmReleaseSpecChartSpecArgs{...} +type HelmReleaseSpecChartSpecInput interface { + pulumi.Input + + ToHelmReleaseSpecChartSpecOutput() HelmReleaseSpecChartSpecOutput + ToHelmReleaseSpecChartSpecOutputWithContext(context.Context) HelmReleaseSpecChartSpecOutput +} + +// Spec holds the template for the v1.HelmChartSpec for this HelmRelease. +type HelmReleaseSpecChartSpecArgs struct { + // The name or path the Helm chart is available at in the SourceRef. + Chart pulumi.StringPtrInput `pulumi:"chart"` + // IgnoreMissingValuesFiles controls whether to silently ignore missing values files rather than failing. + IgnoreMissingValuesFiles pulumi.BoolPtrInput `pulumi:"ignoreMissingValuesFiles"` + // Interval at which to check the v1.Source for updates. Defaults to + // 'HelmReleaseSpec.Interval'. + Interval pulumi.StringPtrInput `pulumi:"interval"` + // Determines what enables the creation of a new artifact. Valid values are + // ('ChartVersion', 'Revision'). + // See the documentation of the values for an explanation on their behavior. + // Defaults to ChartVersion when omitted. + ReconcileStrategy pulumi.StringPtrInput `pulumi:"reconcileStrategy"` + SourceRef HelmReleaseSpecChartSpecSourceRefPtrInput `pulumi:"sourceRef"` + // Alternative list of values files to use as the chart values (values.yaml + // is not included by default), expected to be a relative path in the SourceRef. + // Values files are merged in the order of this list with the last file overriding + // the first. Ignored when omitted. + ValuesFiles pulumi.StringArrayInput `pulumi:"valuesFiles"` + Verify HelmReleaseSpecChartSpecVerifyPtrInput `pulumi:"verify"` + // Version semver expression, ignored for charts from v1.GitRepository and + // v1beta2.Bucket sources. Defaults to latest when omitted. + Version pulumi.StringPtrInput `pulumi:"version"` +} + +func (HelmReleaseSpecChartSpecArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecChartSpec)(nil)).Elem() +} + +func (i HelmReleaseSpecChartSpecArgs) ToHelmReleaseSpecChartSpecOutput() HelmReleaseSpecChartSpecOutput { + return i.ToHelmReleaseSpecChartSpecOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecChartSpecArgs) ToHelmReleaseSpecChartSpecOutputWithContext(ctx context.Context) HelmReleaseSpecChartSpecOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecChartSpecOutput) +} + +func (i HelmReleaseSpecChartSpecArgs) ToHelmReleaseSpecChartSpecPtrOutput() HelmReleaseSpecChartSpecPtrOutput { + return i.ToHelmReleaseSpecChartSpecPtrOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecChartSpecArgs) ToHelmReleaseSpecChartSpecPtrOutputWithContext(ctx context.Context) HelmReleaseSpecChartSpecPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecChartSpecOutput).ToHelmReleaseSpecChartSpecPtrOutputWithContext(ctx) +} + +// HelmReleaseSpecChartSpecPtrInput is an input type that accepts HelmReleaseSpecChartSpecArgs, HelmReleaseSpecChartSpecPtr and HelmReleaseSpecChartSpecPtrOutput values. +// You can construct a concrete instance of `HelmReleaseSpecChartSpecPtrInput` via: +// +// HelmReleaseSpecChartSpecArgs{...} +// +// or: +// +// nil +type HelmReleaseSpecChartSpecPtrInput interface { + pulumi.Input + + ToHelmReleaseSpecChartSpecPtrOutput() HelmReleaseSpecChartSpecPtrOutput + ToHelmReleaseSpecChartSpecPtrOutputWithContext(context.Context) HelmReleaseSpecChartSpecPtrOutput +} + +type helmReleaseSpecChartSpecPtrType HelmReleaseSpecChartSpecArgs + +func HelmReleaseSpecChartSpecPtr(v *HelmReleaseSpecChartSpecArgs) HelmReleaseSpecChartSpecPtrInput { + return (*helmReleaseSpecChartSpecPtrType)(v) +} + +func (*helmReleaseSpecChartSpecPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecChartSpec)(nil)).Elem() +} + +func (i *helmReleaseSpecChartSpecPtrType) ToHelmReleaseSpecChartSpecPtrOutput() HelmReleaseSpecChartSpecPtrOutput { + return i.ToHelmReleaseSpecChartSpecPtrOutputWithContext(context.Background()) +} + +func (i *helmReleaseSpecChartSpecPtrType) ToHelmReleaseSpecChartSpecPtrOutputWithContext(ctx context.Context) HelmReleaseSpecChartSpecPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecChartSpecPtrOutput) +} + +// Spec holds the template for the v1.HelmChartSpec for this HelmRelease. +type HelmReleaseSpecChartSpecOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecChartSpecOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecChartSpec)(nil)).Elem() +} + +func (o HelmReleaseSpecChartSpecOutput) ToHelmReleaseSpecChartSpecOutput() HelmReleaseSpecChartSpecOutput { + return o +} + +func (o HelmReleaseSpecChartSpecOutput) ToHelmReleaseSpecChartSpecOutputWithContext(ctx context.Context) HelmReleaseSpecChartSpecOutput { + return o +} + +func (o HelmReleaseSpecChartSpecOutput) ToHelmReleaseSpecChartSpecPtrOutput() HelmReleaseSpecChartSpecPtrOutput { + return o.ToHelmReleaseSpecChartSpecPtrOutputWithContext(context.Background()) +} + +func (o HelmReleaseSpecChartSpecOutput) ToHelmReleaseSpecChartSpecPtrOutputWithContext(ctx context.Context) HelmReleaseSpecChartSpecPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v HelmReleaseSpecChartSpec) *HelmReleaseSpecChartSpec { + return &v + }).(HelmReleaseSpecChartSpecPtrOutput) +} + +// The name or path the Helm chart is available at in the SourceRef. +func (o HelmReleaseSpecChartSpecOutput) Chart() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecChartSpec) *string { return v.Chart }).(pulumi.StringPtrOutput) +} + +// IgnoreMissingValuesFiles controls whether to silently ignore missing values files rather than failing. +func (o HelmReleaseSpecChartSpecOutput) IgnoreMissingValuesFiles() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecChartSpec) *bool { return v.IgnoreMissingValuesFiles }).(pulumi.BoolPtrOutput) +} + +// Interval at which to check the v1.Source for updates. Defaults to +// 'HelmReleaseSpec.Interval'. +func (o HelmReleaseSpecChartSpecOutput) Interval() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecChartSpec) *string { return v.Interval }).(pulumi.StringPtrOutput) +} + +// Determines what enables the creation of a new artifact. Valid values are +// ('ChartVersion', 'Revision'). +// See the documentation of the values for an explanation on their behavior. +// Defaults to ChartVersion when omitted. +func (o HelmReleaseSpecChartSpecOutput) ReconcileStrategy() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecChartSpec) *string { return v.ReconcileStrategy }).(pulumi.StringPtrOutput) +} + +func (o HelmReleaseSpecChartSpecOutput) SourceRef() HelmReleaseSpecChartSpecSourceRefPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecChartSpec) *HelmReleaseSpecChartSpecSourceRef { return v.SourceRef }).(HelmReleaseSpecChartSpecSourceRefPtrOutput) +} + +// Alternative list of values files to use as the chart values (values.yaml +// is not included by default), expected to be a relative path in the SourceRef. +// Values files are merged in the order of this list with the last file overriding +// the first. Ignored when omitted. +func (o HelmReleaseSpecChartSpecOutput) ValuesFiles() pulumi.StringArrayOutput { + return o.ApplyT(func(v HelmReleaseSpecChartSpec) []string { return v.ValuesFiles }).(pulumi.StringArrayOutput) +} + +func (o HelmReleaseSpecChartSpecOutput) Verify() HelmReleaseSpecChartSpecVerifyPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecChartSpec) *HelmReleaseSpecChartSpecVerify { return v.Verify }).(HelmReleaseSpecChartSpecVerifyPtrOutput) +} + +// Version semver expression, ignored for charts from v1.GitRepository and +// v1beta2.Bucket sources. Defaults to latest when omitted. +func (o HelmReleaseSpecChartSpecOutput) Version() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecChartSpec) *string { return v.Version }).(pulumi.StringPtrOutput) +} + +type HelmReleaseSpecChartSpecPtrOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecChartSpecPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecChartSpec)(nil)).Elem() +} + +func (o HelmReleaseSpecChartSpecPtrOutput) ToHelmReleaseSpecChartSpecPtrOutput() HelmReleaseSpecChartSpecPtrOutput { + return o +} + +func (o HelmReleaseSpecChartSpecPtrOutput) ToHelmReleaseSpecChartSpecPtrOutputWithContext(ctx context.Context) HelmReleaseSpecChartSpecPtrOutput { + return o +} + +func (o HelmReleaseSpecChartSpecPtrOutput) Elem() HelmReleaseSpecChartSpecOutput { + return o.ApplyT(func(v *HelmReleaseSpecChartSpec) HelmReleaseSpecChartSpec { + if v != nil { + return *v + } + var ret HelmReleaseSpecChartSpec + return ret + }).(HelmReleaseSpecChartSpecOutput) +} + +// The name or path the Helm chart is available at in the SourceRef. +func (o HelmReleaseSpecChartSpecPtrOutput) Chart() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecChartSpec) *string { + if v == nil { + return nil + } + return v.Chart + }).(pulumi.StringPtrOutput) +} + +// IgnoreMissingValuesFiles controls whether to silently ignore missing values files rather than failing. +func (o HelmReleaseSpecChartSpecPtrOutput) IgnoreMissingValuesFiles() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecChartSpec) *bool { + if v == nil { + return nil + } + return v.IgnoreMissingValuesFiles + }).(pulumi.BoolPtrOutput) +} + +// Interval at which to check the v1.Source for updates. Defaults to +// 'HelmReleaseSpec.Interval'. +func (o HelmReleaseSpecChartSpecPtrOutput) Interval() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecChartSpec) *string { + if v == nil { + return nil + } + return v.Interval + }).(pulumi.StringPtrOutput) +} + +// Determines what enables the creation of a new artifact. Valid values are +// ('ChartVersion', 'Revision'). +// See the documentation of the values for an explanation on their behavior. +// Defaults to ChartVersion when omitted. +func (o HelmReleaseSpecChartSpecPtrOutput) ReconcileStrategy() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecChartSpec) *string { + if v == nil { + return nil + } + return v.ReconcileStrategy + }).(pulumi.StringPtrOutput) +} + +func (o HelmReleaseSpecChartSpecPtrOutput) SourceRef() HelmReleaseSpecChartSpecSourceRefPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecChartSpec) *HelmReleaseSpecChartSpecSourceRef { + if v == nil { + return nil + } + return v.SourceRef + }).(HelmReleaseSpecChartSpecSourceRefPtrOutput) +} + +// Alternative list of values files to use as the chart values (values.yaml +// is not included by default), expected to be a relative path in the SourceRef. +// Values files are merged in the order of this list with the last file overriding +// the first. Ignored when omitted. +func (o HelmReleaseSpecChartSpecPtrOutput) ValuesFiles() pulumi.StringArrayOutput { + return o.ApplyT(func(v *HelmReleaseSpecChartSpec) []string { + if v == nil { + return nil + } + return v.ValuesFiles + }).(pulumi.StringArrayOutput) +} + +func (o HelmReleaseSpecChartSpecPtrOutput) Verify() HelmReleaseSpecChartSpecVerifyPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecChartSpec) *HelmReleaseSpecChartSpecVerify { + if v == nil { + return nil + } + return v.Verify + }).(HelmReleaseSpecChartSpecVerifyPtrOutput) +} + +// Version semver expression, ignored for charts from v1.GitRepository and +// v1beta2.Bucket sources. Defaults to latest when omitted. +func (o HelmReleaseSpecChartSpecPtrOutput) Version() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecChartSpec) *string { + if v == nil { + return nil + } + return v.Version + }).(pulumi.StringPtrOutput) +} + +// Spec holds the template for the v1.HelmChartSpec for this HelmRelease. +type HelmReleaseSpecChartSpecPatch struct { + // The name or path the Helm chart is available at in the SourceRef. + Chart *string `pulumi:"chart"` + // IgnoreMissingValuesFiles controls whether to silently ignore missing values files rather than failing. + IgnoreMissingValuesFiles *bool `pulumi:"ignoreMissingValuesFiles"` + // Interval at which to check the v1.Source for updates. Defaults to + // 'HelmReleaseSpec.Interval'. + Interval *string `pulumi:"interval"` + // Determines what enables the creation of a new artifact. Valid values are + // ('ChartVersion', 'Revision'). + // See the documentation of the values for an explanation on their behavior. + // Defaults to ChartVersion when omitted. + ReconcileStrategy *string `pulumi:"reconcileStrategy"` + SourceRef *HelmReleaseSpecChartSpecSourceRefPatch `pulumi:"sourceRef"` + // Alternative list of values files to use as the chart values (values.yaml + // is not included by default), expected to be a relative path in the SourceRef. + // Values files are merged in the order of this list with the last file overriding + // the first. Ignored when omitted. + ValuesFiles []string `pulumi:"valuesFiles"` + Verify *HelmReleaseSpecChartSpecVerifyPatch `pulumi:"verify"` + // Version semver expression, ignored for charts from v1.GitRepository and + // v1beta2.Bucket sources. Defaults to latest when omitted. + Version *string `pulumi:"version"` +} + +// HelmReleaseSpecChartSpecPatchInput is an input type that accepts HelmReleaseSpecChartSpecPatchArgs and HelmReleaseSpecChartSpecPatchOutput values. +// You can construct a concrete instance of `HelmReleaseSpecChartSpecPatchInput` via: +// +// HelmReleaseSpecChartSpecPatchArgs{...} +type HelmReleaseSpecChartSpecPatchInput interface { + pulumi.Input + + ToHelmReleaseSpecChartSpecPatchOutput() HelmReleaseSpecChartSpecPatchOutput + ToHelmReleaseSpecChartSpecPatchOutputWithContext(context.Context) HelmReleaseSpecChartSpecPatchOutput +} + +// Spec holds the template for the v1.HelmChartSpec for this HelmRelease. +type HelmReleaseSpecChartSpecPatchArgs struct { + // The name or path the Helm chart is available at in the SourceRef. + Chart pulumi.StringPtrInput `pulumi:"chart"` + // IgnoreMissingValuesFiles controls whether to silently ignore missing values files rather than failing. + IgnoreMissingValuesFiles pulumi.BoolPtrInput `pulumi:"ignoreMissingValuesFiles"` + // Interval at which to check the v1.Source for updates. Defaults to + // 'HelmReleaseSpec.Interval'. + Interval pulumi.StringPtrInput `pulumi:"interval"` + // Determines what enables the creation of a new artifact. Valid values are + // ('ChartVersion', 'Revision'). + // See the documentation of the values for an explanation on their behavior. + // Defaults to ChartVersion when omitted. + ReconcileStrategy pulumi.StringPtrInput `pulumi:"reconcileStrategy"` + SourceRef HelmReleaseSpecChartSpecSourceRefPatchPtrInput `pulumi:"sourceRef"` + // Alternative list of values files to use as the chart values (values.yaml + // is not included by default), expected to be a relative path in the SourceRef. + // Values files are merged in the order of this list with the last file overriding + // the first. Ignored when omitted. + ValuesFiles pulumi.StringArrayInput `pulumi:"valuesFiles"` + Verify HelmReleaseSpecChartSpecVerifyPatchPtrInput `pulumi:"verify"` + // Version semver expression, ignored for charts from v1.GitRepository and + // v1beta2.Bucket sources. Defaults to latest when omitted. + Version pulumi.StringPtrInput `pulumi:"version"` +} + +func (HelmReleaseSpecChartSpecPatchArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecChartSpecPatch)(nil)).Elem() +} + +func (i HelmReleaseSpecChartSpecPatchArgs) ToHelmReleaseSpecChartSpecPatchOutput() HelmReleaseSpecChartSpecPatchOutput { + return i.ToHelmReleaseSpecChartSpecPatchOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecChartSpecPatchArgs) ToHelmReleaseSpecChartSpecPatchOutputWithContext(ctx context.Context) HelmReleaseSpecChartSpecPatchOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecChartSpecPatchOutput) +} + +func (i HelmReleaseSpecChartSpecPatchArgs) ToHelmReleaseSpecChartSpecPatchPtrOutput() HelmReleaseSpecChartSpecPatchPtrOutput { + return i.ToHelmReleaseSpecChartSpecPatchPtrOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecChartSpecPatchArgs) ToHelmReleaseSpecChartSpecPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecChartSpecPatchPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecChartSpecPatchOutput).ToHelmReleaseSpecChartSpecPatchPtrOutputWithContext(ctx) +} + +// HelmReleaseSpecChartSpecPatchPtrInput is an input type that accepts HelmReleaseSpecChartSpecPatchArgs, HelmReleaseSpecChartSpecPatchPtr and HelmReleaseSpecChartSpecPatchPtrOutput values. +// You can construct a concrete instance of `HelmReleaseSpecChartSpecPatchPtrInput` via: +// +// HelmReleaseSpecChartSpecPatchArgs{...} +// +// or: +// +// nil +type HelmReleaseSpecChartSpecPatchPtrInput interface { + pulumi.Input + + ToHelmReleaseSpecChartSpecPatchPtrOutput() HelmReleaseSpecChartSpecPatchPtrOutput + ToHelmReleaseSpecChartSpecPatchPtrOutputWithContext(context.Context) HelmReleaseSpecChartSpecPatchPtrOutput +} + +type helmReleaseSpecChartSpecPatchPtrType HelmReleaseSpecChartSpecPatchArgs + +func HelmReleaseSpecChartSpecPatchPtr(v *HelmReleaseSpecChartSpecPatchArgs) HelmReleaseSpecChartSpecPatchPtrInput { + return (*helmReleaseSpecChartSpecPatchPtrType)(v) +} + +func (*helmReleaseSpecChartSpecPatchPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecChartSpecPatch)(nil)).Elem() +} + +func (i *helmReleaseSpecChartSpecPatchPtrType) ToHelmReleaseSpecChartSpecPatchPtrOutput() HelmReleaseSpecChartSpecPatchPtrOutput { + return i.ToHelmReleaseSpecChartSpecPatchPtrOutputWithContext(context.Background()) +} + +func (i *helmReleaseSpecChartSpecPatchPtrType) ToHelmReleaseSpecChartSpecPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecChartSpecPatchPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecChartSpecPatchPtrOutput) +} + +// Spec holds the template for the v1.HelmChartSpec for this HelmRelease. +type HelmReleaseSpecChartSpecPatchOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecChartSpecPatchOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecChartSpecPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecChartSpecPatchOutput) ToHelmReleaseSpecChartSpecPatchOutput() HelmReleaseSpecChartSpecPatchOutput { + return o +} + +func (o HelmReleaseSpecChartSpecPatchOutput) ToHelmReleaseSpecChartSpecPatchOutputWithContext(ctx context.Context) HelmReleaseSpecChartSpecPatchOutput { + return o +} + +func (o HelmReleaseSpecChartSpecPatchOutput) ToHelmReleaseSpecChartSpecPatchPtrOutput() HelmReleaseSpecChartSpecPatchPtrOutput { + return o.ToHelmReleaseSpecChartSpecPatchPtrOutputWithContext(context.Background()) +} + +func (o HelmReleaseSpecChartSpecPatchOutput) ToHelmReleaseSpecChartSpecPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecChartSpecPatchPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v HelmReleaseSpecChartSpecPatch) *HelmReleaseSpecChartSpecPatch { + return &v + }).(HelmReleaseSpecChartSpecPatchPtrOutput) +} + +// The name or path the Helm chart is available at in the SourceRef. +func (o HelmReleaseSpecChartSpecPatchOutput) Chart() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecChartSpecPatch) *string { return v.Chart }).(pulumi.StringPtrOutput) +} + +// IgnoreMissingValuesFiles controls whether to silently ignore missing values files rather than failing. +func (o HelmReleaseSpecChartSpecPatchOutput) IgnoreMissingValuesFiles() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecChartSpecPatch) *bool { return v.IgnoreMissingValuesFiles }).(pulumi.BoolPtrOutput) +} + +// Interval at which to check the v1.Source for updates. Defaults to +// 'HelmReleaseSpec.Interval'. +func (o HelmReleaseSpecChartSpecPatchOutput) Interval() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecChartSpecPatch) *string { return v.Interval }).(pulumi.StringPtrOutput) +} + +// Determines what enables the creation of a new artifact. Valid values are +// ('ChartVersion', 'Revision'). +// See the documentation of the values for an explanation on their behavior. +// Defaults to ChartVersion when omitted. +func (o HelmReleaseSpecChartSpecPatchOutput) ReconcileStrategy() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecChartSpecPatch) *string { return v.ReconcileStrategy }).(pulumi.StringPtrOutput) +} + +func (o HelmReleaseSpecChartSpecPatchOutput) SourceRef() HelmReleaseSpecChartSpecSourceRefPatchPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecChartSpecPatch) *HelmReleaseSpecChartSpecSourceRefPatch { return v.SourceRef }).(HelmReleaseSpecChartSpecSourceRefPatchPtrOutput) +} + +// Alternative list of values files to use as the chart values (values.yaml +// is not included by default), expected to be a relative path in the SourceRef. +// Values files are merged in the order of this list with the last file overriding +// the first. Ignored when omitted. +func (o HelmReleaseSpecChartSpecPatchOutput) ValuesFiles() pulumi.StringArrayOutput { + return o.ApplyT(func(v HelmReleaseSpecChartSpecPatch) []string { return v.ValuesFiles }).(pulumi.StringArrayOutput) +} + +func (o HelmReleaseSpecChartSpecPatchOutput) Verify() HelmReleaseSpecChartSpecVerifyPatchPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecChartSpecPatch) *HelmReleaseSpecChartSpecVerifyPatch { return v.Verify }).(HelmReleaseSpecChartSpecVerifyPatchPtrOutput) +} + +// Version semver expression, ignored for charts from v1.GitRepository and +// v1beta2.Bucket sources. Defaults to latest when omitted. +func (o HelmReleaseSpecChartSpecPatchOutput) Version() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecChartSpecPatch) *string { return v.Version }).(pulumi.StringPtrOutput) +} + +type HelmReleaseSpecChartSpecPatchPtrOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecChartSpecPatchPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecChartSpecPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecChartSpecPatchPtrOutput) ToHelmReleaseSpecChartSpecPatchPtrOutput() HelmReleaseSpecChartSpecPatchPtrOutput { + return o +} + +func (o HelmReleaseSpecChartSpecPatchPtrOutput) ToHelmReleaseSpecChartSpecPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecChartSpecPatchPtrOutput { + return o +} + +func (o HelmReleaseSpecChartSpecPatchPtrOutput) Elem() HelmReleaseSpecChartSpecPatchOutput { + return o.ApplyT(func(v *HelmReleaseSpecChartSpecPatch) HelmReleaseSpecChartSpecPatch { + if v != nil { + return *v + } + var ret HelmReleaseSpecChartSpecPatch + return ret + }).(HelmReleaseSpecChartSpecPatchOutput) +} + +// The name or path the Helm chart is available at in the SourceRef. +func (o HelmReleaseSpecChartSpecPatchPtrOutput) Chart() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecChartSpecPatch) *string { + if v == nil { + return nil + } + return v.Chart + }).(pulumi.StringPtrOutput) +} + +// IgnoreMissingValuesFiles controls whether to silently ignore missing values files rather than failing. +func (o HelmReleaseSpecChartSpecPatchPtrOutput) IgnoreMissingValuesFiles() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecChartSpecPatch) *bool { + if v == nil { + return nil + } + return v.IgnoreMissingValuesFiles + }).(pulumi.BoolPtrOutput) +} + +// Interval at which to check the v1.Source for updates. Defaults to +// 'HelmReleaseSpec.Interval'. +func (o HelmReleaseSpecChartSpecPatchPtrOutput) Interval() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecChartSpecPatch) *string { + if v == nil { + return nil + } + return v.Interval + }).(pulumi.StringPtrOutput) +} + +// Determines what enables the creation of a new artifact. Valid values are +// ('ChartVersion', 'Revision'). +// See the documentation of the values for an explanation on their behavior. +// Defaults to ChartVersion when omitted. +func (o HelmReleaseSpecChartSpecPatchPtrOutput) ReconcileStrategy() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecChartSpecPatch) *string { + if v == nil { + return nil + } + return v.ReconcileStrategy + }).(pulumi.StringPtrOutput) +} + +func (o HelmReleaseSpecChartSpecPatchPtrOutput) SourceRef() HelmReleaseSpecChartSpecSourceRefPatchPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecChartSpecPatch) *HelmReleaseSpecChartSpecSourceRefPatch { + if v == nil { + return nil + } + return v.SourceRef + }).(HelmReleaseSpecChartSpecSourceRefPatchPtrOutput) +} + +// Alternative list of values files to use as the chart values (values.yaml +// is not included by default), expected to be a relative path in the SourceRef. +// Values files are merged in the order of this list with the last file overriding +// the first. Ignored when omitted. +func (o HelmReleaseSpecChartSpecPatchPtrOutput) ValuesFiles() pulumi.StringArrayOutput { + return o.ApplyT(func(v *HelmReleaseSpecChartSpecPatch) []string { + if v == nil { + return nil + } + return v.ValuesFiles + }).(pulumi.StringArrayOutput) +} + +func (o HelmReleaseSpecChartSpecPatchPtrOutput) Verify() HelmReleaseSpecChartSpecVerifyPatchPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecChartSpecPatch) *HelmReleaseSpecChartSpecVerifyPatch { + if v == nil { + return nil + } + return v.Verify + }).(HelmReleaseSpecChartSpecVerifyPatchPtrOutput) +} + +// Version semver expression, ignored for charts from v1.GitRepository and +// v1beta2.Bucket sources. Defaults to latest when omitted. +func (o HelmReleaseSpecChartSpecPatchPtrOutput) Version() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecChartSpecPatch) *string { + if v == nil { + return nil + } + return v.Version + }).(pulumi.StringPtrOutput) +} + +// The name and namespace of the v1.Source the chart is available at. +type HelmReleaseSpecChartSpecSourceRef struct { + // APIVersion of the referent. + ApiVersion *string `pulumi:"apiVersion"` + // Kind of the referent. + Kind *string `pulumi:"kind"` + // Name of the referent. + Name *string `pulumi:"name"` + // Namespace of the referent. + Namespace *string `pulumi:"namespace"` +} + +// HelmReleaseSpecChartSpecSourceRefInput is an input type that accepts HelmReleaseSpecChartSpecSourceRefArgs and HelmReleaseSpecChartSpecSourceRefOutput values. +// You can construct a concrete instance of `HelmReleaseSpecChartSpecSourceRefInput` via: +// +// HelmReleaseSpecChartSpecSourceRefArgs{...} +type HelmReleaseSpecChartSpecSourceRefInput interface { + pulumi.Input + + ToHelmReleaseSpecChartSpecSourceRefOutput() HelmReleaseSpecChartSpecSourceRefOutput + ToHelmReleaseSpecChartSpecSourceRefOutputWithContext(context.Context) HelmReleaseSpecChartSpecSourceRefOutput +} + +// The name and namespace of the v1.Source the chart is available at. +type HelmReleaseSpecChartSpecSourceRefArgs struct { + // APIVersion of the referent. + ApiVersion pulumi.StringPtrInput `pulumi:"apiVersion"` + // Kind of the referent. + Kind pulumi.StringPtrInput `pulumi:"kind"` + // Name of the referent. + Name pulumi.StringPtrInput `pulumi:"name"` + // Namespace of the referent. + Namespace pulumi.StringPtrInput `pulumi:"namespace"` +} + +func (HelmReleaseSpecChartSpecSourceRefArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecChartSpecSourceRef)(nil)).Elem() +} + +func (i HelmReleaseSpecChartSpecSourceRefArgs) ToHelmReleaseSpecChartSpecSourceRefOutput() HelmReleaseSpecChartSpecSourceRefOutput { + return i.ToHelmReleaseSpecChartSpecSourceRefOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecChartSpecSourceRefArgs) ToHelmReleaseSpecChartSpecSourceRefOutputWithContext(ctx context.Context) HelmReleaseSpecChartSpecSourceRefOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecChartSpecSourceRefOutput) +} + +func (i HelmReleaseSpecChartSpecSourceRefArgs) ToHelmReleaseSpecChartSpecSourceRefPtrOutput() HelmReleaseSpecChartSpecSourceRefPtrOutput { + return i.ToHelmReleaseSpecChartSpecSourceRefPtrOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecChartSpecSourceRefArgs) ToHelmReleaseSpecChartSpecSourceRefPtrOutputWithContext(ctx context.Context) HelmReleaseSpecChartSpecSourceRefPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecChartSpecSourceRefOutput).ToHelmReleaseSpecChartSpecSourceRefPtrOutputWithContext(ctx) +} + +// HelmReleaseSpecChartSpecSourceRefPtrInput is an input type that accepts HelmReleaseSpecChartSpecSourceRefArgs, HelmReleaseSpecChartSpecSourceRefPtr and HelmReleaseSpecChartSpecSourceRefPtrOutput values. +// You can construct a concrete instance of `HelmReleaseSpecChartSpecSourceRefPtrInput` via: +// +// HelmReleaseSpecChartSpecSourceRefArgs{...} +// +// or: +// +// nil +type HelmReleaseSpecChartSpecSourceRefPtrInput interface { + pulumi.Input + + ToHelmReleaseSpecChartSpecSourceRefPtrOutput() HelmReleaseSpecChartSpecSourceRefPtrOutput + ToHelmReleaseSpecChartSpecSourceRefPtrOutputWithContext(context.Context) HelmReleaseSpecChartSpecSourceRefPtrOutput +} + +type helmReleaseSpecChartSpecSourceRefPtrType HelmReleaseSpecChartSpecSourceRefArgs + +func HelmReleaseSpecChartSpecSourceRefPtr(v *HelmReleaseSpecChartSpecSourceRefArgs) HelmReleaseSpecChartSpecSourceRefPtrInput { + return (*helmReleaseSpecChartSpecSourceRefPtrType)(v) +} + +func (*helmReleaseSpecChartSpecSourceRefPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecChartSpecSourceRef)(nil)).Elem() +} + +func (i *helmReleaseSpecChartSpecSourceRefPtrType) ToHelmReleaseSpecChartSpecSourceRefPtrOutput() HelmReleaseSpecChartSpecSourceRefPtrOutput { + return i.ToHelmReleaseSpecChartSpecSourceRefPtrOutputWithContext(context.Background()) +} + +func (i *helmReleaseSpecChartSpecSourceRefPtrType) ToHelmReleaseSpecChartSpecSourceRefPtrOutputWithContext(ctx context.Context) HelmReleaseSpecChartSpecSourceRefPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecChartSpecSourceRefPtrOutput) +} + +// The name and namespace of the v1.Source the chart is available at. +type HelmReleaseSpecChartSpecSourceRefOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecChartSpecSourceRefOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecChartSpecSourceRef)(nil)).Elem() +} + +func (o HelmReleaseSpecChartSpecSourceRefOutput) ToHelmReleaseSpecChartSpecSourceRefOutput() HelmReleaseSpecChartSpecSourceRefOutput { + return o +} + +func (o HelmReleaseSpecChartSpecSourceRefOutput) ToHelmReleaseSpecChartSpecSourceRefOutputWithContext(ctx context.Context) HelmReleaseSpecChartSpecSourceRefOutput { + return o +} + +func (o HelmReleaseSpecChartSpecSourceRefOutput) ToHelmReleaseSpecChartSpecSourceRefPtrOutput() HelmReleaseSpecChartSpecSourceRefPtrOutput { + return o.ToHelmReleaseSpecChartSpecSourceRefPtrOutputWithContext(context.Background()) +} + +func (o HelmReleaseSpecChartSpecSourceRefOutput) ToHelmReleaseSpecChartSpecSourceRefPtrOutputWithContext(ctx context.Context) HelmReleaseSpecChartSpecSourceRefPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v HelmReleaseSpecChartSpecSourceRef) *HelmReleaseSpecChartSpecSourceRef { + return &v + }).(HelmReleaseSpecChartSpecSourceRefPtrOutput) +} + +// APIVersion of the referent. +func (o HelmReleaseSpecChartSpecSourceRefOutput) ApiVersion() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecChartSpecSourceRef) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) +} + +// Kind of the referent. +func (o HelmReleaseSpecChartSpecSourceRefOutput) Kind() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecChartSpecSourceRef) *string { return v.Kind }).(pulumi.StringPtrOutput) +} + +// Name of the referent. +func (o HelmReleaseSpecChartSpecSourceRefOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecChartSpecSourceRef) *string { return v.Name }).(pulumi.StringPtrOutput) +} + +// Namespace of the referent. +func (o HelmReleaseSpecChartSpecSourceRefOutput) Namespace() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecChartSpecSourceRef) *string { return v.Namespace }).(pulumi.StringPtrOutput) +} + +type HelmReleaseSpecChartSpecSourceRefPtrOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecChartSpecSourceRefPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecChartSpecSourceRef)(nil)).Elem() +} + +func (o HelmReleaseSpecChartSpecSourceRefPtrOutput) ToHelmReleaseSpecChartSpecSourceRefPtrOutput() HelmReleaseSpecChartSpecSourceRefPtrOutput { + return o +} + +func (o HelmReleaseSpecChartSpecSourceRefPtrOutput) ToHelmReleaseSpecChartSpecSourceRefPtrOutputWithContext(ctx context.Context) HelmReleaseSpecChartSpecSourceRefPtrOutput { + return o +} + +func (o HelmReleaseSpecChartSpecSourceRefPtrOutput) Elem() HelmReleaseSpecChartSpecSourceRefOutput { + return o.ApplyT(func(v *HelmReleaseSpecChartSpecSourceRef) HelmReleaseSpecChartSpecSourceRef { + if v != nil { + return *v + } + var ret HelmReleaseSpecChartSpecSourceRef + return ret + }).(HelmReleaseSpecChartSpecSourceRefOutput) +} + +// APIVersion of the referent. +func (o HelmReleaseSpecChartSpecSourceRefPtrOutput) ApiVersion() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecChartSpecSourceRef) *string { + if v == nil { + return nil + } + return v.ApiVersion + }).(pulumi.StringPtrOutput) +} + +// Kind of the referent. +func (o HelmReleaseSpecChartSpecSourceRefPtrOutput) Kind() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecChartSpecSourceRef) *string { + if v == nil { + return nil + } + return v.Kind + }).(pulumi.StringPtrOutput) +} + +// Name of the referent. +func (o HelmReleaseSpecChartSpecSourceRefPtrOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecChartSpecSourceRef) *string { + if v == nil { + return nil + } + return v.Name + }).(pulumi.StringPtrOutput) +} + +// Namespace of the referent. +func (o HelmReleaseSpecChartSpecSourceRefPtrOutput) Namespace() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecChartSpecSourceRef) *string { + if v == nil { + return nil + } + return v.Namespace + }).(pulumi.StringPtrOutput) +} + +// The name and namespace of the v1.Source the chart is available at. +type HelmReleaseSpecChartSpecSourceRefPatch struct { + // APIVersion of the referent. + ApiVersion *string `pulumi:"apiVersion"` + // Kind of the referent. + Kind *string `pulumi:"kind"` + // Name of the referent. + Name *string `pulumi:"name"` + // Namespace of the referent. + Namespace *string `pulumi:"namespace"` +} + +// HelmReleaseSpecChartSpecSourceRefPatchInput is an input type that accepts HelmReleaseSpecChartSpecSourceRefPatchArgs and HelmReleaseSpecChartSpecSourceRefPatchOutput values. +// You can construct a concrete instance of `HelmReleaseSpecChartSpecSourceRefPatchInput` via: +// +// HelmReleaseSpecChartSpecSourceRefPatchArgs{...} +type HelmReleaseSpecChartSpecSourceRefPatchInput interface { + pulumi.Input + + ToHelmReleaseSpecChartSpecSourceRefPatchOutput() HelmReleaseSpecChartSpecSourceRefPatchOutput + ToHelmReleaseSpecChartSpecSourceRefPatchOutputWithContext(context.Context) HelmReleaseSpecChartSpecSourceRefPatchOutput +} + +// The name and namespace of the v1.Source the chart is available at. +type HelmReleaseSpecChartSpecSourceRefPatchArgs struct { + // APIVersion of the referent. + ApiVersion pulumi.StringPtrInput `pulumi:"apiVersion"` + // Kind of the referent. + Kind pulumi.StringPtrInput `pulumi:"kind"` + // Name of the referent. + Name pulumi.StringPtrInput `pulumi:"name"` + // Namespace of the referent. + Namespace pulumi.StringPtrInput `pulumi:"namespace"` +} + +func (HelmReleaseSpecChartSpecSourceRefPatchArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecChartSpecSourceRefPatch)(nil)).Elem() +} + +func (i HelmReleaseSpecChartSpecSourceRefPatchArgs) ToHelmReleaseSpecChartSpecSourceRefPatchOutput() HelmReleaseSpecChartSpecSourceRefPatchOutput { + return i.ToHelmReleaseSpecChartSpecSourceRefPatchOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecChartSpecSourceRefPatchArgs) ToHelmReleaseSpecChartSpecSourceRefPatchOutputWithContext(ctx context.Context) HelmReleaseSpecChartSpecSourceRefPatchOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecChartSpecSourceRefPatchOutput) +} + +func (i HelmReleaseSpecChartSpecSourceRefPatchArgs) ToHelmReleaseSpecChartSpecSourceRefPatchPtrOutput() HelmReleaseSpecChartSpecSourceRefPatchPtrOutput { + return i.ToHelmReleaseSpecChartSpecSourceRefPatchPtrOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecChartSpecSourceRefPatchArgs) ToHelmReleaseSpecChartSpecSourceRefPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecChartSpecSourceRefPatchPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecChartSpecSourceRefPatchOutput).ToHelmReleaseSpecChartSpecSourceRefPatchPtrOutputWithContext(ctx) +} + +// HelmReleaseSpecChartSpecSourceRefPatchPtrInput is an input type that accepts HelmReleaseSpecChartSpecSourceRefPatchArgs, HelmReleaseSpecChartSpecSourceRefPatchPtr and HelmReleaseSpecChartSpecSourceRefPatchPtrOutput values. +// You can construct a concrete instance of `HelmReleaseSpecChartSpecSourceRefPatchPtrInput` via: +// +// HelmReleaseSpecChartSpecSourceRefPatchArgs{...} +// +// or: +// +// nil +type HelmReleaseSpecChartSpecSourceRefPatchPtrInput interface { + pulumi.Input + + ToHelmReleaseSpecChartSpecSourceRefPatchPtrOutput() HelmReleaseSpecChartSpecSourceRefPatchPtrOutput + ToHelmReleaseSpecChartSpecSourceRefPatchPtrOutputWithContext(context.Context) HelmReleaseSpecChartSpecSourceRefPatchPtrOutput +} + +type helmReleaseSpecChartSpecSourceRefPatchPtrType HelmReleaseSpecChartSpecSourceRefPatchArgs + +func HelmReleaseSpecChartSpecSourceRefPatchPtr(v *HelmReleaseSpecChartSpecSourceRefPatchArgs) HelmReleaseSpecChartSpecSourceRefPatchPtrInput { + return (*helmReleaseSpecChartSpecSourceRefPatchPtrType)(v) +} + +func (*helmReleaseSpecChartSpecSourceRefPatchPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecChartSpecSourceRefPatch)(nil)).Elem() +} + +func (i *helmReleaseSpecChartSpecSourceRefPatchPtrType) ToHelmReleaseSpecChartSpecSourceRefPatchPtrOutput() HelmReleaseSpecChartSpecSourceRefPatchPtrOutput { + return i.ToHelmReleaseSpecChartSpecSourceRefPatchPtrOutputWithContext(context.Background()) +} + +func (i *helmReleaseSpecChartSpecSourceRefPatchPtrType) ToHelmReleaseSpecChartSpecSourceRefPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecChartSpecSourceRefPatchPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecChartSpecSourceRefPatchPtrOutput) +} + +// The name and namespace of the v1.Source the chart is available at. +type HelmReleaseSpecChartSpecSourceRefPatchOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecChartSpecSourceRefPatchOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecChartSpecSourceRefPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecChartSpecSourceRefPatchOutput) ToHelmReleaseSpecChartSpecSourceRefPatchOutput() HelmReleaseSpecChartSpecSourceRefPatchOutput { + return o +} + +func (o HelmReleaseSpecChartSpecSourceRefPatchOutput) ToHelmReleaseSpecChartSpecSourceRefPatchOutputWithContext(ctx context.Context) HelmReleaseSpecChartSpecSourceRefPatchOutput { + return o +} + +func (o HelmReleaseSpecChartSpecSourceRefPatchOutput) ToHelmReleaseSpecChartSpecSourceRefPatchPtrOutput() HelmReleaseSpecChartSpecSourceRefPatchPtrOutput { + return o.ToHelmReleaseSpecChartSpecSourceRefPatchPtrOutputWithContext(context.Background()) +} + +func (o HelmReleaseSpecChartSpecSourceRefPatchOutput) ToHelmReleaseSpecChartSpecSourceRefPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecChartSpecSourceRefPatchPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v HelmReleaseSpecChartSpecSourceRefPatch) *HelmReleaseSpecChartSpecSourceRefPatch { + return &v + }).(HelmReleaseSpecChartSpecSourceRefPatchPtrOutput) +} + +// APIVersion of the referent. +func (o HelmReleaseSpecChartSpecSourceRefPatchOutput) ApiVersion() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecChartSpecSourceRefPatch) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) +} + +// Kind of the referent. +func (o HelmReleaseSpecChartSpecSourceRefPatchOutput) Kind() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecChartSpecSourceRefPatch) *string { return v.Kind }).(pulumi.StringPtrOutput) +} + +// Name of the referent. +func (o HelmReleaseSpecChartSpecSourceRefPatchOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecChartSpecSourceRefPatch) *string { return v.Name }).(pulumi.StringPtrOutput) +} + +// Namespace of the referent. +func (o HelmReleaseSpecChartSpecSourceRefPatchOutput) Namespace() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecChartSpecSourceRefPatch) *string { return v.Namespace }).(pulumi.StringPtrOutput) +} + +type HelmReleaseSpecChartSpecSourceRefPatchPtrOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecChartSpecSourceRefPatchPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecChartSpecSourceRefPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecChartSpecSourceRefPatchPtrOutput) ToHelmReleaseSpecChartSpecSourceRefPatchPtrOutput() HelmReleaseSpecChartSpecSourceRefPatchPtrOutput { + return o +} + +func (o HelmReleaseSpecChartSpecSourceRefPatchPtrOutput) ToHelmReleaseSpecChartSpecSourceRefPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecChartSpecSourceRefPatchPtrOutput { + return o +} + +func (o HelmReleaseSpecChartSpecSourceRefPatchPtrOutput) Elem() HelmReleaseSpecChartSpecSourceRefPatchOutput { + return o.ApplyT(func(v *HelmReleaseSpecChartSpecSourceRefPatch) HelmReleaseSpecChartSpecSourceRefPatch { + if v != nil { + return *v + } + var ret HelmReleaseSpecChartSpecSourceRefPatch + return ret + }).(HelmReleaseSpecChartSpecSourceRefPatchOutput) +} + +// APIVersion of the referent. +func (o HelmReleaseSpecChartSpecSourceRefPatchPtrOutput) ApiVersion() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecChartSpecSourceRefPatch) *string { + if v == nil { + return nil + } + return v.ApiVersion + }).(pulumi.StringPtrOutput) +} + +// Kind of the referent. +func (o HelmReleaseSpecChartSpecSourceRefPatchPtrOutput) Kind() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecChartSpecSourceRefPatch) *string { + if v == nil { + return nil + } + return v.Kind + }).(pulumi.StringPtrOutput) +} + +// Name of the referent. +func (o HelmReleaseSpecChartSpecSourceRefPatchPtrOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecChartSpecSourceRefPatch) *string { + if v == nil { + return nil + } + return v.Name + }).(pulumi.StringPtrOutput) +} + +// Namespace of the referent. +func (o HelmReleaseSpecChartSpecSourceRefPatchPtrOutput) Namespace() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecChartSpecSourceRefPatch) *string { + if v == nil { + return nil + } + return v.Namespace + }).(pulumi.StringPtrOutput) +} + +// Verify contains the secret name containing the trusted public keys +// used to verify the signature and specifies which provider to use to check +// whether OCI image is authentic. +// This field is only supported for OCI sources. +// Chart dependencies, which are not bundled in the umbrella chart artifact, +// are not verified. +type HelmReleaseSpecChartSpecVerify struct { + // Provider specifies the technology used to sign the OCI Helm chart. + Provider *string `pulumi:"provider"` + SecretRef *HelmReleaseSpecChartSpecVerifySecretRef `pulumi:"secretRef"` +} + +// HelmReleaseSpecChartSpecVerifyInput is an input type that accepts HelmReleaseSpecChartSpecVerifyArgs and HelmReleaseSpecChartSpecVerifyOutput values. +// You can construct a concrete instance of `HelmReleaseSpecChartSpecVerifyInput` via: +// +// HelmReleaseSpecChartSpecVerifyArgs{...} +type HelmReleaseSpecChartSpecVerifyInput interface { + pulumi.Input + + ToHelmReleaseSpecChartSpecVerifyOutput() HelmReleaseSpecChartSpecVerifyOutput + ToHelmReleaseSpecChartSpecVerifyOutputWithContext(context.Context) HelmReleaseSpecChartSpecVerifyOutput +} + +// Verify contains the secret name containing the trusted public keys +// used to verify the signature and specifies which provider to use to check +// whether OCI image is authentic. +// This field is only supported for OCI sources. +// Chart dependencies, which are not bundled in the umbrella chart artifact, +// are not verified. +type HelmReleaseSpecChartSpecVerifyArgs struct { + // Provider specifies the technology used to sign the OCI Helm chart. + Provider pulumi.StringPtrInput `pulumi:"provider"` + SecretRef HelmReleaseSpecChartSpecVerifySecretRefPtrInput `pulumi:"secretRef"` +} + +func (HelmReleaseSpecChartSpecVerifyArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecChartSpecVerify)(nil)).Elem() +} + +func (i HelmReleaseSpecChartSpecVerifyArgs) ToHelmReleaseSpecChartSpecVerifyOutput() HelmReleaseSpecChartSpecVerifyOutput { + return i.ToHelmReleaseSpecChartSpecVerifyOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecChartSpecVerifyArgs) ToHelmReleaseSpecChartSpecVerifyOutputWithContext(ctx context.Context) HelmReleaseSpecChartSpecVerifyOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecChartSpecVerifyOutput) +} + +func (i HelmReleaseSpecChartSpecVerifyArgs) ToHelmReleaseSpecChartSpecVerifyPtrOutput() HelmReleaseSpecChartSpecVerifyPtrOutput { + return i.ToHelmReleaseSpecChartSpecVerifyPtrOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecChartSpecVerifyArgs) ToHelmReleaseSpecChartSpecVerifyPtrOutputWithContext(ctx context.Context) HelmReleaseSpecChartSpecVerifyPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecChartSpecVerifyOutput).ToHelmReleaseSpecChartSpecVerifyPtrOutputWithContext(ctx) +} + +// HelmReleaseSpecChartSpecVerifyPtrInput is an input type that accepts HelmReleaseSpecChartSpecVerifyArgs, HelmReleaseSpecChartSpecVerifyPtr and HelmReleaseSpecChartSpecVerifyPtrOutput values. +// You can construct a concrete instance of `HelmReleaseSpecChartSpecVerifyPtrInput` via: +// +// HelmReleaseSpecChartSpecVerifyArgs{...} +// +// or: +// +// nil +type HelmReleaseSpecChartSpecVerifyPtrInput interface { + pulumi.Input + + ToHelmReleaseSpecChartSpecVerifyPtrOutput() HelmReleaseSpecChartSpecVerifyPtrOutput + ToHelmReleaseSpecChartSpecVerifyPtrOutputWithContext(context.Context) HelmReleaseSpecChartSpecVerifyPtrOutput +} + +type helmReleaseSpecChartSpecVerifyPtrType HelmReleaseSpecChartSpecVerifyArgs + +func HelmReleaseSpecChartSpecVerifyPtr(v *HelmReleaseSpecChartSpecVerifyArgs) HelmReleaseSpecChartSpecVerifyPtrInput { + return (*helmReleaseSpecChartSpecVerifyPtrType)(v) +} + +func (*helmReleaseSpecChartSpecVerifyPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecChartSpecVerify)(nil)).Elem() +} + +func (i *helmReleaseSpecChartSpecVerifyPtrType) ToHelmReleaseSpecChartSpecVerifyPtrOutput() HelmReleaseSpecChartSpecVerifyPtrOutput { + return i.ToHelmReleaseSpecChartSpecVerifyPtrOutputWithContext(context.Background()) +} + +func (i *helmReleaseSpecChartSpecVerifyPtrType) ToHelmReleaseSpecChartSpecVerifyPtrOutputWithContext(ctx context.Context) HelmReleaseSpecChartSpecVerifyPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecChartSpecVerifyPtrOutput) +} + +// Verify contains the secret name containing the trusted public keys +// used to verify the signature and specifies which provider to use to check +// whether OCI image is authentic. +// This field is only supported for OCI sources. +// Chart dependencies, which are not bundled in the umbrella chart artifact, +// are not verified. +type HelmReleaseSpecChartSpecVerifyOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecChartSpecVerifyOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecChartSpecVerify)(nil)).Elem() +} + +func (o HelmReleaseSpecChartSpecVerifyOutput) ToHelmReleaseSpecChartSpecVerifyOutput() HelmReleaseSpecChartSpecVerifyOutput { + return o +} + +func (o HelmReleaseSpecChartSpecVerifyOutput) ToHelmReleaseSpecChartSpecVerifyOutputWithContext(ctx context.Context) HelmReleaseSpecChartSpecVerifyOutput { + return o +} + +func (o HelmReleaseSpecChartSpecVerifyOutput) ToHelmReleaseSpecChartSpecVerifyPtrOutput() HelmReleaseSpecChartSpecVerifyPtrOutput { + return o.ToHelmReleaseSpecChartSpecVerifyPtrOutputWithContext(context.Background()) +} + +func (o HelmReleaseSpecChartSpecVerifyOutput) ToHelmReleaseSpecChartSpecVerifyPtrOutputWithContext(ctx context.Context) HelmReleaseSpecChartSpecVerifyPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v HelmReleaseSpecChartSpecVerify) *HelmReleaseSpecChartSpecVerify { + return &v + }).(HelmReleaseSpecChartSpecVerifyPtrOutput) +} + +// Provider specifies the technology used to sign the OCI Helm chart. +func (o HelmReleaseSpecChartSpecVerifyOutput) Provider() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecChartSpecVerify) *string { return v.Provider }).(pulumi.StringPtrOutput) +} + +func (o HelmReleaseSpecChartSpecVerifyOutput) SecretRef() HelmReleaseSpecChartSpecVerifySecretRefPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecChartSpecVerify) *HelmReleaseSpecChartSpecVerifySecretRef { return v.SecretRef }).(HelmReleaseSpecChartSpecVerifySecretRefPtrOutput) +} + +type HelmReleaseSpecChartSpecVerifyPtrOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecChartSpecVerifyPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecChartSpecVerify)(nil)).Elem() +} + +func (o HelmReleaseSpecChartSpecVerifyPtrOutput) ToHelmReleaseSpecChartSpecVerifyPtrOutput() HelmReleaseSpecChartSpecVerifyPtrOutput { + return o +} + +func (o HelmReleaseSpecChartSpecVerifyPtrOutput) ToHelmReleaseSpecChartSpecVerifyPtrOutputWithContext(ctx context.Context) HelmReleaseSpecChartSpecVerifyPtrOutput { + return o +} + +func (o HelmReleaseSpecChartSpecVerifyPtrOutput) Elem() HelmReleaseSpecChartSpecVerifyOutput { + return o.ApplyT(func(v *HelmReleaseSpecChartSpecVerify) HelmReleaseSpecChartSpecVerify { + if v != nil { + return *v + } + var ret HelmReleaseSpecChartSpecVerify + return ret + }).(HelmReleaseSpecChartSpecVerifyOutput) +} + +// Provider specifies the technology used to sign the OCI Helm chart. +func (o HelmReleaseSpecChartSpecVerifyPtrOutput) Provider() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecChartSpecVerify) *string { + if v == nil { + return nil + } + return v.Provider + }).(pulumi.StringPtrOutput) +} + +func (o HelmReleaseSpecChartSpecVerifyPtrOutput) SecretRef() HelmReleaseSpecChartSpecVerifySecretRefPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecChartSpecVerify) *HelmReleaseSpecChartSpecVerifySecretRef { + if v == nil { + return nil + } + return v.SecretRef + }).(HelmReleaseSpecChartSpecVerifySecretRefPtrOutput) +} + +// Verify contains the secret name containing the trusted public keys +// used to verify the signature and specifies which provider to use to check +// whether OCI image is authentic. +// This field is only supported for OCI sources. +// Chart dependencies, which are not bundled in the umbrella chart artifact, +// are not verified. +type HelmReleaseSpecChartSpecVerifyPatch struct { + // Provider specifies the technology used to sign the OCI Helm chart. + Provider *string `pulumi:"provider"` + SecretRef *HelmReleaseSpecChartSpecVerifySecretRefPatch `pulumi:"secretRef"` +} + +// HelmReleaseSpecChartSpecVerifyPatchInput is an input type that accepts HelmReleaseSpecChartSpecVerifyPatchArgs and HelmReleaseSpecChartSpecVerifyPatchOutput values. +// You can construct a concrete instance of `HelmReleaseSpecChartSpecVerifyPatchInput` via: +// +// HelmReleaseSpecChartSpecVerifyPatchArgs{...} +type HelmReleaseSpecChartSpecVerifyPatchInput interface { + pulumi.Input + + ToHelmReleaseSpecChartSpecVerifyPatchOutput() HelmReleaseSpecChartSpecVerifyPatchOutput + ToHelmReleaseSpecChartSpecVerifyPatchOutputWithContext(context.Context) HelmReleaseSpecChartSpecVerifyPatchOutput +} + +// Verify contains the secret name containing the trusted public keys +// used to verify the signature and specifies which provider to use to check +// whether OCI image is authentic. +// This field is only supported for OCI sources. +// Chart dependencies, which are not bundled in the umbrella chart artifact, +// are not verified. +type HelmReleaseSpecChartSpecVerifyPatchArgs struct { + // Provider specifies the technology used to sign the OCI Helm chart. + Provider pulumi.StringPtrInput `pulumi:"provider"` + SecretRef HelmReleaseSpecChartSpecVerifySecretRefPatchPtrInput `pulumi:"secretRef"` +} + +func (HelmReleaseSpecChartSpecVerifyPatchArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecChartSpecVerifyPatch)(nil)).Elem() +} + +func (i HelmReleaseSpecChartSpecVerifyPatchArgs) ToHelmReleaseSpecChartSpecVerifyPatchOutput() HelmReleaseSpecChartSpecVerifyPatchOutput { + return i.ToHelmReleaseSpecChartSpecVerifyPatchOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecChartSpecVerifyPatchArgs) ToHelmReleaseSpecChartSpecVerifyPatchOutputWithContext(ctx context.Context) HelmReleaseSpecChartSpecVerifyPatchOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecChartSpecVerifyPatchOutput) +} + +func (i HelmReleaseSpecChartSpecVerifyPatchArgs) ToHelmReleaseSpecChartSpecVerifyPatchPtrOutput() HelmReleaseSpecChartSpecVerifyPatchPtrOutput { + return i.ToHelmReleaseSpecChartSpecVerifyPatchPtrOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecChartSpecVerifyPatchArgs) ToHelmReleaseSpecChartSpecVerifyPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecChartSpecVerifyPatchPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecChartSpecVerifyPatchOutput).ToHelmReleaseSpecChartSpecVerifyPatchPtrOutputWithContext(ctx) +} + +// HelmReleaseSpecChartSpecVerifyPatchPtrInput is an input type that accepts HelmReleaseSpecChartSpecVerifyPatchArgs, HelmReleaseSpecChartSpecVerifyPatchPtr and HelmReleaseSpecChartSpecVerifyPatchPtrOutput values. +// You can construct a concrete instance of `HelmReleaseSpecChartSpecVerifyPatchPtrInput` via: +// +// HelmReleaseSpecChartSpecVerifyPatchArgs{...} +// +// or: +// +// nil +type HelmReleaseSpecChartSpecVerifyPatchPtrInput interface { + pulumi.Input + + ToHelmReleaseSpecChartSpecVerifyPatchPtrOutput() HelmReleaseSpecChartSpecVerifyPatchPtrOutput + ToHelmReleaseSpecChartSpecVerifyPatchPtrOutputWithContext(context.Context) HelmReleaseSpecChartSpecVerifyPatchPtrOutput +} + +type helmReleaseSpecChartSpecVerifyPatchPtrType HelmReleaseSpecChartSpecVerifyPatchArgs + +func HelmReleaseSpecChartSpecVerifyPatchPtr(v *HelmReleaseSpecChartSpecVerifyPatchArgs) HelmReleaseSpecChartSpecVerifyPatchPtrInput { + return (*helmReleaseSpecChartSpecVerifyPatchPtrType)(v) +} + +func (*helmReleaseSpecChartSpecVerifyPatchPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecChartSpecVerifyPatch)(nil)).Elem() +} + +func (i *helmReleaseSpecChartSpecVerifyPatchPtrType) ToHelmReleaseSpecChartSpecVerifyPatchPtrOutput() HelmReleaseSpecChartSpecVerifyPatchPtrOutput { + return i.ToHelmReleaseSpecChartSpecVerifyPatchPtrOutputWithContext(context.Background()) +} + +func (i *helmReleaseSpecChartSpecVerifyPatchPtrType) ToHelmReleaseSpecChartSpecVerifyPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecChartSpecVerifyPatchPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecChartSpecVerifyPatchPtrOutput) +} + +// Verify contains the secret name containing the trusted public keys +// used to verify the signature and specifies which provider to use to check +// whether OCI image is authentic. +// This field is only supported for OCI sources. +// Chart dependencies, which are not bundled in the umbrella chart artifact, +// are not verified. +type HelmReleaseSpecChartSpecVerifyPatchOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecChartSpecVerifyPatchOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecChartSpecVerifyPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecChartSpecVerifyPatchOutput) ToHelmReleaseSpecChartSpecVerifyPatchOutput() HelmReleaseSpecChartSpecVerifyPatchOutput { + return o +} + +func (o HelmReleaseSpecChartSpecVerifyPatchOutput) ToHelmReleaseSpecChartSpecVerifyPatchOutputWithContext(ctx context.Context) HelmReleaseSpecChartSpecVerifyPatchOutput { + return o +} + +func (o HelmReleaseSpecChartSpecVerifyPatchOutput) ToHelmReleaseSpecChartSpecVerifyPatchPtrOutput() HelmReleaseSpecChartSpecVerifyPatchPtrOutput { + return o.ToHelmReleaseSpecChartSpecVerifyPatchPtrOutputWithContext(context.Background()) +} + +func (o HelmReleaseSpecChartSpecVerifyPatchOutput) ToHelmReleaseSpecChartSpecVerifyPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecChartSpecVerifyPatchPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v HelmReleaseSpecChartSpecVerifyPatch) *HelmReleaseSpecChartSpecVerifyPatch { + return &v + }).(HelmReleaseSpecChartSpecVerifyPatchPtrOutput) +} + +// Provider specifies the technology used to sign the OCI Helm chart. +func (o HelmReleaseSpecChartSpecVerifyPatchOutput) Provider() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecChartSpecVerifyPatch) *string { return v.Provider }).(pulumi.StringPtrOutput) +} + +func (o HelmReleaseSpecChartSpecVerifyPatchOutput) SecretRef() HelmReleaseSpecChartSpecVerifySecretRefPatchPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecChartSpecVerifyPatch) *HelmReleaseSpecChartSpecVerifySecretRefPatch { + return v.SecretRef + }).(HelmReleaseSpecChartSpecVerifySecretRefPatchPtrOutput) +} + +type HelmReleaseSpecChartSpecVerifyPatchPtrOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecChartSpecVerifyPatchPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecChartSpecVerifyPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecChartSpecVerifyPatchPtrOutput) ToHelmReleaseSpecChartSpecVerifyPatchPtrOutput() HelmReleaseSpecChartSpecVerifyPatchPtrOutput { + return o +} + +func (o HelmReleaseSpecChartSpecVerifyPatchPtrOutput) ToHelmReleaseSpecChartSpecVerifyPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecChartSpecVerifyPatchPtrOutput { + return o +} + +func (o HelmReleaseSpecChartSpecVerifyPatchPtrOutput) Elem() HelmReleaseSpecChartSpecVerifyPatchOutput { + return o.ApplyT(func(v *HelmReleaseSpecChartSpecVerifyPatch) HelmReleaseSpecChartSpecVerifyPatch { + if v != nil { + return *v + } + var ret HelmReleaseSpecChartSpecVerifyPatch + return ret + }).(HelmReleaseSpecChartSpecVerifyPatchOutput) +} + +// Provider specifies the technology used to sign the OCI Helm chart. +func (o HelmReleaseSpecChartSpecVerifyPatchPtrOutput) Provider() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecChartSpecVerifyPatch) *string { + if v == nil { + return nil + } + return v.Provider + }).(pulumi.StringPtrOutput) +} + +func (o HelmReleaseSpecChartSpecVerifyPatchPtrOutput) SecretRef() HelmReleaseSpecChartSpecVerifySecretRefPatchPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecChartSpecVerifyPatch) *HelmReleaseSpecChartSpecVerifySecretRefPatch { + if v == nil { + return nil + } + return v.SecretRef + }).(HelmReleaseSpecChartSpecVerifySecretRefPatchPtrOutput) +} + +// SecretRef specifies the Kubernetes Secret containing the +// trusted public keys. +type HelmReleaseSpecChartSpecVerifySecretRef struct { + // Name of the referent. + Name *string `pulumi:"name"` +} + +// HelmReleaseSpecChartSpecVerifySecretRefInput is an input type that accepts HelmReleaseSpecChartSpecVerifySecretRefArgs and HelmReleaseSpecChartSpecVerifySecretRefOutput values. +// You can construct a concrete instance of `HelmReleaseSpecChartSpecVerifySecretRefInput` via: +// +// HelmReleaseSpecChartSpecVerifySecretRefArgs{...} +type HelmReleaseSpecChartSpecVerifySecretRefInput interface { + pulumi.Input + + ToHelmReleaseSpecChartSpecVerifySecretRefOutput() HelmReleaseSpecChartSpecVerifySecretRefOutput + ToHelmReleaseSpecChartSpecVerifySecretRefOutputWithContext(context.Context) HelmReleaseSpecChartSpecVerifySecretRefOutput +} + +// SecretRef specifies the Kubernetes Secret containing the +// trusted public keys. +type HelmReleaseSpecChartSpecVerifySecretRefArgs struct { + // Name of the referent. + Name pulumi.StringPtrInput `pulumi:"name"` +} + +func (HelmReleaseSpecChartSpecVerifySecretRefArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecChartSpecVerifySecretRef)(nil)).Elem() +} + +func (i HelmReleaseSpecChartSpecVerifySecretRefArgs) ToHelmReleaseSpecChartSpecVerifySecretRefOutput() HelmReleaseSpecChartSpecVerifySecretRefOutput { + return i.ToHelmReleaseSpecChartSpecVerifySecretRefOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecChartSpecVerifySecretRefArgs) ToHelmReleaseSpecChartSpecVerifySecretRefOutputWithContext(ctx context.Context) HelmReleaseSpecChartSpecVerifySecretRefOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecChartSpecVerifySecretRefOutput) +} + +func (i HelmReleaseSpecChartSpecVerifySecretRefArgs) ToHelmReleaseSpecChartSpecVerifySecretRefPtrOutput() HelmReleaseSpecChartSpecVerifySecretRefPtrOutput { + return i.ToHelmReleaseSpecChartSpecVerifySecretRefPtrOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecChartSpecVerifySecretRefArgs) ToHelmReleaseSpecChartSpecVerifySecretRefPtrOutputWithContext(ctx context.Context) HelmReleaseSpecChartSpecVerifySecretRefPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecChartSpecVerifySecretRefOutput).ToHelmReleaseSpecChartSpecVerifySecretRefPtrOutputWithContext(ctx) +} + +// HelmReleaseSpecChartSpecVerifySecretRefPtrInput is an input type that accepts HelmReleaseSpecChartSpecVerifySecretRefArgs, HelmReleaseSpecChartSpecVerifySecretRefPtr and HelmReleaseSpecChartSpecVerifySecretRefPtrOutput values. +// You can construct a concrete instance of `HelmReleaseSpecChartSpecVerifySecretRefPtrInput` via: +// +// HelmReleaseSpecChartSpecVerifySecretRefArgs{...} +// +// or: +// +// nil +type HelmReleaseSpecChartSpecVerifySecretRefPtrInput interface { + pulumi.Input + + ToHelmReleaseSpecChartSpecVerifySecretRefPtrOutput() HelmReleaseSpecChartSpecVerifySecretRefPtrOutput + ToHelmReleaseSpecChartSpecVerifySecretRefPtrOutputWithContext(context.Context) HelmReleaseSpecChartSpecVerifySecretRefPtrOutput +} + +type helmReleaseSpecChartSpecVerifySecretRefPtrType HelmReleaseSpecChartSpecVerifySecretRefArgs + +func HelmReleaseSpecChartSpecVerifySecretRefPtr(v *HelmReleaseSpecChartSpecVerifySecretRefArgs) HelmReleaseSpecChartSpecVerifySecretRefPtrInput { + return (*helmReleaseSpecChartSpecVerifySecretRefPtrType)(v) +} + +func (*helmReleaseSpecChartSpecVerifySecretRefPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecChartSpecVerifySecretRef)(nil)).Elem() +} + +func (i *helmReleaseSpecChartSpecVerifySecretRefPtrType) ToHelmReleaseSpecChartSpecVerifySecretRefPtrOutput() HelmReleaseSpecChartSpecVerifySecretRefPtrOutput { + return i.ToHelmReleaseSpecChartSpecVerifySecretRefPtrOutputWithContext(context.Background()) +} + +func (i *helmReleaseSpecChartSpecVerifySecretRefPtrType) ToHelmReleaseSpecChartSpecVerifySecretRefPtrOutputWithContext(ctx context.Context) HelmReleaseSpecChartSpecVerifySecretRefPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecChartSpecVerifySecretRefPtrOutput) +} + +// SecretRef specifies the Kubernetes Secret containing the +// trusted public keys. +type HelmReleaseSpecChartSpecVerifySecretRefOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecChartSpecVerifySecretRefOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecChartSpecVerifySecretRef)(nil)).Elem() +} + +func (o HelmReleaseSpecChartSpecVerifySecretRefOutput) ToHelmReleaseSpecChartSpecVerifySecretRefOutput() HelmReleaseSpecChartSpecVerifySecretRefOutput { + return o +} + +func (o HelmReleaseSpecChartSpecVerifySecretRefOutput) ToHelmReleaseSpecChartSpecVerifySecretRefOutputWithContext(ctx context.Context) HelmReleaseSpecChartSpecVerifySecretRefOutput { + return o +} + +func (o HelmReleaseSpecChartSpecVerifySecretRefOutput) ToHelmReleaseSpecChartSpecVerifySecretRefPtrOutput() HelmReleaseSpecChartSpecVerifySecretRefPtrOutput { + return o.ToHelmReleaseSpecChartSpecVerifySecretRefPtrOutputWithContext(context.Background()) +} + +func (o HelmReleaseSpecChartSpecVerifySecretRefOutput) ToHelmReleaseSpecChartSpecVerifySecretRefPtrOutputWithContext(ctx context.Context) HelmReleaseSpecChartSpecVerifySecretRefPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v HelmReleaseSpecChartSpecVerifySecretRef) *HelmReleaseSpecChartSpecVerifySecretRef { + return &v + }).(HelmReleaseSpecChartSpecVerifySecretRefPtrOutput) +} + +// Name of the referent. +func (o HelmReleaseSpecChartSpecVerifySecretRefOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecChartSpecVerifySecretRef) *string { return v.Name }).(pulumi.StringPtrOutput) +} + +type HelmReleaseSpecChartSpecVerifySecretRefPtrOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecChartSpecVerifySecretRefPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecChartSpecVerifySecretRef)(nil)).Elem() +} + +func (o HelmReleaseSpecChartSpecVerifySecretRefPtrOutput) ToHelmReleaseSpecChartSpecVerifySecretRefPtrOutput() HelmReleaseSpecChartSpecVerifySecretRefPtrOutput { + return o +} + +func (o HelmReleaseSpecChartSpecVerifySecretRefPtrOutput) ToHelmReleaseSpecChartSpecVerifySecretRefPtrOutputWithContext(ctx context.Context) HelmReleaseSpecChartSpecVerifySecretRefPtrOutput { + return o +} + +func (o HelmReleaseSpecChartSpecVerifySecretRefPtrOutput) Elem() HelmReleaseSpecChartSpecVerifySecretRefOutput { + return o.ApplyT(func(v *HelmReleaseSpecChartSpecVerifySecretRef) HelmReleaseSpecChartSpecVerifySecretRef { + if v != nil { + return *v + } + var ret HelmReleaseSpecChartSpecVerifySecretRef + return ret + }).(HelmReleaseSpecChartSpecVerifySecretRefOutput) +} + +// Name of the referent. +func (o HelmReleaseSpecChartSpecVerifySecretRefPtrOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecChartSpecVerifySecretRef) *string { + if v == nil { + return nil + } + return v.Name + }).(pulumi.StringPtrOutput) +} + +// SecretRef specifies the Kubernetes Secret containing the +// trusted public keys. +type HelmReleaseSpecChartSpecVerifySecretRefPatch struct { + // Name of the referent. + Name *string `pulumi:"name"` +} + +// HelmReleaseSpecChartSpecVerifySecretRefPatchInput is an input type that accepts HelmReleaseSpecChartSpecVerifySecretRefPatchArgs and HelmReleaseSpecChartSpecVerifySecretRefPatchOutput values. +// You can construct a concrete instance of `HelmReleaseSpecChartSpecVerifySecretRefPatchInput` via: +// +// HelmReleaseSpecChartSpecVerifySecretRefPatchArgs{...} +type HelmReleaseSpecChartSpecVerifySecretRefPatchInput interface { + pulumi.Input + + ToHelmReleaseSpecChartSpecVerifySecretRefPatchOutput() HelmReleaseSpecChartSpecVerifySecretRefPatchOutput + ToHelmReleaseSpecChartSpecVerifySecretRefPatchOutputWithContext(context.Context) HelmReleaseSpecChartSpecVerifySecretRefPatchOutput +} + +// SecretRef specifies the Kubernetes Secret containing the +// trusted public keys. +type HelmReleaseSpecChartSpecVerifySecretRefPatchArgs struct { + // Name of the referent. + Name pulumi.StringPtrInput `pulumi:"name"` +} + +func (HelmReleaseSpecChartSpecVerifySecretRefPatchArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecChartSpecVerifySecretRefPatch)(nil)).Elem() +} + +func (i HelmReleaseSpecChartSpecVerifySecretRefPatchArgs) ToHelmReleaseSpecChartSpecVerifySecretRefPatchOutput() HelmReleaseSpecChartSpecVerifySecretRefPatchOutput { + return i.ToHelmReleaseSpecChartSpecVerifySecretRefPatchOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecChartSpecVerifySecretRefPatchArgs) ToHelmReleaseSpecChartSpecVerifySecretRefPatchOutputWithContext(ctx context.Context) HelmReleaseSpecChartSpecVerifySecretRefPatchOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecChartSpecVerifySecretRefPatchOutput) +} + +func (i HelmReleaseSpecChartSpecVerifySecretRefPatchArgs) ToHelmReleaseSpecChartSpecVerifySecretRefPatchPtrOutput() HelmReleaseSpecChartSpecVerifySecretRefPatchPtrOutput { + return i.ToHelmReleaseSpecChartSpecVerifySecretRefPatchPtrOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecChartSpecVerifySecretRefPatchArgs) ToHelmReleaseSpecChartSpecVerifySecretRefPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecChartSpecVerifySecretRefPatchPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecChartSpecVerifySecretRefPatchOutput).ToHelmReleaseSpecChartSpecVerifySecretRefPatchPtrOutputWithContext(ctx) +} + +// HelmReleaseSpecChartSpecVerifySecretRefPatchPtrInput is an input type that accepts HelmReleaseSpecChartSpecVerifySecretRefPatchArgs, HelmReleaseSpecChartSpecVerifySecretRefPatchPtr and HelmReleaseSpecChartSpecVerifySecretRefPatchPtrOutput values. +// You can construct a concrete instance of `HelmReleaseSpecChartSpecVerifySecretRefPatchPtrInput` via: +// +// HelmReleaseSpecChartSpecVerifySecretRefPatchArgs{...} +// +// or: +// +// nil +type HelmReleaseSpecChartSpecVerifySecretRefPatchPtrInput interface { + pulumi.Input + + ToHelmReleaseSpecChartSpecVerifySecretRefPatchPtrOutput() HelmReleaseSpecChartSpecVerifySecretRefPatchPtrOutput + ToHelmReleaseSpecChartSpecVerifySecretRefPatchPtrOutputWithContext(context.Context) HelmReleaseSpecChartSpecVerifySecretRefPatchPtrOutput +} + +type helmReleaseSpecChartSpecVerifySecretRefPatchPtrType HelmReleaseSpecChartSpecVerifySecretRefPatchArgs + +func HelmReleaseSpecChartSpecVerifySecretRefPatchPtr(v *HelmReleaseSpecChartSpecVerifySecretRefPatchArgs) HelmReleaseSpecChartSpecVerifySecretRefPatchPtrInput { + return (*helmReleaseSpecChartSpecVerifySecretRefPatchPtrType)(v) +} + +func (*helmReleaseSpecChartSpecVerifySecretRefPatchPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecChartSpecVerifySecretRefPatch)(nil)).Elem() +} + +func (i *helmReleaseSpecChartSpecVerifySecretRefPatchPtrType) ToHelmReleaseSpecChartSpecVerifySecretRefPatchPtrOutput() HelmReleaseSpecChartSpecVerifySecretRefPatchPtrOutput { + return i.ToHelmReleaseSpecChartSpecVerifySecretRefPatchPtrOutputWithContext(context.Background()) +} + +func (i *helmReleaseSpecChartSpecVerifySecretRefPatchPtrType) ToHelmReleaseSpecChartSpecVerifySecretRefPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecChartSpecVerifySecretRefPatchPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecChartSpecVerifySecretRefPatchPtrOutput) +} + +// SecretRef specifies the Kubernetes Secret containing the +// trusted public keys. +type HelmReleaseSpecChartSpecVerifySecretRefPatchOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecChartSpecVerifySecretRefPatchOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecChartSpecVerifySecretRefPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecChartSpecVerifySecretRefPatchOutput) ToHelmReleaseSpecChartSpecVerifySecretRefPatchOutput() HelmReleaseSpecChartSpecVerifySecretRefPatchOutput { + return o +} + +func (o HelmReleaseSpecChartSpecVerifySecretRefPatchOutput) ToHelmReleaseSpecChartSpecVerifySecretRefPatchOutputWithContext(ctx context.Context) HelmReleaseSpecChartSpecVerifySecretRefPatchOutput { + return o +} + +func (o HelmReleaseSpecChartSpecVerifySecretRefPatchOutput) ToHelmReleaseSpecChartSpecVerifySecretRefPatchPtrOutput() HelmReleaseSpecChartSpecVerifySecretRefPatchPtrOutput { + return o.ToHelmReleaseSpecChartSpecVerifySecretRefPatchPtrOutputWithContext(context.Background()) +} + +func (o HelmReleaseSpecChartSpecVerifySecretRefPatchOutput) ToHelmReleaseSpecChartSpecVerifySecretRefPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecChartSpecVerifySecretRefPatchPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v HelmReleaseSpecChartSpecVerifySecretRefPatch) *HelmReleaseSpecChartSpecVerifySecretRefPatch { + return &v + }).(HelmReleaseSpecChartSpecVerifySecretRefPatchPtrOutput) +} + +// Name of the referent. +func (o HelmReleaseSpecChartSpecVerifySecretRefPatchOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecChartSpecVerifySecretRefPatch) *string { return v.Name }).(pulumi.StringPtrOutput) +} + +type HelmReleaseSpecChartSpecVerifySecretRefPatchPtrOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecChartSpecVerifySecretRefPatchPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecChartSpecVerifySecretRefPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecChartSpecVerifySecretRefPatchPtrOutput) ToHelmReleaseSpecChartSpecVerifySecretRefPatchPtrOutput() HelmReleaseSpecChartSpecVerifySecretRefPatchPtrOutput { + return o +} + +func (o HelmReleaseSpecChartSpecVerifySecretRefPatchPtrOutput) ToHelmReleaseSpecChartSpecVerifySecretRefPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecChartSpecVerifySecretRefPatchPtrOutput { + return o +} + +func (o HelmReleaseSpecChartSpecVerifySecretRefPatchPtrOutput) Elem() HelmReleaseSpecChartSpecVerifySecretRefPatchOutput { + return o.ApplyT(func(v *HelmReleaseSpecChartSpecVerifySecretRefPatch) HelmReleaseSpecChartSpecVerifySecretRefPatch { + if v != nil { + return *v + } + var ret HelmReleaseSpecChartSpecVerifySecretRefPatch + return ret + }).(HelmReleaseSpecChartSpecVerifySecretRefPatchOutput) +} + +// Name of the referent. +func (o HelmReleaseSpecChartSpecVerifySecretRefPatchPtrOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecChartSpecVerifySecretRefPatch) *string { + if v == nil { + return nil + } + return v.Name + }).(pulumi.StringPtrOutput) +} + +// CommonMetadata specifies the common labels and annotations that are +// applied to all resources. Any existing label or annotation will be +// overridden if its key matches a common one. +type HelmReleaseSpecCommonMetadata struct { + // Annotations to be added to the object's metadata. + Annotations map[string]string `pulumi:"annotations"` + // Labels to be added to the object's metadata. + Labels map[string]string `pulumi:"labels"` +} + +// HelmReleaseSpecCommonMetadataInput is an input type that accepts HelmReleaseSpecCommonMetadataArgs and HelmReleaseSpecCommonMetadataOutput values. +// You can construct a concrete instance of `HelmReleaseSpecCommonMetadataInput` via: +// +// HelmReleaseSpecCommonMetadataArgs{...} +type HelmReleaseSpecCommonMetadataInput interface { + pulumi.Input + + ToHelmReleaseSpecCommonMetadataOutput() HelmReleaseSpecCommonMetadataOutput + ToHelmReleaseSpecCommonMetadataOutputWithContext(context.Context) HelmReleaseSpecCommonMetadataOutput +} + +// CommonMetadata specifies the common labels and annotations that are +// applied to all resources. Any existing label or annotation will be +// overridden if its key matches a common one. +type HelmReleaseSpecCommonMetadataArgs struct { + // Annotations to be added to the object's metadata. + Annotations pulumi.StringMapInput `pulumi:"annotations"` + // Labels to be added to the object's metadata. + Labels pulumi.StringMapInput `pulumi:"labels"` +} + +func (HelmReleaseSpecCommonMetadataArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecCommonMetadata)(nil)).Elem() +} + +func (i HelmReleaseSpecCommonMetadataArgs) ToHelmReleaseSpecCommonMetadataOutput() HelmReleaseSpecCommonMetadataOutput { + return i.ToHelmReleaseSpecCommonMetadataOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecCommonMetadataArgs) ToHelmReleaseSpecCommonMetadataOutputWithContext(ctx context.Context) HelmReleaseSpecCommonMetadataOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecCommonMetadataOutput) +} + +func (i HelmReleaseSpecCommonMetadataArgs) ToHelmReleaseSpecCommonMetadataPtrOutput() HelmReleaseSpecCommonMetadataPtrOutput { + return i.ToHelmReleaseSpecCommonMetadataPtrOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecCommonMetadataArgs) ToHelmReleaseSpecCommonMetadataPtrOutputWithContext(ctx context.Context) HelmReleaseSpecCommonMetadataPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecCommonMetadataOutput).ToHelmReleaseSpecCommonMetadataPtrOutputWithContext(ctx) +} + +// HelmReleaseSpecCommonMetadataPtrInput is an input type that accepts HelmReleaseSpecCommonMetadataArgs, HelmReleaseSpecCommonMetadataPtr and HelmReleaseSpecCommonMetadataPtrOutput values. +// You can construct a concrete instance of `HelmReleaseSpecCommonMetadataPtrInput` via: +// +// HelmReleaseSpecCommonMetadataArgs{...} +// +// or: +// +// nil +type HelmReleaseSpecCommonMetadataPtrInput interface { + pulumi.Input + + ToHelmReleaseSpecCommonMetadataPtrOutput() HelmReleaseSpecCommonMetadataPtrOutput + ToHelmReleaseSpecCommonMetadataPtrOutputWithContext(context.Context) HelmReleaseSpecCommonMetadataPtrOutput +} + +type helmReleaseSpecCommonMetadataPtrType HelmReleaseSpecCommonMetadataArgs + +func HelmReleaseSpecCommonMetadataPtr(v *HelmReleaseSpecCommonMetadataArgs) HelmReleaseSpecCommonMetadataPtrInput { + return (*helmReleaseSpecCommonMetadataPtrType)(v) +} + +func (*helmReleaseSpecCommonMetadataPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecCommonMetadata)(nil)).Elem() +} + +func (i *helmReleaseSpecCommonMetadataPtrType) ToHelmReleaseSpecCommonMetadataPtrOutput() HelmReleaseSpecCommonMetadataPtrOutput { + return i.ToHelmReleaseSpecCommonMetadataPtrOutputWithContext(context.Background()) +} + +func (i *helmReleaseSpecCommonMetadataPtrType) ToHelmReleaseSpecCommonMetadataPtrOutputWithContext(ctx context.Context) HelmReleaseSpecCommonMetadataPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecCommonMetadataPtrOutput) +} + +// CommonMetadata specifies the common labels and annotations that are +// applied to all resources. Any existing label or annotation will be +// overridden if its key matches a common one. +type HelmReleaseSpecCommonMetadataOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecCommonMetadataOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecCommonMetadata)(nil)).Elem() +} + +func (o HelmReleaseSpecCommonMetadataOutput) ToHelmReleaseSpecCommonMetadataOutput() HelmReleaseSpecCommonMetadataOutput { + return o +} + +func (o HelmReleaseSpecCommonMetadataOutput) ToHelmReleaseSpecCommonMetadataOutputWithContext(ctx context.Context) HelmReleaseSpecCommonMetadataOutput { + return o +} + +func (o HelmReleaseSpecCommonMetadataOutput) ToHelmReleaseSpecCommonMetadataPtrOutput() HelmReleaseSpecCommonMetadataPtrOutput { + return o.ToHelmReleaseSpecCommonMetadataPtrOutputWithContext(context.Background()) +} + +func (o HelmReleaseSpecCommonMetadataOutput) ToHelmReleaseSpecCommonMetadataPtrOutputWithContext(ctx context.Context) HelmReleaseSpecCommonMetadataPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v HelmReleaseSpecCommonMetadata) *HelmReleaseSpecCommonMetadata { + return &v + }).(HelmReleaseSpecCommonMetadataPtrOutput) +} + +// Annotations to be added to the object's metadata. +func (o HelmReleaseSpecCommonMetadataOutput) Annotations() pulumi.StringMapOutput { + return o.ApplyT(func(v HelmReleaseSpecCommonMetadata) map[string]string { return v.Annotations }).(pulumi.StringMapOutput) +} + +// Labels to be added to the object's metadata. +func (o HelmReleaseSpecCommonMetadataOutput) Labels() pulumi.StringMapOutput { + return o.ApplyT(func(v HelmReleaseSpecCommonMetadata) map[string]string { return v.Labels }).(pulumi.StringMapOutput) +} + +type HelmReleaseSpecCommonMetadataPtrOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecCommonMetadataPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecCommonMetadata)(nil)).Elem() +} + +func (o HelmReleaseSpecCommonMetadataPtrOutput) ToHelmReleaseSpecCommonMetadataPtrOutput() HelmReleaseSpecCommonMetadataPtrOutput { + return o +} + +func (o HelmReleaseSpecCommonMetadataPtrOutput) ToHelmReleaseSpecCommonMetadataPtrOutputWithContext(ctx context.Context) HelmReleaseSpecCommonMetadataPtrOutput { + return o +} + +func (o HelmReleaseSpecCommonMetadataPtrOutput) Elem() HelmReleaseSpecCommonMetadataOutput { + return o.ApplyT(func(v *HelmReleaseSpecCommonMetadata) HelmReleaseSpecCommonMetadata { + if v != nil { + return *v + } + var ret HelmReleaseSpecCommonMetadata + return ret + }).(HelmReleaseSpecCommonMetadataOutput) +} + +// Annotations to be added to the object's metadata. +func (o HelmReleaseSpecCommonMetadataPtrOutput) Annotations() pulumi.StringMapOutput { + return o.ApplyT(func(v *HelmReleaseSpecCommonMetadata) map[string]string { + if v == nil { + return nil + } + return v.Annotations + }).(pulumi.StringMapOutput) +} + +// Labels to be added to the object's metadata. +func (o HelmReleaseSpecCommonMetadataPtrOutput) Labels() pulumi.StringMapOutput { + return o.ApplyT(func(v *HelmReleaseSpecCommonMetadata) map[string]string { + if v == nil { + return nil + } + return v.Labels + }).(pulumi.StringMapOutput) +} + +// CommonMetadata specifies the common labels and annotations that are +// applied to all resources. Any existing label or annotation will be +// overridden if its key matches a common one. +type HelmReleaseSpecCommonMetadataPatch struct { + // Annotations to be added to the object's metadata. + Annotations map[string]string `pulumi:"annotations"` + // Labels to be added to the object's metadata. + Labels map[string]string `pulumi:"labels"` +} + +// HelmReleaseSpecCommonMetadataPatchInput is an input type that accepts HelmReleaseSpecCommonMetadataPatchArgs and HelmReleaseSpecCommonMetadataPatchOutput values. +// You can construct a concrete instance of `HelmReleaseSpecCommonMetadataPatchInput` via: +// +// HelmReleaseSpecCommonMetadataPatchArgs{...} +type HelmReleaseSpecCommonMetadataPatchInput interface { + pulumi.Input + + ToHelmReleaseSpecCommonMetadataPatchOutput() HelmReleaseSpecCommonMetadataPatchOutput + ToHelmReleaseSpecCommonMetadataPatchOutputWithContext(context.Context) HelmReleaseSpecCommonMetadataPatchOutput +} + +// CommonMetadata specifies the common labels and annotations that are +// applied to all resources. Any existing label or annotation will be +// overridden if its key matches a common one. +type HelmReleaseSpecCommonMetadataPatchArgs struct { + // Annotations to be added to the object's metadata. + Annotations pulumi.StringMapInput `pulumi:"annotations"` + // Labels to be added to the object's metadata. + Labels pulumi.StringMapInput `pulumi:"labels"` +} + +func (HelmReleaseSpecCommonMetadataPatchArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecCommonMetadataPatch)(nil)).Elem() +} + +func (i HelmReleaseSpecCommonMetadataPatchArgs) ToHelmReleaseSpecCommonMetadataPatchOutput() HelmReleaseSpecCommonMetadataPatchOutput { + return i.ToHelmReleaseSpecCommonMetadataPatchOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecCommonMetadataPatchArgs) ToHelmReleaseSpecCommonMetadataPatchOutputWithContext(ctx context.Context) HelmReleaseSpecCommonMetadataPatchOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecCommonMetadataPatchOutput) +} + +func (i HelmReleaseSpecCommonMetadataPatchArgs) ToHelmReleaseSpecCommonMetadataPatchPtrOutput() HelmReleaseSpecCommonMetadataPatchPtrOutput { + return i.ToHelmReleaseSpecCommonMetadataPatchPtrOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecCommonMetadataPatchArgs) ToHelmReleaseSpecCommonMetadataPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecCommonMetadataPatchPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecCommonMetadataPatchOutput).ToHelmReleaseSpecCommonMetadataPatchPtrOutputWithContext(ctx) +} + +// HelmReleaseSpecCommonMetadataPatchPtrInput is an input type that accepts HelmReleaseSpecCommonMetadataPatchArgs, HelmReleaseSpecCommonMetadataPatchPtr and HelmReleaseSpecCommonMetadataPatchPtrOutput values. +// You can construct a concrete instance of `HelmReleaseSpecCommonMetadataPatchPtrInput` via: +// +// HelmReleaseSpecCommonMetadataPatchArgs{...} +// +// or: +// +// nil +type HelmReleaseSpecCommonMetadataPatchPtrInput interface { + pulumi.Input + + ToHelmReleaseSpecCommonMetadataPatchPtrOutput() HelmReleaseSpecCommonMetadataPatchPtrOutput + ToHelmReleaseSpecCommonMetadataPatchPtrOutputWithContext(context.Context) HelmReleaseSpecCommonMetadataPatchPtrOutput +} + +type helmReleaseSpecCommonMetadataPatchPtrType HelmReleaseSpecCommonMetadataPatchArgs + +func HelmReleaseSpecCommonMetadataPatchPtr(v *HelmReleaseSpecCommonMetadataPatchArgs) HelmReleaseSpecCommonMetadataPatchPtrInput { + return (*helmReleaseSpecCommonMetadataPatchPtrType)(v) +} + +func (*helmReleaseSpecCommonMetadataPatchPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecCommonMetadataPatch)(nil)).Elem() +} + +func (i *helmReleaseSpecCommonMetadataPatchPtrType) ToHelmReleaseSpecCommonMetadataPatchPtrOutput() HelmReleaseSpecCommonMetadataPatchPtrOutput { + return i.ToHelmReleaseSpecCommonMetadataPatchPtrOutputWithContext(context.Background()) +} + +func (i *helmReleaseSpecCommonMetadataPatchPtrType) ToHelmReleaseSpecCommonMetadataPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecCommonMetadataPatchPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecCommonMetadataPatchPtrOutput) +} + +// CommonMetadata specifies the common labels and annotations that are +// applied to all resources. Any existing label or annotation will be +// overridden if its key matches a common one. +type HelmReleaseSpecCommonMetadataPatchOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecCommonMetadataPatchOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecCommonMetadataPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecCommonMetadataPatchOutput) ToHelmReleaseSpecCommonMetadataPatchOutput() HelmReleaseSpecCommonMetadataPatchOutput { + return o +} + +func (o HelmReleaseSpecCommonMetadataPatchOutput) ToHelmReleaseSpecCommonMetadataPatchOutputWithContext(ctx context.Context) HelmReleaseSpecCommonMetadataPatchOutput { + return o +} + +func (o HelmReleaseSpecCommonMetadataPatchOutput) ToHelmReleaseSpecCommonMetadataPatchPtrOutput() HelmReleaseSpecCommonMetadataPatchPtrOutput { + return o.ToHelmReleaseSpecCommonMetadataPatchPtrOutputWithContext(context.Background()) +} + +func (o HelmReleaseSpecCommonMetadataPatchOutput) ToHelmReleaseSpecCommonMetadataPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecCommonMetadataPatchPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v HelmReleaseSpecCommonMetadataPatch) *HelmReleaseSpecCommonMetadataPatch { + return &v + }).(HelmReleaseSpecCommonMetadataPatchPtrOutput) +} + +// Annotations to be added to the object's metadata. +func (o HelmReleaseSpecCommonMetadataPatchOutput) Annotations() pulumi.StringMapOutput { + return o.ApplyT(func(v HelmReleaseSpecCommonMetadataPatch) map[string]string { return v.Annotations }).(pulumi.StringMapOutput) +} + +// Labels to be added to the object's metadata. +func (o HelmReleaseSpecCommonMetadataPatchOutput) Labels() pulumi.StringMapOutput { + return o.ApplyT(func(v HelmReleaseSpecCommonMetadataPatch) map[string]string { return v.Labels }).(pulumi.StringMapOutput) +} + +type HelmReleaseSpecCommonMetadataPatchPtrOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecCommonMetadataPatchPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecCommonMetadataPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecCommonMetadataPatchPtrOutput) ToHelmReleaseSpecCommonMetadataPatchPtrOutput() HelmReleaseSpecCommonMetadataPatchPtrOutput { + return o +} + +func (o HelmReleaseSpecCommonMetadataPatchPtrOutput) ToHelmReleaseSpecCommonMetadataPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecCommonMetadataPatchPtrOutput { + return o +} + +func (o HelmReleaseSpecCommonMetadataPatchPtrOutput) Elem() HelmReleaseSpecCommonMetadataPatchOutput { + return o.ApplyT(func(v *HelmReleaseSpecCommonMetadataPatch) HelmReleaseSpecCommonMetadataPatch { + if v != nil { + return *v + } + var ret HelmReleaseSpecCommonMetadataPatch + return ret + }).(HelmReleaseSpecCommonMetadataPatchOutput) +} + +// Annotations to be added to the object's metadata. +func (o HelmReleaseSpecCommonMetadataPatchPtrOutput) Annotations() pulumi.StringMapOutput { + return o.ApplyT(func(v *HelmReleaseSpecCommonMetadataPatch) map[string]string { + if v == nil { + return nil + } + return v.Annotations + }).(pulumi.StringMapOutput) +} + +// Labels to be added to the object's metadata. +func (o HelmReleaseSpecCommonMetadataPatchPtrOutput) Labels() pulumi.StringMapOutput { + return o.ApplyT(func(v *HelmReleaseSpecCommonMetadataPatch) map[string]string { + if v == nil { + return nil + } + return v.Labels + }).(pulumi.StringMapOutput) +} + +// DependencyReference defines a HelmRelease dependency on another HelmRelease resource. +type HelmReleaseSpecDependsOn struct { + // Name of the referent. + Name *string `pulumi:"name"` + // Namespace of the referent, defaults to the namespace of the HelmRelease + // resource object that contains the reference. + Namespace *string `pulumi:"namespace"` + // ReadyExpr is a CEL expression that can be used to assess the readiness + // of a dependency. When specified, the built-in readiness check + // is replaced by the logic defined in the CEL expression. + // To make the CEL expression additive to the built-in readiness check, + // the feature gate `AdditiveCELDependencyCheck` must be set to `true`. + ReadyExpr *string `pulumi:"readyExpr"` +} + +// HelmReleaseSpecDependsOnInput is an input type that accepts HelmReleaseSpecDependsOnArgs and HelmReleaseSpecDependsOnOutput values. +// You can construct a concrete instance of `HelmReleaseSpecDependsOnInput` via: +// +// HelmReleaseSpecDependsOnArgs{...} +type HelmReleaseSpecDependsOnInput interface { + pulumi.Input + + ToHelmReleaseSpecDependsOnOutput() HelmReleaseSpecDependsOnOutput + ToHelmReleaseSpecDependsOnOutputWithContext(context.Context) HelmReleaseSpecDependsOnOutput +} + +// DependencyReference defines a HelmRelease dependency on another HelmRelease resource. +type HelmReleaseSpecDependsOnArgs struct { + // Name of the referent. + Name pulumi.StringPtrInput `pulumi:"name"` + // Namespace of the referent, defaults to the namespace of the HelmRelease + // resource object that contains the reference. + Namespace pulumi.StringPtrInput `pulumi:"namespace"` + // ReadyExpr is a CEL expression that can be used to assess the readiness + // of a dependency. When specified, the built-in readiness check + // is replaced by the logic defined in the CEL expression. + // To make the CEL expression additive to the built-in readiness check, + // the feature gate `AdditiveCELDependencyCheck` must be set to `true`. + ReadyExpr pulumi.StringPtrInput `pulumi:"readyExpr"` +} + +func (HelmReleaseSpecDependsOnArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecDependsOn)(nil)).Elem() +} + +func (i HelmReleaseSpecDependsOnArgs) ToHelmReleaseSpecDependsOnOutput() HelmReleaseSpecDependsOnOutput { + return i.ToHelmReleaseSpecDependsOnOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecDependsOnArgs) ToHelmReleaseSpecDependsOnOutputWithContext(ctx context.Context) HelmReleaseSpecDependsOnOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecDependsOnOutput) +} + +// HelmReleaseSpecDependsOnArrayInput is an input type that accepts HelmReleaseSpecDependsOnArray and HelmReleaseSpecDependsOnArrayOutput values. +// You can construct a concrete instance of `HelmReleaseSpecDependsOnArrayInput` via: +// +// HelmReleaseSpecDependsOnArray{ HelmReleaseSpecDependsOnArgs{...} } +type HelmReleaseSpecDependsOnArrayInput interface { + pulumi.Input + + ToHelmReleaseSpecDependsOnArrayOutput() HelmReleaseSpecDependsOnArrayOutput + ToHelmReleaseSpecDependsOnArrayOutputWithContext(context.Context) HelmReleaseSpecDependsOnArrayOutput +} + +type HelmReleaseSpecDependsOnArray []HelmReleaseSpecDependsOnInput + +func (HelmReleaseSpecDependsOnArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]HelmReleaseSpecDependsOn)(nil)).Elem() +} + +func (i HelmReleaseSpecDependsOnArray) ToHelmReleaseSpecDependsOnArrayOutput() HelmReleaseSpecDependsOnArrayOutput { + return i.ToHelmReleaseSpecDependsOnArrayOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecDependsOnArray) ToHelmReleaseSpecDependsOnArrayOutputWithContext(ctx context.Context) HelmReleaseSpecDependsOnArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecDependsOnArrayOutput) +} + +// DependencyReference defines a HelmRelease dependency on another HelmRelease resource. +type HelmReleaseSpecDependsOnOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecDependsOnOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecDependsOn)(nil)).Elem() +} + +func (o HelmReleaseSpecDependsOnOutput) ToHelmReleaseSpecDependsOnOutput() HelmReleaseSpecDependsOnOutput { + return o +} + +func (o HelmReleaseSpecDependsOnOutput) ToHelmReleaseSpecDependsOnOutputWithContext(ctx context.Context) HelmReleaseSpecDependsOnOutput { + return o +} + +// Name of the referent. +func (o HelmReleaseSpecDependsOnOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecDependsOn) *string { return v.Name }).(pulumi.StringPtrOutput) +} + +// Namespace of the referent, defaults to the namespace of the HelmRelease +// resource object that contains the reference. +func (o HelmReleaseSpecDependsOnOutput) Namespace() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecDependsOn) *string { return v.Namespace }).(pulumi.StringPtrOutput) +} + +// ReadyExpr is a CEL expression that can be used to assess the readiness +// of a dependency. When specified, the built-in readiness check +// is replaced by the logic defined in the CEL expression. +// To make the CEL expression additive to the built-in readiness check, +// the feature gate `AdditiveCELDependencyCheck` must be set to `true`. +func (o HelmReleaseSpecDependsOnOutput) ReadyExpr() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecDependsOn) *string { return v.ReadyExpr }).(pulumi.StringPtrOutput) +} + +type HelmReleaseSpecDependsOnArrayOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecDependsOnArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]HelmReleaseSpecDependsOn)(nil)).Elem() +} + +func (o HelmReleaseSpecDependsOnArrayOutput) ToHelmReleaseSpecDependsOnArrayOutput() HelmReleaseSpecDependsOnArrayOutput { + return o +} + +func (o HelmReleaseSpecDependsOnArrayOutput) ToHelmReleaseSpecDependsOnArrayOutputWithContext(ctx context.Context) HelmReleaseSpecDependsOnArrayOutput { + return o +} + +func (o HelmReleaseSpecDependsOnArrayOutput) Index(i pulumi.IntInput) HelmReleaseSpecDependsOnOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) HelmReleaseSpecDependsOn { + return vs[0].([]HelmReleaseSpecDependsOn)[vs[1].(int)] + }).(HelmReleaseSpecDependsOnOutput) +} + +// DependencyReference defines a HelmRelease dependency on another HelmRelease resource. +type HelmReleaseSpecDependsOnPatch struct { + // Name of the referent. + Name *string `pulumi:"name"` + // Namespace of the referent, defaults to the namespace of the HelmRelease + // resource object that contains the reference. + Namespace *string `pulumi:"namespace"` + // ReadyExpr is a CEL expression that can be used to assess the readiness + // of a dependency. When specified, the built-in readiness check + // is replaced by the logic defined in the CEL expression. + // To make the CEL expression additive to the built-in readiness check, + // the feature gate `AdditiveCELDependencyCheck` must be set to `true`. + ReadyExpr *string `pulumi:"readyExpr"` +} + +// HelmReleaseSpecDependsOnPatchInput is an input type that accepts HelmReleaseSpecDependsOnPatchArgs and HelmReleaseSpecDependsOnPatchOutput values. +// You can construct a concrete instance of `HelmReleaseSpecDependsOnPatchInput` via: +// +// HelmReleaseSpecDependsOnPatchArgs{...} +type HelmReleaseSpecDependsOnPatchInput interface { + pulumi.Input + + ToHelmReleaseSpecDependsOnPatchOutput() HelmReleaseSpecDependsOnPatchOutput + ToHelmReleaseSpecDependsOnPatchOutputWithContext(context.Context) HelmReleaseSpecDependsOnPatchOutput +} + +// DependencyReference defines a HelmRelease dependency on another HelmRelease resource. +type HelmReleaseSpecDependsOnPatchArgs struct { + // Name of the referent. + Name pulumi.StringPtrInput `pulumi:"name"` + // Namespace of the referent, defaults to the namespace of the HelmRelease + // resource object that contains the reference. + Namespace pulumi.StringPtrInput `pulumi:"namespace"` + // ReadyExpr is a CEL expression that can be used to assess the readiness + // of a dependency. When specified, the built-in readiness check + // is replaced by the logic defined in the CEL expression. + // To make the CEL expression additive to the built-in readiness check, + // the feature gate `AdditiveCELDependencyCheck` must be set to `true`. + ReadyExpr pulumi.StringPtrInput `pulumi:"readyExpr"` +} + +func (HelmReleaseSpecDependsOnPatchArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecDependsOnPatch)(nil)).Elem() +} + +func (i HelmReleaseSpecDependsOnPatchArgs) ToHelmReleaseSpecDependsOnPatchOutput() HelmReleaseSpecDependsOnPatchOutput { + return i.ToHelmReleaseSpecDependsOnPatchOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecDependsOnPatchArgs) ToHelmReleaseSpecDependsOnPatchOutputWithContext(ctx context.Context) HelmReleaseSpecDependsOnPatchOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecDependsOnPatchOutput) +} + +// HelmReleaseSpecDependsOnPatchArrayInput is an input type that accepts HelmReleaseSpecDependsOnPatchArray and HelmReleaseSpecDependsOnPatchArrayOutput values. +// You can construct a concrete instance of `HelmReleaseSpecDependsOnPatchArrayInput` via: +// +// HelmReleaseSpecDependsOnPatchArray{ HelmReleaseSpecDependsOnPatchArgs{...} } +type HelmReleaseSpecDependsOnPatchArrayInput interface { + pulumi.Input + + ToHelmReleaseSpecDependsOnPatchArrayOutput() HelmReleaseSpecDependsOnPatchArrayOutput + ToHelmReleaseSpecDependsOnPatchArrayOutputWithContext(context.Context) HelmReleaseSpecDependsOnPatchArrayOutput +} + +type HelmReleaseSpecDependsOnPatchArray []HelmReleaseSpecDependsOnPatchInput + +func (HelmReleaseSpecDependsOnPatchArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]HelmReleaseSpecDependsOnPatch)(nil)).Elem() +} + +func (i HelmReleaseSpecDependsOnPatchArray) ToHelmReleaseSpecDependsOnPatchArrayOutput() HelmReleaseSpecDependsOnPatchArrayOutput { + return i.ToHelmReleaseSpecDependsOnPatchArrayOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecDependsOnPatchArray) ToHelmReleaseSpecDependsOnPatchArrayOutputWithContext(ctx context.Context) HelmReleaseSpecDependsOnPatchArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecDependsOnPatchArrayOutput) +} + +// DependencyReference defines a HelmRelease dependency on another HelmRelease resource. +type HelmReleaseSpecDependsOnPatchOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecDependsOnPatchOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecDependsOnPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecDependsOnPatchOutput) ToHelmReleaseSpecDependsOnPatchOutput() HelmReleaseSpecDependsOnPatchOutput { + return o +} + +func (o HelmReleaseSpecDependsOnPatchOutput) ToHelmReleaseSpecDependsOnPatchOutputWithContext(ctx context.Context) HelmReleaseSpecDependsOnPatchOutput { + return o +} + +// Name of the referent. +func (o HelmReleaseSpecDependsOnPatchOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecDependsOnPatch) *string { return v.Name }).(pulumi.StringPtrOutput) +} + +// Namespace of the referent, defaults to the namespace of the HelmRelease +// resource object that contains the reference. +func (o HelmReleaseSpecDependsOnPatchOutput) Namespace() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecDependsOnPatch) *string { return v.Namespace }).(pulumi.StringPtrOutput) +} + +// ReadyExpr is a CEL expression that can be used to assess the readiness +// of a dependency. When specified, the built-in readiness check +// is replaced by the logic defined in the CEL expression. +// To make the CEL expression additive to the built-in readiness check, +// the feature gate `AdditiveCELDependencyCheck` must be set to `true`. +func (o HelmReleaseSpecDependsOnPatchOutput) ReadyExpr() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecDependsOnPatch) *string { return v.ReadyExpr }).(pulumi.StringPtrOutput) +} + +type HelmReleaseSpecDependsOnPatchArrayOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecDependsOnPatchArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]HelmReleaseSpecDependsOnPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecDependsOnPatchArrayOutput) ToHelmReleaseSpecDependsOnPatchArrayOutput() HelmReleaseSpecDependsOnPatchArrayOutput { + return o +} + +func (o HelmReleaseSpecDependsOnPatchArrayOutput) ToHelmReleaseSpecDependsOnPatchArrayOutputWithContext(ctx context.Context) HelmReleaseSpecDependsOnPatchArrayOutput { + return o +} + +func (o HelmReleaseSpecDependsOnPatchArrayOutput) Index(i pulumi.IntInput) HelmReleaseSpecDependsOnPatchOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) HelmReleaseSpecDependsOnPatch { + return vs[0].([]HelmReleaseSpecDependsOnPatch)[vs[1].(int)] + }).(HelmReleaseSpecDependsOnPatchOutput) +} + +// DriftDetection holds the configuration for detecting and handling +// differences between the manifest in the Helm storage and the resources +// currently existing in the cluster. +type HelmReleaseSpecDriftDetection struct { + // Ignore contains a list of rules for specifying which changes to ignore + // during diffing. + Ignore []HelmReleaseSpecDriftDetectionIgnore `pulumi:"ignore"` + // Mode defines how differences should be handled between the Helm manifest + // and the manifest currently applied to the cluster. + // If not explicitly set, it defaults to DiffModeDisabled. + Mode *string `pulumi:"mode"` +} + +// HelmReleaseSpecDriftDetectionInput is an input type that accepts HelmReleaseSpecDriftDetectionArgs and HelmReleaseSpecDriftDetectionOutput values. +// You can construct a concrete instance of `HelmReleaseSpecDriftDetectionInput` via: +// +// HelmReleaseSpecDriftDetectionArgs{...} +type HelmReleaseSpecDriftDetectionInput interface { + pulumi.Input + + ToHelmReleaseSpecDriftDetectionOutput() HelmReleaseSpecDriftDetectionOutput + ToHelmReleaseSpecDriftDetectionOutputWithContext(context.Context) HelmReleaseSpecDriftDetectionOutput +} + +// DriftDetection holds the configuration for detecting and handling +// differences between the manifest in the Helm storage and the resources +// currently existing in the cluster. +type HelmReleaseSpecDriftDetectionArgs struct { + // Ignore contains a list of rules for specifying which changes to ignore + // during diffing. + Ignore HelmReleaseSpecDriftDetectionIgnoreArrayInput `pulumi:"ignore"` + // Mode defines how differences should be handled between the Helm manifest + // and the manifest currently applied to the cluster. + // If not explicitly set, it defaults to DiffModeDisabled. + Mode pulumi.StringPtrInput `pulumi:"mode"` +} + +func (HelmReleaseSpecDriftDetectionArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecDriftDetection)(nil)).Elem() +} + +func (i HelmReleaseSpecDriftDetectionArgs) ToHelmReleaseSpecDriftDetectionOutput() HelmReleaseSpecDriftDetectionOutput { + return i.ToHelmReleaseSpecDriftDetectionOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecDriftDetectionArgs) ToHelmReleaseSpecDriftDetectionOutputWithContext(ctx context.Context) HelmReleaseSpecDriftDetectionOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecDriftDetectionOutput) +} + +func (i HelmReleaseSpecDriftDetectionArgs) ToHelmReleaseSpecDriftDetectionPtrOutput() HelmReleaseSpecDriftDetectionPtrOutput { + return i.ToHelmReleaseSpecDriftDetectionPtrOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecDriftDetectionArgs) ToHelmReleaseSpecDriftDetectionPtrOutputWithContext(ctx context.Context) HelmReleaseSpecDriftDetectionPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecDriftDetectionOutput).ToHelmReleaseSpecDriftDetectionPtrOutputWithContext(ctx) +} + +// HelmReleaseSpecDriftDetectionPtrInput is an input type that accepts HelmReleaseSpecDriftDetectionArgs, HelmReleaseSpecDriftDetectionPtr and HelmReleaseSpecDriftDetectionPtrOutput values. +// You can construct a concrete instance of `HelmReleaseSpecDriftDetectionPtrInput` via: +// +// HelmReleaseSpecDriftDetectionArgs{...} +// +// or: +// +// nil +type HelmReleaseSpecDriftDetectionPtrInput interface { + pulumi.Input + + ToHelmReleaseSpecDriftDetectionPtrOutput() HelmReleaseSpecDriftDetectionPtrOutput + ToHelmReleaseSpecDriftDetectionPtrOutputWithContext(context.Context) HelmReleaseSpecDriftDetectionPtrOutput +} + +type helmReleaseSpecDriftDetectionPtrType HelmReleaseSpecDriftDetectionArgs + +func HelmReleaseSpecDriftDetectionPtr(v *HelmReleaseSpecDriftDetectionArgs) HelmReleaseSpecDriftDetectionPtrInput { + return (*helmReleaseSpecDriftDetectionPtrType)(v) +} + +func (*helmReleaseSpecDriftDetectionPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecDriftDetection)(nil)).Elem() +} + +func (i *helmReleaseSpecDriftDetectionPtrType) ToHelmReleaseSpecDriftDetectionPtrOutput() HelmReleaseSpecDriftDetectionPtrOutput { + return i.ToHelmReleaseSpecDriftDetectionPtrOutputWithContext(context.Background()) +} + +func (i *helmReleaseSpecDriftDetectionPtrType) ToHelmReleaseSpecDriftDetectionPtrOutputWithContext(ctx context.Context) HelmReleaseSpecDriftDetectionPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecDriftDetectionPtrOutput) +} + +// DriftDetection holds the configuration for detecting and handling +// differences between the manifest in the Helm storage and the resources +// currently existing in the cluster. +type HelmReleaseSpecDriftDetectionOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecDriftDetectionOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecDriftDetection)(nil)).Elem() +} + +func (o HelmReleaseSpecDriftDetectionOutput) ToHelmReleaseSpecDriftDetectionOutput() HelmReleaseSpecDriftDetectionOutput { + return o +} + +func (o HelmReleaseSpecDriftDetectionOutput) ToHelmReleaseSpecDriftDetectionOutputWithContext(ctx context.Context) HelmReleaseSpecDriftDetectionOutput { + return o +} + +func (o HelmReleaseSpecDriftDetectionOutput) ToHelmReleaseSpecDriftDetectionPtrOutput() HelmReleaseSpecDriftDetectionPtrOutput { + return o.ToHelmReleaseSpecDriftDetectionPtrOutputWithContext(context.Background()) +} + +func (o HelmReleaseSpecDriftDetectionOutput) ToHelmReleaseSpecDriftDetectionPtrOutputWithContext(ctx context.Context) HelmReleaseSpecDriftDetectionPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v HelmReleaseSpecDriftDetection) *HelmReleaseSpecDriftDetection { + return &v + }).(HelmReleaseSpecDriftDetectionPtrOutput) +} + +// Ignore contains a list of rules for specifying which changes to ignore +// during diffing. +func (o HelmReleaseSpecDriftDetectionOutput) Ignore() HelmReleaseSpecDriftDetectionIgnoreArrayOutput { + return o.ApplyT(func(v HelmReleaseSpecDriftDetection) []HelmReleaseSpecDriftDetectionIgnore { return v.Ignore }).(HelmReleaseSpecDriftDetectionIgnoreArrayOutput) +} + +// Mode defines how differences should be handled between the Helm manifest +// and the manifest currently applied to the cluster. +// If not explicitly set, it defaults to DiffModeDisabled. +func (o HelmReleaseSpecDriftDetectionOutput) Mode() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecDriftDetection) *string { return v.Mode }).(pulumi.StringPtrOutput) +} + +type HelmReleaseSpecDriftDetectionPtrOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecDriftDetectionPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecDriftDetection)(nil)).Elem() +} + +func (o HelmReleaseSpecDriftDetectionPtrOutput) ToHelmReleaseSpecDriftDetectionPtrOutput() HelmReleaseSpecDriftDetectionPtrOutput { + return o +} + +func (o HelmReleaseSpecDriftDetectionPtrOutput) ToHelmReleaseSpecDriftDetectionPtrOutputWithContext(ctx context.Context) HelmReleaseSpecDriftDetectionPtrOutput { + return o +} + +func (o HelmReleaseSpecDriftDetectionPtrOutput) Elem() HelmReleaseSpecDriftDetectionOutput { + return o.ApplyT(func(v *HelmReleaseSpecDriftDetection) HelmReleaseSpecDriftDetection { + if v != nil { + return *v + } + var ret HelmReleaseSpecDriftDetection + return ret + }).(HelmReleaseSpecDriftDetectionOutput) +} + +// Ignore contains a list of rules for specifying which changes to ignore +// during diffing. +func (o HelmReleaseSpecDriftDetectionPtrOutput) Ignore() HelmReleaseSpecDriftDetectionIgnoreArrayOutput { + return o.ApplyT(func(v *HelmReleaseSpecDriftDetection) []HelmReleaseSpecDriftDetectionIgnore { + if v == nil { + return nil + } + return v.Ignore + }).(HelmReleaseSpecDriftDetectionIgnoreArrayOutput) +} + +// Mode defines how differences should be handled between the Helm manifest +// and the manifest currently applied to the cluster. +// If not explicitly set, it defaults to DiffModeDisabled. +func (o HelmReleaseSpecDriftDetectionPtrOutput) Mode() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecDriftDetection) *string { + if v == nil { + return nil + } + return v.Mode + }).(pulumi.StringPtrOutput) +} + +// IgnoreRule defines a rule to selectively disregard specific changes during +// the drift detection process. +type HelmReleaseSpecDriftDetectionIgnore struct { + // Paths is a list of JSON Pointer (RFC 6901) paths to be excluded from + // consideration in a Kubernetes object. + Paths []string `pulumi:"paths"` + Target *HelmReleaseSpecDriftDetectionIgnoreTarget `pulumi:"target"` +} + +// HelmReleaseSpecDriftDetectionIgnoreInput is an input type that accepts HelmReleaseSpecDriftDetectionIgnoreArgs and HelmReleaseSpecDriftDetectionIgnoreOutput values. +// You can construct a concrete instance of `HelmReleaseSpecDriftDetectionIgnoreInput` via: +// +// HelmReleaseSpecDriftDetectionIgnoreArgs{...} +type HelmReleaseSpecDriftDetectionIgnoreInput interface { + pulumi.Input + + ToHelmReleaseSpecDriftDetectionIgnoreOutput() HelmReleaseSpecDriftDetectionIgnoreOutput + ToHelmReleaseSpecDriftDetectionIgnoreOutputWithContext(context.Context) HelmReleaseSpecDriftDetectionIgnoreOutput +} + +// IgnoreRule defines a rule to selectively disregard specific changes during +// the drift detection process. +type HelmReleaseSpecDriftDetectionIgnoreArgs struct { + // Paths is a list of JSON Pointer (RFC 6901) paths to be excluded from + // consideration in a Kubernetes object. + Paths pulumi.StringArrayInput `pulumi:"paths"` + Target HelmReleaseSpecDriftDetectionIgnoreTargetPtrInput `pulumi:"target"` +} + +func (HelmReleaseSpecDriftDetectionIgnoreArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecDriftDetectionIgnore)(nil)).Elem() +} + +func (i HelmReleaseSpecDriftDetectionIgnoreArgs) ToHelmReleaseSpecDriftDetectionIgnoreOutput() HelmReleaseSpecDriftDetectionIgnoreOutput { + return i.ToHelmReleaseSpecDriftDetectionIgnoreOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecDriftDetectionIgnoreArgs) ToHelmReleaseSpecDriftDetectionIgnoreOutputWithContext(ctx context.Context) HelmReleaseSpecDriftDetectionIgnoreOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecDriftDetectionIgnoreOutput) +} + +// HelmReleaseSpecDriftDetectionIgnoreArrayInput is an input type that accepts HelmReleaseSpecDriftDetectionIgnoreArray and HelmReleaseSpecDriftDetectionIgnoreArrayOutput values. +// You can construct a concrete instance of `HelmReleaseSpecDriftDetectionIgnoreArrayInput` via: +// +// HelmReleaseSpecDriftDetectionIgnoreArray{ HelmReleaseSpecDriftDetectionIgnoreArgs{...} } +type HelmReleaseSpecDriftDetectionIgnoreArrayInput interface { + pulumi.Input + + ToHelmReleaseSpecDriftDetectionIgnoreArrayOutput() HelmReleaseSpecDriftDetectionIgnoreArrayOutput + ToHelmReleaseSpecDriftDetectionIgnoreArrayOutputWithContext(context.Context) HelmReleaseSpecDriftDetectionIgnoreArrayOutput +} + +type HelmReleaseSpecDriftDetectionIgnoreArray []HelmReleaseSpecDriftDetectionIgnoreInput + +func (HelmReleaseSpecDriftDetectionIgnoreArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]HelmReleaseSpecDriftDetectionIgnore)(nil)).Elem() +} + +func (i HelmReleaseSpecDriftDetectionIgnoreArray) ToHelmReleaseSpecDriftDetectionIgnoreArrayOutput() HelmReleaseSpecDriftDetectionIgnoreArrayOutput { + return i.ToHelmReleaseSpecDriftDetectionIgnoreArrayOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecDriftDetectionIgnoreArray) ToHelmReleaseSpecDriftDetectionIgnoreArrayOutputWithContext(ctx context.Context) HelmReleaseSpecDriftDetectionIgnoreArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecDriftDetectionIgnoreArrayOutput) +} + +// IgnoreRule defines a rule to selectively disregard specific changes during +// the drift detection process. +type HelmReleaseSpecDriftDetectionIgnoreOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecDriftDetectionIgnoreOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecDriftDetectionIgnore)(nil)).Elem() +} + +func (o HelmReleaseSpecDriftDetectionIgnoreOutput) ToHelmReleaseSpecDriftDetectionIgnoreOutput() HelmReleaseSpecDriftDetectionIgnoreOutput { + return o +} + +func (o HelmReleaseSpecDriftDetectionIgnoreOutput) ToHelmReleaseSpecDriftDetectionIgnoreOutputWithContext(ctx context.Context) HelmReleaseSpecDriftDetectionIgnoreOutput { + return o +} + +// Paths is a list of JSON Pointer (RFC 6901) paths to be excluded from +// consideration in a Kubernetes object. +func (o HelmReleaseSpecDriftDetectionIgnoreOutput) Paths() pulumi.StringArrayOutput { + return o.ApplyT(func(v HelmReleaseSpecDriftDetectionIgnore) []string { return v.Paths }).(pulumi.StringArrayOutput) +} + +func (o HelmReleaseSpecDriftDetectionIgnoreOutput) Target() HelmReleaseSpecDriftDetectionIgnoreTargetPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecDriftDetectionIgnore) *HelmReleaseSpecDriftDetectionIgnoreTarget { + return v.Target + }).(HelmReleaseSpecDriftDetectionIgnoreTargetPtrOutput) +} + +type HelmReleaseSpecDriftDetectionIgnoreArrayOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecDriftDetectionIgnoreArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]HelmReleaseSpecDriftDetectionIgnore)(nil)).Elem() +} + +func (o HelmReleaseSpecDriftDetectionIgnoreArrayOutput) ToHelmReleaseSpecDriftDetectionIgnoreArrayOutput() HelmReleaseSpecDriftDetectionIgnoreArrayOutput { + return o +} + +func (o HelmReleaseSpecDriftDetectionIgnoreArrayOutput) ToHelmReleaseSpecDriftDetectionIgnoreArrayOutputWithContext(ctx context.Context) HelmReleaseSpecDriftDetectionIgnoreArrayOutput { + return o +} + +func (o HelmReleaseSpecDriftDetectionIgnoreArrayOutput) Index(i pulumi.IntInput) HelmReleaseSpecDriftDetectionIgnoreOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) HelmReleaseSpecDriftDetectionIgnore { + return vs[0].([]HelmReleaseSpecDriftDetectionIgnore)[vs[1].(int)] + }).(HelmReleaseSpecDriftDetectionIgnoreOutput) +} + +// IgnoreRule defines a rule to selectively disregard specific changes during +// the drift detection process. +type HelmReleaseSpecDriftDetectionIgnorePatch struct { + // Paths is a list of JSON Pointer (RFC 6901) paths to be excluded from + // consideration in a Kubernetes object. + Paths []string `pulumi:"paths"` + Target *HelmReleaseSpecDriftDetectionIgnoreTargetPatch `pulumi:"target"` +} + +// HelmReleaseSpecDriftDetectionIgnorePatchInput is an input type that accepts HelmReleaseSpecDriftDetectionIgnorePatchArgs and HelmReleaseSpecDriftDetectionIgnorePatchOutput values. +// You can construct a concrete instance of `HelmReleaseSpecDriftDetectionIgnorePatchInput` via: +// +// HelmReleaseSpecDriftDetectionIgnorePatchArgs{...} +type HelmReleaseSpecDriftDetectionIgnorePatchInput interface { + pulumi.Input + + ToHelmReleaseSpecDriftDetectionIgnorePatchOutput() HelmReleaseSpecDriftDetectionIgnorePatchOutput + ToHelmReleaseSpecDriftDetectionIgnorePatchOutputWithContext(context.Context) HelmReleaseSpecDriftDetectionIgnorePatchOutput +} + +// IgnoreRule defines a rule to selectively disregard specific changes during +// the drift detection process. +type HelmReleaseSpecDriftDetectionIgnorePatchArgs struct { + // Paths is a list of JSON Pointer (RFC 6901) paths to be excluded from + // consideration in a Kubernetes object. + Paths pulumi.StringArrayInput `pulumi:"paths"` + Target HelmReleaseSpecDriftDetectionIgnoreTargetPatchPtrInput `pulumi:"target"` +} + +func (HelmReleaseSpecDriftDetectionIgnorePatchArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecDriftDetectionIgnorePatch)(nil)).Elem() +} + +func (i HelmReleaseSpecDriftDetectionIgnorePatchArgs) ToHelmReleaseSpecDriftDetectionIgnorePatchOutput() HelmReleaseSpecDriftDetectionIgnorePatchOutput { + return i.ToHelmReleaseSpecDriftDetectionIgnorePatchOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecDriftDetectionIgnorePatchArgs) ToHelmReleaseSpecDriftDetectionIgnorePatchOutputWithContext(ctx context.Context) HelmReleaseSpecDriftDetectionIgnorePatchOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecDriftDetectionIgnorePatchOutput) +} + +// HelmReleaseSpecDriftDetectionIgnorePatchArrayInput is an input type that accepts HelmReleaseSpecDriftDetectionIgnorePatchArray and HelmReleaseSpecDriftDetectionIgnorePatchArrayOutput values. +// You can construct a concrete instance of `HelmReleaseSpecDriftDetectionIgnorePatchArrayInput` via: +// +// HelmReleaseSpecDriftDetectionIgnorePatchArray{ HelmReleaseSpecDriftDetectionIgnorePatchArgs{...} } +type HelmReleaseSpecDriftDetectionIgnorePatchArrayInput interface { + pulumi.Input + + ToHelmReleaseSpecDriftDetectionIgnorePatchArrayOutput() HelmReleaseSpecDriftDetectionIgnorePatchArrayOutput + ToHelmReleaseSpecDriftDetectionIgnorePatchArrayOutputWithContext(context.Context) HelmReleaseSpecDriftDetectionIgnorePatchArrayOutput +} + +type HelmReleaseSpecDriftDetectionIgnorePatchArray []HelmReleaseSpecDriftDetectionIgnorePatchInput + +func (HelmReleaseSpecDriftDetectionIgnorePatchArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]HelmReleaseSpecDriftDetectionIgnorePatch)(nil)).Elem() +} + +func (i HelmReleaseSpecDriftDetectionIgnorePatchArray) ToHelmReleaseSpecDriftDetectionIgnorePatchArrayOutput() HelmReleaseSpecDriftDetectionIgnorePatchArrayOutput { + return i.ToHelmReleaseSpecDriftDetectionIgnorePatchArrayOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecDriftDetectionIgnorePatchArray) ToHelmReleaseSpecDriftDetectionIgnorePatchArrayOutputWithContext(ctx context.Context) HelmReleaseSpecDriftDetectionIgnorePatchArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecDriftDetectionIgnorePatchArrayOutput) +} + +// IgnoreRule defines a rule to selectively disregard specific changes during +// the drift detection process. +type HelmReleaseSpecDriftDetectionIgnorePatchOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecDriftDetectionIgnorePatchOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecDriftDetectionIgnorePatch)(nil)).Elem() +} + +func (o HelmReleaseSpecDriftDetectionIgnorePatchOutput) ToHelmReleaseSpecDriftDetectionIgnorePatchOutput() HelmReleaseSpecDriftDetectionIgnorePatchOutput { + return o +} + +func (o HelmReleaseSpecDriftDetectionIgnorePatchOutput) ToHelmReleaseSpecDriftDetectionIgnorePatchOutputWithContext(ctx context.Context) HelmReleaseSpecDriftDetectionIgnorePatchOutput { + return o +} + +// Paths is a list of JSON Pointer (RFC 6901) paths to be excluded from +// consideration in a Kubernetes object. +func (o HelmReleaseSpecDriftDetectionIgnorePatchOutput) Paths() pulumi.StringArrayOutput { + return o.ApplyT(func(v HelmReleaseSpecDriftDetectionIgnorePatch) []string { return v.Paths }).(pulumi.StringArrayOutput) +} + +func (o HelmReleaseSpecDriftDetectionIgnorePatchOutput) Target() HelmReleaseSpecDriftDetectionIgnoreTargetPatchPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecDriftDetectionIgnorePatch) *HelmReleaseSpecDriftDetectionIgnoreTargetPatch { + return v.Target + }).(HelmReleaseSpecDriftDetectionIgnoreTargetPatchPtrOutput) +} + +type HelmReleaseSpecDriftDetectionIgnorePatchArrayOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecDriftDetectionIgnorePatchArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]HelmReleaseSpecDriftDetectionIgnorePatch)(nil)).Elem() +} + +func (o HelmReleaseSpecDriftDetectionIgnorePatchArrayOutput) ToHelmReleaseSpecDriftDetectionIgnorePatchArrayOutput() HelmReleaseSpecDriftDetectionIgnorePatchArrayOutput { + return o +} + +func (o HelmReleaseSpecDriftDetectionIgnorePatchArrayOutput) ToHelmReleaseSpecDriftDetectionIgnorePatchArrayOutputWithContext(ctx context.Context) HelmReleaseSpecDriftDetectionIgnorePatchArrayOutput { + return o +} + +func (o HelmReleaseSpecDriftDetectionIgnorePatchArrayOutput) Index(i pulumi.IntInput) HelmReleaseSpecDriftDetectionIgnorePatchOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) HelmReleaseSpecDriftDetectionIgnorePatch { + return vs[0].([]HelmReleaseSpecDriftDetectionIgnorePatch)[vs[1].(int)] + }).(HelmReleaseSpecDriftDetectionIgnorePatchOutput) +} + +// Target is a selector for specifying Kubernetes objects to which this +// rule applies. +// If Target is not set, the Paths will be ignored for all Kubernetes +// objects within the manifest of the Helm release. +type HelmReleaseSpecDriftDetectionIgnoreTarget struct { + // AnnotationSelector is a string that follows the label selection expression + // https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#api + // It matches with the resource annotations. + AnnotationSelector *string `pulumi:"annotationSelector"` + // Group is the API group to select resources from. + // Together with Version and Kind it is capable of unambiguously identifying and/or selecting resources. + // https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md + Group *string `pulumi:"group"` + // Kind of the API Group to select resources from. + // Together with Group and Version it is capable of unambiguously + // identifying and/or selecting resources. + // https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md + Kind *string `pulumi:"kind"` + // LabelSelector is a string that follows the label selection expression + // https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#api + // It matches with the resource labels. + LabelSelector *string `pulumi:"labelSelector"` + // Name to match resources with. + Name *string `pulumi:"name"` + // Namespace to select resources from. + Namespace *string `pulumi:"namespace"` + // Version of the API Group to select resources from. + // Together with Group and Kind it is capable of unambiguously identifying and/or selecting resources. + // https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md + Version *string `pulumi:"version"` +} + +// HelmReleaseSpecDriftDetectionIgnoreTargetInput is an input type that accepts HelmReleaseSpecDriftDetectionIgnoreTargetArgs and HelmReleaseSpecDriftDetectionIgnoreTargetOutput values. +// You can construct a concrete instance of `HelmReleaseSpecDriftDetectionIgnoreTargetInput` via: +// +// HelmReleaseSpecDriftDetectionIgnoreTargetArgs{...} +type HelmReleaseSpecDriftDetectionIgnoreTargetInput interface { + pulumi.Input + + ToHelmReleaseSpecDriftDetectionIgnoreTargetOutput() HelmReleaseSpecDriftDetectionIgnoreTargetOutput + ToHelmReleaseSpecDriftDetectionIgnoreTargetOutputWithContext(context.Context) HelmReleaseSpecDriftDetectionIgnoreTargetOutput +} + +// Target is a selector for specifying Kubernetes objects to which this +// rule applies. +// If Target is not set, the Paths will be ignored for all Kubernetes +// objects within the manifest of the Helm release. +type HelmReleaseSpecDriftDetectionIgnoreTargetArgs struct { + // AnnotationSelector is a string that follows the label selection expression + // https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#api + // It matches with the resource annotations. + AnnotationSelector pulumi.StringPtrInput `pulumi:"annotationSelector"` + // Group is the API group to select resources from. + // Together with Version and Kind it is capable of unambiguously identifying and/or selecting resources. + // https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md + Group pulumi.StringPtrInput `pulumi:"group"` + // Kind of the API Group to select resources from. + // Together with Group and Version it is capable of unambiguously + // identifying and/or selecting resources. + // https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md + Kind pulumi.StringPtrInput `pulumi:"kind"` + // LabelSelector is a string that follows the label selection expression + // https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#api + // It matches with the resource labels. + LabelSelector pulumi.StringPtrInput `pulumi:"labelSelector"` + // Name to match resources with. + Name pulumi.StringPtrInput `pulumi:"name"` + // Namespace to select resources from. + Namespace pulumi.StringPtrInput `pulumi:"namespace"` + // Version of the API Group to select resources from. + // Together with Group and Kind it is capable of unambiguously identifying and/or selecting resources. + // https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md + Version pulumi.StringPtrInput `pulumi:"version"` +} + +func (HelmReleaseSpecDriftDetectionIgnoreTargetArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecDriftDetectionIgnoreTarget)(nil)).Elem() +} + +func (i HelmReleaseSpecDriftDetectionIgnoreTargetArgs) ToHelmReleaseSpecDriftDetectionIgnoreTargetOutput() HelmReleaseSpecDriftDetectionIgnoreTargetOutput { + return i.ToHelmReleaseSpecDriftDetectionIgnoreTargetOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecDriftDetectionIgnoreTargetArgs) ToHelmReleaseSpecDriftDetectionIgnoreTargetOutputWithContext(ctx context.Context) HelmReleaseSpecDriftDetectionIgnoreTargetOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecDriftDetectionIgnoreTargetOutput) +} + +func (i HelmReleaseSpecDriftDetectionIgnoreTargetArgs) ToHelmReleaseSpecDriftDetectionIgnoreTargetPtrOutput() HelmReleaseSpecDriftDetectionIgnoreTargetPtrOutput { + return i.ToHelmReleaseSpecDriftDetectionIgnoreTargetPtrOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecDriftDetectionIgnoreTargetArgs) ToHelmReleaseSpecDriftDetectionIgnoreTargetPtrOutputWithContext(ctx context.Context) HelmReleaseSpecDriftDetectionIgnoreTargetPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecDriftDetectionIgnoreTargetOutput).ToHelmReleaseSpecDriftDetectionIgnoreTargetPtrOutputWithContext(ctx) +} + +// HelmReleaseSpecDriftDetectionIgnoreTargetPtrInput is an input type that accepts HelmReleaseSpecDriftDetectionIgnoreTargetArgs, HelmReleaseSpecDriftDetectionIgnoreTargetPtr and HelmReleaseSpecDriftDetectionIgnoreTargetPtrOutput values. +// You can construct a concrete instance of `HelmReleaseSpecDriftDetectionIgnoreTargetPtrInput` via: +// +// HelmReleaseSpecDriftDetectionIgnoreTargetArgs{...} +// +// or: +// +// nil +type HelmReleaseSpecDriftDetectionIgnoreTargetPtrInput interface { + pulumi.Input + + ToHelmReleaseSpecDriftDetectionIgnoreTargetPtrOutput() HelmReleaseSpecDriftDetectionIgnoreTargetPtrOutput + ToHelmReleaseSpecDriftDetectionIgnoreTargetPtrOutputWithContext(context.Context) HelmReleaseSpecDriftDetectionIgnoreTargetPtrOutput +} + +type helmReleaseSpecDriftDetectionIgnoreTargetPtrType HelmReleaseSpecDriftDetectionIgnoreTargetArgs + +func HelmReleaseSpecDriftDetectionIgnoreTargetPtr(v *HelmReleaseSpecDriftDetectionIgnoreTargetArgs) HelmReleaseSpecDriftDetectionIgnoreTargetPtrInput { + return (*helmReleaseSpecDriftDetectionIgnoreTargetPtrType)(v) +} + +func (*helmReleaseSpecDriftDetectionIgnoreTargetPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecDriftDetectionIgnoreTarget)(nil)).Elem() +} + +func (i *helmReleaseSpecDriftDetectionIgnoreTargetPtrType) ToHelmReleaseSpecDriftDetectionIgnoreTargetPtrOutput() HelmReleaseSpecDriftDetectionIgnoreTargetPtrOutput { + return i.ToHelmReleaseSpecDriftDetectionIgnoreTargetPtrOutputWithContext(context.Background()) +} + +func (i *helmReleaseSpecDriftDetectionIgnoreTargetPtrType) ToHelmReleaseSpecDriftDetectionIgnoreTargetPtrOutputWithContext(ctx context.Context) HelmReleaseSpecDriftDetectionIgnoreTargetPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecDriftDetectionIgnoreTargetPtrOutput) +} + +// Target is a selector for specifying Kubernetes objects to which this +// rule applies. +// If Target is not set, the Paths will be ignored for all Kubernetes +// objects within the manifest of the Helm release. +type HelmReleaseSpecDriftDetectionIgnoreTargetOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecDriftDetectionIgnoreTargetOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecDriftDetectionIgnoreTarget)(nil)).Elem() +} + +func (o HelmReleaseSpecDriftDetectionIgnoreTargetOutput) ToHelmReleaseSpecDriftDetectionIgnoreTargetOutput() HelmReleaseSpecDriftDetectionIgnoreTargetOutput { + return o +} + +func (o HelmReleaseSpecDriftDetectionIgnoreTargetOutput) ToHelmReleaseSpecDriftDetectionIgnoreTargetOutputWithContext(ctx context.Context) HelmReleaseSpecDriftDetectionIgnoreTargetOutput { + return o +} + +func (o HelmReleaseSpecDriftDetectionIgnoreTargetOutput) ToHelmReleaseSpecDriftDetectionIgnoreTargetPtrOutput() HelmReleaseSpecDriftDetectionIgnoreTargetPtrOutput { + return o.ToHelmReleaseSpecDriftDetectionIgnoreTargetPtrOutputWithContext(context.Background()) +} + +func (o HelmReleaseSpecDriftDetectionIgnoreTargetOutput) ToHelmReleaseSpecDriftDetectionIgnoreTargetPtrOutputWithContext(ctx context.Context) HelmReleaseSpecDriftDetectionIgnoreTargetPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v HelmReleaseSpecDriftDetectionIgnoreTarget) *HelmReleaseSpecDriftDetectionIgnoreTarget { + return &v + }).(HelmReleaseSpecDriftDetectionIgnoreTargetPtrOutput) +} + +// AnnotationSelector is a string that follows the label selection expression +// https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#api +// It matches with the resource annotations. +func (o HelmReleaseSpecDriftDetectionIgnoreTargetOutput) AnnotationSelector() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecDriftDetectionIgnoreTarget) *string { return v.AnnotationSelector }).(pulumi.StringPtrOutput) +} + +// Group is the API group to select resources from. +// Together with Version and Kind it is capable of unambiguously identifying and/or selecting resources. +// https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md +func (o HelmReleaseSpecDriftDetectionIgnoreTargetOutput) Group() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecDriftDetectionIgnoreTarget) *string { return v.Group }).(pulumi.StringPtrOutput) +} + +// Kind of the API Group to select resources from. +// Together with Group and Version it is capable of unambiguously +// identifying and/or selecting resources. +// https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md +func (o HelmReleaseSpecDriftDetectionIgnoreTargetOutput) Kind() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecDriftDetectionIgnoreTarget) *string { return v.Kind }).(pulumi.StringPtrOutput) +} + +// LabelSelector is a string that follows the label selection expression +// https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#api +// It matches with the resource labels. +func (o HelmReleaseSpecDriftDetectionIgnoreTargetOutput) LabelSelector() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecDriftDetectionIgnoreTarget) *string { return v.LabelSelector }).(pulumi.StringPtrOutput) +} + +// Name to match resources with. +func (o HelmReleaseSpecDriftDetectionIgnoreTargetOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecDriftDetectionIgnoreTarget) *string { return v.Name }).(pulumi.StringPtrOutput) +} + +// Namespace to select resources from. +func (o HelmReleaseSpecDriftDetectionIgnoreTargetOutput) Namespace() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecDriftDetectionIgnoreTarget) *string { return v.Namespace }).(pulumi.StringPtrOutput) +} + +// Version of the API Group to select resources from. +// Together with Group and Kind it is capable of unambiguously identifying and/or selecting resources. +// https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md +func (o HelmReleaseSpecDriftDetectionIgnoreTargetOutput) Version() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecDriftDetectionIgnoreTarget) *string { return v.Version }).(pulumi.StringPtrOutput) +} + +type HelmReleaseSpecDriftDetectionIgnoreTargetPtrOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecDriftDetectionIgnoreTargetPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecDriftDetectionIgnoreTarget)(nil)).Elem() +} + +func (o HelmReleaseSpecDriftDetectionIgnoreTargetPtrOutput) ToHelmReleaseSpecDriftDetectionIgnoreTargetPtrOutput() HelmReleaseSpecDriftDetectionIgnoreTargetPtrOutput { + return o +} + +func (o HelmReleaseSpecDriftDetectionIgnoreTargetPtrOutput) ToHelmReleaseSpecDriftDetectionIgnoreTargetPtrOutputWithContext(ctx context.Context) HelmReleaseSpecDriftDetectionIgnoreTargetPtrOutput { + return o +} + +func (o HelmReleaseSpecDriftDetectionIgnoreTargetPtrOutput) Elem() HelmReleaseSpecDriftDetectionIgnoreTargetOutput { + return o.ApplyT(func(v *HelmReleaseSpecDriftDetectionIgnoreTarget) HelmReleaseSpecDriftDetectionIgnoreTarget { + if v != nil { + return *v + } + var ret HelmReleaseSpecDriftDetectionIgnoreTarget + return ret + }).(HelmReleaseSpecDriftDetectionIgnoreTargetOutput) +} + +// AnnotationSelector is a string that follows the label selection expression +// https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#api +// It matches with the resource annotations. +func (o HelmReleaseSpecDriftDetectionIgnoreTargetPtrOutput) AnnotationSelector() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecDriftDetectionIgnoreTarget) *string { + if v == nil { + return nil + } + return v.AnnotationSelector + }).(pulumi.StringPtrOutput) +} + +// Group is the API group to select resources from. +// Together with Version and Kind it is capable of unambiguously identifying and/or selecting resources. +// https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md +func (o HelmReleaseSpecDriftDetectionIgnoreTargetPtrOutput) Group() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecDriftDetectionIgnoreTarget) *string { + if v == nil { + return nil + } + return v.Group + }).(pulumi.StringPtrOutput) +} + +// Kind of the API Group to select resources from. +// Together with Group and Version it is capable of unambiguously +// identifying and/or selecting resources. +// https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md +func (o HelmReleaseSpecDriftDetectionIgnoreTargetPtrOutput) Kind() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecDriftDetectionIgnoreTarget) *string { + if v == nil { + return nil + } + return v.Kind + }).(pulumi.StringPtrOutput) +} + +// LabelSelector is a string that follows the label selection expression +// https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#api +// It matches with the resource labels. +func (o HelmReleaseSpecDriftDetectionIgnoreTargetPtrOutput) LabelSelector() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecDriftDetectionIgnoreTarget) *string { + if v == nil { + return nil + } + return v.LabelSelector + }).(pulumi.StringPtrOutput) +} + +// Name to match resources with. +func (o HelmReleaseSpecDriftDetectionIgnoreTargetPtrOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecDriftDetectionIgnoreTarget) *string { + if v == nil { + return nil + } + return v.Name + }).(pulumi.StringPtrOutput) +} + +// Namespace to select resources from. +func (o HelmReleaseSpecDriftDetectionIgnoreTargetPtrOutput) Namespace() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecDriftDetectionIgnoreTarget) *string { + if v == nil { + return nil + } + return v.Namespace + }).(pulumi.StringPtrOutput) +} + +// Version of the API Group to select resources from. +// Together with Group and Kind it is capable of unambiguously identifying and/or selecting resources. +// https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md +func (o HelmReleaseSpecDriftDetectionIgnoreTargetPtrOutput) Version() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecDriftDetectionIgnoreTarget) *string { + if v == nil { + return nil + } + return v.Version + }).(pulumi.StringPtrOutput) +} + +// Target is a selector for specifying Kubernetes objects to which this +// rule applies. +// If Target is not set, the Paths will be ignored for all Kubernetes +// objects within the manifest of the Helm release. +type HelmReleaseSpecDriftDetectionIgnoreTargetPatch struct { + // AnnotationSelector is a string that follows the label selection expression + // https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#api + // It matches with the resource annotations. + AnnotationSelector *string `pulumi:"annotationSelector"` + // Group is the API group to select resources from. + // Together with Version and Kind it is capable of unambiguously identifying and/or selecting resources. + // https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md + Group *string `pulumi:"group"` + // Kind of the API Group to select resources from. + // Together with Group and Version it is capable of unambiguously + // identifying and/or selecting resources. + // https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md + Kind *string `pulumi:"kind"` + // LabelSelector is a string that follows the label selection expression + // https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#api + // It matches with the resource labels. + LabelSelector *string `pulumi:"labelSelector"` + // Name to match resources with. + Name *string `pulumi:"name"` + // Namespace to select resources from. + Namespace *string `pulumi:"namespace"` + // Version of the API Group to select resources from. + // Together with Group and Kind it is capable of unambiguously identifying and/or selecting resources. + // https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md + Version *string `pulumi:"version"` +} + +// HelmReleaseSpecDriftDetectionIgnoreTargetPatchInput is an input type that accepts HelmReleaseSpecDriftDetectionIgnoreTargetPatchArgs and HelmReleaseSpecDriftDetectionIgnoreTargetPatchOutput values. +// You can construct a concrete instance of `HelmReleaseSpecDriftDetectionIgnoreTargetPatchInput` via: +// +// HelmReleaseSpecDriftDetectionIgnoreTargetPatchArgs{...} +type HelmReleaseSpecDriftDetectionIgnoreTargetPatchInput interface { + pulumi.Input + + ToHelmReleaseSpecDriftDetectionIgnoreTargetPatchOutput() HelmReleaseSpecDriftDetectionIgnoreTargetPatchOutput + ToHelmReleaseSpecDriftDetectionIgnoreTargetPatchOutputWithContext(context.Context) HelmReleaseSpecDriftDetectionIgnoreTargetPatchOutput +} + +// Target is a selector for specifying Kubernetes objects to which this +// rule applies. +// If Target is not set, the Paths will be ignored for all Kubernetes +// objects within the manifest of the Helm release. +type HelmReleaseSpecDriftDetectionIgnoreTargetPatchArgs struct { + // AnnotationSelector is a string that follows the label selection expression + // https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#api + // It matches with the resource annotations. + AnnotationSelector pulumi.StringPtrInput `pulumi:"annotationSelector"` + // Group is the API group to select resources from. + // Together with Version and Kind it is capable of unambiguously identifying and/or selecting resources. + // https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md + Group pulumi.StringPtrInput `pulumi:"group"` + // Kind of the API Group to select resources from. + // Together with Group and Version it is capable of unambiguously + // identifying and/or selecting resources. + // https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md + Kind pulumi.StringPtrInput `pulumi:"kind"` + // LabelSelector is a string that follows the label selection expression + // https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#api + // It matches with the resource labels. + LabelSelector pulumi.StringPtrInput `pulumi:"labelSelector"` + // Name to match resources with. + Name pulumi.StringPtrInput `pulumi:"name"` + // Namespace to select resources from. + Namespace pulumi.StringPtrInput `pulumi:"namespace"` + // Version of the API Group to select resources from. + // Together with Group and Kind it is capable of unambiguously identifying and/or selecting resources. + // https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md + Version pulumi.StringPtrInput `pulumi:"version"` +} + +func (HelmReleaseSpecDriftDetectionIgnoreTargetPatchArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecDriftDetectionIgnoreTargetPatch)(nil)).Elem() +} + +func (i HelmReleaseSpecDriftDetectionIgnoreTargetPatchArgs) ToHelmReleaseSpecDriftDetectionIgnoreTargetPatchOutput() HelmReleaseSpecDriftDetectionIgnoreTargetPatchOutput { + return i.ToHelmReleaseSpecDriftDetectionIgnoreTargetPatchOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecDriftDetectionIgnoreTargetPatchArgs) ToHelmReleaseSpecDriftDetectionIgnoreTargetPatchOutputWithContext(ctx context.Context) HelmReleaseSpecDriftDetectionIgnoreTargetPatchOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecDriftDetectionIgnoreTargetPatchOutput) +} + +func (i HelmReleaseSpecDriftDetectionIgnoreTargetPatchArgs) ToHelmReleaseSpecDriftDetectionIgnoreTargetPatchPtrOutput() HelmReleaseSpecDriftDetectionIgnoreTargetPatchPtrOutput { + return i.ToHelmReleaseSpecDriftDetectionIgnoreTargetPatchPtrOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecDriftDetectionIgnoreTargetPatchArgs) ToHelmReleaseSpecDriftDetectionIgnoreTargetPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecDriftDetectionIgnoreTargetPatchPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecDriftDetectionIgnoreTargetPatchOutput).ToHelmReleaseSpecDriftDetectionIgnoreTargetPatchPtrOutputWithContext(ctx) +} + +// HelmReleaseSpecDriftDetectionIgnoreTargetPatchPtrInput is an input type that accepts HelmReleaseSpecDriftDetectionIgnoreTargetPatchArgs, HelmReleaseSpecDriftDetectionIgnoreTargetPatchPtr and HelmReleaseSpecDriftDetectionIgnoreTargetPatchPtrOutput values. +// You can construct a concrete instance of `HelmReleaseSpecDriftDetectionIgnoreTargetPatchPtrInput` via: +// +// HelmReleaseSpecDriftDetectionIgnoreTargetPatchArgs{...} +// +// or: +// +// nil +type HelmReleaseSpecDriftDetectionIgnoreTargetPatchPtrInput interface { + pulumi.Input + + ToHelmReleaseSpecDriftDetectionIgnoreTargetPatchPtrOutput() HelmReleaseSpecDriftDetectionIgnoreTargetPatchPtrOutput + ToHelmReleaseSpecDriftDetectionIgnoreTargetPatchPtrOutputWithContext(context.Context) HelmReleaseSpecDriftDetectionIgnoreTargetPatchPtrOutput +} + +type helmReleaseSpecDriftDetectionIgnoreTargetPatchPtrType HelmReleaseSpecDriftDetectionIgnoreTargetPatchArgs + +func HelmReleaseSpecDriftDetectionIgnoreTargetPatchPtr(v *HelmReleaseSpecDriftDetectionIgnoreTargetPatchArgs) HelmReleaseSpecDriftDetectionIgnoreTargetPatchPtrInput { + return (*helmReleaseSpecDriftDetectionIgnoreTargetPatchPtrType)(v) +} + +func (*helmReleaseSpecDriftDetectionIgnoreTargetPatchPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecDriftDetectionIgnoreTargetPatch)(nil)).Elem() +} + +func (i *helmReleaseSpecDriftDetectionIgnoreTargetPatchPtrType) ToHelmReleaseSpecDriftDetectionIgnoreTargetPatchPtrOutput() HelmReleaseSpecDriftDetectionIgnoreTargetPatchPtrOutput { + return i.ToHelmReleaseSpecDriftDetectionIgnoreTargetPatchPtrOutputWithContext(context.Background()) +} + +func (i *helmReleaseSpecDriftDetectionIgnoreTargetPatchPtrType) ToHelmReleaseSpecDriftDetectionIgnoreTargetPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecDriftDetectionIgnoreTargetPatchPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecDriftDetectionIgnoreTargetPatchPtrOutput) +} + +// Target is a selector for specifying Kubernetes objects to which this +// rule applies. +// If Target is not set, the Paths will be ignored for all Kubernetes +// objects within the manifest of the Helm release. +type HelmReleaseSpecDriftDetectionIgnoreTargetPatchOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecDriftDetectionIgnoreTargetPatchOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecDriftDetectionIgnoreTargetPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecDriftDetectionIgnoreTargetPatchOutput) ToHelmReleaseSpecDriftDetectionIgnoreTargetPatchOutput() HelmReleaseSpecDriftDetectionIgnoreTargetPatchOutput { + return o +} + +func (o HelmReleaseSpecDriftDetectionIgnoreTargetPatchOutput) ToHelmReleaseSpecDriftDetectionIgnoreTargetPatchOutputWithContext(ctx context.Context) HelmReleaseSpecDriftDetectionIgnoreTargetPatchOutput { + return o +} + +func (o HelmReleaseSpecDriftDetectionIgnoreTargetPatchOutput) ToHelmReleaseSpecDriftDetectionIgnoreTargetPatchPtrOutput() HelmReleaseSpecDriftDetectionIgnoreTargetPatchPtrOutput { + return o.ToHelmReleaseSpecDriftDetectionIgnoreTargetPatchPtrOutputWithContext(context.Background()) +} + +func (o HelmReleaseSpecDriftDetectionIgnoreTargetPatchOutput) ToHelmReleaseSpecDriftDetectionIgnoreTargetPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecDriftDetectionIgnoreTargetPatchPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v HelmReleaseSpecDriftDetectionIgnoreTargetPatch) *HelmReleaseSpecDriftDetectionIgnoreTargetPatch { + return &v + }).(HelmReleaseSpecDriftDetectionIgnoreTargetPatchPtrOutput) +} + +// AnnotationSelector is a string that follows the label selection expression +// https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#api +// It matches with the resource annotations. +func (o HelmReleaseSpecDriftDetectionIgnoreTargetPatchOutput) AnnotationSelector() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecDriftDetectionIgnoreTargetPatch) *string { return v.AnnotationSelector }).(pulumi.StringPtrOutput) +} + +// Group is the API group to select resources from. +// Together with Version and Kind it is capable of unambiguously identifying and/or selecting resources. +// https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md +func (o HelmReleaseSpecDriftDetectionIgnoreTargetPatchOutput) Group() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecDriftDetectionIgnoreTargetPatch) *string { return v.Group }).(pulumi.StringPtrOutput) +} + +// Kind of the API Group to select resources from. +// Together with Group and Version it is capable of unambiguously +// identifying and/or selecting resources. +// https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md +func (o HelmReleaseSpecDriftDetectionIgnoreTargetPatchOutput) Kind() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecDriftDetectionIgnoreTargetPatch) *string { return v.Kind }).(pulumi.StringPtrOutput) +} + +// LabelSelector is a string that follows the label selection expression +// https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#api +// It matches with the resource labels. +func (o HelmReleaseSpecDriftDetectionIgnoreTargetPatchOutput) LabelSelector() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecDriftDetectionIgnoreTargetPatch) *string { return v.LabelSelector }).(pulumi.StringPtrOutput) +} + +// Name to match resources with. +func (o HelmReleaseSpecDriftDetectionIgnoreTargetPatchOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecDriftDetectionIgnoreTargetPatch) *string { return v.Name }).(pulumi.StringPtrOutput) +} + +// Namespace to select resources from. +func (o HelmReleaseSpecDriftDetectionIgnoreTargetPatchOutput) Namespace() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecDriftDetectionIgnoreTargetPatch) *string { return v.Namespace }).(pulumi.StringPtrOutput) +} + +// Version of the API Group to select resources from. +// Together with Group and Kind it is capable of unambiguously identifying and/or selecting resources. +// https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md +func (o HelmReleaseSpecDriftDetectionIgnoreTargetPatchOutput) Version() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecDriftDetectionIgnoreTargetPatch) *string { return v.Version }).(pulumi.StringPtrOutput) +} + +type HelmReleaseSpecDriftDetectionIgnoreTargetPatchPtrOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecDriftDetectionIgnoreTargetPatchPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecDriftDetectionIgnoreTargetPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecDriftDetectionIgnoreTargetPatchPtrOutput) ToHelmReleaseSpecDriftDetectionIgnoreTargetPatchPtrOutput() HelmReleaseSpecDriftDetectionIgnoreTargetPatchPtrOutput { + return o +} + +func (o HelmReleaseSpecDriftDetectionIgnoreTargetPatchPtrOutput) ToHelmReleaseSpecDriftDetectionIgnoreTargetPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecDriftDetectionIgnoreTargetPatchPtrOutput { + return o +} + +func (o HelmReleaseSpecDriftDetectionIgnoreTargetPatchPtrOutput) Elem() HelmReleaseSpecDriftDetectionIgnoreTargetPatchOutput { + return o.ApplyT(func(v *HelmReleaseSpecDriftDetectionIgnoreTargetPatch) HelmReleaseSpecDriftDetectionIgnoreTargetPatch { + if v != nil { + return *v + } + var ret HelmReleaseSpecDriftDetectionIgnoreTargetPatch + return ret + }).(HelmReleaseSpecDriftDetectionIgnoreTargetPatchOutput) +} + +// AnnotationSelector is a string that follows the label selection expression +// https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#api +// It matches with the resource annotations. +func (o HelmReleaseSpecDriftDetectionIgnoreTargetPatchPtrOutput) AnnotationSelector() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecDriftDetectionIgnoreTargetPatch) *string { + if v == nil { + return nil + } + return v.AnnotationSelector + }).(pulumi.StringPtrOutput) +} + +// Group is the API group to select resources from. +// Together with Version and Kind it is capable of unambiguously identifying and/or selecting resources. +// https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md +func (o HelmReleaseSpecDriftDetectionIgnoreTargetPatchPtrOutput) Group() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecDriftDetectionIgnoreTargetPatch) *string { + if v == nil { + return nil + } + return v.Group + }).(pulumi.StringPtrOutput) +} + +// Kind of the API Group to select resources from. +// Together with Group and Version it is capable of unambiguously +// identifying and/or selecting resources. +// https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md +func (o HelmReleaseSpecDriftDetectionIgnoreTargetPatchPtrOutput) Kind() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecDriftDetectionIgnoreTargetPatch) *string { + if v == nil { + return nil + } + return v.Kind + }).(pulumi.StringPtrOutput) +} + +// LabelSelector is a string that follows the label selection expression +// https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#api +// It matches with the resource labels. +func (o HelmReleaseSpecDriftDetectionIgnoreTargetPatchPtrOutput) LabelSelector() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecDriftDetectionIgnoreTargetPatch) *string { + if v == nil { + return nil + } + return v.LabelSelector + }).(pulumi.StringPtrOutput) +} + +// Name to match resources with. +func (o HelmReleaseSpecDriftDetectionIgnoreTargetPatchPtrOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecDriftDetectionIgnoreTargetPatch) *string { + if v == nil { + return nil + } + return v.Name + }).(pulumi.StringPtrOutput) +} + +// Namespace to select resources from. +func (o HelmReleaseSpecDriftDetectionIgnoreTargetPatchPtrOutput) Namespace() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecDriftDetectionIgnoreTargetPatch) *string { + if v == nil { + return nil + } + return v.Namespace + }).(pulumi.StringPtrOutput) +} + +// Version of the API Group to select resources from. +// Together with Group and Kind it is capable of unambiguously identifying and/or selecting resources. +// https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md +func (o HelmReleaseSpecDriftDetectionIgnoreTargetPatchPtrOutput) Version() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecDriftDetectionIgnoreTargetPatch) *string { + if v == nil { + return nil + } + return v.Version + }).(pulumi.StringPtrOutput) +} + +// DriftDetection holds the configuration for detecting and handling +// differences between the manifest in the Helm storage and the resources +// currently existing in the cluster. +type HelmReleaseSpecDriftDetectionPatch struct { + // Ignore contains a list of rules for specifying which changes to ignore + // during diffing. + Ignore []HelmReleaseSpecDriftDetectionIgnorePatch `pulumi:"ignore"` + // Mode defines how differences should be handled between the Helm manifest + // and the manifest currently applied to the cluster. + // If not explicitly set, it defaults to DiffModeDisabled. + Mode *string `pulumi:"mode"` +} + +// HelmReleaseSpecDriftDetectionPatchInput is an input type that accepts HelmReleaseSpecDriftDetectionPatchArgs and HelmReleaseSpecDriftDetectionPatchOutput values. +// You can construct a concrete instance of `HelmReleaseSpecDriftDetectionPatchInput` via: +// +// HelmReleaseSpecDriftDetectionPatchArgs{...} +type HelmReleaseSpecDriftDetectionPatchInput interface { + pulumi.Input + + ToHelmReleaseSpecDriftDetectionPatchOutput() HelmReleaseSpecDriftDetectionPatchOutput + ToHelmReleaseSpecDriftDetectionPatchOutputWithContext(context.Context) HelmReleaseSpecDriftDetectionPatchOutput +} + +// DriftDetection holds the configuration for detecting and handling +// differences between the manifest in the Helm storage and the resources +// currently existing in the cluster. +type HelmReleaseSpecDriftDetectionPatchArgs struct { + // Ignore contains a list of rules for specifying which changes to ignore + // during diffing. + Ignore HelmReleaseSpecDriftDetectionIgnorePatchArrayInput `pulumi:"ignore"` + // Mode defines how differences should be handled between the Helm manifest + // and the manifest currently applied to the cluster. + // If not explicitly set, it defaults to DiffModeDisabled. + Mode pulumi.StringPtrInput `pulumi:"mode"` +} + +func (HelmReleaseSpecDriftDetectionPatchArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecDriftDetectionPatch)(nil)).Elem() +} + +func (i HelmReleaseSpecDriftDetectionPatchArgs) ToHelmReleaseSpecDriftDetectionPatchOutput() HelmReleaseSpecDriftDetectionPatchOutput { + return i.ToHelmReleaseSpecDriftDetectionPatchOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecDriftDetectionPatchArgs) ToHelmReleaseSpecDriftDetectionPatchOutputWithContext(ctx context.Context) HelmReleaseSpecDriftDetectionPatchOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecDriftDetectionPatchOutput) +} + +func (i HelmReleaseSpecDriftDetectionPatchArgs) ToHelmReleaseSpecDriftDetectionPatchPtrOutput() HelmReleaseSpecDriftDetectionPatchPtrOutput { + return i.ToHelmReleaseSpecDriftDetectionPatchPtrOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecDriftDetectionPatchArgs) ToHelmReleaseSpecDriftDetectionPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecDriftDetectionPatchPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecDriftDetectionPatchOutput).ToHelmReleaseSpecDriftDetectionPatchPtrOutputWithContext(ctx) +} + +// HelmReleaseSpecDriftDetectionPatchPtrInput is an input type that accepts HelmReleaseSpecDriftDetectionPatchArgs, HelmReleaseSpecDriftDetectionPatchPtr and HelmReleaseSpecDriftDetectionPatchPtrOutput values. +// You can construct a concrete instance of `HelmReleaseSpecDriftDetectionPatchPtrInput` via: +// +// HelmReleaseSpecDriftDetectionPatchArgs{...} +// +// or: +// +// nil +type HelmReleaseSpecDriftDetectionPatchPtrInput interface { + pulumi.Input + + ToHelmReleaseSpecDriftDetectionPatchPtrOutput() HelmReleaseSpecDriftDetectionPatchPtrOutput + ToHelmReleaseSpecDriftDetectionPatchPtrOutputWithContext(context.Context) HelmReleaseSpecDriftDetectionPatchPtrOutput +} + +type helmReleaseSpecDriftDetectionPatchPtrType HelmReleaseSpecDriftDetectionPatchArgs + +func HelmReleaseSpecDriftDetectionPatchPtr(v *HelmReleaseSpecDriftDetectionPatchArgs) HelmReleaseSpecDriftDetectionPatchPtrInput { + return (*helmReleaseSpecDriftDetectionPatchPtrType)(v) +} + +func (*helmReleaseSpecDriftDetectionPatchPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecDriftDetectionPatch)(nil)).Elem() +} + +func (i *helmReleaseSpecDriftDetectionPatchPtrType) ToHelmReleaseSpecDriftDetectionPatchPtrOutput() HelmReleaseSpecDriftDetectionPatchPtrOutput { + return i.ToHelmReleaseSpecDriftDetectionPatchPtrOutputWithContext(context.Background()) +} + +func (i *helmReleaseSpecDriftDetectionPatchPtrType) ToHelmReleaseSpecDriftDetectionPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecDriftDetectionPatchPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecDriftDetectionPatchPtrOutput) +} + +// DriftDetection holds the configuration for detecting and handling +// differences between the manifest in the Helm storage and the resources +// currently existing in the cluster. +type HelmReleaseSpecDriftDetectionPatchOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecDriftDetectionPatchOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecDriftDetectionPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecDriftDetectionPatchOutput) ToHelmReleaseSpecDriftDetectionPatchOutput() HelmReleaseSpecDriftDetectionPatchOutput { + return o +} + +func (o HelmReleaseSpecDriftDetectionPatchOutput) ToHelmReleaseSpecDriftDetectionPatchOutputWithContext(ctx context.Context) HelmReleaseSpecDriftDetectionPatchOutput { + return o +} + +func (o HelmReleaseSpecDriftDetectionPatchOutput) ToHelmReleaseSpecDriftDetectionPatchPtrOutput() HelmReleaseSpecDriftDetectionPatchPtrOutput { + return o.ToHelmReleaseSpecDriftDetectionPatchPtrOutputWithContext(context.Background()) +} + +func (o HelmReleaseSpecDriftDetectionPatchOutput) ToHelmReleaseSpecDriftDetectionPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecDriftDetectionPatchPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v HelmReleaseSpecDriftDetectionPatch) *HelmReleaseSpecDriftDetectionPatch { + return &v + }).(HelmReleaseSpecDriftDetectionPatchPtrOutput) +} + +// Ignore contains a list of rules for specifying which changes to ignore +// during diffing. +func (o HelmReleaseSpecDriftDetectionPatchOutput) Ignore() HelmReleaseSpecDriftDetectionIgnorePatchArrayOutput { + return o.ApplyT(func(v HelmReleaseSpecDriftDetectionPatch) []HelmReleaseSpecDriftDetectionIgnorePatch { return v.Ignore }).(HelmReleaseSpecDriftDetectionIgnorePatchArrayOutput) +} + +// Mode defines how differences should be handled between the Helm manifest +// and the manifest currently applied to the cluster. +// If not explicitly set, it defaults to DiffModeDisabled. +func (o HelmReleaseSpecDriftDetectionPatchOutput) Mode() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecDriftDetectionPatch) *string { return v.Mode }).(pulumi.StringPtrOutput) +} + +type HelmReleaseSpecDriftDetectionPatchPtrOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecDriftDetectionPatchPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecDriftDetectionPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecDriftDetectionPatchPtrOutput) ToHelmReleaseSpecDriftDetectionPatchPtrOutput() HelmReleaseSpecDriftDetectionPatchPtrOutput { + return o +} + +func (o HelmReleaseSpecDriftDetectionPatchPtrOutput) ToHelmReleaseSpecDriftDetectionPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecDriftDetectionPatchPtrOutput { + return o +} + +func (o HelmReleaseSpecDriftDetectionPatchPtrOutput) Elem() HelmReleaseSpecDriftDetectionPatchOutput { + return o.ApplyT(func(v *HelmReleaseSpecDriftDetectionPatch) HelmReleaseSpecDriftDetectionPatch { + if v != nil { + return *v + } + var ret HelmReleaseSpecDriftDetectionPatch + return ret + }).(HelmReleaseSpecDriftDetectionPatchOutput) +} + +// Ignore contains a list of rules for specifying which changes to ignore +// during diffing. +func (o HelmReleaseSpecDriftDetectionPatchPtrOutput) Ignore() HelmReleaseSpecDriftDetectionIgnorePatchArrayOutput { + return o.ApplyT(func(v *HelmReleaseSpecDriftDetectionPatch) []HelmReleaseSpecDriftDetectionIgnorePatch { + if v == nil { + return nil + } + return v.Ignore + }).(HelmReleaseSpecDriftDetectionIgnorePatchArrayOutput) +} + +// Mode defines how differences should be handled between the Helm manifest +// and the manifest currently applied to the cluster. +// If not explicitly set, it defaults to DiffModeDisabled. +func (o HelmReleaseSpecDriftDetectionPatchPtrOutput) Mode() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecDriftDetectionPatch) *string { + if v == nil { + return nil + } + return v.Mode + }).(pulumi.StringPtrOutput) +} + +// CustomHealthCheck defines the health check for custom resources. +type HelmReleaseSpecHealthCheckExprs struct { + // APIVersion of the custom resource under evaluation. + ApiVersion *string `pulumi:"apiVersion"` + // Current is the CEL expression that determines if the status + // of the custom resource has reached the desired state. + Current *string `pulumi:"current"` + // Failed is the CEL expression that determines if the status + // of the custom resource has failed to reach the desired state. + Failed *string `pulumi:"failed"` + // InProgress is the CEL expression that determines if the status + // of the custom resource has not yet reached the desired state. + InProgress *string `pulumi:"inProgress"` + // Kind of the custom resource under evaluation. + Kind *string `pulumi:"kind"` +} + +// HelmReleaseSpecHealthCheckExprsInput is an input type that accepts HelmReleaseSpecHealthCheckExprsArgs and HelmReleaseSpecHealthCheckExprsOutput values. +// You can construct a concrete instance of `HelmReleaseSpecHealthCheckExprsInput` via: +// +// HelmReleaseSpecHealthCheckExprsArgs{...} +type HelmReleaseSpecHealthCheckExprsInput interface { + pulumi.Input + + ToHelmReleaseSpecHealthCheckExprsOutput() HelmReleaseSpecHealthCheckExprsOutput + ToHelmReleaseSpecHealthCheckExprsOutputWithContext(context.Context) HelmReleaseSpecHealthCheckExprsOutput +} + +// CustomHealthCheck defines the health check for custom resources. +type HelmReleaseSpecHealthCheckExprsArgs struct { + // APIVersion of the custom resource under evaluation. + ApiVersion pulumi.StringPtrInput `pulumi:"apiVersion"` + // Current is the CEL expression that determines if the status + // of the custom resource has reached the desired state. + Current pulumi.StringPtrInput `pulumi:"current"` + // Failed is the CEL expression that determines if the status + // of the custom resource has failed to reach the desired state. + Failed pulumi.StringPtrInput `pulumi:"failed"` + // InProgress is the CEL expression that determines if the status + // of the custom resource has not yet reached the desired state. + InProgress pulumi.StringPtrInput `pulumi:"inProgress"` + // Kind of the custom resource under evaluation. + Kind pulumi.StringPtrInput `pulumi:"kind"` +} + +func (HelmReleaseSpecHealthCheckExprsArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecHealthCheckExprs)(nil)).Elem() +} + +func (i HelmReleaseSpecHealthCheckExprsArgs) ToHelmReleaseSpecHealthCheckExprsOutput() HelmReleaseSpecHealthCheckExprsOutput { + return i.ToHelmReleaseSpecHealthCheckExprsOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecHealthCheckExprsArgs) ToHelmReleaseSpecHealthCheckExprsOutputWithContext(ctx context.Context) HelmReleaseSpecHealthCheckExprsOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecHealthCheckExprsOutput) +} + +// HelmReleaseSpecHealthCheckExprsArrayInput is an input type that accepts HelmReleaseSpecHealthCheckExprsArray and HelmReleaseSpecHealthCheckExprsArrayOutput values. +// You can construct a concrete instance of `HelmReleaseSpecHealthCheckExprsArrayInput` via: +// +// HelmReleaseSpecHealthCheckExprsArray{ HelmReleaseSpecHealthCheckExprsArgs{...} } +type HelmReleaseSpecHealthCheckExprsArrayInput interface { + pulumi.Input + + ToHelmReleaseSpecHealthCheckExprsArrayOutput() HelmReleaseSpecHealthCheckExprsArrayOutput + ToHelmReleaseSpecHealthCheckExprsArrayOutputWithContext(context.Context) HelmReleaseSpecHealthCheckExprsArrayOutput +} + +type HelmReleaseSpecHealthCheckExprsArray []HelmReleaseSpecHealthCheckExprsInput + +func (HelmReleaseSpecHealthCheckExprsArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]HelmReleaseSpecHealthCheckExprs)(nil)).Elem() +} + +func (i HelmReleaseSpecHealthCheckExprsArray) ToHelmReleaseSpecHealthCheckExprsArrayOutput() HelmReleaseSpecHealthCheckExprsArrayOutput { + return i.ToHelmReleaseSpecHealthCheckExprsArrayOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecHealthCheckExprsArray) ToHelmReleaseSpecHealthCheckExprsArrayOutputWithContext(ctx context.Context) HelmReleaseSpecHealthCheckExprsArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecHealthCheckExprsArrayOutput) +} + +// CustomHealthCheck defines the health check for custom resources. +type HelmReleaseSpecHealthCheckExprsOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecHealthCheckExprsOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecHealthCheckExprs)(nil)).Elem() +} + +func (o HelmReleaseSpecHealthCheckExprsOutput) ToHelmReleaseSpecHealthCheckExprsOutput() HelmReleaseSpecHealthCheckExprsOutput { + return o +} + +func (o HelmReleaseSpecHealthCheckExprsOutput) ToHelmReleaseSpecHealthCheckExprsOutputWithContext(ctx context.Context) HelmReleaseSpecHealthCheckExprsOutput { + return o +} + +// APIVersion of the custom resource under evaluation. +func (o HelmReleaseSpecHealthCheckExprsOutput) ApiVersion() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecHealthCheckExprs) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) +} + +// Current is the CEL expression that determines if the status +// of the custom resource has reached the desired state. +func (o HelmReleaseSpecHealthCheckExprsOutput) Current() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecHealthCheckExprs) *string { return v.Current }).(pulumi.StringPtrOutput) +} + +// Failed is the CEL expression that determines if the status +// of the custom resource has failed to reach the desired state. +func (o HelmReleaseSpecHealthCheckExprsOutput) Failed() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecHealthCheckExprs) *string { return v.Failed }).(pulumi.StringPtrOutput) +} + +// InProgress is the CEL expression that determines if the status +// of the custom resource has not yet reached the desired state. +func (o HelmReleaseSpecHealthCheckExprsOutput) InProgress() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecHealthCheckExprs) *string { return v.InProgress }).(pulumi.StringPtrOutput) +} + +// Kind of the custom resource under evaluation. +func (o HelmReleaseSpecHealthCheckExprsOutput) Kind() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecHealthCheckExprs) *string { return v.Kind }).(pulumi.StringPtrOutput) +} + +type HelmReleaseSpecHealthCheckExprsArrayOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecHealthCheckExprsArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]HelmReleaseSpecHealthCheckExprs)(nil)).Elem() +} + +func (o HelmReleaseSpecHealthCheckExprsArrayOutput) ToHelmReleaseSpecHealthCheckExprsArrayOutput() HelmReleaseSpecHealthCheckExprsArrayOutput { + return o +} + +func (o HelmReleaseSpecHealthCheckExprsArrayOutput) ToHelmReleaseSpecHealthCheckExprsArrayOutputWithContext(ctx context.Context) HelmReleaseSpecHealthCheckExprsArrayOutput { + return o +} + +func (o HelmReleaseSpecHealthCheckExprsArrayOutput) Index(i pulumi.IntInput) HelmReleaseSpecHealthCheckExprsOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) HelmReleaseSpecHealthCheckExprs { + return vs[0].([]HelmReleaseSpecHealthCheckExprs)[vs[1].(int)] + }).(HelmReleaseSpecHealthCheckExprsOutput) +} + +// CustomHealthCheck defines the health check for custom resources. +type HelmReleaseSpecHealthCheckExprsPatch struct { + // APIVersion of the custom resource under evaluation. + ApiVersion *string `pulumi:"apiVersion"` + // Current is the CEL expression that determines if the status + // of the custom resource has reached the desired state. + Current *string `pulumi:"current"` + // Failed is the CEL expression that determines if the status + // of the custom resource has failed to reach the desired state. + Failed *string `pulumi:"failed"` + // InProgress is the CEL expression that determines if the status + // of the custom resource has not yet reached the desired state. + InProgress *string `pulumi:"inProgress"` + // Kind of the custom resource under evaluation. + Kind *string `pulumi:"kind"` +} + +// HelmReleaseSpecHealthCheckExprsPatchInput is an input type that accepts HelmReleaseSpecHealthCheckExprsPatchArgs and HelmReleaseSpecHealthCheckExprsPatchOutput values. +// You can construct a concrete instance of `HelmReleaseSpecHealthCheckExprsPatchInput` via: +// +// HelmReleaseSpecHealthCheckExprsPatchArgs{...} +type HelmReleaseSpecHealthCheckExprsPatchInput interface { + pulumi.Input + + ToHelmReleaseSpecHealthCheckExprsPatchOutput() HelmReleaseSpecHealthCheckExprsPatchOutput + ToHelmReleaseSpecHealthCheckExprsPatchOutputWithContext(context.Context) HelmReleaseSpecHealthCheckExprsPatchOutput +} + +// CustomHealthCheck defines the health check for custom resources. +type HelmReleaseSpecHealthCheckExprsPatchArgs struct { + // APIVersion of the custom resource under evaluation. + ApiVersion pulumi.StringPtrInput `pulumi:"apiVersion"` + // Current is the CEL expression that determines if the status + // of the custom resource has reached the desired state. + Current pulumi.StringPtrInput `pulumi:"current"` + // Failed is the CEL expression that determines if the status + // of the custom resource has failed to reach the desired state. + Failed pulumi.StringPtrInput `pulumi:"failed"` + // InProgress is the CEL expression that determines if the status + // of the custom resource has not yet reached the desired state. + InProgress pulumi.StringPtrInput `pulumi:"inProgress"` + // Kind of the custom resource under evaluation. + Kind pulumi.StringPtrInput `pulumi:"kind"` +} + +func (HelmReleaseSpecHealthCheckExprsPatchArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecHealthCheckExprsPatch)(nil)).Elem() +} + +func (i HelmReleaseSpecHealthCheckExprsPatchArgs) ToHelmReleaseSpecHealthCheckExprsPatchOutput() HelmReleaseSpecHealthCheckExprsPatchOutput { + return i.ToHelmReleaseSpecHealthCheckExprsPatchOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecHealthCheckExprsPatchArgs) ToHelmReleaseSpecHealthCheckExprsPatchOutputWithContext(ctx context.Context) HelmReleaseSpecHealthCheckExprsPatchOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecHealthCheckExprsPatchOutput) +} + +// HelmReleaseSpecHealthCheckExprsPatchArrayInput is an input type that accepts HelmReleaseSpecHealthCheckExprsPatchArray and HelmReleaseSpecHealthCheckExprsPatchArrayOutput values. +// You can construct a concrete instance of `HelmReleaseSpecHealthCheckExprsPatchArrayInput` via: +// +// HelmReleaseSpecHealthCheckExprsPatchArray{ HelmReleaseSpecHealthCheckExprsPatchArgs{...} } +type HelmReleaseSpecHealthCheckExprsPatchArrayInput interface { + pulumi.Input + + ToHelmReleaseSpecHealthCheckExprsPatchArrayOutput() HelmReleaseSpecHealthCheckExprsPatchArrayOutput + ToHelmReleaseSpecHealthCheckExprsPatchArrayOutputWithContext(context.Context) HelmReleaseSpecHealthCheckExprsPatchArrayOutput +} + +type HelmReleaseSpecHealthCheckExprsPatchArray []HelmReleaseSpecHealthCheckExprsPatchInput + +func (HelmReleaseSpecHealthCheckExprsPatchArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]HelmReleaseSpecHealthCheckExprsPatch)(nil)).Elem() +} + +func (i HelmReleaseSpecHealthCheckExprsPatchArray) ToHelmReleaseSpecHealthCheckExprsPatchArrayOutput() HelmReleaseSpecHealthCheckExprsPatchArrayOutput { + return i.ToHelmReleaseSpecHealthCheckExprsPatchArrayOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecHealthCheckExprsPatchArray) ToHelmReleaseSpecHealthCheckExprsPatchArrayOutputWithContext(ctx context.Context) HelmReleaseSpecHealthCheckExprsPatchArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecHealthCheckExprsPatchArrayOutput) +} + +// CustomHealthCheck defines the health check for custom resources. +type HelmReleaseSpecHealthCheckExprsPatchOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecHealthCheckExprsPatchOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecHealthCheckExprsPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecHealthCheckExprsPatchOutput) ToHelmReleaseSpecHealthCheckExprsPatchOutput() HelmReleaseSpecHealthCheckExprsPatchOutput { + return o +} + +func (o HelmReleaseSpecHealthCheckExprsPatchOutput) ToHelmReleaseSpecHealthCheckExprsPatchOutputWithContext(ctx context.Context) HelmReleaseSpecHealthCheckExprsPatchOutput { + return o +} + +// APIVersion of the custom resource under evaluation. +func (o HelmReleaseSpecHealthCheckExprsPatchOutput) ApiVersion() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecHealthCheckExprsPatch) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) +} + +// Current is the CEL expression that determines if the status +// of the custom resource has reached the desired state. +func (o HelmReleaseSpecHealthCheckExprsPatchOutput) Current() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecHealthCheckExprsPatch) *string { return v.Current }).(pulumi.StringPtrOutput) +} + +// Failed is the CEL expression that determines if the status +// of the custom resource has failed to reach the desired state. +func (o HelmReleaseSpecHealthCheckExprsPatchOutput) Failed() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecHealthCheckExprsPatch) *string { return v.Failed }).(pulumi.StringPtrOutput) +} + +// InProgress is the CEL expression that determines if the status +// of the custom resource has not yet reached the desired state. +func (o HelmReleaseSpecHealthCheckExprsPatchOutput) InProgress() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecHealthCheckExprsPatch) *string { return v.InProgress }).(pulumi.StringPtrOutput) +} + +// Kind of the custom resource under evaluation. +func (o HelmReleaseSpecHealthCheckExprsPatchOutput) Kind() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecHealthCheckExprsPatch) *string { return v.Kind }).(pulumi.StringPtrOutput) +} + +type HelmReleaseSpecHealthCheckExprsPatchArrayOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecHealthCheckExprsPatchArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]HelmReleaseSpecHealthCheckExprsPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecHealthCheckExprsPatchArrayOutput) ToHelmReleaseSpecHealthCheckExprsPatchArrayOutput() HelmReleaseSpecHealthCheckExprsPatchArrayOutput { + return o +} + +func (o HelmReleaseSpecHealthCheckExprsPatchArrayOutput) ToHelmReleaseSpecHealthCheckExprsPatchArrayOutputWithContext(ctx context.Context) HelmReleaseSpecHealthCheckExprsPatchArrayOutput { + return o +} + +func (o HelmReleaseSpecHealthCheckExprsPatchArrayOutput) Index(i pulumi.IntInput) HelmReleaseSpecHealthCheckExprsPatchOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) HelmReleaseSpecHealthCheckExprsPatch { + return vs[0].([]HelmReleaseSpecHealthCheckExprsPatch)[vs[1].(int)] + }).(HelmReleaseSpecHealthCheckExprsPatchOutput) +} + +// Install holds the configuration for Helm install actions for this HelmRelease. +type HelmReleaseSpecInstall struct { + // CRDs upgrade CRDs from the Helm Chart's crds directory according + // to the CRD upgrade policy provided here. Valid values are `Skip`, + // `Create` or `CreateReplace`. Default is `Create` and if omitted + // CRDs are installed but not updated. + // + // Skip: do neither install nor replace (update) any CRDs. + // + // Create: new CRDs are created, existing CRDs are neither updated nor deleted. + // + // CreateReplace: new CRDs are created, existing CRDs are updated (replaced) + // but not deleted. + // + // By default, CRDs are applied (installed) during Helm install action. + // With this option users can opt in to CRD replace existing CRDs on Helm + // install actions, which is not (yet) natively supported by Helm. + // https://helm.sh/docs/chart_best_practices/custom_resource_definitions. + Crds *string `pulumi:"crds"` + // CreateNamespace tells the Helm install action to create the + // HelmReleaseSpec.TargetNamespace if it does not exist yet. + // On uninstall, the namespace will not be garbage collected. + CreateNamespace *bool `pulumi:"createNamespace"` + // DisableHooks prevents hooks from running during the Helm install action. + DisableHooks *bool `pulumi:"disableHooks"` + // DisableOpenAPIValidation prevents the Helm install action from validating + // rendered templates against the Kubernetes OpenAPI Schema. + DisableOpenAPIValidation *bool `pulumi:"disableOpenAPIValidation"` + // DisableSchemaValidation prevents the Helm install action from validating + // the values against the JSON Schema. + DisableSchemaValidation *bool `pulumi:"disableSchemaValidation"` + // DisableTakeOwnership disables taking ownership of existing resources + // during the Helm install action. Defaults to false. + DisableTakeOwnership *bool `pulumi:"disableTakeOwnership"` + // DisableWait disables the waiting for resources to be ready after a Helm + // install has been performed. + DisableWait *bool `pulumi:"disableWait"` + // DisableWaitForJobs disables waiting for jobs to complete after a Helm + // install has been performed. + DisableWaitForJobs *bool `pulumi:"disableWaitForJobs"` + Remediation *HelmReleaseSpecInstallRemediation `pulumi:"remediation"` + // Replace tells the Helm install action to re-use the 'ReleaseName', but only + // if that name is a deleted release which remains in the history. + Replace *bool `pulumi:"replace"` + // ServerSideApply enables server-side apply for resources during install. + // Defaults to true (or false when UseHelm3Defaults feature gate is enabled). + ServerSideApply *bool `pulumi:"serverSideApply"` + // SkipCRDs tells the Helm install action to not install any CRDs. By default, + // CRDs are installed if not already present. + // + // Deprecated use CRD policy (`crds`) attribute with value `Skip` instead. + SkipCRDs *bool `pulumi:"skipCRDs"` + Strategy *HelmReleaseSpecInstallStrategy `pulumi:"strategy"` + // Timeout is the time to wait for any individual Kubernetes operation (like + // Jobs for hooks) during the performance of a Helm install action. Defaults to + // 'HelmReleaseSpec.Timeout'. + Timeout *string `pulumi:"timeout"` +} + +// HelmReleaseSpecInstallInput is an input type that accepts HelmReleaseSpecInstallArgs and HelmReleaseSpecInstallOutput values. +// You can construct a concrete instance of `HelmReleaseSpecInstallInput` via: +// +// HelmReleaseSpecInstallArgs{...} +type HelmReleaseSpecInstallInput interface { + pulumi.Input + + ToHelmReleaseSpecInstallOutput() HelmReleaseSpecInstallOutput + ToHelmReleaseSpecInstallOutputWithContext(context.Context) HelmReleaseSpecInstallOutput +} + +// Install holds the configuration for Helm install actions for this HelmRelease. +type HelmReleaseSpecInstallArgs struct { + // CRDs upgrade CRDs from the Helm Chart's crds directory according + // to the CRD upgrade policy provided here. Valid values are `Skip`, + // `Create` or `CreateReplace`. Default is `Create` and if omitted + // CRDs are installed but not updated. + // + // Skip: do neither install nor replace (update) any CRDs. + // + // Create: new CRDs are created, existing CRDs are neither updated nor deleted. + // + // CreateReplace: new CRDs are created, existing CRDs are updated (replaced) + // but not deleted. + // + // By default, CRDs are applied (installed) during Helm install action. + // With this option users can opt in to CRD replace existing CRDs on Helm + // install actions, which is not (yet) natively supported by Helm. + // https://helm.sh/docs/chart_best_practices/custom_resource_definitions. + Crds pulumi.StringPtrInput `pulumi:"crds"` + // CreateNamespace tells the Helm install action to create the + // HelmReleaseSpec.TargetNamespace if it does not exist yet. + // On uninstall, the namespace will not be garbage collected. + CreateNamespace pulumi.BoolPtrInput `pulumi:"createNamespace"` + // DisableHooks prevents hooks from running during the Helm install action. + DisableHooks pulumi.BoolPtrInput `pulumi:"disableHooks"` + // DisableOpenAPIValidation prevents the Helm install action from validating + // rendered templates against the Kubernetes OpenAPI Schema. + DisableOpenAPIValidation pulumi.BoolPtrInput `pulumi:"disableOpenAPIValidation"` + // DisableSchemaValidation prevents the Helm install action from validating + // the values against the JSON Schema. + DisableSchemaValidation pulumi.BoolPtrInput `pulumi:"disableSchemaValidation"` + // DisableTakeOwnership disables taking ownership of existing resources + // during the Helm install action. Defaults to false. + DisableTakeOwnership pulumi.BoolPtrInput `pulumi:"disableTakeOwnership"` + // DisableWait disables the waiting for resources to be ready after a Helm + // install has been performed. + DisableWait pulumi.BoolPtrInput `pulumi:"disableWait"` + // DisableWaitForJobs disables waiting for jobs to complete after a Helm + // install has been performed. + DisableWaitForJobs pulumi.BoolPtrInput `pulumi:"disableWaitForJobs"` + Remediation HelmReleaseSpecInstallRemediationPtrInput `pulumi:"remediation"` + // Replace tells the Helm install action to re-use the 'ReleaseName', but only + // if that name is a deleted release which remains in the history. + Replace pulumi.BoolPtrInput `pulumi:"replace"` + // ServerSideApply enables server-side apply for resources during install. + // Defaults to true (or false when UseHelm3Defaults feature gate is enabled). + ServerSideApply pulumi.BoolPtrInput `pulumi:"serverSideApply"` + // SkipCRDs tells the Helm install action to not install any CRDs. By default, + // CRDs are installed if not already present. + // + // Deprecated use CRD policy (`crds`) attribute with value `Skip` instead. + SkipCRDs pulumi.BoolPtrInput `pulumi:"skipCRDs"` + Strategy HelmReleaseSpecInstallStrategyPtrInput `pulumi:"strategy"` + // Timeout is the time to wait for any individual Kubernetes operation (like + // Jobs for hooks) during the performance of a Helm install action. Defaults to + // 'HelmReleaseSpec.Timeout'. + Timeout pulumi.StringPtrInput `pulumi:"timeout"` +} + +func (HelmReleaseSpecInstallArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecInstall)(nil)).Elem() +} + +func (i HelmReleaseSpecInstallArgs) ToHelmReleaseSpecInstallOutput() HelmReleaseSpecInstallOutput { + return i.ToHelmReleaseSpecInstallOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecInstallArgs) ToHelmReleaseSpecInstallOutputWithContext(ctx context.Context) HelmReleaseSpecInstallOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecInstallOutput) +} + +func (i HelmReleaseSpecInstallArgs) ToHelmReleaseSpecInstallPtrOutput() HelmReleaseSpecInstallPtrOutput { + return i.ToHelmReleaseSpecInstallPtrOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecInstallArgs) ToHelmReleaseSpecInstallPtrOutputWithContext(ctx context.Context) HelmReleaseSpecInstallPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecInstallOutput).ToHelmReleaseSpecInstallPtrOutputWithContext(ctx) +} + +// HelmReleaseSpecInstallPtrInput is an input type that accepts HelmReleaseSpecInstallArgs, HelmReleaseSpecInstallPtr and HelmReleaseSpecInstallPtrOutput values. +// You can construct a concrete instance of `HelmReleaseSpecInstallPtrInput` via: +// +// HelmReleaseSpecInstallArgs{...} +// +// or: +// +// nil +type HelmReleaseSpecInstallPtrInput interface { + pulumi.Input + + ToHelmReleaseSpecInstallPtrOutput() HelmReleaseSpecInstallPtrOutput + ToHelmReleaseSpecInstallPtrOutputWithContext(context.Context) HelmReleaseSpecInstallPtrOutput +} + +type helmReleaseSpecInstallPtrType HelmReleaseSpecInstallArgs + +func HelmReleaseSpecInstallPtr(v *HelmReleaseSpecInstallArgs) HelmReleaseSpecInstallPtrInput { + return (*helmReleaseSpecInstallPtrType)(v) +} + +func (*helmReleaseSpecInstallPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecInstall)(nil)).Elem() +} + +func (i *helmReleaseSpecInstallPtrType) ToHelmReleaseSpecInstallPtrOutput() HelmReleaseSpecInstallPtrOutput { + return i.ToHelmReleaseSpecInstallPtrOutputWithContext(context.Background()) +} + +func (i *helmReleaseSpecInstallPtrType) ToHelmReleaseSpecInstallPtrOutputWithContext(ctx context.Context) HelmReleaseSpecInstallPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecInstallPtrOutput) +} + +// Install holds the configuration for Helm install actions for this HelmRelease. +type HelmReleaseSpecInstallOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecInstallOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecInstall)(nil)).Elem() +} + +func (o HelmReleaseSpecInstallOutput) ToHelmReleaseSpecInstallOutput() HelmReleaseSpecInstallOutput { + return o +} + +func (o HelmReleaseSpecInstallOutput) ToHelmReleaseSpecInstallOutputWithContext(ctx context.Context) HelmReleaseSpecInstallOutput { + return o +} + +func (o HelmReleaseSpecInstallOutput) ToHelmReleaseSpecInstallPtrOutput() HelmReleaseSpecInstallPtrOutput { + return o.ToHelmReleaseSpecInstallPtrOutputWithContext(context.Background()) +} + +func (o HelmReleaseSpecInstallOutput) ToHelmReleaseSpecInstallPtrOutputWithContext(ctx context.Context) HelmReleaseSpecInstallPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v HelmReleaseSpecInstall) *HelmReleaseSpecInstall { + return &v + }).(HelmReleaseSpecInstallPtrOutput) +} + +// CRDs upgrade CRDs from the Helm Chart's crds directory according +// to the CRD upgrade policy provided here. Valid values are `Skip`, +// `Create` or `CreateReplace`. Default is `Create` and if omitted +// CRDs are installed but not updated. +// +// Skip: do neither install nor replace (update) any CRDs. +// +// Create: new CRDs are created, existing CRDs are neither updated nor deleted. +// +// CreateReplace: new CRDs are created, existing CRDs are updated (replaced) +// but not deleted. +// +// By default, CRDs are applied (installed) during Helm install action. +// With this option users can opt in to CRD replace existing CRDs on Helm +// install actions, which is not (yet) natively supported by Helm. +// https://helm.sh/docs/chart_best_practices/custom_resource_definitions. +func (o HelmReleaseSpecInstallOutput) Crds() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecInstall) *string { return v.Crds }).(pulumi.StringPtrOutput) +} + +// CreateNamespace tells the Helm install action to create the +// HelmReleaseSpec.TargetNamespace if it does not exist yet. +// On uninstall, the namespace will not be garbage collected. +func (o HelmReleaseSpecInstallOutput) CreateNamespace() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecInstall) *bool { return v.CreateNamespace }).(pulumi.BoolPtrOutput) +} + +// DisableHooks prevents hooks from running during the Helm install action. +func (o HelmReleaseSpecInstallOutput) DisableHooks() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecInstall) *bool { return v.DisableHooks }).(pulumi.BoolPtrOutput) +} + +// DisableOpenAPIValidation prevents the Helm install action from validating +// rendered templates against the Kubernetes OpenAPI Schema. +func (o HelmReleaseSpecInstallOutput) DisableOpenAPIValidation() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecInstall) *bool { return v.DisableOpenAPIValidation }).(pulumi.BoolPtrOutput) +} + +// DisableSchemaValidation prevents the Helm install action from validating +// the values against the JSON Schema. +func (o HelmReleaseSpecInstallOutput) DisableSchemaValidation() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecInstall) *bool { return v.DisableSchemaValidation }).(pulumi.BoolPtrOutput) +} + +// DisableTakeOwnership disables taking ownership of existing resources +// during the Helm install action. Defaults to false. +func (o HelmReleaseSpecInstallOutput) DisableTakeOwnership() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecInstall) *bool { return v.DisableTakeOwnership }).(pulumi.BoolPtrOutput) +} + +// DisableWait disables the waiting for resources to be ready after a Helm +// install has been performed. +func (o HelmReleaseSpecInstallOutput) DisableWait() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecInstall) *bool { return v.DisableWait }).(pulumi.BoolPtrOutput) +} + +// DisableWaitForJobs disables waiting for jobs to complete after a Helm +// install has been performed. +func (o HelmReleaseSpecInstallOutput) DisableWaitForJobs() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecInstall) *bool { return v.DisableWaitForJobs }).(pulumi.BoolPtrOutput) +} + +func (o HelmReleaseSpecInstallOutput) Remediation() HelmReleaseSpecInstallRemediationPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecInstall) *HelmReleaseSpecInstallRemediation { return v.Remediation }).(HelmReleaseSpecInstallRemediationPtrOutput) +} + +// Replace tells the Helm install action to re-use the 'ReleaseName', but only +// if that name is a deleted release which remains in the history. +func (o HelmReleaseSpecInstallOutput) Replace() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecInstall) *bool { return v.Replace }).(pulumi.BoolPtrOutput) +} + +// ServerSideApply enables server-side apply for resources during install. +// Defaults to true (or false when UseHelm3Defaults feature gate is enabled). +func (o HelmReleaseSpecInstallOutput) ServerSideApply() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecInstall) *bool { return v.ServerSideApply }).(pulumi.BoolPtrOutput) +} + +// SkipCRDs tells the Helm install action to not install any CRDs. By default, +// CRDs are installed if not already present. +// +// Deprecated use CRD policy (`crds`) attribute with value `Skip` instead. +func (o HelmReleaseSpecInstallOutput) SkipCRDs() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecInstall) *bool { return v.SkipCRDs }).(pulumi.BoolPtrOutput) +} + +func (o HelmReleaseSpecInstallOutput) Strategy() HelmReleaseSpecInstallStrategyPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecInstall) *HelmReleaseSpecInstallStrategy { return v.Strategy }).(HelmReleaseSpecInstallStrategyPtrOutput) +} + +// Timeout is the time to wait for any individual Kubernetes operation (like +// Jobs for hooks) during the performance of a Helm install action. Defaults to +// 'HelmReleaseSpec.Timeout'. +func (o HelmReleaseSpecInstallOutput) Timeout() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecInstall) *string { return v.Timeout }).(pulumi.StringPtrOutput) +} + +type HelmReleaseSpecInstallPtrOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecInstallPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecInstall)(nil)).Elem() +} + +func (o HelmReleaseSpecInstallPtrOutput) ToHelmReleaseSpecInstallPtrOutput() HelmReleaseSpecInstallPtrOutput { + return o +} + +func (o HelmReleaseSpecInstallPtrOutput) ToHelmReleaseSpecInstallPtrOutputWithContext(ctx context.Context) HelmReleaseSpecInstallPtrOutput { + return o +} + +func (o HelmReleaseSpecInstallPtrOutput) Elem() HelmReleaseSpecInstallOutput { + return o.ApplyT(func(v *HelmReleaseSpecInstall) HelmReleaseSpecInstall { + if v != nil { + return *v + } + var ret HelmReleaseSpecInstall + return ret + }).(HelmReleaseSpecInstallOutput) +} + +// CRDs upgrade CRDs from the Helm Chart's crds directory according +// to the CRD upgrade policy provided here. Valid values are `Skip`, +// `Create` or `CreateReplace`. Default is `Create` and if omitted +// CRDs are installed but not updated. +// +// Skip: do neither install nor replace (update) any CRDs. +// +// Create: new CRDs are created, existing CRDs are neither updated nor deleted. +// +// CreateReplace: new CRDs are created, existing CRDs are updated (replaced) +// but not deleted. +// +// By default, CRDs are applied (installed) during Helm install action. +// With this option users can opt in to CRD replace existing CRDs on Helm +// install actions, which is not (yet) natively supported by Helm. +// https://helm.sh/docs/chart_best_practices/custom_resource_definitions. +func (o HelmReleaseSpecInstallPtrOutput) Crds() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecInstall) *string { + if v == nil { + return nil + } + return v.Crds + }).(pulumi.StringPtrOutput) +} + +// CreateNamespace tells the Helm install action to create the +// HelmReleaseSpec.TargetNamespace if it does not exist yet. +// On uninstall, the namespace will not be garbage collected. +func (o HelmReleaseSpecInstallPtrOutput) CreateNamespace() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecInstall) *bool { + if v == nil { + return nil + } + return v.CreateNamespace + }).(pulumi.BoolPtrOutput) +} + +// DisableHooks prevents hooks from running during the Helm install action. +func (o HelmReleaseSpecInstallPtrOutput) DisableHooks() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecInstall) *bool { + if v == nil { + return nil + } + return v.DisableHooks + }).(pulumi.BoolPtrOutput) +} + +// DisableOpenAPIValidation prevents the Helm install action from validating +// rendered templates against the Kubernetes OpenAPI Schema. +func (o HelmReleaseSpecInstallPtrOutput) DisableOpenAPIValidation() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecInstall) *bool { + if v == nil { + return nil + } + return v.DisableOpenAPIValidation + }).(pulumi.BoolPtrOutput) +} + +// DisableSchemaValidation prevents the Helm install action from validating +// the values against the JSON Schema. +func (o HelmReleaseSpecInstallPtrOutput) DisableSchemaValidation() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecInstall) *bool { + if v == nil { + return nil + } + return v.DisableSchemaValidation + }).(pulumi.BoolPtrOutput) +} + +// DisableTakeOwnership disables taking ownership of existing resources +// during the Helm install action. Defaults to false. +func (o HelmReleaseSpecInstallPtrOutput) DisableTakeOwnership() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecInstall) *bool { + if v == nil { + return nil + } + return v.DisableTakeOwnership + }).(pulumi.BoolPtrOutput) +} + +// DisableWait disables the waiting for resources to be ready after a Helm +// install has been performed. +func (o HelmReleaseSpecInstallPtrOutput) DisableWait() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecInstall) *bool { + if v == nil { + return nil + } + return v.DisableWait + }).(pulumi.BoolPtrOutput) +} + +// DisableWaitForJobs disables waiting for jobs to complete after a Helm +// install has been performed. +func (o HelmReleaseSpecInstallPtrOutput) DisableWaitForJobs() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecInstall) *bool { + if v == nil { + return nil + } + return v.DisableWaitForJobs + }).(pulumi.BoolPtrOutput) +} + +func (o HelmReleaseSpecInstallPtrOutput) Remediation() HelmReleaseSpecInstallRemediationPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecInstall) *HelmReleaseSpecInstallRemediation { + if v == nil { + return nil + } + return v.Remediation + }).(HelmReleaseSpecInstallRemediationPtrOutput) +} + +// Replace tells the Helm install action to re-use the 'ReleaseName', but only +// if that name is a deleted release which remains in the history. +func (o HelmReleaseSpecInstallPtrOutput) Replace() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecInstall) *bool { + if v == nil { + return nil + } + return v.Replace + }).(pulumi.BoolPtrOutput) +} + +// ServerSideApply enables server-side apply for resources during install. +// Defaults to true (or false when UseHelm3Defaults feature gate is enabled). +func (o HelmReleaseSpecInstallPtrOutput) ServerSideApply() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecInstall) *bool { + if v == nil { + return nil + } + return v.ServerSideApply + }).(pulumi.BoolPtrOutput) +} + +// SkipCRDs tells the Helm install action to not install any CRDs. By default, +// CRDs are installed if not already present. +// +// Deprecated use CRD policy (`crds`) attribute with value `Skip` instead. +func (o HelmReleaseSpecInstallPtrOutput) SkipCRDs() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecInstall) *bool { + if v == nil { + return nil + } + return v.SkipCRDs + }).(pulumi.BoolPtrOutput) +} + +func (o HelmReleaseSpecInstallPtrOutput) Strategy() HelmReleaseSpecInstallStrategyPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecInstall) *HelmReleaseSpecInstallStrategy { + if v == nil { + return nil + } + return v.Strategy + }).(HelmReleaseSpecInstallStrategyPtrOutput) +} + +// Timeout is the time to wait for any individual Kubernetes operation (like +// Jobs for hooks) during the performance of a Helm install action. Defaults to +// 'HelmReleaseSpec.Timeout'. +func (o HelmReleaseSpecInstallPtrOutput) Timeout() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecInstall) *string { + if v == nil { + return nil + } + return v.Timeout + }).(pulumi.StringPtrOutput) +} + +// Install holds the configuration for Helm install actions for this HelmRelease. +type HelmReleaseSpecInstallPatch struct { + // CRDs upgrade CRDs from the Helm Chart's crds directory according + // to the CRD upgrade policy provided here. Valid values are `Skip`, + // `Create` or `CreateReplace`. Default is `Create` and if omitted + // CRDs are installed but not updated. + // + // Skip: do neither install nor replace (update) any CRDs. + // + // Create: new CRDs are created, existing CRDs are neither updated nor deleted. + // + // CreateReplace: new CRDs are created, existing CRDs are updated (replaced) + // but not deleted. + // + // By default, CRDs are applied (installed) during Helm install action. + // With this option users can opt in to CRD replace existing CRDs on Helm + // install actions, which is not (yet) natively supported by Helm. + // https://helm.sh/docs/chart_best_practices/custom_resource_definitions. + Crds *string `pulumi:"crds"` + // CreateNamespace tells the Helm install action to create the + // HelmReleaseSpec.TargetNamespace if it does not exist yet. + // On uninstall, the namespace will not be garbage collected. + CreateNamespace *bool `pulumi:"createNamespace"` + // DisableHooks prevents hooks from running during the Helm install action. + DisableHooks *bool `pulumi:"disableHooks"` + // DisableOpenAPIValidation prevents the Helm install action from validating + // rendered templates against the Kubernetes OpenAPI Schema. + DisableOpenAPIValidation *bool `pulumi:"disableOpenAPIValidation"` + // DisableSchemaValidation prevents the Helm install action from validating + // the values against the JSON Schema. + DisableSchemaValidation *bool `pulumi:"disableSchemaValidation"` + // DisableTakeOwnership disables taking ownership of existing resources + // during the Helm install action. Defaults to false. + DisableTakeOwnership *bool `pulumi:"disableTakeOwnership"` + // DisableWait disables the waiting for resources to be ready after a Helm + // install has been performed. + DisableWait *bool `pulumi:"disableWait"` + // DisableWaitForJobs disables waiting for jobs to complete after a Helm + // install has been performed. + DisableWaitForJobs *bool `pulumi:"disableWaitForJobs"` + Remediation *HelmReleaseSpecInstallRemediationPatch `pulumi:"remediation"` + // Replace tells the Helm install action to re-use the 'ReleaseName', but only + // if that name is a deleted release which remains in the history. + Replace *bool `pulumi:"replace"` + // ServerSideApply enables server-side apply for resources during install. + // Defaults to true (or false when UseHelm3Defaults feature gate is enabled). + ServerSideApply *bool `pulumi:"serverSideApply"` + // SkipCRDs tells the Helm install action to not install any CRDs. By default, + // CRDs are installed if not already present. + // + // Deprecated use CRD policy (`crds`) attribute with value `Skip` instead. + SkipCRDs *bool `pulumi:"skipCRDs"` + Strategy *HelmReleaseSpecInstallStrategyPatch `pulumi:"strategy"` + // Timeout is the time to wait for any individual Kubernetes operation (like + // Jobs for hooks) during the performance of a Helm install action. Defaults to + // 'HelmReleaseSpec.Timeout'. + Timeout *string `pulumi:"timeout"` +} + +// HelmReleaseSpecInstallPatchInput is an input type that accepts HelmReleaseSpecInstallPatchArgs and HelmReleaseSpecInstallPatchOutput values. +// You can construct a concrete instance of `HelmReleaseSpecInstallPatchInput` via: +// +// HelmReleaseSpecInstallPatchArgs{...} +type HelmReleaseSpecInstallPatchInput interface { + pulumi.Input + + ToHelmReleaseSpecInstallPatchOutput() HelmReleaseSpecInstallPatchOutput + ToHelmReleaseSpecInstallPatchOutputWithContext(context.Context) HelmReleaseSpecInstallPatchOutput +} + +// Install holds the configuration for Helm install actions for this HelmRelease. +type HelmReleaseSpecInstallPatchArgs struct { + // CRDs upgrade CRDs from the Helm Chart's crds directory according + // to the CRD upgrade policy provided here. Valid values are `Skip`, + // `Create` or `CreateReplace`. Default is `Create` and if omitted + // CRDs are installed but not updated. + // + // Skip: do neither install nor replace (update) any CRDs. + // + // Create: new CRDs are created, existing CRDs are neither updated nor deleted. + // + // CreateReplace: new CRDs are created, existing CRDs are updated (replaced) + // but not deleted. + // + // By default, CRDs are applied (installed) during Helm install action. + // With this option users can opt in to CRD replace existing CRDs on Helm + // install actions, which is not (yet) natively supported by Helm. + // https://helm.sh/docs/chart_best_practices/custom_resource_definitions. + Crds pulumi.StringPtrInput `pulumi:"crds"` + // CreateNamespace tells the Helm install action to create the + // HelmReleaseSpec.TargetNamespace if it does not exist yet. + // On uninstall, the namespace will not be garbage collected. + CreateNamespace pulumi.BoolPtrInput `pulumi:"createNamespace"` + // DisableHooks prevents hooks from running during the Helm install action. + DisableHooks pulumi.BoolPtrInput `pulumi:"disableHooks"` + // DisableOpenAPIValidation prevents the Helm install action from validating + // rendered templates against the Kubernetes OpenAPI Schema. + DisableOpenAPIValidation pulumi.BoolPtrInput `pulumi:"disableOpenAPIValidation"` + // DisableSchemaValidation prevents the Helm install action from validating + // the values against the JSON Schema. + DisableSchemaValidation pulumi.BoolPtrInput `pulumi:"disableSchemaValidation"` + // DisableTakeOwnership disables taking ownership of existing resources + // during the Helm install action. Defaults to false. + DisableTakeOwnership pulumi.BoolPtrInput `pulumi:"disableTakeOwnership"` + // DisableWait disables the waiting for resources to be ready after a Helm + // install has been performed. + DisableWait pulumi.BoolPtrInput `pulumi:"disableWait"` + // DisableWaitForJobs disables waiting for jobs to complete after a Helm + // install has been performed. + DisableWaitForJobs pulumi.BoolPtrInput `pulumi:"disableWaitForJobs"` + Remediation HelmReleaseSpecInstallRemediationPatchPtrInput `pulumi:"remediation"` + // Replace tells the Helm install action to re-use the 'ReleaseName', but only + // if that name is a deleted release which remains in the history. + Replace pulumi.BoolPtrInput `pulumi:"replace"` + // ServerSideApply enables server-side apply for resources during install. + // Defaults to true (or false when UseHelm3Defaults feature gate is enabled). + ServerSideApply pulumi.BoolPtrInput `pulumi:"serverSideApply"` + // SkipCRDs tells the Helm install action to not install any CRDs. By default, + // CRDs are installed if not already present. + // + // Deprecated use CRD policy (`crds`) attribute with value `Skip` instead. + SkipCRDs pulumi.BoolPtrInput `pulumi:"skipCRDs"` + Strategy HelmReleaseSpecInstallStrategyPatchPtrInput `pulumi:"strategy"` + // Timeout is the time to wait for any individual Kubernetes operation (like + // Jobs for hooks) during the performance of a Helm install action. Defaults to + // 'HelmReleaseSpec.Timeout'. + Timeout pulumi.StringPtrInput `pulumi:"timeout"` +} + +func (HelmReleaseSpecInstallPatchArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecInstallPatch)(nil)).Elem() +} + +func (i HelmReleaseSpecInstallPatchArgs) ToHelmReleaseSpecInstallPatchOutput() HelmReleaseSpecInstallPatchOutput { + return i.ToHelmReleaseSpecInstallPatchOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecInstallPatchArgs) ToHelmReleaseSpecInstallPatchOutputWithContext(ctx context.Context) HelmReleaseSpecInstallPatchOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecInstallPatchOutput) +} + +func (i HelmReleaseSpecInstallPatchArgs) ToHelmReleaseSpecInstallPatchPtrOutput() HelmReleaseSpecInstallPatchPtrOutput { + return i.ToHelmReleaseSpecInstallPatchPtrOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecInstallPatchArgs) ToHelmReleaseSpecInstallPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecInstallPatchPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecInstallPatchOutput).ToHelmReleaseSpecInstallPatchPtrOutputWithContext(ctx) +} + +// HelmReleaseSpecInstallPatchPtrInput is an input type that accepts HelmReleaseSpecInstallPatchArgs, HelmReleaseSpecInstallPatchPtr and HelmReleaseSpecInstallPatchPtrOutput values. +// You can construct a concrete instance of `HelmReleaseSpecInstallPatchPtrInput` via: +// +// HelmReleaseSpecInstallPatchArgs{...} +// +// or: +// +// nil +type HelmReleaseSpecInstallPatchPtrInput interface { + pulumi.Input + + ToHelmReleaseSpecInstallPatchPtrOutput() HelmReleaseSpecInstallPatchPtrOutput + ToHelmReleaseSpecInstallPatchPtrOutputWithContext(context.Context) HelmReleaseSpecInstallPatchPtrOutput +} + +type helmReleaseSpecInstallPatchPtrType HelmReleaseSpecInstallPatchArgs + +func HelmReleaseSpecInstallPatchPtr(v *HelmReleaseSpecInstallPatchArgs) HelmReleaseSpecInstallPatchPtrInput { + return (*helmReleaseSpecInstallPatchPtrType)(v) +} + +func (*helmReleaseSpecInstallPatchPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecInstallPatch)(nil)).Elem() +} + +func (i *helmReleaseSpecInstallPatchPtrType) ToHelmReleaseSpecInstallPatchPtrOutput() HelmReleaseSpecInstallPatchPtrOutput { + return i.ToHelmReleaseSpecInstallPatchPtrOutputWithContext(context.Background()) +} + +func (i *helmReleaseSpecInstallPatchPtrType) ToHelmReleaseSpecInstallPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecInstallPatchPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecInstallPatchPtrOutput) +} + +// Install holds the configuration for Helm install actions for this HelmRelease. +type HelmReleaseSpecInstallPatchOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecInstallPatchOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecInstallPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecInstallPatchOutput) ToHelmReleaseSpecInstallPatchOutput() HelmReleaseSpecInstallPatchOutput { + return o +} + +func (o HelmReleaseSpecInstallPatchOutput) ToHelmReleaseSpecInstallPatchOutputWithContext(ctx context.Context) HelmReleaseSpecInstallPatchOutput { + return o +} + +func (o HelmReleaseSpecInstallPatchOutput) ToHelmReleaseSpecInstallPatchPtrOutput() HelmReleaseSpecInstallPatchPtrOutput { + return o.ToHelmReleaseSpecInstallPatchPtrOutputWithContext(context.Background()) +} + +func (o HelmReleaseSpecInstallPatchOutput) ToHelmReleaseSpecInstallPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecInstallPatchPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v HelmReleaseSpecInstallPatch) *HelmReleaseSpecInstallPatch { + return &v + }).(HelmReleaseSpecInstallPatchPtrOutput) +} + +// CRDs upgrade CRDs from the Helm Chart's crds directory according +// to the CRD upgrade policy provided here. Valid values are `Skip`, +// `Create` or `CreateReplace`. Default is `Create` and if omitted +// CRDs are installed but not updated. +// +// Skip: do neither install nor replace (update) any CRDs. +// +// Create: new CRDs are created, existing CRDs are neither updated nor deleted. +// +// CreateReplace: new CRDs are created, existing CRDs are updated (replaced) +// but not deleted. +// +// By default, CRDs are applied (installed) during Helm install action. +// With this option users can opt in to CRD replace existing CRDs on Helm +// install actions, which is not (yet) natively supported by Helm. +// https://helm.sh/docs/chart_best_practices/custom_resource_definitions. +func (o HelmReleaseSpecInstallPatchOutput) Crds() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecInstallPatch) *string { return v.Crds }).(pulumi.StringPtrOutput) +} + +// CreateNamespace tells the Helm install action to create the +// HelmReleaseSpec.TargetNamespace if it does not exist yet. +// On uninstall, the namespace will not be garbage collected. +func (o HelmReleaseSpecInstallPatchOutput) CreateNamespace() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecInstallPatch) *bool { return v.CreateNamespace }).(pulumi.BoolPtrOutput) +} + +// DisableHooks prevents hooks from running during the Helm install action. +func (o HelmReleaseSpecInstallPatchOutput) DisableHooks() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecInstallPatch) *bool { return v.DisableHooks }).(pulumi.BoolPtrOutput) +} + +// DisableOpenAPIValidation prevents the Helm install action from validating +// rendered templates against the Kubernetes OpenAPI Schema. +func (o HelmReleaseSpecInstallPatchOutput) DisableOpenAPIValidation() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecInstallPatch) *bool { return v.DisableOpenAPIValidation }).(pulumi.BoolPtrOutput) +} + +// DisableSchemaValidation prevents the Helm install action from validating +// the values against the JSON Schema. +func (o HelmReleaseSpecInstallPatchOutput) DisableSchemaValidation() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecInstallPatch) *bool { return v.DisableSchemaValidation }).(pulumi.BoolPtrOutput) +} + +// DisableTakeOwnership disables taking ownership of existing resources +// during the Helm install action. Defaults to false. +func (o HelmReleaseSpecInstallPatchOutput) DisableTakeOwnership() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecInstallPatch) *bool { return v.DisableTakeOwnership }).(pulumi.BoolPtrOutput) +} + +// DisableWait disables the waiting for resources to be ready after a Helm +// install has been performed. +func (o HelmReleaseSpecInstallPatchOutput) DisableWait() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecInstallPatch) *bool { return v.DisableWait }).(pulumi.BoolPtrOutput) +} + +// DisableWaitForJobs disables waiting for jobs to complete after a Helm +// install has been performed. +func (o HelmReleaseSpecInstallPatchOutput) DisableWaitForJobs() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecInstallPatch) *bool { return v.DisableWaitForJobs }).(pulumi.BoolPtrOutput) +} + +func (o HelmReleaseSpecInstallPatchOutput) Remediation() HelmReleaseSpecInstallRemediationPatchPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecInstallPatch) *HelmReleaseSpecInstallRemediationPatch { return v.Remediation }).(HelmReleaseSpecInstallRemediationPatchPtrOutput) +} + +// Replace tells the Helm install action to re-use the 'ReleaseName', but only +// if that name is a deleted release which remains in the history. +func (o HelmReleaseSpecInstallPatchOutput) Replace() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecInstallPatch) *bool { return v.Replace }).(pulumi.BoolPtrOutput) +} + +// ServerSideApply enables server-side apply for resources during install. +// Defaults to true (or false when UseHelm3Defaults feature gate is enabled). +func (o HelmReleaseSpecInstallPatchOutput) ServerSideApply() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecInstallPatch) *bool { return v.ServerSideApply }).(pulumi.BoolPtrOutput) +} + +// SkipCRDs tells the Helm install action to not install any CRDs. By default, +// CRDs are installed if not already present. +// +// Deprecated use CRD policy (`crds`) attribute with value `Skip` instead. +func (o HelmReleaseSpecInstallPatchOutput) SkipCRDs() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecInstallPatch) *bool { return v.SkipCRDs }).(pulumi.BoolPtrOutput) +} + +func (o HelmReleaseSpecInstallPatchOutput) Strategy() HelmReleaseSpecInstallStrategyPatchPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecInstallPatch) *HelmReleaseSpecInstallStrategyPatch { return v.Strategy }).(HelmReleaseSpecInstallStrategyPatchPtrOutput) +} + +// Timeout is the time to wait for any individual Kubernetes operation (like +// Jobs for hooks) during the performance of a Helm install action. Defaults to +// 'HelmReleaseSpec.Timeout'. +func (o HelmReleaseSpecInstallPatchOutput) Timeout() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecInstallPatch) *string { return v.Timeout }).(pulumi.StringPtrOutput) +} + +type HelmReleaseSpecInstallPatchPtrOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecInstallPatchPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecInstallPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecInstallPatchPtrOutput) ToHelmReleaseSpecInstallPatchPtrOutput() HelmReleaseSpecInstallPatchPtrOutput { + return o +} + +func (o HelmReleaseSpecInstallPatchPtrOutput) ToHelmReleaseSpecInstallPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecInstallPatchPtrOutput { + return o +} + +func (o HelmReleaseSpecInstallPatchPtrOutput) Elem() HelmReleaseSpecInstallPatchOutput { + return o.ApplyT(func(v *HelmReleaseSpecInstallPatch) HelmReleaseSpecInstallPatch { + if v != nil { + return *v + } + var ret HelmReleaseSpecInstallPatch + return ret + }).(HelmReleaseSpecInstallPatchOutput) +} + +// CRDs upgrade CRDs from the Helm Chart's crds directory according +// to the CRD upgrade policy provided here. Valid values are `Skip`, +// `Create` or `CreateReplace`. Default is `Create` and if omitted +// CRDs are installed but not updated. +// +// Skip: do neither install nor replace (update) any CRDs. +// +// Create: new CRDs are created, existing CRDs are neither updated nor deleted. +// +// CreateReplace: new CRDs are created, existing CRDs are updated (replaced) +// but not deleted. +// +// By default, CRDs are applied (installed) during Helm install action. +// With this option users can opt in to CRD replace existing CRDs on Helm +// install actions, which is not (yet) natively supported by Helm. +// https://helm.sh/docs/chart_best_practices/custom_resource_definitions. +func (o HelmReleaseSpecInstallPatchPtrOutput) Crds() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecInstallPatch) *string { + if v == nil { + return nil + } + return v.Crds + }).(pulumi.StringPtrOutput) +} + +// CreateNamespace tells the Helm install action to create the +// HelmReleaseSpec.TargetNamespace if it does not exist yet. +// On uninstall, the namespace will not be garbage collected. +func (o HelmReleaseSpecInstallPatchPtrOutput) CreateNamespace() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecInstallPatch) *bool { + if v == nil { + return nil + } + return v.CreateNamespace + }).(pulumi.BoolPtrOutput) +} + +// DisableHooks prevents hooks from running during the Helm install action. +func (o HelmReleaseSpecInstallPatchPtrOutput) DisableHooks() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecInstallPatch) *bool { + if v == nil { + return nil + } + return v.DisableHooks + }).(pulumi.BoolPtrOutput) +} + +// DisableOpenAPIValidation prevents the Helm install action from validating +// rendered templates against the Kubernetes OpenAPI Schema. +func (o HelmReleaseSpecInstallPatchPtrOutput) DisableOpenAPIValidation() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecInstallPatch) *bool { + if v == nil { + return nil + } + return v.DisableOpenAPIValidation + }).(pulumi.BoolPtrOutput) +} + +// DisableSchemaValidation prevents the Helm install action from validating +// the values against the JSON Schema. +func (o HelmReleaseSpecInstallPatchPtrOutput) DisableSchemaValidation() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecInstallPatch) *bool { + if v == nil { + return nil + } + return v.DisableSchemaValidation + }).(pulumi.BoolPtrOutput) +} + +// DisableTakeOwnership disables taking ownership of existing resources +// during the Helm install action. Defaults to false. +func (o HelmReleaseSpecInstallPatchPtrOutput) DisableTakeOwnership() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecInstallPatch) *bool { + if v == nil { + return nil + } + return v.DisableTakeOwnership + }).(pulumi.BoolPtrOutput) +} + +// DisableWait disables the waiting for resources to be ready after a Helm +// install has been performed. +func (o HelmReleaseSpecInstallPatchPtrOutput) DisableWait() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecInstallPatch) *bool { + if v == nil { + return nil + } + return v.DisableWait + }).(pulumi.BoolPtrOutput) +} + +// DisableWaitForJobs disables waiting for jobs to complete after a Helm +// install has been performed. +func (o HelmReleaseSpecInstallPatchPtrOutput) DisableWaitForJobs() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecInstallPatch) *bool { + if v == nil { + return nil + } + return v.DisableWaitForJobs + }).(pulumi.BoolPtrOutput) +} + +func (o HelmReleaseSpecInstallPatchPtrOutput) Remediation() HelmReleaseSpecInstallRemediationPatchPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecInstallPatch) *HelmReleaseSpecInstallRemediationPatch { + if v == nil { + return nil + } + return v.Remediation + }).(HelmReleaseSpecInstallRemediationPatchPtrOutput) +} + +// Replace tells the Helm install action to re-use the 'ReleaseName', but only +// if that name is a deleted release which remains in the history. +func (o HelmReleaseSpecInstallPatchPtrOutput) Replace() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecInstallPatch) *bool { + if v == nil { + return nil + } + return v.Replace + }).(pulumi.BoolPtrOutput) +} + +// ServerSideApply enables server-side apply for resources during install. +// Defaults to true (or false when UseHelm3Defaults feature gate is enabled). +func (o HelmReleaseSpecInstallPatchPtrOutput) ServerSideApply() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecInstallPatch) *bool { + if v == nil { + return nil + } + return v.ServerSideApply + }).(pulumi.BoolPtrOutput) +} + +// SkipCRDs tells the Helm install action to not install any CRDs. By default, +// CRDs are installed if not already present. +// +// Deprecated use CRD policy (`crds`) attribute with value `Skip` instead. +func (o HelmReleaseSpecInstallPatchPtrOutput) SkipCRDs() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecInstallPatch) *bool { + if v == nil { + return nil + } + return v.SkipCRDs + }).(pulumi.BoolPtrOutput) +} + +func (o HelmReleaseSpecInstallPatchPtrOutput) Strategy() HelmReleaseSpecInstallStrategyPatchPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecInstallPatch) *HelmReleaseSpecInstallStrategyPatch { + if v == nil { + return nil + } + return v.Strategy + }).(HelmReleaseSpecInstallStrategyPatchPtrOutput) +} + +// Timeout is the time to wait for any individual Kubernetes operation (like +// Jobs for hooks) during the performance of a Helm install action. Defaults to +// 'HelmReleaseSpec.Timeout'. +func (o HelmReleaseSpecInstallPatchPtrOutput) Timeout() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecInstallPatch) *string { + if v == nil { + return nil + } + return v.Timeout + }).(pulumi.StringPtrOutput) +} + +// Remediation holds the remediation configuration for when the Helm install +// action for the HelmRelease fails. The default is to not perform any action. +type HelmReleaseSpecInstallRemediation struct { + // IgnoreTestFailures tells the controller to skip remediation when the Helm + // tests are run after an install action but fail. Defaults to + // 'Test.IgnoreFailures'. + IgnoreTestFailures *bool `pulumi:"ignoreTestFailures"` + // RemediateLastFailure tells the controller to remediate the last failure, when + // no retries remain. Defaults to 'false'. + RemediateLastFailure *bool `pulumi:"remediateLastFailure"` + // Retries is the number of retries that should be attempted on failures before + // bailing. Remediation, using an uninstall, is performed between each attempt. + // Defaults to '0', a negative integer equals to unlimited retries. + Retries *int `pulumi:"retries"` +} + +// HelmReleaseSpecInstallRemediationInput is an input type that accepts HelmReleaseSpecInstallRemediationArgs and HelmReleaseSpecInstallRemediationOutput values. +// You can construct a concrete instance of `HelmReleaseSpecInstallRemediationInput` via: +// +// HelmReleaseSpecInstallRemediationArgs{...} +type HelmReleaseSpecInstallRemediationInput interface { + pulumi.Input + + ToHelmReleaseSpecInstallRemediationOutput() HelmReleaseSpecInstallRemediationOutput + ToHelmReleaseSpecInstallRemediationOutputWithContext(context.Context) HelmReleaseSpecInstallRemediationOutput +} + +// Remediation holds the remediation configuration for when the Helm install +// action for the HelmRelease fails. The default is to not perform any action. +type HelmReleaseSpecInstallRemediationArgs struct { + // IgnoreTestFailures tells the controller to skip remediation when the Helm + // tests are run after an install action but fail. Defaults to + // 'Test.IgnoreFailures'. + IgnoreTestFailures pulumi.BoolPtrInput `pulumi:"ignoreTestFailures"` + // RemediateLastFailure tells the controller to remediate the last failure, when + // no retries remain. Defaults to 'false'. + RemediateLastFailure pulumi.BoolPtrInput `pulumi:"remediateLastFailure"` + // Retries is the number of retries that should be attempted on failures before + // bailing. Remediation, using an uninstall, is performed between each attempt. + // Defaults to '0', a negative integer equals to unlimited retries. + Retries pulumi.IntPtrInput `pulumi:"retries"` +} + +func (HelmReleaseSpecInstallRemediationArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecInstallRemediation)(nil)).Elem() +} + +func (i HelmReleaseSpecInstallRemediationArgs) ToHelmReleaseSpecInstallRemediationOutput() HelmReleaseSpecInstallRemediationOutput { + return i.ToHelmReleaseSpecInstallRemediationOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecInstallRemediationArgs) ToHelmReleaseSpecInstallRemediationOutputWithContext(ctx context.Context) HelmReleaseSpecInstallRemediationOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecInstallRemediationOutput) +} + +func (i HelmReleaseSpecInstallRemediationArgs) ToHelmReleaseSpecInstallRemediationPtrOutput() HelmReleaseSpecInstallRemediationPtrOutput { + return i.ToHelmReleaseSpecInstallRemediationPtrOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecInstallRemediationArgs) ToHelmReleaseSpecInstallRemediationPtrOutputWithContext(ctx context.Context) HelmReleaseSpecInstallRemediationPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecInstallRemediationOutput).ToHelmReleaseSpecInstallRemediationPtrOutputWithContext(ctx) +} + +// HelmReleaseSpecInstallRemediationPtrInput is an input type that accepts HelmReleaseSpecInstallRemediationArgs, HelmReleaseSpecInstallRemediationPtr and HelmReleaseSpecInstallRemediationPtrOutput values. +// You can construct a concrete instance of `HelmReleaseSpecInstallRemediationPtrInput` via: +// +// HelmReleaseSpecInstallRemediationArgs{...} +// +// or: +// +// nil +type HelmReleaseSpecInstallRemediationPtrInput interface { + pulumi.Input + + ToHelmReleaseSpecInstallRemediationPtrOutput() HelmReleaseSpecInstallRemediationPtrOutput + ToHelmReleaseSpecInstallRemediationPtrOutputWithContext(context.Context) HelmReleaseSpecInstallRemediationPtrOutput +} + +type helmReleaseSpecInstallRemediationPtrType HelmReleaseSpecInstallRemediationArgs + +func HelmReleaseSpecInstallRemediationPtr(v *HelmReleaseSpecInstallRemediationArgs) HelmReleaseSpecInstallRemediationPtrInput { + return (*helmReleaseSpecInstallRemediationPtrType)(v) +} + +func (*helmReleaseSpecInstallRemediationPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecInstallRemediation)(nil)).Elem() +} + +func (i *helmReleaseSpecInstallRemediationPtrType) ToHelmReleaseSpecInstallRemediationPtrOutput() HelmReleaseSpecInstallRemediationPtrOutput { + return i.ToHelmReleaseSpecInstallRemediationPtrOutputWithContext(context.Background()) +} + +func (i *helmReleaseSpecInstallRemediationPtrType) ToHelmReleaseSpecInstallRemediationPtrOutputWithContext(ctx context.Context) HelmReleaseSpecInstallRemediationPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecInstallRemediationPtrOutput) +} + +// Remediation holds the remediation configuration for when the Helm install +// action for the HelmRelease fails. The default is to not perform any action. +type HelmReleaseSpecInstallRemediationOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecInstallRemediationOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecInstallRemediation)(nil)).Elem() +} + +func (o HelmReleaseSpecInstallRemediationOutput) ToHelmReleaseSpecInstallRemediationOutput() HelmReleaseSpecInstallRemediationOutput { + return o +} + +func (o HelmReleaseSpecInstallRemediationOutput) ToHelmReleaseSpecInstallRemediationOutputWithContext(ctx context.Context) HelmReleaseSpecInstallRemediationOutput { + return o +} + +func (o HelmReleaseSpecInstallRemediationOutput) ToHelmReleaseSpecInstallRemediationPtrOutput() HelmReleaseSpecInstallRemediationPtrOutput { + return o.ToHelmReleaseSpecInstallRemediationPtrOutputWithContext(context.Background()) +} + +func (o HelmReleaseSpecInstallRemediationOutput) ToHelmReleaseSpecInstallRemediationPtrOutputWithContext(ctx context.Context) HelmReleaseSpecInstallRemediationPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v HelmReleaseSpecInstallRemediation) *HelmReleaseSpecInstallRemediation { + return &v + }).(HelmReleaseSpecInstallRemediationPtrOutput) +} + +// IgnoreTestFailures tells the controller to skip remediation when the Helm +// tests are run after an install action but fail. Defaults to +// 'Test.IgnoreFailures'. +func (o HelmReleaseSpecInstallRemediationOutput) IgnoreTestFailures() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecInstallRemediation) *bool { return v.IgnoreTestFailures }).(pulumi.BoolPtrOutput) +} + +// RemediateLastFailure tells the controller to remediate the last failure, when +// no retries remain. Defaults to 'false'. +func (o HelmReleaseSpecInstallRemediationOutput) RemediateLastFailure() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecInstallRemediation) *bool { return v.RemediateLastFailure }).(pulumi.BoolPtrOutput) +} + +// Retries is the number of retries that should be attempted on failures before +// bailing. Remediation, using an uninstall, is performed between each attempt. +// Defaults to '0', a negative integer equals to unlimited retries. +func (o HelmReleaseSpecInstallRemediationOutput) Retries() pulumi.IntPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecInstallRemediation) *int { return v.Retries }).(pulumi.IntPtrOutput) +} + +type HelmReleaseSpecInstallRemediationPtrOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecInstallRemediationPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecInstallRemediation)(nil)).Elem() +} + +func (o HelmReleaseSpecInstallRemediationPtrOutput) ToHelmReleaseSpecInstallRemediationPtrOutput() HelmReleaseSpecInstallRemediationPtrOutput { + return o +} + +func (o HelmReleaseSpecInstallRemediationPtrOutput) ToHelmReleaseSpecInstallRemediationPtrOutputWithContext(ctx context.Context) HelmReleaseSpecInstallRemediationPtrOutput { + return o +} + +func (o HelmReleaseSpecInstallRemediationPtrOutput) Elem() HelmReleaseSpecInstallRemediationOutput { + return o.ApplyT(func(v *HelmReleaseSpecInstallRemediation) HelmReleaseSpecInstallRemediation { + if v != nil { + return *v + } + var ret HelmReleaseSpecInstallRemediation + return ret + }).(HelmReleaseSpecInstallRemediationOutput) +} + +// IgnoreTestFailures tells the controller to skip remediation when the Helm +// tests are run after an install action but fail. Defaults to +// 'Test.IgnoreFailures'. +func (o HelmReleaseSpecInstallRemediationPtrOutput) IgnoreTestFailures() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecInstallRemediation) *bool { + if v == nil { + return nil + } + return v.IgnoreTestFailures + }).(pulumi.BoolPtrOutput) +} + +// RemediateLastFailure tells the controller to remediate the last failure, when +// no retries remain. Defaults to 'false'. +func (o HelmReleaseSpecInstallRemediationPtrOutput) RemediateLastFailure() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecInstallRemediation) *bool { + if v == nil { + return nil + } + return v.RemediateLastFailure + }).(pulumi.BoolPtrOutput) +} + +// Retries is the number of retries that should be attempted on failures before +// bailing. Remediation, using an uninstall, is performed between each attempt. +// Defaults to '0', a negative integer equals to unlimited retries. +func (o HelmReleaseSpecInstallRemediationPtrOutput) Retries() pulumi.IntPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecInstallRemediation) *int { + if v == nil { + return nil + } + return v.Retries + }).(pulumi.IntPtrOutput) +} + +// Remediation holds the remediation configuration for when the Helm install +// action for the HelmRelease fails. The default is to not perform any action. +type HelmReleaseSpecInstallRemediationPatch struct { + // IgnoreTestFailures tells the controller to skip remediation when the Helm + // tests are run after an install action but fail. Defaults to + // 'Test.IgnoreFailures'. + IgnoreTestFailures *bool `pulumi:"ignoreTestFailures"` + // RemediateLastFailure tells the controller to remediate the last failure, when + // no retries remain. Defaults to 'false'. + RemediateLastFailure *bool `pulumi:"remediateLastFailure"` + // Retries is the number of retries that should be attempted on failures before + // bailing. Remediation, using an uninstall, is performed between each attempt. + // Defaults to '0', a negative integer equals to unlimited retries. + Retries *int `pulumi:"retries"` +} + +// HelmReleaseSpecInstallRemediationPatchInput is an input type that accepts HelmReleaseSpecInstallRemediationPatchArgs and HelmReleaseSpecInstallRemediationPatchOutput values. +// You can construct a concrete instance of `HelmReleaseSpecInstallRemediationPatchInput` via: +// +// HelmReleaseSpecInstallRemediationPatchArgs{...} +type HelmReleaseSpecInstallRemediationPatchInput interface { + pulumi.Input + + ToHelmReleaseSpecInstallRemediationPatchOutput() HelmReleaseSpecInstallRemediationPatchOutput + ToHelmReleaseSpecInstallRemediationPatchOutputWithContext(context.Context) HelmReleaseSpecInstallRemediationPatchOutput +} + +// Remediation holds the remediation configuration for when the Helm install +// action for the HelmRelease fails. The default is to not perform any action. +type HelmReleaseSpecInstallRemediationPatchArgs struct { + // IgnoreTestFailures tells the controller to skip remediation when the Helm + // tests are run after an install action but fail. Defaults to + // 'Test.IgnoreFailures'. + IgnoreTestFailures pulumi.BoolPtrInput `pulumi:"ignoreTestFailures"` + // RemediateLastFailure tells the controller to remediate the last failure, when + // no retries remain. Defaults to 'false'. + RemediateLastFailure pulumi.BoolPtrInput `pulumi:"remediateLastFailure"` + // Retries is the number of retries that should be attempted on failures before + // bailing. Remediation, using an uninstall, is performed between each attempt. + // Defaults to '0', a negative integer equals to unlimited retries. + Retries pulumi.IntPtrInput `pulumi:"retries"` +} + +func (HelmReleaseSpecInstallRemediationPatchArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecInstallRemediationPatch)(nil)).Elem() +} + +func (i HelmReleaseSpecInstallRemediationPatchArgs) ToHelmReleaseSpecInstallRemediationPatchOutput() HelmReleaseSpecInstallRemediationPatchOutput { + return i.ToHelmReleaseSpecInstallRemediationPatchOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecInstallRemediationPatchArgs) ToHelmReleaseSpecInstallRemediationPatchOutputWithContext(ctx context.Context) HelmReleaseSpecInstallRemediationPatchOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecInstallRemediationPatchOutput) +} + +func (i HelmReleaseSpecInstallRemediationPatchArgs) ToHelmReleaseSpecInstallRemediationPatchPtrOutput() HelmReleaseSpecInstallRemediationPatchPtrOutput { + return i.ToHelmReleaseSpecInstallRemediationPatchPtrOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecInstallRemediationPatchArgs) ToHelmReleaseSpecInstallRemediationPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecInstallRemediationPatchPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecInstallRemediationPatchOutput).ToHelmReleaseSpecInstallRemediationPatchPtrOutputWithContext(ctx) +} + +// HelmReleaseSpecInstallRemediationPatchPtrInput is an input type that accepts HelmReleaseSpecInstallRemediationPatchArgs, HelmReleaseSpecInstallRemediationPatchPtr and HelmReleaseSpecInstallRemediationPatchPtrOutput values. +// You can construct a concrete instance of `HelmReleaseSpecInstallRemediationPatchPtrInput` via: +// +// HelmReleaseSpecInstallRemediationPatchArgs{...} +// +// or: +// +// nil +type HelmReleaseSpecInstallRemediationPatchPtrInput interface { + pulumi.Input + + ToHelmReleaseSpecInstallRemediationPatchPtrOutput() HelmReleaseSpecInstallRemediationPatchPtrOutput + ToHelmReleaseSpecInstallRemediationPatchPtrOutputWithContext(context.Context) HelmReleaseSpecInstallRemediationPatchPtrOutput +} + +type helmReleaseSpecInstallRemediationPatchPtrType HelmReleaseSpecInstallRemediationPatchArgs + +func HelmReleaseSpecInstallRemediationPatchPtr(v *HelmReleaseSpecInstallRemediationPatchArgs) HelmReleaseSpecInstallRemediationPatchPtrInput { + return (*helmReleaseSpecInstallRemediationPatchPtrType)(v) +} + +func (*helmReleaseSpecInstallRemediationPatchPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecInstallRemediationPatch)(nil)).Elem() +} + +func (i *helmReleaseSpecInstallRemediationPatchPtrType) ToHelmReleaseSpecInstallRemediationPatchPtrOutput() HelmReleaseSpecInstallRemediationPatchPtrOutput { + return i.ToHelmReleaseSpecInstallRemediationPatchPtrOutputWithContext(context.Background()) +} + +func (i *helmReleaseSpecInstallRemediationPatchPtrType) ToHelmReleaseSpecInstallRemediationPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecInstallRemediationPatchPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecInstallRemediationPatchPtrOutput) +} + +// Remediation holds the remediation configuration for when the Helm install +// action for the HelmRelease fails. The default is to not perform any action. +type HelmReleaseSpecInstallRemediationPatchOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecInstallRemediationPatchOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecInstallRemediationPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecInstallRemediationPatchOutput) ToHelmReleaseSpecInstallRemediationPatchOutput() HelmReleaseSpecInstallRemediationPatchOutput { + return o +} + +func (o HelmReleaseSpecInstallRemediationPatchOutput) ToHelmReleaseSpecInstallRemediationPatchOutputWithContext(ctx context.Context) HelmReleaseSpecInstallRemediationPatchOutput { + return o +} + +func (o HelmReleaseSpecInstallRemediationPatchOutput) ToHelmReleaseSpecInstallRemediationPatchPtrOutput() HelmReleaseSpecInstallRemediationPatchPtrOutput { + return o.ToHelmReleaseSpecInstallRemediationPatchPtrOutputWithContext(context.Background()) +} + +func (o HelmReleaseSpecInstallRemediationPatchOutput) ToHelmReleaseSpecInstallRemediationPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecInstallRemediationPatchPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v HelmReleaseSpecInstallRemediationPatch) *HelmReleaseSpecInstallRemediationPatch { + return &v + }).(HelmReleaseSpecInstallRemediationPatchPtrOutput) +} + +// IgnoreTestFailures tells the controller to skip remediation when the Helm +// tests are run after an install action but fail. Defaults to +// 'Test.IgnoreFailures'. +func (o HelmReleaseSpecInstallRemediationPatchOutput) IgnoreTestFailures() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecInstallRemediationPatch) *bool { return v.IgnoreTestFailures }).(pulumi.BoolPtrOutput) +} + +// RemediateLastFailure tells the controller to remediate the last failure, when +// no retries remain. Defaults to 'false'. +func (o HelmReleaseSpecInstallRemediationPatchOutput) RemediateLastFailure() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecInstallRemediationPatch) *bool { return v.RemediateLastFailure }).(pulumi.BoolPtrOutput) +} + +// Retries is the number of retries that should be attempted on failures before +// bailing. Remediation, using an uninstall, is performed between each attempt. +// Defaults to '0', a negative integer equals to unlimited retries. +func (o HelmReleaseSpecInstallRemediationPatchOutput) Retries() pulumi.IntPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecInstallRemediationPatch) *int { return v.Retries }).(pulumi.IntPtrOutput) +} + +type HelmReleaseSpecInstallRemediationPatchPtrOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecInstallRemediationPatchPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecInstallRemediationPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecInstallRemediationPatchPtrOutput) ToHelmReleaseSpecInstallRemediationPatchPtrOutput() HelmReleaseSpecInstallRemediationPatchPtrOutput { + return o +} + +func (o HelmReleaseSpecInstallRemediationPatchPtrOutput) ToHelmReleaseSpecInstallRemediationPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecInstallRemediationPatchPtrOutput { + return o +} + +func (o HelmReleaseSpecInstallRemediationPatchPtrOutput) Elem() HelmReleaseSpecInstallRemediationPatchOutput { + return o.ApplyT(func(v *HelmReleaseSpecInstallRemediationPatch) HelmReleaseSpecInstallRemediationPatch { + if v != nil { + return *v + } + var ret HelmReleaseSpecInstallRemediationPatch + return ret + }).(HelmReleaseSpecInstallRemediationPatchOutput) +} + +// IgnoreTestFailures tells the controller to skip remediation when the Helm +// tests are run after an install action but fail. Defaults to +// 'Test.IgnoreFailures'. +func (o HelmReleaseSpecInstallRemediationPatchPtrOutput) IgnoreTestFailures() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecInstallRemediationPatch) *bool { + if v == nil { + return nil + } + return v.IgnoreTestFailures + }).(pulumi.BoolPtrOutput) +} + +// RemediateLastFailure tells the controller to remediate the last failure, when +// no retries remain. Defaults to 'false'. +func (o HelmReleaseSpecInstallRemediationPatchPtrOutput) RemediateLastFailure() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecInstallRemediationPatch) *bool { + if v == nil { + return nil + } + return v.RemediateLastFailure + }).(pulumi.BoolPtrOutput) +} + +// Retries is the number of retries that should be attempted on failures before +// bailing. Remediation, using an uninstall, is performed between each attempt. +// Defaults to '0', a negative integer equals to unlimited retries. +func (o HelmReleaseSpecInstallRemediationPatchPtrOutput) Retries() pulumi.IntPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecInstallRemediationPatch) *int { + if v == nil { + return nil + } + return v.Retries + }).(pulumi.IntPtrOutput) +} + +// Strategy defines the install strategy to use for this HelmRelease. +// Defaults to 'RemediateOnFailure', or 'RetryOnFailure' when the +// DefaultToRetryOnFailure feature gate is enabled. +type HelmReleaseSpecInstallStrategy struct { + // Name of the install strategy. + Name *string `pulumi:"name"` + // RetryInterval is the interval at which to retry a failed install. + // Can be used only when Name is set to RetryOnFailure. + // Defaults to '5m'. + RetryInterval *string `pulumi:"retryInterval"` +} + +// HelmReleaseSpecInstallStrategyInput is an input type that accepts HelmReleaseSpecInstallStrategyArgs and HelmReleaseSpecInstallStrategyOutput values. +// You can construct a concrete instance of `HelmReleaseSpecInstallStrategyInput` via: +// +// HelmReleaseSpecInstallStrategyArgs{...} +type HelmReleaseSpecInstallStrategyInput interface { + pulumi.Input + + ToHelmReleaseSpecInstallStrategyOutput() HelmReleaseSpecInstallStrategyOutput + ToHelmReleaseSpecInstallStrategyOutputWithContext(context.Context) HelmReleaseSpecInstallStrategyOutput +} + +// Strategy defines the install strategy to use for this HelmRelease. +// Defaults to 'RemediateOnFailure', or 'RetryOnFailure' when the +// DefaultToRetryOnFailure feature gate is enabled. +type HelmReleaseSpecInstallStrategyArgs struct { + // Name of the install strategy. + Name pulumi.StringPtrInput `pulumi:"name"` + // RetryInterval is the interval at which to retry a failed install. + // Can be used only when Name is set to RetryOnFailure. + // Defaults to '5m'. + RetryInterval pulumi.StringPtrInput `pulumi:"retryInterval"` +} + +func (HelmReleaseSpecInstallStrategyArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecInstallStrategy)(nil)).Elem() +} + +func (i HelmReleaseSpecInstallStrategyArgs) ToHelmReleaseSpecInstallStrategyOutput() HelmReleaseSpecInstallStrategyOutput { + return i.ToHelmReleaseSpecInstallStrategyOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecInstallStrategyArgs) ToHelmReleaseSpecInstallStrategyOutputWithContext(ctx context.Context) HelmReleaseSpecInstallStrategyOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecInstallStrategyOutput) +} + +func (i HelmReleaseSpecInstallStrategyArgs) ToHelmReleaseSpecInstallStrategyPtrOutput() HelmReleaseSpecInstallStrategyPtrOutput { + return i.ToHelmReleaseSpecInstallStrategyPtrOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecInstallStrategyArgs) ToHelmReleaseSpecInstallStrategyPtrOutputWithContext(ctx context.Context) HelmReleaseSpecInstallStrategyPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecInstallStrategyOutput).ToHelmReleaseSpecInstallStrategyPtrOutputWithContext(ctx) +} + +// HelmReleaseSpecInstallStrategyPtrInput is an input type that accepts HelmReleaseSpecInstallStrategyArgs, HelmReleaseSpecInstallStrategyPtr and HelmReleaseSpecInstallStrategyPtrOutput values. +// You can construct a concrete instance of `HelmReleaseSpecInstallStrategyPtrInput` via: +// +// HelmReleaseSpecInstallStrategyArgs{...} +// +// or: +// +// nil +type HelmReleaseSpecInstallStrategyPtrInput interface { + pulumi.Input + + ToHelmReleaseSpecInstallStrategyPtrOutput() HelmReleaseSpecInstallStrategyPtrOutput + ToHelmReleaseSpecInstallStrategyPtrOutputWithContext(context.Context) HelmReleaseSpecInstallStrategyPtrOutput +} + +type helmReleaseSpecInstallStrategyPtrType HelmReleaseSpecInstallStrategyArgs + +func HelmReleaseSpecInstallStrategyPtr(v *HelmReleaseSpecInstallStrategyArgs) HelmReleaseSpecInstallStrategyPtrInput { + return (*helmReleaseSpecInstallStrategyPtrType)(v) +} + +func (*helmReleaseSpecInstallStrategyPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecInstallStrategy)(nil)).Elem() +} + +func (i *helmReleaseSpecInstallStrategyPtrType) ToHelmReleaseSpecInstallStrategyPtrOutput() HelmReleaseSpecInstallStrategyPtrOutput { + return i.ToHelmReleaseSpecInstallStrategyPtrOutputWithContext(context.Background()) +} + +func (i *helmReleaseSpecInstallStrategyPtrType) ToHelmReleaseSpecInstallStrategyPtrOutputWithContext(ctx context.Context) HelmReleaseSpecInstallStrategyPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecInstallStrategyPtrOutput) +} + +// Strategy defines the install strategy to use for this HelmRelease. +// Defaults to 'RemediateOnFailure', or 'RetryOnFailure' when the +// DefaultToRetryOnFailure feature gate is enabled. +type HelmReleaseSpecInstallStrategyOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecInstallStrategyOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecInstallStrategy)(nil)).Elem() +} + +func (o HelmReleaseSpecInstallStrategyOutput) ToHelmReleaseSpecInstallStrategyOutput() HelmReleaseSpecInstallStrategyOutput { + return o +} + +func (o HelmReleaseSpecInstallStrategyOutput) ToHelmReleaseSpecInstallStrategyOutputWithContext(ctx context.Context) HelmReleaseSpecInstallStrategyOutput { + return o +} + +func (o HelmReleaseSpecInstallStrategyOutput) ToHelmReleaseSpecInstallStrategyPtrOutput() HelmReleaseSpecInstallStrategyPtrOutput { + return o.ToHelmReleaseSpecInstallStrategyPtrOutputWithContext(context.Background()) +} + +func (o HelmReleaseSpecInstallStrategyOutput) ToHelmReleaseSpecInstallStrategyPtrOutputWithContext(ctx context.Context) HelmReleaseSpecInstallStrategyPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v HelmReleaseSpecInstallStrategy) *HelmReleaseSpecInstallStrategy { + return &v + }).(HelmReleaseSpecInstallStrategyPtrOutput) +} + +// Name of the install strategy. +func (o HelmReleaseSpecInstallStrategyOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecInstallStrategy) *string { return v.Name }).(pulumi.StringPtrOutput) +} + +// RetryInterval is the interval at which to retry a failed install. +// Can be used only when Name is set to RetryOnFailure. +// Defaults to '5m'. +func (o HelmReleaseSpecInstallStrategyOutput) RetryInterval() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecInstallStrategy) *string { return v.RetryInterval }).(pulumi.StringPtrOutput) +} + +type HelmReleaseSpecInstallStrategyPtrOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecInstallStrategyPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecInstallStrategy)(nil)).Elem() +} + +func (o HelmReleaseSpecInstallStrategyPtrOutput) ToHelmReleaseSpecInstallStrategyPtrOutput() HelmReleaseSpecInstallStrategyPtrOutput { + return o +} + +func (o HelmReleaseSpecInstallStrategyPtrOutput) ToHelmReleaseSpecInstallStrategyPtrOutputWithContext(ctx context.Context) HelmReleaseSpecInstallStrategyPtrOutput { + return o +} + +func (o HelmReleaseSpecInstallStrategyPtrOutput) Elem() HelmReleaseSpecInstallStrategyOutput { + return o.ApplyT(func(v *HelmReleaseSpecInstallStrategy) HelmReleaseSpecInstallStrategy { + if v != nil { + return *v + } + var ret HelmReleaseSpecInstallStrategy + return ret + }).(HelmReleaseSpecInstallStrategyOutput) +} + +// Name of the install strategy. +func (o HelmReleaseSpecInstallStrategyPtrOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecInstallStrategy) *string { + if v == nil { + return nil + } + return v.Name + }).(pulumi.StringPtrOutput) +} + +// RetryInterval is the interval at which to retry a failed install. +// Can be used only when Name is set to RetryOnFailure. +// Defaults to '5m'. +func (o HelmReleaseSpecInstallStrategyPtrOutput) RetryInterval() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecInstallStrategy) *string { + if v == nil { + return nil + } + return v.RetryInterval + }).(pulumi.StringPtrOutput) +} + +// Strategy defines the install strategy to use for this HelmRelease. +// Defaults to 'RemediateOnFailure', or 'RetryOnFailure' when the +// DefaultToRetryOnFailure feature gate is enabled. +type HelmReleaseSpecInstallStrategyPatch struct { + // Name of the install strategy. + Name *string `pulumi:"name"` + // RetryInterval is the interval at which to retry a failed install. + // Can be used only when Name is set to RetryOnFailure. + // Defaults to '5m'. + RetryInterval *string `pulumi:"retryInterval"` +} + +// HelmReleaseSpecInstallStrategyPatchInput is an input type that accepts HelmReleaseSpecInstallStrategyPatchArgs and HelmReleaseSpecInstallStrategyPatchOutput values. +// You can construct a concrete instance of `HelmReleaseSpecInstallStrategyPatchInput` via: +// +// HelmReleaseSpecInstallStrategyPatchArgs{...} +type HelmReleaseSpecInstallStrategyPatchInput interface { + pulumi.Input + + ToHelmReleaseSpecInstallStrategyPatchOutput() HelmReleaseSpecInstallStrategyPatchOutput + ToHelmReleaseSpecInstallStrategyPatchOutputWithContext(context.Context) HelmReleaseSpecInstallStrategyPatchOutput +} + +// Strategy defines the install strategy to use for this HelmRelease. +// Defaults to 'RemediateOnFailure', or 'RetryOnFailure' when the +// DefaultToRetryOnFailure feature gate is enabled. +type HelmReleaseSpecInstallStrategyPatchArgs struct { + // Name of the install strategy. + Name pulumi.StringPtrInput `pulumi:"name"` + // RetryInterval is the interval at which to retry a failed install. + // Can be used only when Name is set to RetryOnFailure. + // Defaults to '5m'. + RetryInterval pulumi.StringPtrInput `pulumi:"retryInterval"` +} + +func (HelmReleaseSpecInstallStrategyPatchArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecInstallStrategyPatch)(nil)).Elem() +} + +func (i HelmReleaseSpecInstallStrategyPatchArgs) ToHelmReleaseSpecInstallStrategyPatchOutput() HelmReleaseSpecInstallStrategyPatchOutput { + return i.ToHelmReleaseSpecInstallStrategyPatchOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecInstallStrategyPatchArgs) ToHelmReleaseSpecInstallStrategyPatchOutputWithContext(ctx context.Context) HelmReleaseSpecInstallStrategyPatchOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecInstallStrategyPatchOutput) +} + +func (i HelmReleaseSpecInstallStrategyPatchArgs) ToHelmReleaseSpecInstallStrategyPatchPtrOutput() HelmReleaseSpecInstallStrategyPatchPtrOutput { + return i.ToHelmReleaseSpecInstallStrategyPatchPtrOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecInstallStrategyPatchArgs) ToHelmReleaseSpecInstallStrategyPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecInstallStrategyPatchPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecInstallStrategyPatchOutput).ToHelmReleaseSpecInstallStrategyPatchPtrOutputWithContext(ctx) +} + +// HelmReleaseSpecInstallStrategyPatchPtrInput is an input type that accepts HelmReleaseSpecInstallStrategyPatchArgs, HelmReleaseSpecInstallStrategyPatchPtr and HelmReleaseSpecInstallStrategyPatchPtrOutput values. +// You can construct a concrete instance of `HelmReleaseSpecInstallStrategyPatchPtrInput` via: +// +// HelmReleaseSpecInstallStrategyPatchArgs{...} +// +// or: +// +// nil +type HelmReleaseSpecInstallStrategyPatchPtrInput interface { + pulumi.Input + + ToHelmReleaseSpecInstallStrategyPatchPtrOutput() HelmReleaseSpecInstallStrategyPatchPtrOutput + ToHelmReleaseSpecInstallStrategyPatchPtrOutputWithContext(context.Context) HelmReleaseSpecInstallStrategyPatchPtrOutput +} + +type helmReleaseSpecInstallStrategyPatchPtrType HelmReleaseSpecInstallStrategyPatchArgs + +func HelmReleaseSpecInstallStrategyPatchPtr(v *HelmReleaseSpecInstallStrategyPatchArgs) HelmReleaseSpecInstallStrategyPatchPtrInput { + return (*helmReleaseSpecInstallStrategyPatchPtrType)(v) +} + +func (*helmReleaseSpecInstallStrategyPatchPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecInstallStrategyPatch)(nil)).Elem() +} + +func (i *helmReleaseSpecInstallStrategyPatchPtrType) ToHelmReleaseSpecInstallStrategyPatchPtrOutput() HelmReleaseSpecInstallStrategyPatchPtrOutput { + return i.ToHelmReleaseSpecInstallStrategyPatchPtrOutputWithContext(context.Background()) +} + +func (i *helmReleaseSpecInstallStrategyPatchPtrType) ToHelmReleaseSpecInstallStrategyPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecInstallStrategyPatchPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecInstallStrategyPatchPtrOutput) +} + +// Strategy defines the install strategy to use for this HelmRelease. +// Defaults to 'RemediateOnFailure', or 'RetryOnFailure' when the +// DefaultToRetryOnFailure feature gate is enabled. +type HelmReleaseSpecInstallStrategyPatchOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecInstallStrategyPatchOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecInstallStrategyPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecInstallStrategyPatchOutput) ToHelmReleaseSpecInstallStrategyPatchOutput() HelmReleaseSpecInstallStrategyPatchOutput { + return o +} + +func (o HelmReleaseSpecInstallStrategyPatchOutput) ToHelmReleaseSpecInstallStrategyPatchOutputWithContext(ctx context.Context) HelmReleaseSpecInstallStrategyPatchOutput { + return o +} + +func (o HelmReleaseSpecInstallStrategyPatchOutput) ToHelmReleaseSpecInstallStrategyPatchPtrOutput() HelmReleaseSpecInstallStrategyPatchPtrOutput { + return o.ToHelmReleaseSpecInstallStrategyPatchPtrOutputWithContext(context.Background()) +} + +func (o HelmReleaseSpecInstallStrategyPatchOutput) ToHelmReleaseSpecInstallStrategyPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecInstallStrategyPatchPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v HelmReleaseSpecInstallStrategyPatch) *HelmReleaseSpecInstallStrategyPatch { + return &v + }).(HelmReleaseSpecInstallStrategyPatchPtrOutput) +} + +// Name of the install strategy. +func (o HelmReleaseSpecInstallStrategyPatchOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecInstallStrategyPatch) *string { return v.Name }).(pulumi.StringPtrOutput) +} + +// RetryInterval is the interval at which to retry a failed install. +// Can be used only when Name is set to RetryOnFailure. +// Defaults to '5m'. +func (o HelmReleaseSpecInstallStrategyPatchOutput) RetryInterval() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecInstallStrategyPatch) *string { return v.RetryInterval }).(pulumi.StringPtrOutput) +} + +type HelmReleaseSpecInstallStrategyPatchPtrOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecInstallStrategyPatchPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecInstallStrategyPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecInstallStrategyPatchPtrOutput) ToHelmReleaseSpecInstallStrategyPatchPtrOutput() HelmReleaseSpecInstallStrategyPatchPtrOutput { + return o +} + +func (o HelmReleaseSpecInstallStrategyPatchPtrOutput) ToHelmReleaseSpecInstallStrategyPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecInstallStrategyPatchPtrOutput { + return o +} + +func (o HelmReleaseSpecInstallStrategyPatchPtrOutput) Elem() HelmReleaseSpecInstallStrategyPatchOutput { + return o.ApplyT(func(v *HelmReleaseSpecInstallStrategyPatch) HelmReleaseSpecInstallStrategyPatch { + if v != nil { + return *v + } + var ret HelmReleaseSpecInstallStrategyPatch + return ret + }).(HelmReleaseSpecInstallStrategyPatchOutput) +} + +// Name of the install strategy. +func (o HelmReleaseSpecInstallStrategyPatchPtrOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecInstallStrategyPatch) *string { + if v == nil { + return nil + } + return v.Name + }).(pulumi.StringPtrOutput) +} + +// RetryInterval is the interval at which to retry a failed install. +// Can be used only when Name is set to RetryOnFailure. +// Defaults to '5m'. +func (o HelmReleaseSpecInstallStrategyPatchPtrOutput) RetryInterval() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecInstallStrategyPatch) *string { + if v == nil { + return nil + } + return v.RetryInterval + }).(pulumi.StringPtrOutput) +} + +// KubeConfig for reconciling the HelmRelease on a remote cluster. +// When used in combination with HelmReleaseSpec.ServiceAccountName, +// forces the controller to act on behalf of that Service Account at the +// target cluster. +// If the --default-service-account flag is set, its value will be used as +// a controller level fallback for when HelmReleaseSpec.ServiceAccountName +// is empty. +type HelmReleaseSpecKubeConfig struct { + ConfigMapRef *HelmReleaseSpecKubeConfigConfigMapRef `pulumi:"configMapRef"` + SecretRef *HelmReleaseSpecKubeConfigSecretRef `pulumi:"secretRef"` +} + +// HelmReleaseSpecKubeConfigInput is an input type that accepts HelmReleaseSpecKubeConfigArgs and HelmReleaseSpecKubeConfigOutput values. +// You can construct a concrete instance of `HelmReleaseSpecKubeConfigInput` via: +// +// HelmReleaseSpecKubeConfigArgs{...} +type HelmReleaseSpecKubeConfigInput interface { + pulumi.Input + + ToHelmReleaseSpecKubeConfigOutput() HelmReleaseSpecKubeConfigOutput + ToHelmReleaseSpecKubeConfigOutputWithContext(context.Context) HelmReleaseSpecKubeConfigOutput +} + +// KubeConfig for reconciling the HelmRelease on a remote cluster. +// When used in combination with HelmReleaseSpec.ServiceAccountName, +// forces the controller to act on behalf of that Service Account at the +// target cluster. +// If the --default-service-account flag is set, its value will be used as +// a controller level fallback for when HelmReleaseSpec.ServiceAccountName +// is empty. +type HelmReleaseSpecKubeConfigArgs struct { + ConfigMapRef HelmReleaseSpecKubeConfigConfigMapRefPtrInput `pulumi:"configMapRef"` + SecretRef HelmReleaseSpecKubeConfigSecretRefPtrInput `pulumi:"secretRef"` +} + +func (HelmReleaseSpecKubeConfigArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecKubeConfig)(nil)).Elem() +} + +func (i HelmReleaseSpecKubeConfigArgs) ToHelmReleaseSpecKubeConfigOutput() HelmReleaseSpecKubeConfigOutput { + return i.ToHelmReleaseSpecKubeConfigOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecKubeConfigArgs) ToHelmReleaseSpecKubeConfigOutputWithContext(ctx context.Context) HelmReleaseSpecKubeConfigOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecKubeConfigOutput) +} + +func (i HelmReleaseSpecKubeConfigArgs) ToHelmReleaseSpecKubeConfigPtrOutput() HelmReleaseSpecKubeConfigPtrOutput { + return i.ToHelmReleaseSpecKubeConfigPtrOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecKubeConfigArgs) ToHelmReleaseSpecKubeConfigPtrOutputWithContext(ctx context.Context) HelmReleaseSpecKubeConfigPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecKubeConfigOutput).ToHelmReleaseSpecKubeConfigPtrOutputWithContext(ctx) +} + +// HelmReleaseSpecKubeConfigPtrInput is an input type that accepts HelmReleaseSpecKubeConfigArgs, HelmReleaseSpecKubeConfigPtr and HelmReleaseSpecKubeConfigPtrOutput values. +// You can construct a concrete instance of `HelmReleaseSpecKubeConfigPtrInput` via: +// +// HelmReleaseSpecKubeConfigArgs{...} +// +// or: +// +// nil +type HelmReleaseSpecKubeConfigPtrInput interface { + pulumi.Input + + ToHelmReleaseSpecKubeConfigPtrOutput() HelmReleaseSpecKubeConfigPtrOutput + ToHelmReleaseSpecKubeConfigPtrOutputWithContext(context.Context) HelmReleaseSpecKubeConfigPtrOutput +} + +type helmReleaseSpecKubeConfigPtrType HelmReleaseSpecKubeConfigArgs + +func HelmReleaseSpecKubeConfigPtr(v *HelmReleaseSpecKubeConfigArgs) HelmReleaseSpecKubeConfigPtrInput { + return (*helmReleaseSpecKubeConfigPtrType)(v) +} + +func (*helmReleaseSpecKubeConfigPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecKubeConfig)(nil)).Elem() +} + +func (i *helmReleaseSpecKubeConfigPtrType) ToHelmReleaseSpecKubeConfigPtrOutput() HelmReleaseSpecKubeConfigPtrOutput { + return i.ToHelmReleaseSpecKubeConfigPtrOutputWithContext(context.Background()) +} + +func (i *helmReleaseSpecKubeConfigPtrType) ToHelmReleaseSpecKubeConfigPtrOutputWithContext(ctx context.Context) HelmReleaseSpecKubeConfigPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecKubeConfigPtrOutput) +} + +// KubeConfig for reconciling the HelmRelease on a remote cluster. +// When used in combination with HelmReleaseSpec.ServiceAccountName, +// forces the controller to act on behalf of that Service Account at the +// target cluster. +// If the --default-service-account flag is set, its value will be used as +// a controller level fallback for when HelmReleaseSpec.ServiceAccountName +// is empty. +type HelmReleaseSpecKubeConfigOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecKubeConfigOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecKubeConfig)(nil)).Elem() +} + +func (o HelmReleaseSpecKubeConfigOutput) ToHelmReleaseSpecKubeConfigOutput() HelmReleaseSpecKubeConfigOutput { + return o +} + +func (o HelmReleaseSpecKubeConfigOutput) ToHelmReleaseSpecKubeConfigOutputWithContext(ctx context.Context) HelmReleaseSpecKubeConfigOutput { + return o +} + +func (o HelmReleaseSpecKubeConfigOutput) ToHelmReleaseSpecKubeConfigPtrOutput() HelmReleaseSpecKubeConfigPtrOutput { + return o.ToHelmReleaseSpecKubeConfigPtrOutputWithContext(context.Background()) +} + +func (o HelmReleaseSpecKubeConfigOutput) ToHelmReleaseSpecKubeConfigPtrOutputWithContext(ctx context.Context) HelmReleaseSpecKubeConfigPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v HelmReleaseSpecKubeConfig) *HelmReleaseSpecKubeConfig { + return &v + }).(HelmReleaseSpecKubeConfigPtrOutput) +} + +func (o HelmReleaseSpecKubeConfigOutput) ConfigMapRef() HelmReleaseSpecKubeConfigConfigMapRefPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecKubeConfig) *HelmReleaseSpecKubeConfigConfigMapRef { return v.ConfigMapRef }).(HelmReleaseSpecKubeConfigConfigMapRefPtrOutput) +} + +func (o HelmReleaseSpecKubeConfigOutput) SecretRef() HelmReleaseSpecKubeConfigSecretRefPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecKubeConfig) *HelmReleaseSpecKubeConfigSecretRef { return v.SecretRef }).(HelmReleaseSpecKubeConfigSecretRefPtrOutput) +} + +type HelmReleaseSpecKubeConfigPtrOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecKubeConfigPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecKubeConfig)(nil)).Elem() +} + +func (o HelmReleaseSpecKubeConfigPtrOutput) ToHelmReleaseSpecKubeConfigPtrOutput() HelmReleaseSpecKubeConfigPtrOutput { + return o +} + +func (o HelmReleaseSpecKubeConfigPtrOutput) ToHelmReleaseSpecKubeConfigPtrOutputWithContext(ctx context.Context) HelmReleaseSpecKubeConfigPtrOutput { + return o +} + +func (o HelmReleaseSpecKubeConfigPtrOutput) Elem() HelmReleaseSpecKubeConfigOutput { + return o.ApplyT(func(v *HelmReleaseSpecKubeConfig) HelmReleaseSpecKubeConfig { + if v != nil { + return *v + } + var ret HelmReleaseSpecKubeConfig + return ret + }).(HelmReleaseSpecKubeConfigOutput) +} + +func (o HelmReleaseSpecKubeConfigPtrOutput) ConfigMapRef() HelmReleaseSpecKubeConfigConfigMapRefPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecKubeConfig) *HelmReleaseSpecKubeConfigConfigMapRef { + if v == nil { + return nil + } + return v.ConfigMapRef + }).(HelmReleaseSpecKubeConfigConfigMapRefPtrOutput) +} + +func (o HelmReleaseSpecKubeConfigPtrOutput) SecretRef() HelmReleaseSpecKubeConfigSecretRefPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecKubeConfig) *HelmReleaseSpecKubeConfigSecretRef { + if v == nil { + return nil + } + return v.SecretRef + }).(HelmReleaseSpecKubeConfigSecretRefPtrOutput) +} + +// ConfigMapRef holds an optional name of a ConfigMap that contains +// the following keys: +// +// - `provider`: the provider to use. One of `aws`, `azure`, `gcp`, or +// `generic`. Required. +// - `cluster`: the fully qualified resource name of the Kubernetes +// cluster in the cloud provider API. Not used by the `generic` +// provider. Required when one of `address` or `ca.crt` is not set. +// - `address`: the address of the Kubernetes API server. Required +// for `generic`. For the other providers, if not specified, the +// first address in the cluster resource will be used, and if +// specified, it must match one of the addresses in the cluster +// resource. +// If audiences is not set, will be used as the audience for the +// `generic` provider. +// - `ca.crt`: the optional PEM-encoded CA certificate for the +// Kubernetes API server. If not set, the controller will use the +// CA certificate from the cluster resource. +// - `audiences`: the optional audiences as a list of +// line-break-separated strings for the Kubernetes ServiceAccount +// token. Defaults to the `address` for the `generic` provider, or +// to specific values for the other providers depending on the +// provider. +// - `serviceAccountName`: the optional name of the Kubernetes +// ServiceAccount in the same namespace that should be used +// for authentication. If not specified, the controller +// ServiceAccount will be used. +// +// Mutually exclusive with SecretRef. +type HelmReleaseSpecKubeConfigConfigMapRef struct { + // Name of the referent. + Name *string `pulumi:"name"` +} + +// HelmReleaseSpecKubeConfigConfigMapRefInput is an input type that accepts HelmReleaseSpecKubeConfigConfigMapRefArgs and HelmReleaseSpecKubeConfigConfigMapRefOutput values. +// You can construct a concrete instance of `HelmReleaseSpecKubeConfigConfigMapRefInput` via: +// +// HelmReleaseSpecKubeConfigConfigMapRefArgs{...} +type HelmReleaseSpecKubeConfigConfigMapRefInput interface { + pulumi.Input + + ToHelmReleaseSpecKubeConfigConfigMapRefOutput() HelmReleaseSpecKubeConfigConfigMapRefOutput + ToHelmReleaseSpecKubeConfigConfigMapRefOutputWithContext(context.Context) HelmReleaseSpecKubeConfigConfigMapRefOutput +} + +// ConfigMapRef holds an optional name of a ConfigMap that contains +// the following keys: +// +// - `provider`: the provider to use. One of `aws`, `azure`, `gcp`, or +// `generic`. Required. +// - `cluster`: the fully qualified resource name of the Kubernetes +// cluster in the cloud provider API. Not used by the `generic` +// provider. Required when one of `address` or `ca.crt` is not set. +// - `address`: the address of the Kubernetes API server. Required +// for `generic`. For the other providers, if not specified, the +// first address in the cluster resource will be used, and if +// specified, it must match one of the addresses in the cluster +// resource. +// If audiences is not set, will be used as the audience for the +// `generic` provider. +// - `ca.crt`: the optional PEM-encoded CA certificate for the +// Kubernetes API server. If not set, the controller will use the +// CA certificate from the cluster resource. +// - `audiences`: the optional audiences as a list of +// line-break-separated strings for the Kubernetes ServiceAccount +// token. Defaults to the `address` for the `generic` provider, or +// to specific values for the other providers depending on the +// provider. +// - `serviceAccountName`: the optional name of the Kubernetes +// ServiceAccount in the same namespace that should be used +// for authentication. If not specified, the controller +// ServiceAccount will be used. +// +// Mutually exclusive with SecretRef. +type HelmReleaseSpecKubeConfigConfigMapRefArgs struct { + // Name of the referent. + Name pulumi.StringPtrInput `pulumi:"name"` +} + +func (HelmReleaseSpecKubeConfigConfigMapRefArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecKubeConfigConfigMapRef)(nil)).Elem() +} + +func (i HelmReleaseSpecKubeConfigConfigMapRefArgs) ToHelmReleaseSpecKubeConfigConfigMapRefOutput() HelmReleaseSpecKubeConfigConfigMapRefOutput { + return i.ToHelmReleaseSpecKubeConfigConfigMapRefOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecKubeConfigConfigMapRefArgs) ToHelmReleaseSpecKubeConfigConfigMapRefOutputWithContext(ctx context.Context) HelmReleaseSpecKubeConfigConfigMapRefOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecKubeConfigConfigMapRefOutput) +} + +func (i HelmReleaseSpecKubeConfigConfigMapRefArgs) ToHelmReleaseSpecKubeConfigConfigMapRefPtrOutput() HelmReleaseSpecKubeConfigConfigMapRefPtrOutput { + return i.ToHelmReleaseSpecKubeConfigConfigMapRefPtrOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecKubeConfigConfigMapRefArgs) ToHelmReleaseSpecKubeConfigConfigMapRefPtrOutputWithContext(ctx context.Context) HelmReleaseSpecKubeConfigConfigMapRefPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecKubeConfigConfigMapRefOutput).ToHelmReleaseSpecKubeConfigConfigMapRefPtrOutputWithContext(ctx) +} + +// HelmReleaseSpecKubeConfigConfigMapRefPtrInput is an input type that accepts HelmReleaseSpecKubeConfigConfigMapRefArgs, HelmReleaseSpecKubeConfigConfigMapRefPtr and HelmReleaseSpecKubeConfigConfigMapRefPtrOutput values. +// You can construct a concrete instance of `HelmReleaseSpecKubeConfigConfigMapRefPtrInput` via: +// +// HelmReleaseSpecKubeConfigConfigMapRefArgs{...} +// +// or: +// +// nil +type HelmReleaseSpecKubeConfigConfigMapRefPtrInput interface { + pulumi.Input + + ToHelmReleaseSpecKubeConfigConfigMapRefPtrOutput() HelmReleaseSpecKubeConfigConfigMapRefPtrOutput + ToHelmReleaseSpecKubeConfigConfigMapRefPtrOutputWithContext(context.Context) HelmReleaseSpecKubeConfigConfigMapRefPtrOutput +} + +type helmReleaseSpecKubeConfigConfigMapRefPtrType HelmReleaseSpecKubeConfigConfigMapRefArgs + +func HelmReleaseSpecKubeConfigConfigMapRefPtr(v *HelmReleaseSpecKubeConfigConfigMapRefArgs) HelmReleaseSpecKubeConfigConfigMapRefPtrInput { + return (*helmReleaseSpecKubeConfigConfigMapRefPtrType)(v) +} + +func (*helmReleaseSpecKubeConfigConfigMapRefPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecKubeConfigConfigMapRef)(nil)).Elem() +} + +func (i *helmReleaseSpecKubeConfigConfigMapRefPtrType) ToHelmReleaseSpecKubeConfigConfigMapRefPtrOutput() HelmReleaseSpecKubeConfigConfigMapRefPtrOutput { + return i.ToHelmReleaseSpecKubeConfigConfigMapRefPtrOutputWithContext(context.Background()) +} + +func (i *helmReleaseSpecKubeConfigConfigMapRefPtrType) ToHelmReleaseSpecKubeConfigConfigMapRefPtrOutputWithContext(ctx context.Context) HelmReleaseSpecKubeConfigConfigMapRefPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecKubeConfigConfigMapRefPtrOutput) +} + +// ConfigMapRef holds an optional name of a ConfigMap that contains +// the following keys: +// +// - `provider`: the provider to use. One of `aws`, `azure`, `gcp`, or +// `generic`. Required. +// - `cluster`: the fully qualified resource name of the Kubernetes +// cluster in the cloud provider API. Not used by the `generic` +// provider. Required when one of `address` or `ca.crt` is not set. +// - `address`: the address of the Kubernetes API server. Required +// for `generic`. For the other providers, if not specified, the +// first address in the cluster resource will be used, and if +// specified, it must match one of the addresses in the cluster +// resource. +// If audiences is not set, will be used as the audience for the +// `generic` provider. +// - `ca.crt`: the optional PEM-encoded CA certificate for the +// Kubernetes API server. If not set, the controller will use the +// CA certificate from the cluster resource. +// - `audiences`: the optional audiences as a list of +// line-break-separated strings for the Kubernetes ServiceAccount +// token. Defaults to the `address` for the `generic` provider, or +// to specific values for the other providers depending on the +// provider. +// - `serviceAccountName`: the optional name of the Kubernetes +// ServiceAccount in the same namespace that should be used +// for authentication. If not specified, the controller +// ServiceAccount will be used. +// +// Mutually exclusive with SecretRef. +type HelmReleaseSpecKubeConfigConfigMapRefOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecKubeConfigConfigMapRefOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecKubeConfigConfigMapRef)(nil)).Elem() +} + +func (o HelmReleaseSpecKubeConfigConfigMapRefOutput) ToHelmReleaseSpecKubeConfigConfigMapRefOutput() HelmReleaseSpecKubeConfigConfigMapRefOutput { + return o +} + +func (o HelmReleaseSpecKubeConfigConfigMapRefOutput) ToHelmReleaseSpecKubeConfigConfigMapRefOutputWithContext(ctx context.Context) HelmReleaseSpecKubeConfigConfigMapRefOutput { + return o +} + +func (o HelmReleaseSpecKubeConfigConfigMapRefOutput) ToHelmReleaseSpecKubeConfigConfigMapRefPtrOutput() HelmReleaseSpecKubeConfigConfigMapRefPtrOutput { + return o.ToHelmReleaseSpecKubeConfigConfigMapRefPtrOutputWithContext(context.Background()) +} + +func (o HelmReleaseSpecKubeConfigConfigMapRefOutput) ToHelmReleaseSpecKubeConfigConfigMapRefPtrOutputWithContext(ctx context.Context) HelmReleaseSpecKubeConfigConfigMapRefPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v HelmReleaseSpecKubeConfigConfigMapRef) *HelmReleaseSpecKubeConfigConfigMapRef { + return &v + }).(HelmReleaseSpecKubeConfigConfigMapRefPtrOutput) +} + +// Name of the referent. +func (o HelmReleaseSpecKubeConfigConfigMapRefOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecKubeConfigConfigMapRef) *string { return v.Name }).(pulumi.StringPtrOutput) +} + +type HelmReleaseSpecKubeConfigConfigMapRefPtrOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecKubeConfigConfigMapRefPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecKubeConfigConfigMapRef)(nil)).Elem() +} + +func (o HelmReleaseSpecKubeConfigConfigMapRefPtrOutput) ToHelmReleaseSpecKubeConfigConfigMapRefPtrOutput() HelmReleaseSpecKubeConfigConfigMapRefPtrOutput { + return o +} + +func (o HelmReleaseSpecKubeConfigConfigMapRefPtrOutput) ToHelmReleaseSpecKubeConfigConfigMapRefPtrOutputWithContext(ctx context.Context) HelmReleaseSpecKubeConfigConfigMapRefPtrOutput { + return o +} + +func (o HelmReleaseSpecKubeConfigConfigMapRefPtrOutput) Elem() HelmReleaseSpecKubeConfigConfigMapRefOutput { + return o.ApplyT(func(v *HelmReleaseSpecKubeConfigConfigMapRef) HelmReleaseSpecKubeConfigConfigMapRef { + if v != nil { + return *v + } + var ret HelmReleaseSpecKubeConfigConfigMapRef + return ret + }).(HelmReleaseSpecKubeConfigConfigMapRefOutput) +} + +// Name of the referent. +func (o HelmReleaseSpecKubeConfigConfigMapRefPtrOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecKubeConfigConfigMapRef) *string { + if v == nil { + return nil + } + return v.Name + }).(pulumi.StringPtrOutput) +} + +// ConfigMapRef holds an optional name of a ConfigMap that contains +// the following keys: +// +// - `provider`: the provider to use. One of `aws`, `azure`, `gcp`, or +// `generic`. Required. +// - `cluster`: the fully qualified resource name of the Kubernetes +// cluster in the cloud provider API. Not used by the `generic` +// provider. Required when one of `address` or `ca.crt` is not set. +// - `address`: the address of the Kubernetes API server. Required +// for `generic`. For the other providers, if not specified, the +// first address in the cluster resource will be used, and if +// specified, it must match one of the addresses in the cluster +// resource. +// If audiences is not set, will be used as the audience for the +// `generic` provider. +// - `ca.crt`: the optional PEM-encoded CA certificate for the +// Kubernetes API server. If not set, the controller will use the +// CA certificate from the cluster resource. +// - `audiences`: the optional audiences as a list of +// line-break-separated strings for the Kubernetes ServiceAccount +// token. Defaults to the `address` for the `generic` provider, or +// to specific values for the other providers depending on the +// provider. +// - `serviceAccountName`: the optional name of the Kubernetes +// ServiceAccount in the same namespace that should be used +// for authentication. If not specified, the controller +// ServiceAccount will be used. +// +// Mutually exclusive with SecretRef. +type HelmReleaseSpecKubeConfigConfigMapRefPatch struct { + // Name of the referent. + Name *string `pulumi:"name"` +} + +// HelmReleaseSpecKubeConfigConfigMapRefPatchInput is an input type that accepts HelmReleaseSpecKubeConfigConfigMapRefPatchArgs and HelmReleaseSpecKubeConfigConfigMapRefPatchOutput values. +// You can construct a concrete instance of `HelmReleaseSpecKubeConfigConfigMapRefPatchInput` via: +// +// HelmReleaseSpecKubeConfigConfigMapRefPatchArgs{...} +type HelmReleaseSpecKubeConfigConfigMapRefPatchInput interface { + pulumi.Input + + ToHelmReleaseSpecKubeConfigConfigMapRefPatchOutput() HelmReleaseSpecKubeConfigConfigMapRefPatchOutput + ToHelmReleaseSpecKubeConfigConfigMapRefPatchOutputWithContext(context.Context) HelmReleaseSpecKubeConfigConfigMapRefPatchOutput +} + +// ConfigMapRef holds an optional name of a ConfigMap that contains +// the following keys: +// +// - `provider`: the provider to use. One of `aws`, `azure`, `gcp`, or +// `generic`. Required. +// - `cluster`: the fully qualified resource name of the Kubernetes +// cluster in the cloud provider API. Not used by the `generic` +// provider. Required when one of `address` or `ca.crt` is not set. +// - `address`: the address of the Kubernetes API server. Required +// for `generic`. For the other providers, if not specified, the +// first address in the cluster resource will be used, and if +// specified, it must match one of the addresses in the cluster +// resource. +// If audiences is not set, will be used as the audience for the +// `generic` provider. +// - `ca.crt`: the optional PEM-encoded CA certificate for the +// Kubernetes API server. If not set, the controller will use the +// CA certificate from the cluster resource. +// - `audiences`: the optional audiences as a list of +// line-break-separated strings for the Kubernetes ServiceAccount +// token. Defaults to the `address` for the `generic` provider, or +// to specific values for the other providers depending on the +// provider. +// - `serviceAccountName`: the optional name of the Kubernetes +// ServiceAccount in the same namespace that should be used +// for authentication. If not specified, the controller +// ServiceAccount will be used. +// +// Mutually exclusive with SecretRef. +type HelmReleaseSpecKubeConfigConfigMapRefPatchArgs struct { + // Name of the referent. + Name pulumi.StringPtrInput `pulumi:"name"` +} + +func (HelmReleaseSpecKubeConfigConfigMapRefPatchArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecKubeConfigConfigMapRefPatch)(nil)).Elem() +} + +func (i HelmReleaseSpecKubeConfigConfigMapRefPatchArgs) ToHelmReleaseSpecKubeConfigConfigMapRefPatchOutput() HelmReleaseSpecKubeConfigConfigMapRefPatchOutput { + return i.ToHelmReleaseSpecKubeConfigConfigMapRefPatchOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecKubeConfigConfigMapRefPatchArgs) ToHelmReleaseSpecKubeConfigConfigMapRefPatchOutputWithContext(ctx context.Context) HelmReleaseSpecKubeConfigConfigMapRefPatchOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecKubeConfigConfigMapRefPatchOutput) +} + +func (i HelmReleaseSpecKubeConfigConfigMapRefPatchArgs) ToHelmReleaseSpecKubeConfigConfigMapRefPatchPtrOutput() HelmReleaseSpecKubeConfigConfigMapRefPatchPtrOutput { + return i.ToHelmReleaseSpecKubeConfigConfigMapRefPatchPtrOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecKubeConfigConfigMapRefPatchArgs) ToHelmReleaseSpecKubeConfigConfigMapRefPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecKubeConfigConfigMapRefPatchPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecKubeConfigConfigMapRefPatchOutput).ToHelmReleaseSpecKubeConfigConfigMapRefPatchPtrOutputWithContext(ctx) +} + +// HelmReleaseSpecKubeConfigConfigMapRefPatchPtrInput is an input type that accepts HelmReleaseSpecKubeConfigConfigMapRefPatchArgs, HelmReleaseSpecKubeConfigConfigMapRefPatchPtr and HelmReleaseSpecKubeConfigConfigMapRefPatchPtrOutput values. +// You can construct a concrete instance of `HelmReleaseSpecKubeConfigConfigMapRefPatchPtrInput` via: +// +// HelmReleaseSpecKubeConfigConfigMapRefPatchArgs{...} +// +// or: +// +// nil +type HelmReleaseSpecKubeConfigConfigMapRefPatchPtrInput interface { + pulumi.Input + + ToHelmReleaseSpecKubeConfigConfigMapRefPatchPtrOutput() HelmReleaseSpecKubeConfigConfigMapRefPatchPtrOutput + ToHelmReleaseSpecKubeConfigConfigMapRefPatchPtrOutputWithContext(context.Context) HelmReleaseSpecKubeConfigConfigMapRefPatchPtrOutput +} + +type helmReleaseSpecKubeConfigConfigMapRefPatchPtrType HelmReleaseSpecKubeConfigConfigMapRefPatchArgs + +func HelmReleaseSpecKubeConfigConfigMapRefPatchPtr(v *HelmReleaseSpecKubeConfigConfigMapRefPatchArgs) HelmReleaseSpecKubeConfigConfigMapRefPatchPtrInput { + return (*helmReleaseSpecKubeConfigConfigMapRefPatchPtrType)(v) +} + +func (*helmReleaseSpecKubeConfigConfigMapRefPatchPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecKubeConfigConfigMapRefPatch)(nil)).Elem() +} + +func (i *helmReleaseSpecKubeConfigConfigMapRefPatchPtrType) ToHelmReleaseSpecKubeConfigConfigMapRefPatchPtrOutput() HelmReleaseSpecKubeConfigConfigMapRefPatchPtrOutput { + return i.ToHelmReleaseSpecKubeConfigConfigMapRefPatchPtrOutputWithContext(context.Background()) +} + +func (i *helmReleaseSpecKubeConfigConfigMapRefPatchPtrType) ToHelmReleaseSpecKubeConfigConfigMapRefPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecKubeConfigConfigMapRefPatchPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecKubeConfigConfigMapRefPatchPtrOutput) +} + +// ConfigMapRef holds an optional name of a ConfigMap that contains +// the following keys: +// +// - `provider`: the provider to use. One of `aws`, `azure`, `gcp`, or +// `generic`. Required. +// - `cluster`: the fully qualified resource name of the Kubernetes +// cluster in the cloud provider API. Not used by the `generic` +// provider. Required when one of `address` or `ca.crt` is not set. +// - `address`: the address of the Kubernetes API server. Required +// for `generic`. For the other providers, if not specified, the +// first address in the cluster resource will be used, and if +// specified, it must match one of the addresses in the cluster +// resource. +// If audiences is not set, will be used as the audience for the +// `generic` provider. +// - `ca.crt`: the optional PEM-encoded CA certificate for the +// Kubernetes API server. If not set, the controller will use the +// CA certificate from the cluster resource. +// - `audiences`: the optional audiences as a list of +// line-break-separated strings for the Kubernetes ServiceAccount +// token. Defaults to the `address` for the `generic` provider, or +// to specific values for the other providers depending on the +// provider. +// - `serviceAccountName`: the optional name of the Kubernetes +// ServiceAccount in the same namespace that should be used +// for authentication. If not specified, the controller +// ServiceAccount will be used. +// +// Mutually exclusive with SecretRef. +type HelmReleaseSpecKubeConfigConfigMapRefPatchOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecKubeConfigConfigMapRefPatchOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecKubeConfigConfigMapRefPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecKubeConfigConfigMapRefPatchOutput) ToHelmReleaseSpecKubeConfigConfigMapRefPatchOutput() HelmReleaseSpecKubeConfigConfigMapRefPatchOutput { + return o +} + +func (o HelmReleaseSpecKubeConfigConfigMapRefPatchOutput) ToHelmReleaseSpecKubeConfigConfigMapRefPatchOutputWithContext(ctx context.Context) HelmReleaseSpecKubeConfigConfigMapRefPatchOutput { + return o +} + +func (o HelmReleaseSpecKubeConfigConfigMapRefPatchOutput) ToHelmReleaseSpecKubeConfigConfigMapRefPatchPtrOutput() HelmReleaseSpecKubeConfigConfigMapRefPatchPtrOutput { + return o.ToHelmReleaseSpecKubeConfigConfigMapRefPatchPtrOutputWithContext(context.Background()) +} + +func (o HelmReleaseSpecKubeConfigConfigMapRefPatchOutput) ToHelmReleaseSpecKubeConfigConfigMapRefPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecKubeConfigConfigMapRefPatchPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v HelmReleaseSpecKubeConfigConfigMapRefPatch) *HelmReleaseSpecKubeConfigConfigMapRefPatch { + return &v + }).(HelmReleaseSpecKubeConfigConfigMapRefPatchPtrOutput) +} + +// Name of the referent. +func (o HelmReleaseSpecKubeConfigConfigMapRefPatchOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecKubeConfigConfigMapRefPatch) *string { return v.Name }).(pulumi.StringPtrOutput) +} + +type HelmReleaseSpecKubeConfigConfigMapRefPatchPtrOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecKubeConfigConfigMapRefPatchPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecKubeConfigConfigMapRefPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecKubeConfigConfigMapRefPatchPtrOutput) ToHelmReleaseSpecKubeConfigConfigMapRefPatchPtrOutput() HelmReleaseSpecKubeConfigConfigMapRefPatchPtrOutput { + return o +} + +func (o HelmReleaseSpecKubeConfigConfigMapRefPatchPtrOutput) ToHelmReleaseSpecKubeConfigConfigMapRefPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecKubeConfigConfigMapRefPatchPtrOutput { + return o +} + +func (o HelmReleaseSpecKubeConfigConfigMapRefPatchPtrOutput) Elem() HelmReleaseSpecKubeConfigConfigMapRefPatchOutput { + return o.ApplyT(func(v *HelmReleaseSpecKubeConfigConfigMapRefPatch) HelmReleaseSpecKubeConfigConfigMapRefPatch { + if v != nil { + return *v + } + var ret HelmReleaseSpecKubeConfigConfigMapRefPatch + return ret + }).(HelmReleaseSpecKubeConfigConfigMapRefPatchOutput) +} + +// Name of the referent. +func (o HelmReleaseSpecKubeConfigConfigMapRefPatchPtrOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecKubeConfigConfigMapRefPatch) *string { + if v == nil { + return nil + } + return v.Name + }).(pulumi.StringPtrOutput) +} + +// KubeConfig for reconciling the HelmRelease on a remote cluster. +// When used in combination with HelmReleaseSpec.ServiceAccountName, +// forces the controller to act on behalf of that Service Account at the +// target cluster. +// If the --default-service-account flag is set, its value will be used as +// a controller level fallback for when HelmReleaseSpec.ServiceAccountName +// is empty. +type HelmReleaseSpecKubeConfigPatch struct { + ConfigMapRef *HelmReleaseSpecKubeConfigConfigMapRefPatch `pulumi:"configMapRef"` + SecretRef *HelmReleaseSpecKubeConfigSecretRefPatch `pulumi:"secretRef"` +} + +// HelmReleaseSpecKubeConfigPatchInput is an input type that accepts HelmReleaseSpecKubeConfigPatchArgs and HelmReleaseSpecKubeConfigPatchOutput values. +// You can construct a concrete instance of `HelmReleaseSpecKubeConfigPatchInput` via: +// +// HelmReleaseSpecKubeConfigPatchArgs{...} +type HelmReleaseSpecKubeConfigPatchInput interface { + pulumi.Input + + ToHelmReleaseSpecKubeConfigPatchOutput() HelmReleaseSpecKubeConfigPatchOutput + ToHelmReleaseSpecKubeConfigPatchOutputWithContext(context.Context) HelmReleaseSpecKubeConfigPatchOutput +} + +// KubeConfig for reconciling the HelmRelease on a remote cluster. +// When used in combination with HelmReleaseSpec.ServiceAccountName, +// forces the controller to act on behalf of that Service Account at the +// target cluster. +// If the --default-service-account flag is set, its value will be used as +// a controller level fallback for when HelmReleaseSpec.ServiceAccountName +// is empty. +type HelmReleaseSpecKubeConfigPatchArgs struct { + ConfigMapRef HelmReleaseSpecKubeConfigConfigMapRefPatchPtrInput `pulumi:"configMapRef"` + SecretRef HelmReleaseSpecKubeConfigSecretRefPatchPtrInput `pulumi:"secretRef"` +} + +func (HelmReleaseSpecKubeConfigPatchArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecKubeConfigPatch)(nil)).Elem() +} + +func (i HelmReleaseSpecKubeConfigPatchArgs) ToHelmReleaseSpecKubeConfigPatchOutput() HelmReleaseSpecKubeConfigPatchOutput { + return i.ToHelmReleaseSpecKubeConfigPatchOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecKubeConfigPatchArgs) ToHelmReleaseSpecKubeConfigPatchOutputWithContext(ctx context.Context) HelmReleaseSpecKubeConfigPatchOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecKubeConfigPatchOutput) +} + +func (i HelmReleaseSpecKubeConfigPatchArgs) ToHelmReleaseSpecKubeConfigPatchPtrOutput() HelmReleaseSpecKubeConfigPatchPtrOutput { + return i.ToHelmReleaseSpecKubeConfigPatchPtrOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecKubeConfigPatchArgs) ToHelmReleaseSpecKubeConfigPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecKubeConfigPatchPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecKubeConfigPatchOutput).ToHelmReleaseSpecKubeConfigPatchPtrOutputWithContext(ctx) +} + +// HelmReleaseSpecKubeConfigPatchPtrInput is an input type that accepts HelmReleaseSpecKubeConfigPatchArgs, HelmReleaseSpecKubeConfigPatchPtr and HelmReleaseSpecKubeConfigPatchPtrOutput values. +// You can construct a concrete instance of `HelmReleaseSpecKubeConfigPatchPtrInput` via: +// +// HelmReleaseSpecKubeConfigPatchArgs{...} +// +// or: +// +// nil +type HelmReleaseSpecKubeConfigPatchPtrInput interface { + pulumi.Input + + ToHelmReleaseSpecKubeConfigPatchPtrOutput() HelmReleaseSpecKubeConfigPatchPtrOutput + ToHelmReleaseSpecKubeConfigPatchPtrOutputWithContext(context.Context) HelmReleaseSpecKubeConfigPatchPtrOutput +} + +type helmReleaseSpecKubeConfigPatchPtrType HelmReleaseSpecKubeConfigPatchArgs + +func HelmReleaseSpecKubeConfigPatchPtr(v *HelmReleaseSpecKubeConfigPatchArgs) HelmReleaseSpecKubeConfigPatchPtrInput { + return (*helmReleaseSpecKubeConfigPatchPtrType)(v) +} + +func (*helmReleaseSpecKubeConfigPatchPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecKubeConfigPatch)(nil)).Elem() +} + +func (i *helmReleaseSpecKubeConfigPatchPtrType) ToHelmReleaseSpecKubeConfigPatchPtrOutput() HelmReleaseSpecKubeConfigPatchPtrOutput { + return i.ToHelmReleaseSpecKubeConfigPatchPtrOutputWithContext(context.Background()) +} + +func (i *helmReleaseSpecKubeConfigPatchPtrType) ToHelmReleaseSpecKubeConfigPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecKubeConfigPatchPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecKubeConfigPatchPtrOutput) +} + +// KubeConfig for reconciling the HelmRelease on a remote cluster. +// When used in combination with HelmReleaseSpec.ServiceAccountName, +// forces the controller to act on behalf of that Service Account at the +// target cluster. +// If the --default-service-account flag is set, its value will be used as +// a controller level fallback for when HelmReleaseSpec.ServiceAccountName +// is empty. +type HelmReleaseSpecKubeConfigPatchOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecKubeConfigPatchOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecKubeConfigPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecKubeConfigPatchOutput) ToHelmReleaseSpecKubeConfigPatchOutput() HelmReleaseSpecKubeConfigPatchOutput { + return o +} + +func (o HelmReleaseSpecKubeConfigPatchOutput) ToHelmReleaseSpecKubeConfigPatchOutputWithContext(ctx context.Context) HelmReleaseSpecKubeConfigPatchOutput { + return o +} + +func (o HelmReleaseSpecKubeConfigPatchOutput) ToHelmReleaseSpecKubeConfigPatchPtrOutput() HelmReleaseSpecKubeConfigPatchPtrOutput { + return o.ToHelmReleaseSpecKubeConfigPatchPtrOutputWithContext(context.Background()) +} + +func (o HelmReleaseSpecKubeConfigPatchOutput) ToHelmReleaseSpecKubeConfigPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecKubeConfigPatchPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v HelmReleaseSpecKubeConfigPatch) *HelmReleaseSpecKubeConfigPatch { + return &v + }).(HelmReleaseSpecKubeConfigPatchPtrOutput) +} + +func (o HelmReleaseSpecKubeConfigPatchOutput) ConfigMapRef() HelmReleaseSpecKubeConfigConfigMapRefPatchPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecKubeConfigPatch) *HelmReleaseSpecKubeConfigConfigMapRefPatch { + return v.ConfigMapRef + }).(HelmReleaseSpecKubeConfigConfigMapRefPatchPtrOutput) +} + +func (o HelmReleaseSpecKubeConfigPatchOutput) SecretRef() HelmReleaseSpecKubeConfigSecretRefPatchPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecKubeConfigPatch) *HelmReleaseSpecKubeConfigSecretRefPatch { return v.SecretRef }).(HelmReleaseSpecKubeConfigSecretRefPatchPtrOutput) +} + +type HelmReleaseSpecKubeConfigPatchPtrOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecKubeConfigPatchPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecKubeConfigPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecKubeConfigPatchPtrOutput) ToHelmReleaseSpecKubeConfigPatchPtrOutput() HelmReleaseSpecKubeConfigPatchPtrOutput { + return o +} + +func (o HelmReleaseSpecKubeConfigPatchPtrOutput) ToHelmReleaseSpecKubeConfigPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecKubeConfigPatchPtrOutput { + return o +} + +func (o HelmReleaseSpecKubeConfigPatchPtrOutput) Elem() HelmReleaseSpecKubeConfigPatchOutput { + return o.ApplyT(func(v *HelmReleaseSpecKubeConfigPatch) HelmReleaseSpecKubeConfigPatch { + if v != nil { + return *v + } + var ret HelmReleaseSpecKubeConfigPatch + return ret + }).(HelmReleaseSpecKubeConfigPatchOutput) +} + +func (o HelmReleaseSpecKubeConfigPatchPtrOutput) ConfigMapRef() HelmReleaseSpecKubeConfigConfigMapRefPatchPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecKubeConfigPatch) *HelmReleaseSpecKubeConfigConfigMapRefPatch { + if v == nil { + return nil + } + return v.ConfigMapRef + }).(HelmReleaseSpecKubeConfigConfigMapRefPatchPtrOutput) +} + +func (o HelmReleaseSpecKubeConfigPatchPtrOutput) SecretRef() HelmReleaseSpecKubeConfigSecretRefPatchPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecKubeConfigPatch) *HelmReleaseSpecKubeConfigSecretRefPatch { + if v == nil { + return nil + } + return v.SecretRef + }).(HelmReleaseSpecKubeConfigSecretRefPatchPtrOutput) +} + +// SecretRef holds an optional name of a secret that contains a key with +// the kubeconfig file as the value. If no key is set, the key will default +// to 'value'. Mutually exclusive with ConfigMapRef. +// It is recommended that the kubeconfig is self-contained, and the secret +// is regularly updated if credentials such as a cloud-access-token expire. +// Cloud specific `cmd-path` auth helpers will not function without adding +// binaries and credentials to the Pod that is responsible for reconciling +// Kubernetes resources. Supported only for the generic provider. +type HelmReleaseSpecKubeConfigSecretRef struct { + // Key in the Secret, when not specified an implementation-specific default key is used. + Key *string `pulumi:"key"` + // Name of the Secret. + Name *string `pulumi:"name"` +} + +// HelmReleaseSpecKubeConfigSecretRefInput is an input type that accepts HelmReleaseSpecKubeConfigSecretRefArgs and HelmReleaseSpecKubeConfigSecretRefOutput values. +// You can construct a concrete instance of `HelmReleaseSpecKubeConfigSecretRefInput` via: +// +// HelmReleaseSpecKubeConfigSecretRefArgs{...} +type HelmReleaseSpecKubeConfigSecretRefInput interface { + pulumi.Input + + ToHelmReleaseSpecKubeConfigSecretRefOutput() HelmReleaseSpecKubeConfigSecretRefOutput + ToHelmReleaseSpecKubeConfigSecretRefOutputWithContext(context.Context) HelmReleaseSpecKubeConfigSecretRefOutput +} + +// SecretRef holds an optional name of a secret that contains a key with +// the kubeconfig file as the value. If no key is set, the key will default +// to 'value'. Mutually exclusive with ConfigMapRef. +// It is recommended that the kubeconfig is self-contained, and the secret +// is regularly updated if credentials such as a cloud-access-token expire. +// Cloud specific `cmd-path` auth helpers will not function without adding +// binaries and credentials to the Pod that is responsible for reconciling +// Kubernetes resources. Supported only for the generic provider. +type HelmReleaseSpecKubeConfigSecretRefArgs struct { + // Key in the Secret, when not specified an implementation-specific default key is used. + Key pulumi.StringPtrInput `pulumi:"key"` + // Name of the Secret. + Name pulumi.StringPtrInput `pulumi:"name"` +} + +func (HelmReleaseSpecKubeConfigSecretRefArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecKubeConfigSecretRef)(nil)).Elem() +} + +func (i HelmReleaseSpecKubeConfigSecretRefArgs) ToHelmReleaseSpecKubeConfigSecretRefOutput() HelmReleaseSpecKubeConfigSecretRefOutput { + return i.ToHelmReleaseSpecKubeConfigSecretRefOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecKubeConfigSecretRefArgs) ToHelmReleaseSpecKubeConfigSecretRefOutputWithContext(ctx context.Context) HelmReleaseSpecKubeConfigSecretRefOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecKubeConfigSecretRefOutput) +} + +func (i HelmReleaseSpecKubeConfigSecretRefArgs) ToHelmReleaseSpecKubeConfigSecretRefPtrOutput() HelmReleaseSpecKubeConfigSecretRefPtrOutput { + return i.ToHelmReleaseSpecKubeConfigSecretRefPtrOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecKubeConfigSecretRefArgs) ToHelmReleaseSpecKubeConfigSecretRefPtrOutputWithContext(ctx context.Context) HelmReleaseSpecKubeConfigSecretRefPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecKubeConfigSecretRefOutput).ToHelmReleaseSpecKubeConfigSecretRefPtrOutputWithContext(ctx) +} + +// HelmReleaseSpecKubeConfigSecretRefPtrInput is an input type that accepts HelmReleaseSpecKubeConfigSecretRefArgs, HelmReleaseSpecKubeConfigSecretRefPtr and HelmReleaseSpecKubeConfigSecretRefPtrOutput values. +// You can construct a concrete instance of `HelmReleaseSpecKubeConfigSecretRefPtrInput` via: +// +// HelmReleaseSpecKubeConfigSecretRefArgs{...} +// +// or: +// +// nil +type HelmReleaseSpecKubeConfigSecretRefPtrInput interface { + pulumi.Input + + ToHelmReleaseSpecKubeConfigSecretRefPtrOutput() HelmReleaseSpecKubeConfigSecretRefPtrOutput + ToHelmReleaseSpecKubeConfigSecretRefPtrOutputWithContext(context.Context) HelmReleaseSpecKubeConfigSecretRefPtrOutput +} + +type helmReleaseSpecKubeConfigSecretRefPtrType HelmReleaseSpecKubeConfigSecretRefArgs + +func HelmReleaseSpecKubeConfigSecretRefPtr(v *HelmReleaseSpecKubeConfigSecretRefArgs) HelmReleaseSpecKubeConfigSecretRefPtrInput { + return (*helmReleaseSpecKubeConfigSecretRefPtrType)(v) +} + +func (*helmReleaseSpecKubeConfigSecretRefPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecKubeConfigSecretRef)(nil)).Elem() +} + +func (i *helmReleaseSpecKubeConfigSecretRefPtrType) ToHelmReleaseSpecKubeConfigSecretRefPtrOutput() HelmReleaseSpecKubeConfigSecretRefPtrOutput { + return i.ToHelmReleaseSpecKubeConfigSecretRefPtrOutputWithContext(context.Background()) +} + +func (i *helmReleaseSpecKubeConfigSecretRefPtrType) ToHelmReleaseSpecKubeConfigSecretRefPtrOutputWithContext(ctx context.Context) HelmReleaseSpecKubeConfigSecretRefPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecKubeConfigSecretRefPtrOutput) +} + +// SecretRef holds an optional name of a secret that contains a key with +// the kubeconfig file as the value. If no key is set, the key will default +// to 'value'. Mutually exclusive with ConfigMapRef. +// It is recommended that the kubeconfig is self-contained, and the secret +// is regularly updated if credentials such as a cloud-access-token expire. +// Cloud specific `cmd-path` auth helpers will not function without adding +// binaries and credentials to the Pod that is responsible for reconciling +// Kubernetes resources. Supported only for the generic provider. +type HelmReleaseSpecKubeConfigSecretRefOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecKubeConfigSecretRefOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecKubeConfigSecretRef)(nil)).Elem() +} + +func (o HelmReleaseSpecKubeConfigSecretRefOutput) ToHelmReleaseSpecKubeConfigSecretRefOutput() HelmReleaseSpecKubeConfigSecretRefOutput { + return o +} + +func (o HelmReleaseSpecKubeConfigSecretRefOutput) ToHelmReleaseSpecKubeConfigSecretRefOutputWithContext(ctx context.Context) HelmReleaseSpecKubeConfigSecretRefOutput { + return o +} + +func (o HelmReleaseSpecKubeConfigSecretRefOutput) ToHelmReleaseSpecKubeConfigSecretRefPtrOutput() HelmReleaseSpecKubeConfigSecretRefPtrOutput { + return o.ToHelmReleaseSpecKubeConfigSecretRefPtrOutputWithContext(context.Background()) +} + +func (o HelmReleaseSpecKubeConfigSecretRefOutput) ToHelmReleaseSpecKubeConfigSecretRefPtrOutputWithContext(ctx context.Context) HelmReleaseSpecKubeConfigSecretRefPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v HelmReleaseSpecKubeConfigSecretRef) *HelmReleaseSpecKubeConfigSecretRef { + return &v + }).(HelmReleaseSpecKubeConfigSecretRefPtrOutput) +} + +// Key in the Secret, when not specified an implementation-specific default key is used. +func (o HelmReleaseSpecKubeConfigSecretRefOutput) Key() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecKubeConfigSecretRef) *string { return v.Key }).(pulumi.StringPtrOutput) +} + +// Name of the Secret. +func (o HelmReleaseSpecKubeConfigSecretRefOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecKubeConfigSecretRef) *string { return v.Name }).(pulumi.StringPtrOutput) +} + +type HelmReleaseSpecKubeConfigSecretRefPtrOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecKubeConfigSecretRefPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecKubeConfigSecretRef)(nil)).Elem() +} + +func (o HelmReleaseSpecKubeConfigSecretRefPtrOutput) ToHelmReleaseSpecKubeConfigSecretRefPtrOutput() HelmReleaseSpecKubeConfigSecretRefPtrOutput { + return o +} + +func (o HelmReleaseSpecKubeConfigSecretRefPtrOutput) ToHelmReleaseSpecKubeConfigSecretRefPtrOutputWithContext(ctx context.Context) HelmReleaseSpecKubeConfigSecretRefPtrOutput { + return o +} + +func (o HelmReleaseSpecKubeConfigSecretRefPtrOutput) Elem() HelmReleaseSpecKubeConfigSecretRefOutput { + return o.ApplyT(func(v *HelmReleaseSpecKubeConfigSecretRef) HelmReleaseSpecKubeConfigSecretRef { + if v != nil { + return *v + } + var ret HelmReleaseSpecKubeConfigSecretRef + return ret + }).(HelmReleaseSpecKubeConfigSecretRefOutput) +} + +// Key in the Secret, when not specified an implementation-specific default key is used. +func (o HelmReleaseSpecKubeConfigSecretRefPtrOutput) Key() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecKubeConfigSecretRef) *string { + if v == nil { + return nil + } + return v.Key + }).(pulumi.StringPtrOutput) +} + +// Name of the Secret. +func (o HelmReleaseSpecKubeConfigSecretRefPtrOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecKubeConfigSecretRef) *string { + if v == nil { + return nil + } + return v.Name + }).(pulumi.StringPtrOutput) +} + +// SecretRef holds an optional name of a secret that contains a key with +// the kubeconfig file as the value. If no key is set, the key will default +// to 'value'. Mutually exclusive with ConfigMapRef. +// It is recommended that the kubeconfig is self-contained, and the secret +// is regularly updated if credentials such as a cloud-access-token expire. +// Cloud specific `cmd-path` auth helpers will not function without adding +// binaries and credentials to the Pod that is responsible for reconciling +// Kubernetes resources. Supported only for the generic provider. +type HelmReleaseSpecKubeConfigSecretRefPatch struct { + // Key in the Secret, when not specified an implementation-specific default key is used. + Key *string `pulumi:"key"` + // Name of the Secret. + Name *string `pulumi:"name"` +} + +// HelmReleaseSpecKubeConfigSecretRefPatchInput is an input type that accepts HelmReleaseSpecKubeConfigSecretRefPatchArgs and HelmReleaseSpecKubeConfigSecretRefPatchOutput values. +// You can construct a concrete instance of `HelmReleaseSpecKubeConfigSecretRefPatchInput` via: +// +// HelmReleaseSpecKubeConfigSecretRefPatchArgs{...} +type HelmReleaseSpecKubeConfigSecretRefPatchInput interface { + pulumi.Input + + ToHelmReleaseSpecKubeConfigSecretRefPatchOutput() HelmReleaseSpecKubeConfigSecretRefPatchOutput + ToHelmReleaseSpecKubeConfigSecretRefPatchOutputWithContext(context.Context) HelmReleaseSpecKubeConfigSecretRefPatchOutput +} + +// SecretRef holds an optional name of a secret that contains a key with +// the kubeconfig file as the value. If no key is set, the key will default +// to 'value'. Mutually exclusive with ConfigMapRef. +// It is recommended that the kubeconfig is self-contained, and the secret +// is regularly updated if credentials such as a cloud-access-token expire. +// Cloud specific `cmd-path` auth helpers will not function without adding +// binaries and credentials to the Pod that is responsible for reconciling +// Kubernetes resources. Supported only for the generic provider. +type HelmReleaseSpecKubeConfigSecretRefPatchArgs struct { + // Key in the Secret, when not specified an implementation-specific default key is used. + Key pulumi.StringPtrInput `pulumi:"key"` + // Name of the Secret. + Name pulumi.StringPtrInput `pulumi:"name"` +} + +func (HelmReleaseSpecKubeConfigSecretRefPatchArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecKubeConfigSecretRefPatch)(nil)).Elem() +} + +func (i HelmReleaseSpecKubeConfigSecretRefPatchArgs) ToHelmReleaseSpecKubeConfigSecretRefPatchOutput() HelmReleaseSpecKubeConfigSecretRefPatchOutput { + return i.ToHelmReleaseSpecKubeConfigSecretRefPatchOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecKubeConfigSecretRefPatchArgs) ToHelmReleaseSpecKubeConfigSecretRefPatchOutputWithContext(ctx context.Context) HelmReleaseSpecKubeConfigSecretRefPatchOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecKubeConfigSecretRefPatchOutput) +} + +func (i HelmReleaseSpecKubeConfigSecretRefPatchArgs) ToHelmReleaseSpecKubeConfigSecretRefPatchPtrOutput() HelmReleaseSpecKubeConfigSecretRefPatchPtrOutput { + return i.ToHelmReleaseSpecKubeConfigSecretRefPatchPtrOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecKubeConfigSecretRefPatchArgs) ToHelmReleaseSpecKubeConfigSecretRefPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecKubeConfigSecretRefPatchPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecKubeConfigSecretRefPatchOutput).ToHelmReleaseSpecKubeConfigSecretRefPatchPtrOutputWithContext(ctx) +} + +// HelmReleaseSpecKubeConfigSecretRefPatchPtrInput is an input type that accepts HelmReleaseSpecKubeConfigSecretRefPatchArgs, HelmReleaseSpecKubeConfigSecretRefPatchPtr and HelmReleaseSpecKubeConfigSecretRefPatchPtrOutput values. +// You can construct a concrete instance of `HelmReleaseSpecKubeConfigSecretRefPatchPtrInput` via: +// +// HelmReleaseSpecKubeConfigSecretRefPatchArgs{...} +// +// or: +// +// nil +type HelmReleaseSpecKubeConfigSecretRefPatchPtrInput interface { + pulumi.Input + + ToHelmReleaseSpecKubeConfigSecretRefPatchPtrOutput() HelmReleaseSpecKubeConfigSecretRefPatchPtrOutput + ToHelmReleaseSpecKubeConfigSecretRefPatchPtrOutputWithContext(context.Context) HelmReleaseSpecKubeConfigSecretRefPatchPtrOutput +} + +type helmReleaseSpecKubeConfigSecretRefPatchPtrType HelmReleaseSpecKubeConfigSecretRefPatchArgs + +func HelmReleaseSpecKubeConfigSecretRefPatchPtr(v *HelmReleaseSpecKubeConfigSecretRefPatchArgs) HelmReleaseSpecKubeConfigSecretRefPatchPtrInput { + return (*helmReleaseSpecKubeConfigSecretRefPatchPtrType)(v) +} + +func (*helmReleaseSpecKubeConfigSecretRefPatchPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecKubeConfigSecretRefPatch)(nil)).Elem() +} + +func (i *helmReleaseSpecKubeConfigSecretRefPatchPtrType) ToHelmReleaseSpecKubeConfigSecretRefPatchPtrOutput() HelmReleaseSpecKubeConfigSecretRefPatchPtrOutput { + return i.ToHelmReleaseSpecKubeConfigSecretRefPatchPtrOutputWithContext(context.Background()) +} + +func (i *helmReleaseSpecKubeConfigSecretRefPatchPtrType) ToHelmReleaseSpecKubeConfigSecretRefPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecKubeConfigSecretRefPatchPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecKubeConfigSecretRefPatchPtrOutput) +} + +// SecretRef holds an optional name of a secret that contains a key with +// the kubeconfig file as the value. If no key is set, the key will default +// to 'value'. Mutually exclusive with ConfigMapRef. +// It is recommended that the kubeconfig is self-contained, and the secret +// is regularly updated if credentials such as a cloud-access-token expire. +// Cloud specific `cmd-path` auth helpers will not function without adding +// binaries and credentials to the Pod that is responsible for reconciling +// Kubernetes resources. Supported only for the generic provider. +type HelmReleaseSpecKubeConfigSecretRefPatchOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecKubeConfigSecretRefPatchOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecKubeConfigSecretRefPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecKubeConfigSecretRefPatchOutput) ToHelmReleaseSpecKubeConfigSecretRefPatchOutput() HelmReleaseSpecKubeConfigSecretRefPatchOutput { + return o +} + +func (o HelmReleaseSpecKubeConfigSecretRefPatchOutput) ToHelmReleaseSpecKubeConfigSecretRefPatchOutputWithContext(ctx context.Context) HelmReleaseSpecKubeConfigSecretRefPatchOutput { + return o +} + +func (o HelmReleaseSpecKubeConfigSecretRefPatchOutput) ToHelmReleaseSpecKubeConfigSecretRefPatchPtrOutput() HelmReleaseSpecKubeConfigSecretRefPatchPtrOutput { + return o.ToHelmReleaseSpecKubeConfigSecretRefPatchPtrOutputWithContext(context.Background()) +} + +func (o HelmReleaseSpecKubeConfigSecretRefPatchOutput) ToHelmReleaseSpecKubeConfigSecretRefPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecKubeConfigSecretRefPatchPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v HelmReleaseSpecKubeConfigSecretRefPatch) *HelmReleaseSpecKubeConfigSecretRefPatch { + return &v + }).(HelmReleaseSpecKubeConfigSecretRefPatchPtrOutput) +} + +// Key in the Secret, when not specified an implementation-specific default key is used. +func (o HelmReleaseSpecKubeConfigSecretRefPatchOutput) Key() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecKubeConfigSecretRefPatch) *string { return v.Key }).(pulumi.StringPtrOutput) +} + +// Name of the Secret. +func (o HelmReleaseSpecKubeConfigSecretRefPatchOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecKubeConfigSecretRefPatch) *string { return v.Name }).(pulumi.StringPtrOutput) +} + +type HelmReleaseSpecKubeConfigSecretRefPatchPtrOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecKubeConfigSecretRefPatchPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecKubeConfigSecretRefPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecKubeConfigSecretRefPatchPtrOutput) ToHelmReleaseSpecKubeConfigSecretRefPatchPtrOutput() HelmReleaseSpecKubeConfigSecretRefPatchPtrOutput { + return o +} + +func (o HelmReleaseSpecKubeConfigSecretRefPatchPtrOutput) ToHelmReleaseSpecKubeConfigSecretRefPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecKubeConfigSecretRefPatchPtrOutput { + return o +} + +func (o HelmReleaseSpecKubeConfigSecretRefPatchPtrOutput) Elem() HelmReleaseSpecKubeConfigSecretRefPatchOutput { + return o.ApplyT(func(v *HelmReleaseSpecKubeConfigSecretRefPatch) HelmReleaseSpecKubeConfigSecretRefPatch { + if v != nil { + return *v + } + var ret HelmReleaseSpecKubeConfigSecretRefPatch + return ret + }).(HelmReleaseSpecKubeConfigSecretRefPatchOutput) +} + +// Key in the Secret, when not specified an implementation-specific default key is used. +func (o HelmReleaseSpecKubeConfigSecretRefPatchPtrOutput) Key() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecKubeConfigSecretRefPatch) *string { + if v == nil { + return nil + } + return v.Key + }).(pulumi.StringPtrOutput) +} + +// Name of the Secret. +func (o HelmReleaseSpecKubeConfigSecretRefPatchPtrOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecKubeConfigSecretRefPatch) *string { + if v == nil { + return nil + } + return v.Name + }).(pulumi.StringPtrOutput) +} + +// HelmReleaseSpec defines the desired state of a Helm release. +type HelmReleaseSpecPatch struct { + Chart *HelmReleaseSpecChartPatch `pulumi:"chart"` + ChartRef *HelmReleaseSpecChartRefPatch `pulumi:"chartRef"` + CommonMetadata *HelmReleaseSpecCommonMetadataPatch `pulumi:"commonMetadata"` + // DependsOn may contain a DependencyReference slice with + // references to HelmRelease resources that must be ready before this HelmRelease + // can be reconciled. + DependsOn []HelmReleaseSpecDependsOnPatch `pulumi:"dependsOn"` + DriftDetection *HelmReleaseSpecDriftDetectionPatch `pulumi:"driftDetection"` + // HealthCheckExprs is a list of healthcheck expressions for evaluating the + // health of custom resources using Common Expression Language (CEL). + // The expressions are evaluated only when the specific Helm action + // taking place has wait enabled, i.e. DisableWait is false, and the + // 'poller' WaitStrategy is used. + HealthCheckExprs []HelmReleaseSpecHealthCheckExprsPatch `pulumi:"healthCheckExprs"` + Install *HelmReleaseSpecInstallPatch `pulumi:"install"` + // Interval at which to reconcile the Helm release. + Interval *string `pulumi:"interval"` + KubeConfig *HelmReleaseSpecKubeConfigPatch `pulumi:"kubeConfig"` + // MaxHistory is the number of revisions saved by Helm for this HelmRelease. + // Use '0' for an unlimited number of revisions; defaults to '5'. + MaxHistory *int `pulumi:"maxHistory"` + // PersistentClient tells the controller to use a persistent Kubernetes + // client for this release. When enabled, the client will be reused for the + // duration of the reconciliation, instead of being created and destroyed + // for each (step of a) Helm action. + // + // This can improve performance, but may cause issues with some Helm charts + // that for example do create Custom Resource Definitions during installation + // outside Helm's CRD lifecycle hooks, which are then not observed to be + // available by e.g. post-install hooks. + // + // If not set, it defaults to true. + PersistentClient *bool `pulumi:"persistentClient"` + // PostRenderers holds an array of Helm PostRenderers, which will be applied in order + // of their definition. + PostRenderers []HelmReleaseSpecPostRenderersPatch `pulumi:"postRenderers"` + // ReleaseName used for the Helm release. Defaults to a composition of + // '[TargetNamespace-]Name'. + ReleaseName *string `pulumi:"releaseName"` + Rollback *HelmReleaseSpecRollbackPatch `pulumi:"rollback"` + // The name of the Kubernetes service account to impersonate + // when reconciling this HelmRelease. + ServiceAccountName *string `pulumi:"serviceAccountName"` + // StorageNamespace used for the Helm storage. + // Defaults to the namespace of the HelmRelease. + StorageNamespace *string `pulumi:"storageNamespace"` + // Suspend tells the controller to suspend reconciliation for this HelmRelease, + // it does not apply to already started reconciliations. Defaults to false. + Suspend *bool `pulumi:"suspend"` + // TargetNamespace to target when performing operations for the HelmRelease. + // Defaults to the namespace of the HelmRelease. + TargetNamespace *string `pulumi:"targetNamespace"` + Test *HelmReleaseSpecTestPatch `pulumi:"test"` + // Timeout is the time to wait for any individual Kubernetes operation (like Jobs + // for hooks) during the performance of a Helm action. Defaults to '5m0s'. + Timeout *string `pulumi:"timeout"` + Uninstall *HelmReleaseSpecUninstallPatch `pulumi:"uninstall"` + Upgrade *HelmReleaseSpecUpgradePatch `pulumi:"upgrade"` + // Values holds the values for this Helm release. + Values map[string]interface{} `pulumi:"values"` + // ValuesFrom holds references to resources containing Helm values for this HelmRelease, + // and information about how they should be merged. + ValuesFrom []HelmReleaseSpecValuesFromPatch `pulumi:"valuesFrom"` + WaitStrategy *HelmReleaseSpecWaitStrategyPatch `pulumi:"waitStrategy"` +} + +// HelmReleaseSpecPatchInput is an input type that accepts HelmReleaseSpecPatchArgs and HelmReleaseSpecPatchOutput values. +// You can construct a concrete instance of `HelmReleaseSpecPatchInput` via: +// +// HelmReleaseSpecPatchArgs{...} +type HelmReleaseSpecPatchInput interface { + pulumi.Input + + ToHelmReleaseSpecPatchOutput() HelmReleaseSpecPatchOutput + ToHelmReleaseSpecPatchOutputWithContext(context.Context) HelmReleaseSpecPatchOutput +} + +// HelmReleaseSpec defines the desired state of a Helm release. +type HelmReleaseSpecPatchArgs struct { + Chart HelmReleaseSpecChartPatchPtrInput `pulumi:"chart"` + ChartRef HelmReleaseSpecChartRefPatchPtrInput `pulumi:"chartRef"` + CommonMetadata HelmReleaseSpecCommonMetadataPatchPtrInput `pulumi:"commonMetadata"` + // DependsOn may contain a DependencyReference slice with + // references to HelmRelease resources that must be ready before this HelmRelease + // can be reconciled. + DependsOn HelmReleaseSpecDependsOnPatchArrayInput `pulumi:"dependsOn"` + DriftDetection HelmReleaseSpecDriftDetectionPatchPtrInput `pulumi:"driftDetection"` + // HealthCheckExprs is a list of healthcheck expressions for evaluating the + // health of custom resources using Common Expression Language (CEL). + // The expressions are evaluated only when the specific Helm action + // taking place has wait enabled, i.e. DisableWait is false, and the + // 'poller' WaitStrategy is used. + HealthCheckExprs HelmReleaseSpecHealthCheckExprsPatchArrayInput `pulumi:"healthCheckExprs"` + Install HelmReleaseSpecInstallPatchPtrInput `pulumi:"install"` + // Interval at which to reconcile the Helm release. + Interval pulumi.StringPtrInput `pulumi:"interval"` + KubeConfig HelmReleaseSpecKubeConfigPatchPtrInput `pulumi:"kubeConfig"` + // MaxHistory is the number of revisions saved by Helm for this HelmRelease. + // Use '0' for an unlimited number of revisions; defaults to '5'. + MaxHistory pulumi.IntPtrInput `pulumi:"maxHistory"` + // PersistentClient tells the controller to use a persistent Kubernetes + // client for this release. When enabled, the client will be reused for the + // duration of the reconciliation, instead of being created and destroyed + // for each (step of a) Helm action. + // + // This can improve performance, but may cause issues with some Helm charts + // that for example do create Custom Resource Definitions during installation + // outside Helm's CRD lifecycle hooks, which are then not observed to be + // available by e.g. post-install hooks. + // + // If not set, it defaults to true. + PersistentClient pulumi.BoolPtrInput `pulumi:"persistentClient"` + // PostRenderers holds an array of Helm PostRenderers, which will be applied in order + // of their definition. + PostRenderers HelmReleaseSpecPostRenderersPatchArrayInput `pulumi:"postRenderers"` + // ReleaseName used for the Helm release. Defaults to a composition of + // '[TargetNamespace-]Name'. + ReleaseName pulumi.StringPtrInput `pulumi:"releaseName"` + Rollback HelmReleaseSpecRollbackPatchPtrInput `pulumi:"rollback"` + // The name of the Kubernetes service account to impersonate + // when reconciling this HelmRelease. + ServiceAccountName pulumi.StringPtrInput `pulumi:"serviceAccountName"` + // StorageNamespace used for the Helm storage. + // Defaults to the namespace of the HelmRelease. + StorageNamespace pulumi.StringPtrInput `pulumi:"storageNamespace"` + // Suspend tells the controller to suspend reconciliation for this HelmRelease, + // it does not apply to already started reconciliations. Defaults to false. + Suspend pulumi.BoolPtrInput `pulumi:"suspend"` + // TargetNamespace to target when performing operations for the HelmRelease. + // Defaults to the namespace of the HelmRelease. + TargetNamespace pulumi.StringPtrInput `pulumi:"targetNamespace"` + Test HelmReleaseSpecTestPatchPtrInput `pulumi:"test"` + // Timeout is the time to wait for any individual Kubernetes operation (like Jobs + // for hooks) during the performance of a Helm action. Defaults to '5m0s'. + Timeout pulumi.StringPtrInput `pulumi:"timeout"` + Uninstall HelmReleaseSpecUninstallPatchPtrInput `pulumi:"uninstall"` + Upgrade HelmReleaseSpecUpgradePatchPtrInput `pulumi:"upgrade"` + // Values holds the values for this Helm release. + Values pulumi.MapInput `pulumi:"values"` + // ValuesFrom holds references to resources containing Helm values for this HelmRelease, + // and information about how they should be merged. + ValuesFrom HelmReleaseSpecValuesFromPatchArrayInput `pulumi:"valuesFrom"` + WaitStrategy HelmReleaseSpecWaitStrategyPatchPtrInput `pulumi:"waitStrategy"` +} + +func (HelmReleaseSpecPatchArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecPatch)(nil)).Elem() +} + +func (i HelmReleaseSpecPatchArgs) ToHelmReleaseSpecPatchOutput() HelmReleaseSpecPatchOutput { + return i.ToHelmReleaseSpecPatchOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecPatchArgs) ToHelmReleaseSpecPatchOutputWithContext(ctx context.Context) HelmReleaseSpecPatchOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecPatchOutput) +} + +func (i HelmReleaseSpecPatchArgs) ToHelmReleaseSpecPatchPtrOutput() HelmReleaseSpecPatchPtrOutput { + return i.ToHelmReleaseSpecPatchPtrOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecPatchArgs) ToHelmReleaseSpecPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecPatchPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecPatchOutput).ToHelmReleaseSpecPatchPtrOutputWithContext(ctx) +} + +// HelmReleaseSpecPatchPtrInput is an input type that accepts HelmReleaseSpecPatchArgs, HelmReleaseSpecPatchPtr and HelmReleaseSpecPatchPtrOutput values. +// You can construct a concrete instance of `HelmReleaseSpecPatchPtrInput` via: +// +// HelmReleaseSpecPatchArgs{...} +// +// or: +// +// nil +type HelmReleaseSpecPatchPtrInput interface { + pulumi.Input + + ToHelmReleaseSpecPatchPtrOutput() HelmReleaseSpecPatchPtrOutput + ToHelmReleaseSpecPatchPtrOutputWithContext(context.Context) HelmReleaseSpecPatchPtrOutput +} + +type helmReleaseSpecPatchPtrType HelmReleaseSpecPatchArgs + +func HelmReleaseSpecPatchPtr(v *HelmReleaseSpecPatchArgs) HelmReleaseSpecPatchPtrInput { + return (*helmReleaseSpecPatchPtrType)(v) +} + +func (*helmReleaseSpecPatchPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecPatch)(nil)).Elem() +} + +func (i *helmReleaseSpecPatchPtrType) ToHelmReleaseSpecPatchPtrOutput() HelmReleaseSpecPatchPtrOutput { + return i.ToHelmReleaseSpecPatchPtrOutputWithContext(context.Background()) +} + +func (i *helmReleaseSpecPatchPtrType) ToHelmReleaseSpecPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecPatchPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecPatchPtrOutput) +} + +// HelmReleaseSpec defines the desired state of a Helm release. +type HelmReleaseSpecPatchOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecPatchOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecPatchOutput) ToHelmReleaseSpecPatchOutput() HelmReleaseSpecPatchOutput { + return o +} + +func (o HelmReleaseSpecPatchOutput) ToHelmReleaseSpecPatchOutputWithContext(ctx context.Context) HelmReleaseSpecPatchOutput { + return o +} + +func (o HelmReleaseSpecPatchOutput) ToHelmReleaseSpecPatchPtrOutput() HelmReleaseSpecPatchPtrOutput { + return o.ToHelmReleaseSpecPatchPtrOutputWithContext(context.Background()) +} + +func (o HelmReleaseSpecPatchOutput) ToHelmReleaseSpecPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecPatchPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v HelmReleaseSpecPatch) *HelmReleaseSpecPatch { + return &v + }).(HelmReleaseSpecPatchPtrOutput) +} + +func (o HelmReleaseSpecPatchOutput) Chart() HelmReleaseSpecChartPatchPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecPatch) *HelmReleaseSpecChartPatch { return v.Chart }).(HelmReleaseSpecChartPatchPtrOutput) +} + +func (o HelmReleaseSpecPatchOutput) ChartRef() HelmReleaseSpecChartRefPatchPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecPatch) *HelmReleaseSpecChartRefPatch { return v.ChartRef }).(HelmReleaseSpecChartRefPatchPtrOutput) +} + +func (o HelmReleaseSpecPatchOutput) CommonMetadata() HelmReleaseSpecCommonMetadataPatchPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecPatch) *HelmReleaseSpecCommonMetadataPatch { return v.CommonMetadata }).(HelmReleaseSpecCommonMetadataPatchPtrOutput) +} + +// DependsOn may contain a DependencyReference slice with +// references to HelmRelease resources that must be ready before this HelmRelease +// can be reconciled. +func (o HelmReleaseSpecPatchOutput) DependsOn() HelmReleaseSpecDependsOnPatchArrayOutput { + return o.ApplyT(func(v HelmReleaseSpecPatch) []HelmReleaseSpecDependsOnPatch { return v.DependsOn }).(HelmReleaseSpecDependsOnPatchArrayOutput) +} + +func (o HelmReleaseSpecPatchOutput) DriftDetection() HelmReleaseSpecDriftDetectionPatchPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecPatch) *HelmReleaseSpecDriftDetectionPatch { return v.DriftDetection }).(HelmReleaseSpecDriftDetectionPatchPtrOutput) +} + +// HealthCheckExprs is a list of healthcheck expressions for evaluating the +// health of custom resources using Common Expression Language (CEL). +// The expressions are evaluated only when the specific Helm action +// taking place has wait enabled, i.e. DisableWait is false, and the +// 'poller' WaitStrategy is used. +func (o HelmReleaseSpecPatchOutput) HealthCheckExprs() HelmReleaseSpecHealthCheckExprsPatchArrayOutput { + return o.ApplyT(func(v HelmReleaseSpecPatch) []HelmReleaseSpecHealthCheckExprsPatch { return v.HealthCheckExprs }).(HelmReleaseSpecHealthCheckExprsPatchArrayOutput) +} + +func (o HelmReleaseSpecPatchOutput) Install() HelmReleaseSpecInstallPatchPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecPatch) *HelmReleaseSpecInstallPatch { return v.Install }).(HelmReleaseSpecInstallPatchPtrOutput) +} + +// Interval at which to reconcile the Helm release. +func (o HelmReleaseSpecPatchOutput) Interval() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecPatch) *string { return v.Interval }).(pulumi.StringPtrOutput) +} + +func (o HelmReleaseSpecPatchOutput) KubeConfig() HelmReleaseSpecKubeConfigPatchPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecPatch) *HelmReleaseSpecKubeConfigPatch { return v.KubeConfig }).(HelmReleaseSpecKubeConfigPatchPtrOutput) +} + +// MaxHistory is the number of revisions saved by Helm for this HelmRelease. +// Use '0' for an unlimited number of revisions; defaults to '5'. +func (o HelmReleaseSpecPatchOutput) MaxHistory() pulumi.IntPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecPatch) *int { return v.MaxHistory }).(pulumi.IntPtrOutput) +} + +// PersistentClient tells the controller to use a persistent Kubernetes +// client for this release. When enabled, the client will be reused for the +// duration of the reconciliation, instead of being created and destroyed +// for each (step of a) Helm action. +// +// This can improve performance, but may cause issues with some Helm charts +// that for example do create Custom Resource Definitions during installation +// outside Helm's CRD lifecycle hooks, which are then not observed to be +// available by e.g. post-install hooks. +// +// If not set, it defaults to true. +func (o HelmReleaseSpecPatchOutput) PersistentClient() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecPatch) *bool { return v.PersistentClient }).(pulumi.BoolPtrOutput) +} + +// PostRenderers holds an array of Helm PostRenderers, which will be applied in order +// of their definition. +func (o HelmReleaseSpecPatchOutput) PostRenderers() HelmReleaseSpecPostRenderersPatchArrayOutput { + return o.ApplyT(func(v HelmReleaseSpecPatch) []HelmReleaseSpecPostRenderersPatch { return v.PostRenderers }).(HelmReleaseSpecPostRenderersPatchArrayOutput) +} + +// ReleaseName used for the Helm release. Defaults to a composition of +// '[TargetNamespace-]Name'. +func (o HelmReleaseSpecPatchOutput) ReleaseName() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecPatch) *string { return v.ReleaseName }).(pulumi.StringPtrOutput) +} + +func (o HelmReleaseSpecPatchOutput) Rollback() HelmReleaseSpecRollbackPatchPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecPatch) *HelmReleaseSpecRollbackPatch { return v.Rollback }).(HelmReleaseSpecRollbackPatchPtrOutput) +} + +// The name of the Kubernetes service account to impersonate +// when reconciling this HelmRelease. +func (o HelmReleaseSpecPatchOutput) ServiceAccountName() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecPatch) *string { return v.ServiceAccountName }).(pulumi.StringPtrOutput) +} + +// StorageNamespace used for the Helm storage. +// Defaults to the namespace of the HelmRelease. +func (o HelmReleaseSpecPatchOutput) StorageNamespace() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecPatch) *string { return v.StorageNamespace }).(pulumi.StringPtrOutput) +} + +// Suspend tells the controller to suspend reconciliation for this HelmRelease, +// it does not apply to already started reconciliations. Defaults to false. +func (o HelmReleaseSpecPatchOutput) Suspend() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecPatch) *bool { return v.Suspend }).(pulumi.BoolPtrOutput) +} + +// TargetNamespace to target when performing operations for the HelmRelease. +// Defaults to the namespace of the HelmRelease. +func (o HelmReleaseSpecPatchOutput) TargetNamespace() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecPatch) *string { return v.TargetNamespace }).(pulumi.StringPtrOutput) +} + +func (o HelmReleaseSpecPatchOutput) Test() HelmReleaseSpecTestPatchPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecPatch) *HelmReleaseSpecTestPatch { return v.Test }).(HelmReleaseSpecTestPatchPtrOutput) +} + +// Timeout is the time to wait for any individual Kubernetes operation (like Jobs +// for hooks) during the performance of a Helm action. Defaults to '5m0s'. +func (o HelmReleaseSpecPatchOutput) Timeout() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecPatch) *string { return v.Timeout }).(pulumi.StringPtrOutput) +} + +func (o HelmReleaseSpecPatchOutput) Uninstall() HelmReleaseSpecUninstallPatchPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecPatch) *HelmReleaseSpecUninstallPatch { return v.Uninstall }).(HelmReleaseSpecUninstallPatchPtrOutput) +} + +func (o HelmReleaseSpecPatchOutput) Upgrade() HelmReleaseSpecUpgradePatchPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecPatch) *HelmReleaseSpecUpgradePatch { return v.Upgrade }).(HelmReleaseSpecUpgradePatchPtrOutput) +} + +// Values holds the values for this Helm release. +func (o HelmReleaseSpecPatchOutput) Values() pulumi.MapOutput { + return o.ApplyT(func(v HelmReleaseSpecPatch) map[string]interface{} { return v.Values }).(pulumi.MapOutput) +} + +// ValuesFrom holds references to resources containing Helm values for this HelmRelease, +// and information about how they should be merged. +func (o HelmReleaseSpecPatchOutput) ValuesFrom() HelmReleaseSpecValuesFromPatchArrayOutput { + return o.ApplyT(func(v HelmReleaseSpecPatch) []HelmReleaseSpecValuesFromPatch { return v.ValuesFrom }).(HelmReleaseSpecValuesFromPatchArrayOutput) +} + +func (o HelmReleaseSpecPatchOutput) WaitStrategy() HelmReleaseSpecWaitStrategyPatchPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecPatch) *HelmReleaseSpecWaitStrategyPatch { return v.WaitStrategy }).(HelmReleaseSpecWaitStrategyPatchPtrOutput) +} + +type HelmReleaseSpecPatchPtrOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecPatchPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecPatchPtrOutput) ToHelmReleaseSpecPatchPtrOutput() HelmReleaseSpecPatchPtrOutput { + return o +} + +func (o HelmReleaseSpecPatchPtrOutput) ToHelmReleaseSpecPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecPatchPtrOutput { + return o +} + +func (o HelmReleaseSpecPatchPtrOutput) Elem() HelmReleaseSpecPatchOutput { + return o.ApplyT(func(v *HelmReleaseSpecPatch) HelmReleaseSpecPatch { + if v != nil { + return *v + } + var ret HelmReleaseSpecPatch + return ret + }).(HelmReleaseSpecPatchOutput) +} + +func (o HelmReleaseSpecPatchPtrOutput) Chart() HelmReleaseSpecChartPatchPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecPatch) *HelmReleaseSpecChartPatch { + if v == nil { + return nil + } + return v.Chart + }).(HelmReleaseSpecChartPatchPtrOutput) +} + +func (o HelmReleaseSpecPatchPtrOutput) ChartRef() HelmReleaseSpecChartRefPatchPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecPatch) *HelmReleaseSpecChartRefPatch { + if v == nil { + return nil + } + return v.ChartRef + }).(HelmReleaseSpecChartRefPatchPtrOutput) +} + +func (o HelmReleaseSpecPatchPtrOutput) CommonMetadata() HelmReleaseSpecCommonMetadataPatchPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecPatch) *HelmReleaseSpecCommonMetadataPatch { + if v == nil { + return nil + } + return v.CommonMetadata + }).(HelmReleaseSpecCommonMetadataPatchPtrOutput) +} + +// DependsOn may contain a DependencyReference slice with +// references to HelmRelease resources that must be ready before this HelmRelease +// can be reconciled. +func (o HelmReleaseSpecPatchPtrOutput) DependsOn() HelmReleaseSpecDependsOnPatchArrayOutput { + return o.ApplyT(func(v *HelmReleaseSpecPatch) []HelmReleaseSpecDependsOnPatch { + if v == nil { + return nil + } + return v.DependsOn + }).(HelmReleaseSpecDependsOnPatchArrayOutput) +} + +func (o HelmReleaseSpecPatchPtrOutput) DriftDetection() HelmReleaseSpecDriftDetectionPatchPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecPatch) *HelmReleaseSpecDriftDetectionPatch { + if v == nil { + return nil + } + return v.DriftDetection + }).(HelmReleaseSpecDriftDetectionPatchPtrOutput) +} + +// HealthCheckExprs is a list of healthcheck expressions for evaluating the +// health of custom resources using Common Expression Language (CEL). +// The expressions are evaluated only when the specific Helm action +// taking place has wait enabled, i.e. DisableWait is false, and the +// 'poller' WaitStrategy is used. +func (o HelmReleaseSpecPatchPtrOutput) HealthCheckExprs() HelmReleaseSpecHealthCheckExprsPatchArrayOutput { + return o.ApplyT(func(v *HelmReleaseSpecPatch) []HelmReleaseSpecHealthCheckExprsPatch { + if v == nil { + return nil + } + return v.HealthCheckExprs + }).(HelmReleaseSpecHealthCheckExprsPatchArrayOutput) +} + +func (o HelmReleaseSpecPatchPtrOutput) Install() HelmReleaseSpecInstallPatchPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecPatch) *HelmReleaseSpecInstallPatch { + if v == nil { + return nil + } + return v.Install + }).(HelmReleaseSpecInstallPatchPtrOutput) +} + +// Interval at which to reconcile the Helm release. +func (o HelmReleaseSpecPatchPtrOutput) Interval() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecPatch) *string { + if v == nil { + return nil + } + return v.Interval + }).(pulumi.StringPtrOutput) +} + +func (o HelmReleaseSpecPatchPtrOutput) KubeConfig() HelmReleaseSpecKubeConfigPatchPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecPatch) *HelmReleaseSpecKubeConfigPatch { + if v == nil { + return nil + } + return v.KubeConfig + }).(HelmReleaseSpecKubeConfigPatchPtrOutput) +} + +// MaxHistory is the number of revisions saved by Helm for this HelmRelease. +// Use '0' for an unlimited number of revisions; defaults to '5'. +func (o HelmReleaseSpecPatchPtrOutput) MaxHistory() pulumi.IntPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecPatch) *int { + if v == nil { + return nil + } + return v.MaxHistory + }).(pulumi.IntPtrOutput) +} + +// PersistentClient tells the controller to use a persistent Kubernetes +// client for this release. When enabled, the client will be reused for the +// duration of the reconciliation, instead of being created and destroyed +// for each (step of a) Helm action. +// +// This can improve performance, but may cause issues with some Helm charts +// that for example do create Custom Resource Definitions during installation +// outside Helm's CRD lifecycle hooks, which are then not observed to be +// available by e.g. post-install hooks. +// +// If not set, it defaults to true. +func (o HelmReleaseSpecPatchPtrOutput) PersistentClient() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecPatch) *bool { + if v == nil { + return nil + } + return v.PersistentClient + }).(pulumi.BoolPtrOutput) +} + +// PostRenderers holds an array of Helm PostRenderers, which will be applied in order +// of their definition. +func (o HelmReleaseSpecPatchPtrOutput) PostRenderers() HelmReleaseSpecPostRenderersPatchArrayOutput { + return o.ApplyT(func(v *HelmReleaseSpecPatch) []HelmReleaseSpecPostRenderersPatch { + if v == nil { + return nil + } + return v.PostRenderers + }).(HelmReleaseSpecPostRenderersPatchArrayOutput) +} + +// ReleaseName used for the Helm release. Defaults to a composition of +// '[TargetNamespace-]Name'. +func (o HelmReleaseSpecPatchPtrOutput) ReleaseName() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecPatch) *string { + if v == nil { + return nil + } + return v.ReleaseName + }).(pulumi.StringPtrOutput) +} + +func (o HelmReleaseSpecPatchPtrOutput) Rollback() HelmReleaseSpecRollbackPatchPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecPatch) *HelmReleaseSpecRollbackPatch { + if v == nil { + return nil + } + return v.Rollback + }).(HelmReleaseSpecRollbackPatchPtrOutput) +} + +// The name of the Kubernetes service account to impersonate +// when reconciling this HelmRelease. +func (o HelmReleaseSpecPatchPtrOutput) ServiceAccountName() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecPatch) *string { + if v == nil { + return nil + } + return v.ServiceAccountName + }).(pulumi.StringPtrOutput) +} + +// StorageNamespace used for the Helm storage. +// Defaults to the namespace of the HelmRelease. +func (o HelmReleaseSpecPatchPtrOutput) StorageNamespace() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecPatch) *string { + if v == nil { + return nil + } + return v.StorageNamespace + }).(pulumi.StringPtrOutput) +} + +// Suspend tells the controller to suspend reconciliation for this HelmRelease, +// it does not apply to already started reconciliations. Defaults to false. +func (o HelmReleaseSpecPatchPtrOutput) Suspend() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecPatch) *bool { + if v == nil { + return nil + } + return v.Suspend + }).(pulumi.BoolPtrOutput) +} + +// TargetNamespace to target when performing operations for the HelmRelease. +// Defaults to the namespace of the HelmRelease. +func (o HelmReleaseSpecPatchPtrOutput) TargetNamespace() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecPatch) *string { + if v == nil { + return nil + } + return v.TargetNamespace + }).(pulumi.StringPtrOutput) +} + +func (o HelmReleaseSpecPatchPtrOutput) Test() HelmReleaseSpecTestPatchPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecPatch) *HelmReleaseSpecTestPatch { + if v == nil { + return nil + } + return v.Test + }).(HelmReleaseSpecTestPatchPtrOutput) +} + +// Timeout is the time to wait for any individual Kubernetes operation (like Jobs +// for hooks) during the performance of a Helm action. Defaults to '5m0s'. +func (o HelmReleaseSpecPatchPtrOutput) Timeout() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecPatch) *string { + if v == nil { + return nil + } + return v.Timeout + }).(pulumi.StringPtrOutput) +} + +func (o HelmReleaseSpecPatchPtrOutput) Uninstall() HelmReleaseSpecUninstallPatchPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecPatch) *HelmReleaseSpecUninstallPatch { + if v == nil { + return nil + } + return v.Uninstall + }).(HelmReleaseSpecUninstallPatchPtrOutput) +} + +func (o HelmReleaseSpecPatchPtrOutput) Upgrade() HelmReleaseSpecUpgradePatchPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecPatch) *HelmReleaseSpecUpgradePatch { + if v == nil { + return nil + } + return v.Upgrade + }).(HelmReleaseSpecUpgradePatchPtrOutput) +} + +// Values holds the values for this Helm release. +func (o HelmReleaseSpecPatchPtrOutput) Values() pulumi.MapOutput { + return o.ApplyT(func(v *HelmReleaseSpecPatch) map[string]interface{} { + if v == nil { + return nil + } + return v.Values + }).(pulumi.MapOutput) +} + +// ValuesFrom holds references to resources containing Helm values for this HelmRelease, +// and information about how they should be merged. +func (o HelmReleaseSpecPatchPtrOutput) ValuesFrom() HelmReleaseSpecValuesFromPatchArrayOutput { + return o.ApplyT(func(v *HelmReleaseSpecPatch) []HelmReleaseSpecValuesFromPatch { + if v == nil { + return nil + } + return v.ValuesFrom + }).(HelmReleaseSpecValuesFromPatchArrayOutput) +} + +func (o HelmReleaseSpecPatchPtrOutput) WaitStrategy() HelmReleaseSpecWaitStrategyPatchPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecPatch) *HelmReleaseSpecWaitStrategyPatch { + if v == nil { + return nil + } + return v.WaitStrategy + }).(HelmReleaseSpecWaitStrategyPatchPtrOutput) +} + +// PostRenderer contains a Helm PostRenderer specification. +type HelmReleaseSpecPostRenderers struct { + Kustomize *HelmReleaseSpecPostRenderersKustomize `pulumi:"kustomize"` +} + +// HelmReleaseSpecPostRenderersInput is an input type that accepts HelmReleaseSpecPostRenderersArgs and HelmReleaseSpecPostRenderersOutput values. +// You can construct a concrete instance of `HelmReleaseSpecPostRenderersInput` via: +// +// HelmReleaseSpecPostRenderersArgs{...} +type HelmReleaseSpecPostRenderersInput interface { + pulumi.Input + + ToHelmReleaseSpecPostRenderersOutput() HelmReleaseSpecPostRenderersOutput + ToHelmReleaseSpecPostRenderersOutputWithContext(context.Context) HelmReleaseSpecPostRenderersOutput +} + +// PostRenderer contains a Helm PostRenderer specification. +type HelmReleaseSpecPostRenderersArgs struct { + Kustomize HelmReleaseSpecPostRenderersKustomizePtrInput `pulumi:"kustomize"` +} + +func (HelmReleaseSpecPostRenderersArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecPostRenderers)(nil)).Elem() +} + +func (i HelmReleaseSpecPostRenderersArgs) ToHelmReleaseSpecPostRenderersOutput() HelmReleaseSpecPostRenderersOutput { + return i.ToHelmReleaseSpecPostRenderersOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecPostRenderersArgs) ToHelmReleaseSpecPostRenderersOutputWithContext(ctx context.Context) HelmReleaseSpecPostRenderersOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecPostRenderersOutput) +} + +// HelmReleaseSpecPostRenderersArrayInput is an input type that accepts HelmReleaseSpecPostRenderersArray and HelmReleaseSpecPostRenderersArrayOutput values. +// You can construct a concrete instance of `HelmReleaseSpecPostRenderersArrayInput` via: +// +// HelmReleaseSpecPostRenderersArray{ HelmReleaseSpecPostRenderersArgs{...} } +type HelmReleaseSpecPostRenderersArrayInput interface { + pulumi.Input + + ToHelmReleaseSpecPostRenderersArrayOutput() HelmReleaseSpecPostRenderersArrayOutput + ToHelmReleaseSpecPostRenderersArrayOutputWithContext(context.Context) HelmReleaseSpecPostRenderersArrayOutput +} + +type HelmReleaseSpecPostRenderersArray []HelmReleaseSpecPostRenderersInput + +func (HelmReleaseSpecPostRenderersArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]HelmReleaseSpecPostRenderers)(nil)).Elem() +} + +func (i HelmReleaseSpecPostRenderersArray) ToHelmReleaseSpecPostRenderersArrayOutput() HelmReleaseSpecPostRenderersArrayOutput { + return i.ToHelmReleaseSpecPostRenderersArrayOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecPostRenderersArray) ToHelmReleaseSpecPostRenderersArrayOutputWithContext(ctx context.Context) HelmReleaseSpecPostRenderersArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecPostRenderersArrayOutput) +} + +// PostRenderer contains a Helm PostRenderer specification. +type HelmReleaseSpecPostRenderersOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecPostRenderersOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecPostRenderers)(nil)).Elem() +} + +func (o HelmReleaseSpecPostRenderersOutput) ToHelmReleaseSpecPostRenderersOutput() HelmReleaseSpecPostRenderersOutput { + return o +} + +func (o HelmReleaseSpecPostRenderersOutput) ToHelmReleaseSpecPostRenderersOutputWithContext(ctx context.Context) HelmReleaseSpecPostRenderersOutput { + return o +} + +func (o HelmReleaseSpecPostRenderersOutput) Kustomize() HelmReleaseSpecPostRenderersKustomizePtrOutput { + return o.ApplyT(func(v HelmReleaseSpecPostRenderers) *HelmReleaseSpecPostRenderersKustomize { return v.Kustomize }).(HelmReleaseSpecPostRenderersKustomizePtrOutput) +} + +type HelmReleaseSpecPostRenderersArrayOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecPostRenderersArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]HelmReleaseSpecPostRenderers)(nil)).Elem() +} + +func (o HelmReleaseSpecPostRenderersArrayOutput) ToHelmReleaseSpecPostRenderersArrayOutput() HelmReleaseSpecPostRenderersArrayOutput { + return o +} + +func (o HelmReleaseSpecPostRenderersArrayOutput) ToHelmReleaseSpecPostRenderersArrayOutputWithContext(ctx context.Context) HelmReleaseSpecPostRenderersArrayOutput { + return o +} + +func (o HelmReleaseSpecPostRenderersArrayOutput) Index(i pulumi.IntInput) HelmReleaseSpecPostRenderersOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) HelmReleaseSpecPostRenderers { + return vs[0].([]HelmReleaseSpecPostRenderers)[vs[1].(int)] + }).(HelmReleaseSpecPostRenderersOutput) +} + +// Kustomization to apply as PostRenderer. +type HelmReleaseSpecPostRenderersKustomize struct { + // Images is a list of (image name, new name, new tag or digest) + // for changing image names, tags or digests. This can also be achieved with a + // patch, but this operator is simpler to specify. + Images []HelmReleaseSpecPostRenderersKustomizeImages `pulumi:"images"` + // Strategic merge and JSON patches, defined as inline YAML objects, + // capable of targeting objects based on kind, label and annotation selectors. + Patches []HelmReleaseSpecPostRenderersKustomizePatches `pulumi:"patches"` +} + +// HelmReleaseSpecPostRenderersKustomizeInput is an input type that accepts HelmReleaseSpecPostRenderersKustomizeArgs and HelmReleaseSpecPostRenderersKustomizeOutput values. +// You can construct a concrete instance of `HelmReleaseSpecPostRenderersKustomizeInput` via: +// +// HelmReleaseSpecPostRenderersKustomizeArgs{...} +type HelmReleaseSpecPostRenderersKustomizeInput interface { + pulumi.Input + + ToHelmReleaseSpecPostRenderersKustomizeOutput() HelmReleaseSpecPostRenderersKustomizeOutput + ToHelmReleaseSpecPostRenderersKustomizeOutputWithContext(context.Context) HelmReleaseSpecPostRenderersKustomizeOutput +} + +// Kustomization to apply as PostRenderer. +type HelmReleaseSpecPostRenderersKustomizeArgs struct { + // Images is a list of (image name, new name, new tag or digest) + // for changing image names, tags or digests. This can also be achieved with a + // patch, but this operator is simpler to specify. + Images HelmReleaseSpecPostRenderersKustomizeImagesArrayInput `pulumi:"images"` + // Strategic merge and JSON patches, defined as inline YAML objects, + // capable of targeting objects based on kind, label and annotation selectors. + Patches HelmReleaseSpecPostRenderersKustomizePatchesArrayInput `pulumi:"patches"` +} + +func (HelmReleaseSpecPostRenderersKustomizeArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecPostRenderersKustomize)(nil)).Elem() +} + +func (i HelmReleaseSpecPostRenderersKustomizeArgs) ToHelmReleaseSpecPostRenderersKustomizeOutput() HelmReleaseSpecPostRenderersKustomizeOutput { + return i.ToHelmReleaseSpecPostRenderersKustomizeOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecPostRenderersKustomizeArgs) ToHelmReleaseSpecPostRenderersKustomizeOutputWithContext(ctx context.Context) HelmReleaseSpecPostRenderersKustomizeOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecPostRenderersKustomizeOutput) +} + +func (i HelmReleaseSpecPostRenderersKustomizeArgs) ToHelmReleaseSpecPostRenderersKustomizePtrOutput() HelmReleaseSpecPostRenderersKustomizePtrOutput { + return i.ToHelmReleaseSpecPostRenderersKustomizePtrOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecPostRenderersKustomizeArgs) ToHelmReleaseSpecPostRenderersKustomizePtrOutputWithContext(ctx context.Context) HelmReleaseSpecPostRenderersKustomizePtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecPostRenderersKustomizeOutput).ToHelmReleaseSpecPostRenderersKustomizePtrOutputWithContext(ctx) +} + +// HelmReleaseSpecPostRenderersKustomizePtrInput is an input type that accepts HelmReleaseSpecPostRenderersKustomizeArgs, HelmReleaseSpecPostRenderersKustomizePtr and HelmReleaseSpecPostRenderersKustomizePtrOutput values. +// You can construct a concrete instance of `HelmReleaseSpecPostRenderersKustomizePtrInput` via: +// +// HelmReleaseSpecPostRenderersKustomizeArgs{...} +// +// or: +// +// nil +type HelmReleaseSpecPostRenderersKustomizePtrInput interface { + pulumi.Input + + ToHelmReleaseSpecPostRenderersKustomizePtrOutput() HelmReleaseSpecPostRenderersKustomizePtrOutput + ToHelmReleaseSpecPostRenderersKustomizePtrOutputWithContext(context.Context) HelmReleaseSpecPostRenderersKustomizePtrOutput +} + +type helmReleaseSpecPostRenderersKustomizePtrType HelmReleaseSpecPostRenderersKustomizeArgs + +func HelmReleaseSpecPostRenderersKustomizePtr(v *HelmReleaseSpecPostRenderersKustomizeArgs) HelmReleaseSpecPostRenderersKustomizePtrInput { + return (*helmReleaseSpecPostRenderersKustomizePtrType)(v) +} + +func (*helmReleaseSpecPostRenderersKustomizePtrType) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecPostRenderersKustomize)(nil)).Elem() +} + +func (i *helmReleaseSpecPostRenderersKustomizePtrType) ToHelmReleaseSpecPostRenderersKustomizePtrOutput() HelmReleaseSpecPostRenderersKustomizePtrOutput { + return i.ToHelmReleaseSpecPostRenderersKustomizePtrOutputWithContext(context.Background()) +} + +func (i *helmReleaseSpecPostRenderersKustomizePtrType) ToHelmReleaseSpecPostRenderersKustomizePtrOutputWithContext(ctx context.Context) HelmReleaseSpecPostRenderersKustomizePtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecPostRenderersKustomizePtrOutput) +} + +// Kustomization to apply as PostRenderer. +type HelmReleaseSpecPostRenderersKustomizeOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecPostRenderersKustomizeOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecPostRenderersKustomize)(nil)).Elem() +} + +func (o HelmReleaseSpecPostRenderersKustomizeOutput) ToHelmReleaseSpecPostRenderersKustomizeOutput() HelmReleaseSpecPostRenderersKustomizeOutput { + return o +} + +func (o HelmReleaseSpecPostRenderersKustomizeOutput) ToHelmReleaseSpecPostRenderersKustomizeOutputWithContext(ctx context.Context) HelmReleaseSpecPostRenderersKustomizeOutput { + return o +} + +func (o HelmReleaseSpecPostRenderersKustomizeOutput) ToHelmReleaseSpecPostRenderersKustomizePtrOutput() HelmReleaseSpecPostRenderersKustomizePtrOutput { + return o.ToHelmReleaseSpecPostRenderersKustomizePtrOutputWithContext(context.Background()) +} + +func (o HelmReleaseSpecPostRenderersKustomizeOutput) ToHelmReleaseSpecPostRenderersKustomizePtrOutputWithContext(ctx context.Context) HelmReleaseSpecPostRenderersKustomizePtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v HelmReleaseSpecPostRenderersKustomize) *HelmReleaseSpecPostRenderersKustomize { + return &v + }).(HelmReleaseSpecPostRenderersKustomizePtrOutput) +} + +// Images is a list of (image name, new name, new tag or digest) +// for changing image names, tags or digests. This can also be achieved with a +// patch, but this operator is simpler to specify. +func (o HelmReleaseSpecPostRenderersKustomizeOutput) Images() HelmReleaseSpecPostRenderersKustomizeImagesArrayOutput { + return o.ApplyT(func(v HelmReleaseSpecPostRenderersKustomize) []HelmReleaseSpecPostRenderersKustomizeImages { + return v.Images + }).(HelmReleaseSpecPostRenderersKustomizeImagesArrayOutput) +} + +// Strategic merge and JSON patches, defined as inline YAML objects, +// capable of targeting objects based on kind, label and annotation selectors. +func (o HelmReleaseSpecPostRenderersKustomizeOutput) Patches() HelmReleaseSpecPostRenderersKustomizePatchesArrayOutput { + return o.ApplyT(func(v HelmReleaseSpecPostRenderersKustomize) []HelmReleaseSpecPostRenderersKustomizePatches { + return v.Patches + }).(HelmReleaseSpecPostRenderersKustomizePatchesArrayOutput) +} + +type HelmReleaseSpecPostRenderersKustomizePtrOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecPostRenderersKustomizePtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecPostRenderersKustomize)(nil)).Elem() +} + +func (o HelmReleaseSpecPostRenderersKustomizePtrOutput) ToHelmReleaseSpecPostRenderersKustomizePtrOutput() HelmReleaseSpecPostRenderersKustomizePtrOutput { + return o +} + +func (o HelmReleaseSpecPostRenderersKustomizePtrOutput) ToHelmReleaseSpecPostRenderersKustomizePtrOutputWithContext(ctx context.Context) HelmReleaseSpecPostRenderersKustomizePtrOutput { + return o +} + +func (o HelmReleaseSpecPostRenderersKustomizePtrOutput) Elem() HelmReleaseSpecPostRenderersKustomizeOutput { + return o.ApplyT(func(v *HelmReleaseSpecPostRenderersKustomize) HelmReleaseSpecPostRenderersKustomize { + if v != nil { + return *v + } + var ret HelmReleaseSpecPostRenderersKustomize + return ret + }).(HelmReleaseSpecPostRenderersKustomizeOutput) +} + +// Images is a list of (image name, new name, new tag or digest) +// for changing image names, tags or digests. This can also be achieved with a +// patch, but this operator is simpler to specify. +func (o HelmReleaseSpecPostRenderersKustomizePtrOutput) Images() HelmReleaseSpecPostRenderersKustomizeImagesArrayOutput { + return o.ApplyT(func(v *HelmReleaseSpecPostRenderersKustomize) []HelmReleaseSpecPostRenderersKustomizeImages { + if v == nil { + return nil + } + return v.Images + }).(HelmReleaseSpecPostRenderersKustomizeImagesArrayOutput) +} + +// Strategic merge and JSON patches, defined as inline YAML objects, +// capable of targeting objects based on kind, label and annotation selectors. +func (o HelmReleaseSpecPostRenderersKustomizePtrOutput) Patches() HelmReleaseSpecPostRenderersKustomizePatchesArrayOutput { + return o.ApplyT(func(v *HelmReleaseSpecPostRenderersKustomize) []HelmReleaseSpecPostRenderersKustomizePatches { + if v == nil { + return nil + } + return v.Patches + }).(HelmReleaseSpecPostRenderersKustomizePatchesArrayOutput) +} + +// Image contains an image name, a new name, a new tag or digest, which will replace the original name and tag. +type HelmReleaseSpecPostRenderersKustomizeImages struct { + // Digest is the value used to replace the original image tag. + // If digest is present NewTag value is ignored. + Digest *string `pulumi:"digest"` + // Name is a tag-less image name. + Name *string `pulumi:"name"` + // NewName is the value used to replace the original name. + NewName *string `pulumi:"newName"` + // NewTag is the value used to replace the original tag. + NewTag *string `pulumi:"newTag"` +} + +// HelmReleaseSpecPostRenderersKustomizeImagesInput is an input type that accepts HelmReleaseSpecPostRenderersKustomizeImagesArgs and HelmReleaseSpecPostRenderersKustomizeImagesOutput values. +// You can construct a concrete instance of `HelmReleaseSpecPostRenderersKustomizeImagesInput` via: +// +// HelmReleaseSpecPostRenderersKustomizeImagesArgs{...} +type HelmReleaseSpecPostRenderersKustomizeImagesInput interface { + pulumi.Input + + ToHelmReleaseSpecPostRenderersKustomizeImagesOutput() HelmReleaseSpecPostRenderersKustomizeImagesOutput + ToHelmReleaseSpecPostRenderersKustomizeImagesOutputWithContext(context.Context) HelmReleaseSpecPostRenderersKustomizeImagesOutput +} + +// Image contains an image name, a new name, a new tag or digest, which will replace the original name and tag. +type HelmReleaseSpecPostRenderersKustomizeImagesArgs struct { + // Digest is the value used to replace the original image tag. + // If digest is present NewTag value is ignored. + Digest pulumi.StringPtrInput `pulumi:"digest"` + // Name is a tag-less image name. + Name pulumi.StringPtrInput `pulumi:"name"` + // NewName is the value used to replace the original name. + NewName pulumi.StringPtrInput `pulumi:"newName"` + // NewTag is the value used to replace the original tag. + NewTag pulumi.StringPtrInput `pulumi:"newTag"` +} + +func (HelmReleaseSpecPostRenderersKustomizeImagesArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecPostRenderersKustomizeImages)(nil)).Elem() +} + +func (i HelmReleaseSpecPostRenderersKustomizeImagesArgs) ToHelmReleaseSpecPostRenderersKustomizeImagesOutput() HelmReleaseSpecPostRenderersKustomizeImagesOutput { + return i.ToHelmReleaseSpecPostRenderersKustomizeImagesOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecPostRenderersKustomizeImagesArgs) ToHelmReleaseSpecPostRenderersKustomizeImagesOutputWithContext(ctx context.Context) HelmReleaseSpecPostRenderersKustomizeImagesOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecPostRenderersKustomizeImagesOutput) +} + +// HelmReleaseSpecPostRenderersKustomizeImagesArrayInput is an input type that accepts HelmReleaseSpecPostRenderersKustomizeImagesArray and HelmReleaseSpecPostRenderersKustomizeImagesArrayOutput values. +// You can construct a concrete instance of `HelmReleaseSpecPostRenderersKustomizeImagesArrayInput` via: +// +// HelmReleaseSpecPostRenderersKustomizeImagesArray{ HelmReleaseSpecPostRenderersKustomizeImagesArgs{...} } +type HelmReleaseSpecPostRenderersKustomizeImagesArrayInput interface { + pulumi.Input + + ToHelmReleaseSpecPostRenderersKustomizeImagesArrayOutput() HelmReleaseSpecPostRenderersKustomizeImagesArrayOutput + ToHelmReleaseSpecPostRenderersKustomizeImagesArrayOutputWithContext(context.Context) HelmReleaseSpecPostRenderersKustomizeImagesArrayOutput +} + +type HelmReleaseSpecPostRenderersKustomizeImagesArray []HelmReleaseSpecPostRenderersKustomizeImagesInput + +func (HelmReleaseSpecPostRenderersKustomizeImagesArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]HelmReleaseSpecPostRenderersKustomizeImages)(nil)).Elem() +} + +func (i HelmReleaseSpecPostRenderersKustomizeImagesArray) ToHelmReleaseSpecPostRenderersKustomizeImagesArrayOutput() HelmReleaseSpecPostRenderersKustomizeImagesArrayOutput { + return i.ToHelmReleaseSpecPostRenderersKustomizeImagesArrayOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecPostRenderersKustomizeImagesArray) ToHelmReleaseSpecPostRenderersKustomizeImagesArrayOutputWithContext(ctx context.Context) HelmReleaseSpecPostRenderersKustomizeImagesArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecPostRenderersKustomizeImagesArrayOutput) +} + +// Image contains an image name, a new name, a new tag or digest, which will replace the original name and tag. +type HelmReleaseSpecPostRenderersKustomizeImagesOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecPostRenderersKustomizeImagesOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecPostRenderersKustomizeImages)(nil)).Elem() +} + +func (o HelmReleaseSpecPostRenderersKustomizeImagesOutput) ToHelmReleaseSpecPostRenderersKustomizeImagesOutput() HelmReleaseSpecPostRenderersKustomizeImagesOutput { + return o +} + +func (o HelmReleaseSpecPostRenderersKustomizeImagesOutput) ToHelmReleaseSpecPostRenderersKustomizeImagesOutputWithContext(ctx context.Context) HelmReleaseSpecPostRenderersKustomizeImagesOutput { + return o +} + +// Digest is the value used to replace the original image tag. +// If digest is present NewTag value is ignored. +func (o HelmReleaseSpecPostRenderersKustomizeImagesOutput) Digest() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecPostRenderersKustomizeImages) *string { return v.Digest }).(pulumi.StringPtrOutput) +} + +// Name is a tag-less image name. +func (o HelmReleaseSpecPostRenderersKustomizeImagesOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecPostRenderersKustomizeImages) *string { return v.Name }).(pulumi.StringPtrOutput) +} + +// NewName is the value used to replace the original name. +func (o HelmReleaseSpecPostRenderersKustomizeImagesOutput) NewName() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecPostRenderersKustomizeImages) *string { return v.NewName }).(pulumi.StringPtrOutput) +} + +// NewTag is the value used to replace the original tag. +func (o HelmReleaseSpecPostRenderersKustomizeImagesOutput) NewTag() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecPostRenderersKustomizeImages) *string { return v.NewTag }).(pulumi.StringPtrOutput) +} + +type HelmReleaseSpecPostRenderersKustomizeImagesArrayOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecPostRenderersKustomizeImagesArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]HelmReleaseSpecPostRenderersKustomizeImages)(nil)).Elem() +} + +func (o HelmReleaseSpecPostRenderersKustomizeImagesArrayOutput) ToHelmReleaseSpecPostRenderersKustomizeImagesArrayOutput() HelmReleaseSpecPostRenderersKustomizeImagesArrayOutput { + return o +} + +func (o HelmReleaseSpecPostRenderersKustomizeImagesArrayOutput) ToHelmReleaseSpecPostRenderersKustomizeImagesArrayOutputWithContext(ctx context.Context) HelmReleaseSpecPostRenderersKustomizeImagesArrayOutput { + return o +} + +func (o HelmReleaseSpecPostRenderersKustomizeImagesArrayOutput) Index(i pulumi.IntInput) HelmReleaseSpecPostRenderersKustomizeImagesOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) HelmReleaseSpecPostRenderersKustomizeImages { + return vs[0].([]HelmReleaseSpecPostRenderersKustomizeImages)[vs[1].(int)] + }).(HelmReleaseSpecPostRenderersKustomizeImagesOutput) +} + +// Image contains an image name, a new name, a new tag or digest, which will replace the original name and tag. +type HelmReleaseSpecPostRenderersKustomizeImagesPatch struct { + // Digest is the value used to replace the original image tag. + // If digest is present NewTag value is ignored. + Digest *string `pulumi:"digest"` + // Name is a tag-less image name. + Name *string `pulumi:"name"` + // NewName is the value used to replace the original name. + NewName *string `pulumi:"newName"` + // NewTag is the value used to replace the original tag. + NewTag *string `pulumi:"newTag"` +} + +// HelmReleaseSpecPostRenderersKustomizeImagesPatchInput is an input type that accepts HelmReleaseSpecPostRenderersKustomizeImagesPatchArgs and HelmReleaseSpecPostRenderersKustomizeImagesPatchOutput values. +// You can construct a concrete instance of `HelmReleaseSpecPostRenderersKustomizeImagesPatchInput` via: +// +// HelmReleaseSpecPostRenderersKustomizeImagesPatchArgs{...} +type HelmReleaseSpecPostRenderersKustomizeImagesPatchInput interface { + pulumi.Input + + ToHelmReleaseSpecPostRenderersKustomizeImagesPatchOutput() HelmReleaseSpecPostRenderersKustomizeImagesPatchOutput + ToHelmReleaseSpecPostRenderersKustomizeImagesPatchOutputWithContext(context.Context) HelmReleaseSpecPostRenderersKustomizeImagesPatchOutput +} + +// Image contains an image name, a new name, a new tag or digest, which will replace the original name and tag. +type HelmReleaseSpecPostRenderersKustomizeImagesPatchArgs struct { + // Digest is the value used to replace the original image tag. + // If digest is present NewTag value is ignored. + Digest pulumi.StringPtrInput `pulumi:"digest"` + // Name is a tag-less image name. + Name pulumi.StringPtrInput `pulumi:"name"` + // NewName is the value used to replace the original name. + NewName pulumi.StringPtrInput `pulumi:"newName"` + // NewTag is the value used to replace the original tag. + NewTag pulumi.StringPtrInput `pulumi:"newTag"` +} + +func (HelmReleaseSpecPostRenderersKustomizeImagesPatchArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecPostRenderersKustomizeImagesPatch)(nil)).Elem() +} + +func (i HelmReleaseSpecPostRenderersKustomizeImagesPatchArgs) ToHelmReleaseSpecPostRenderersKustomizeImagesPatchOutput() HelmReleaseSpecPostRenderersKustomizeImagesPatchOutput { + return i.ToHelmReleaseSpecPostRenderersKustomizeImagesPatchOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecPostRenderersKustomizeImagesPatchArgs) ToHelmReleaseSpecPostRenderersKustomizeImagesPatchOutputWithContext(ctx context.Context) HelmReleaseSpecPostRenderersKustomizeImagesPatchOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecPostRenderersKustomizeImagesPatchOutput) +} + +// HelmReleaseSpecPostRenderersKustomizeImagesPatchArrayInput is an input type that accepts HelmReleaseSpecPostRenderersKustomizeImagesPatchArray and HelmReleaseSpecPostRenderersKustomizeImagesPatchArrayOutput values. +// You can construct a concrete instance of `HelmReleaseSpecPostRenderersKustomizeImagesPatchArrayInput` via: +// +// HelmReleaseSpecPostRenderersKustomizeImagesPatchArray{ HelmReleaseSpecPostRenderersKustomizeImagesPatchArgs{...} } +type HelmReleaseSpecPostRenderersKustomizeImagesPatchArrayInput interface { + pulumi.Input + + ToHelmReleaseSpecPostRenderersKustomizeImagesPatchArrayOutput() HelmReleaseSpecPostRenderersKustomizeImagesPatchArrayOutput + ToHelmReleaseSpecPostRenderersKustomizeImagesPatchArrayOutputWithContext(context.Context) HelmReleaseSpecPostRenderersKustomizeImagesPatchArrayOutput +} + +type HelmReleaseSpecPostRenderersKustomizeImagesPatchArray []HelmReleaseSpecPostRenderersKustomizeImagesPatchInput + +func (HelmReleaseSpecPostRenderersKustomizeImagesPatchArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]HelmReleaseSpecPostRenderersKustomizeImagesPatch)(nil)).Elem() +} + +func (i HelmReleaseSpecPostRenderersKustomizeImagesPatchArray) ToHelmReleaseSpecPostRenderersKustomizeImagesPatchArrayOutput() HelmReleaseSpecPostRenderersKustomizeImagesPatchArrayOutput { + return i.ToHelmReleaseSpecPostRenderersKustomizeImagesPatchArrayOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecPostRenderersKustomizeImagesPatchArray) ToHelmReleaseSpecPostRenderersKustomizeImagesPatchArrayOutputWithContext(ctx context.Context) HelmReleaseSpecPostRenderersKustomizeImagesPatchArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecPostRenderersKustomizeImagesPatchArrayOutput) +} + +// Image contains an image name, a new name, a new tag or digest, which will replace the original name and tag. +type HelmReleaseSpecPostRenderersKustomizeImagesPatchOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecPostRenderersKustomizeImagesPatchOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecPostRenderersKustomizeImagesPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecPostRenderersKustomizeImagesPatchOutput) ToHelmReleaseSpecPostRenderersKustomizeImagesPatchOutput() HelmReleaseSpecPostRenderersKustomizeImagesPatchOutput { + return o +} + +func (o HelmReleaseSpecPostRenderersKustomizeImagesPatchOutput) ToHelmReleaseSpecPostRenderersKustomizeImagesPatchOutputWithContext(ctx context.Context) HelmReleaseSpecPostRenderersKustomizeImagesPatchOutput { + return o +} + +// Digest is the value used to replace the original image tag. +// If digest is present NewTag value is ignored. +func (o HelmReleaseSpecPostRenderersKustomizeImagesPatchOutput) Digest() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecPostRenderersKustomizeImagesPatch) *string { return v.Digest }).(pulumi.StringPtrOutput) +} + +// Name is a tag-less image name. +func (o HelmReleaseSpecPostRenderersKustomizeImagesPatchOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecPostRenderersKustomizeImagesPatch) *string { return v.Name }).(pulumi.StringPtrOutput) +} + +// NewName is the value used to replace the original name. +func (o HelmReleaseSpecPostRenderersKustomizeImagesPatchOutput) NewName() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecPostRenderersKustomizeImagesPatch) *string { return v.NewName }).(pulumi.StringPtrOutput) +} + +// NewTag is the value used to replace the original tag. +func (o HelmReleaseSpecPostRenderersKustomizeImagesPatchOutput) NewTag() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecPostRenderersKustomizeImagesPatch) *string { return v.NewTag }).(pulumi.StringPtrOutput) +} + +type HelmReleaseSpecPostRenderersKustomizeImagesPatchArrayOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecPostRenderersKustomizeImagesPatchArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]HelmReleaseSpecPostRenderersKustomizeImagesPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecPostRenderersKustomizeImagesPatchArrayOutput) ToHelmReleaseSpecPostRenderersKustomizeImagesPatchArrayOutput() HelmReleaseSpecPostRenderersKustomizeImagesPatchArrayOutput { + return o +} + +func (o HelmReleaseSpecPostRenderersKustomizeImagesPatchArrayOutput) ToHelmReleaseSpecPostRenderersKustomizeImagesPatchArrayOutputWithContext(ctx context.Context) HelmReleaseSpecPostRenderersKustomizeImagesPatchArrayOutput { + return o +} + +func (o HelmReleaseSpecPostRenderersKustomizeImagesPatchArrayOutput) Index(i pulumi.IntInput) HelmReleaseSpecPostRenderersKustomizeImagesPatchOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) HelmReleaseSpecPostRenderersKustomizeImagesPatch { + return vs[0].([]HelmReleaseSpecPostRenderersKustomizeImagesPatch)[vs[1].(int)] + }).(HelmReleaseSpecPostRenderersKustomizeImagesPatchOutput) +} + +// Kustomization to apply as PostRenderer. +type HelmReleaseSpecPostRenderersKustomizePatch struct { + // Images is a list of (image name, new name, new tag or digest) + // for changing image names, tags or digests. This can also be achieved with a + // patch, but this operator is simpler to specify. + Images []HelmReleaseSpecPostRenderersKustomizeImagesPatch `pulumi:"images"` + // Strategic merge and JSON patches, defined as inline YAML objects, + // capable of targeting objects based on kind, label and annotation selectors. + Patches []HelmReleaseSpecPostRenderersKustomizePatchesPatch `pulumi:"patches"` +} + +// HelmReleaseSpecPostRenderersKustomizePatchInput is an input type that accepts HelmReleaseSpecPostRenderersKustomizePatchArgs and HelmReleaseSpecPostRenderersKustomizePatchOutput values. +// You can construct a concrete instance of `HelmReleaseSpecPostRenderersKustomizePatchInput` via: +// +// HelmReleaseSpecPostRenderersKustomizePatchArgs{...} +type HelmReleaseSpecPostRenderersKustomizePatchInput interface { + pulumi.Input + + ToHelmReleaseSpecPostRenderersKustomizePatchOutput() HelmReleaseSpecPostRenderersKustomizePatchOutput + ToHelmReleaseSpecPostRenderersKustomizePatchOutputWithContext(context.Context) HelmReleaseSpecPostRenderersKustomizePatchOutput +} + +// Kustomization to apply as PostRenderer. +type HelmReleaseSpecPostRenderersKustomizePatchArgs struct { + // Images is a list of (image name, new name, new tag or digest) + // for changing image names, tags or digests. This can also be achieved with a + // patch, but this operator is simpler to specify. + Images HelmReleaseSpecPostRenderersKustomizeImagesPatchArrayInput `pulumi:"images"` + // Strategic merge and JSON patches, defined as inline YAML objects, + // capable of targeting objects based on kind, label and annotation selectors. + Patches HelmReleaseSpecPostRenderersKustomizePatchesPatchArrayInput `pulumi:"patches"` +} + +func (HelmReleaseSpecPostRenderersKustomizePatchArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecPostRenderersKustomizePatch)(nil)).Elem() +} + +func (i HelmReleaseSpecPostRenderersKustomizePatchArgs) ToHelmReleaseSpecPostRenderersKustomizePatchOutput() HelmReleaseSpecPostRenderersKustomizePatchOutput { + return i.ToHelmReleaseSpecPostRenderersKustomizePatchOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecPostRenderersKustomizePatchArgs) ToHelmReleaseSpecPostRenderersKustomizePatchOutputWithContext(ctx context.Context) HelmReleaseSpecPostRenderersKustomizePatchOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecPostRenderersKustomizePatchOutput) +} + +func (i HelmReleaseSpecPostRenderersKustomizePatchArgs) ToHelmReleaseSpecPostRenderersKustomizePatchPtrOutput() HelmReleaseSpecPostRenderersKustomizePatchPtrOutput { + return i.ToHelmReleaseSpecPostRenderersKustomizePatchPtrOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecPostRenderersKustomizePatchArgs) ToHelmReleaseSpecPostRenderersKustomizePatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecPostRenderersKustomizePatchPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecPostRenderersKustomizePatchOutput).ToHelmReleaseSpecPostRenderersKustomizePatchPtrOutputWithContext(ctx) +} + +// HelmReleaseSpecPostRenderersKustomizePatchPtrInput is an input type that accepts HelmReleaseSpecPostRenderersKustomizePatchArgs, HelmReleaseSpecPostRenderersKustomizePatchPtr and HelmReleaseSpecPostRenderersKustomizePatchPtrOutput values. +// You can construct a concrete instance of `HelmReleaseSpecPostRenderersKustomizePatchPtrInput` via: +// +// HelmReleaseSpecPostRenderersKustomizePatchArgs{...} +// +// or: +// +// nil +type HelmReleaseSpecPostRenderersKustomizePatchPtrInput interface { + pulumi.Input + + ToHelmReleaseSpecPostRenderersKustomizePatchPtrOutput() HelmReleaseSpecPostRenderersKustomizePatchPtrOutput + ToHelmReleaseSpecPostRenderersKustomizePatchPtrOutputWithContext(context.Context) HelmReleaseSpecPostRenderersKustomizePatchPtrOutput +} + +type helmReleaseSpecPostRenderersKustomizePatchPtrType HelmReleaseSpecPostRenderersKustomizePatchArgs + +func HelmReleaseSpecPostRenderersKustomizePatchPtr(v *HelmReleaseSpecPostRenderersKustomizePatchArgs) HelmReleaseSpecPostRenderersKustomizePatchPtrInput { + return (*helmReleaseSpecPostRenderersKustomizePatchPtrType)(v) +} + +func (*helmReleaseSpecPostRenderersKustomizePatchPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecPostRenderersKustomizePatch)(nil)).Elem() +} + +func (i *helmReleaseSpecPostRenderersKustomizePatchPtrType) ToHelmReleaseSpecPostRenderersKustomizePatchPtrOutput() HelmReleaseSpecPostRenderersKustomizePatchPtrOutput { + return i.ToHelmReleaseSpecPostRenderersKustomizePatchPtrOutputWithContext(context.Background()) +} + +func (i *helmReleaseSpecPostRenderersKustomizePatchPtrType) ToHelmReleaseSpecPostRenderersKustomizePatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecPostRenderersKustomizePatchPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecPostRenderersKustomizePatchPtrOutput) +} + +// Kustomization to apply as PostRenderer. +type HelmReleaseSpecPostRenderersKustomizePatchOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecPostRenderersKustomizePatchOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecPostRenderersKustomizePatch)(nil)).Elem() +} + +func (o HelmReleaseSpecPostRenderersKustomizePatchOutput) ToHelmReleaseSpecPostRenderersKustomizePatchOutput() HelmReleaseSpecPostRenderersKustomizePatchOutput { + return o +} + +func (o HelmReleaseSpecPostRenderersKustomizePatchOutput) ToHelmReleaseSpecPostRenderersKustomizePatchOutputWithContext(ctx context.Context) HelmReleaseSpecPostRenderersKustomizePatchOutput { + return o +} + +func (o HelmReleaseSpecPostRenderersKustomizePatchOutput) ToHelmReleaseSpecPostRenderersKustomizePatchPtrOutput() HelmReleaseSpecPostRenderersKustomizePatchPtrOutput { + return o.ToHelmReleaseSpecPostRenderersKustomizePatchPtrOutputWithContext(context.Background()) +} + +func (o HelmReleaseSpecPostRenderersKustomizePatchOutput) ToHelmReleaseSpecPostRenderersKustomizePatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecPostRenderersKustomizePatchPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v HelmReleaseSpecPostRenderersKustomizePatch) *HelmReleaseSpecPostRenderersKustomizePatch { + return &v + }).(HelmReleaseSpecPostRenderersKustomizePatchPtrOutput) +} + +// Images is a list of (image name, new name, new tag or digest) +// for changing image names, tags or digests. This can also be achieved with a +// patch, but this operator is simpler to specify. +func (o HelmReleaseSpecPostRenderersKustomizePatchOutput) Images() HelmReleaseSpecPostRenderersKustomizeImagesPatchArrayOutput { + return o.ApplyT(func(v HelmReleaseSpecPostRenderersKustomizePatch) []HelmReleaseSpecPostRenderersKustomizeImagesPatch { + return v.Images + }).(HelmReleaseSpecPostRenderersKustomizeImagesPatchArrayOutput) +} + +// Strategic merge and JSON patches, defined as inline YAML objects, +// capable of targeting objects based on kind, label and annotation selectors. +func (o HelmReleaseSpecPostRenderersKustomizePatchOutput) Patches() HelmReleaseSpecPostRenderersKustomizePatchesPatchArrayOutput { + return o.ApplyT(func(v HelmReleaseSpecPostRenderersKustomizePatch) []HelmReleaseSpecPostRenderersKustomizePatchesPatch { + return v.Patches + }).(HelmReleaseSpecPostRenderersKustomizePatchesPatchArrayOutput) +} + +type HelmReleaseSpecPostRenderersKustomizePatchPtrOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecPostRenderersKustomizePatchPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecPostRenderersKustomizePatch)(nil)).Elem() +} + +func (o HelmReleaseSpecPostRenderersKustomizePatchPtrOutput) ToHelmReleaseSpecPostRenderersKustomizePatchPtrOutput() HelmReleaseSpecPostRenderersKustomizePatchPtrOutput { + return o +} + +func (o HelmReleaseSpecPostRenderersKustomizePatchPtrOutput) ToHelmReleaseSpecPostRenderersKustomizePatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecPostRenderersKustomizePatchPtrOutput { + return o +} + +func (o HelmReleaseSpecPostRenderersKustomizePatchPtrOutput) Elem() HelmReleaseSpecPostRenderersKustomizePatchOutput { + return o.ApplyT(func(v *HelmReleaseSpecPostRenderersKustomizePatch) HelmReleaseSpecPostRenderersKustomizePatch { + if v != nil { + return *v + } + var ret HelmReleaseSpecPostRenderersKustomizePatch + return ret + }).(HelmReleaseSpecPostRenderersKustomizePatchOutput) +} + +// Images is a list of (image name, new name, new tag or digest) +// for changing image names, tags or digests. This can also be achieved with a +// patch, but this operator is simpler to specify. +func (o HelmReleaseSpecPostRenderersKustomizePatchPtrOutput) Images() HelmReleaseSpecPostRenderersKustomizeImagesPatchArrayOutput { + return o.ApplyT(func(v *HelmReleaseSpecPostRenderersKustomizePatch) []HelmReleaseSpecPostRenderersKustomizeImagesPatch { + if v == nil { + return nil + } + return v.Images + }).(HelmReleaseSpecPostRenderersKustomizeImagesPatchArrayOutput) +} + +// Strategic merge and JSON patches, defined as inline YAML objects, +// capable of targeting objects based on kind, label and annotation selectors. +func (o HelmReleaseSpecPostRenderersKustomizePatchPtrOutput) Patches() HelmReleaseSpecPostRenderersKustomizePatchesPatchArrayOutput { + return o.ApplyT(func(v *HelmReleaseSpecPostRenderersKustomizePatch) []HelmReleaseSpecPostRenderersKustomizePatchesPatch { + if v == nil { + return nil + } + return v.Patches + }).(HelmReleaseSpecPostRenderersKustomizePatchesPatchArrayOutput) +} + +// Patch contains an inline StrategicMerge or JSON6902 patch, and the target the patch should +// be applied to. +type HelmReleaseSpecPostRenderersKustomizePatches struct { + // Patch contains an inline StrategicMerge patch or an inline JSON6902 patch with + // an array of operation objects. + Patch *string `pulumi:"patch"` + Target *HelmReleaseSpecPostRenderersKustomizePatchesTarget `pulumi:"target"` +} + +// HelmReleaseSpecPostRenderersKustomizePatchesInput is an input type that accepts HelmReleaseSpecPostRenderersKustomizePatchesArgs and HelmReleaseSpecPostRenderersKustomizePatchesOutput values. +// You can construct a concrete instance of `HelmReleaseSpecPostRenderersKustomizePatchesInput` via: +// +// HelmReleaseSpecPostRenderersKustomizePatchesArgs{...} +type HelmReleaseSpecPostRenderersKustomizePatchesInput interface { + pulumi.Input + + ToHelmReleaseSpecPostRenderersKustomizePatchesOutput() HelmReleaseSpecPostRenderersKustomizePatchesOutput + ToHelmReleaseSpecPostRenderersKustomizePatchesOutputWithContext(context.Context) HelmReleaseSpecPostRenderersKustomizePatchesOutput +} + +// Patch contains an inline StrategicMerge or JSON6902 patch, and the target the patch should +// be applied to. +type HelmReleaseSpecPostRenderersKustomizePatchesArgs struct { + // Patch contains an inline StrategicMerge patch or an inline JSON6902 patch with + // an array of operation objects. + Patch pulumi.StringPtrInput `pulumi:"patch"` + Target HelmReleaseSpecPostRenderersKustomizePatchesTargetPtrInput `pulumi:"target"` +} + +func (HelmReleaseSpecPostRenderersKustomizePatchesArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecPostRenderersKustomizePatches)(nil)).Elem() +} + +func (i HelmReleaseSpecPostRenderersKustomizePatchesArgs) ToHelmReleaseSpecPostRenderersKustomizePatchesOutput() HelmReleaseSpecPostRenderersKustomizePatchesOutput { + return i.ToHelmReleaseSpecPostRenderersKustomizePatchesOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecPostRenderersKustomizePatchesArgs) ToHelmReleaseSpecPostRenderersKustomizePatchesOutputWithContext(ctx context.Context) HelmReleaseSpecPostRenderersKustomizePatchesOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecPostRenderersKustomizePatchesOutput) +} + +// HelmReleaseSpecPostRenderersKustomizePatchesArrayInput is an input type that accepts HelmReleaseSpecPostRenderersKustomizePatchesArray and HelmReleaseSpecPostRenderersKustomizePatchesArrayOutput values. +// You can construct a concrete instance of `HelmReleaseSpecPostRenderersKustomizePatchesArrayInput` via: +// +// HelmReleaseSpecPostRenderersKustomizePatchesArray{ HelmReleaseSpecPostRenderersKustomizePatchesArgs{...} } +type HelmReleaseSpecPostRenderersKustomizePatchesArrayInput interface { + pulumi.Input + + ToHelmReleaseSpecPostRenderersKustomizePatchesArrayOutput() HelmReleaseSpecPostRenderersKustomizePatchesArrayOutput + ToHelmReleaseSpecPostRenderersKustomizePatchesArrayOutputWithContext(context.Context) HelmReleaseSpecPostRenderersKustomizePatchesArrayOutput +} + +type HelmReleaseSpecPostRenderersKustomizePatchesArray []HelmReleaseSpecPostRenderersKustomizePatchesInput + +func (HelmReleaseSpecPostRenderersKustomizePatchesArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]HelmReleaseSpecPostRenderersKustomizePatches)(nil)).Elem() +} + +func (i HelmReleaseSpecPostRenderersKustomizePatchesArray) ToHelmReleaseSpecPostRenderersKustomizePatchesArrayOutput() HelmReleaseSpecPostRenderersKustomizePatchesArrayOutput { + return i.ToHelmReleaseSpecPostRenderersKustomizePatchesArrayOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecPostRenderersKustomizePatchesArray) ToHelmReleaseSpecPostRenderersKustomizePatchesArrayOutputWithContext(ctx context.Context) HelmReleaseSpecPostRenderersKustomizePatchesArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecPostRenderersKustomizePatchesArrayOutput) +} + +// Patch contains an inline StrategicMerge or JSON6902 patch, and the target the patch should +// be applied to. +type HelmReleaseSpecPostRenderersKustomizePatchesOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecPostRenderersKustomizePatchesOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecPostRenderersKustomizePatches)(nil)).Elem() +} + +func (o HelmReleaseSpecPostRenderersKustomizePatchesOutput) ToHelmReleaseSpecPostRenderersKustomizePatchesOutput() HelmReleaseSpecPostRenderersKustomizePatchesOutput { + return o +} + +func (o HelmReleaseSpecPostRenderersKustomizePatchesOutput) ToHelmReleaseSpecPostRenderersKustomizePatchesOutputWithContext(ctx context.Context) HelmReleaseSpecPostRenderersKustomizePatchesOutput { + return o +} + +// Patch contains an inline StrategicMerge patch or an inline JSON6902 patch with +// an array of operation objects. +func (o HelmReleaseSpecPostRenderersKustomizePatchesOutput) Patch() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecPostRenderersKustomizePatches) *string { return v.Patch }).(pulumi.StringPtrOutput) +} + +func (o HelmReleaseSpecPostRenderersKustomizePatchesOutput) Target() HelmReleaseSpecPostRenderersKustomizePatchesTargetPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecPostRenderersKustomizePatches) *HelmReleaseSpecPostRenderersKustomizePatchesTarget { + return v.Target + }).(HelmReleaseSpecPostRenderersKustomizePatchesTargetPtrOutput) +} + +type HelmReleaseSpecPostRenderersKustomizePatchesArrayOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecPostRenderersKustomizePatchesArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]HelmReleaseSpecPostRenderersKustomizePatches)(nil)).Elem() +} + +func (o HelmReleaseSpecPostRenderersKustomizePatchesArrayOutput) ToHelmReleaseSpecPostRenderersKustomizePatchesArrayOutput() HelmReleaseSpecPostRenderersKustomizePatchesArrayOutput { + return o +} + +func (o HelmReleaseSpecPostRenderersKustomizePatchesArrayOutput) ToHelmReleaseSpecPostRenderersKustomizePatchesArrayOutputWithContext(ctx context.Context) HelmReleaseSpecPostRenderersKustomizePatchesArrayOutput { + return o +} + +func (o HelmReleaseSpecPostRenderersKustomizePatchesArrayOutput) Index(i pulumi.IntInput) HelmReleaseSpecPostRenderersKustomizePatchesOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) HelmReleaseSpecPostRenderersKustomizePatches { + return vs[0].([]HelmReleaseSpecPostRenderersKustomizePatches)[vs[1].(int)] + }).(HelmReleaseSpecPostRenderersKustomizePatchesOutput) +} + +// Patch contains an inline StrategicMerge or JSON6902 patch, and the target the patch should +// be applied to. +type HelmReleaseSpecPostRenderersKustomizePatchesPatch struct { + // Patch contains an inline StrategicMerge patch or an inline JSON6902 patch with + // an array of operation objects. + Patch *string `pulumi:"patch"` + Target *HelmReleaseSpecPostRenderersKustomizePatchesTargetPatch `pulumi:"target"` +} + +// HelmReleaseSpecPostRenderersKustomizePatchesPatchInput is an input type that accepts HelmReleaseSpecPostRenderersKustomizePatchesPatchArgs and HelmReleaseSpecPostRenderersKustomizePatchesPatchOutput values. +// You can construct a concrete instance of `HelmReleaseSpecPostRenderersKustomizePatchesPatchInput` via: +// +// HelmReleaseSpecPostRenderersKustomizePatchesPatchArgs{...} +type HelmReleaseSpecPostRenderersKustomizePatchesPatchInput interface { + pulumi.Input + + ToHelmReleaseSpecPostRenderersKustomizePatchesPatchOutput() HelmReleaseSpecPostRenderersKustomizePatchesPatchOutput + ToHelmReleaseSpecPostRenderersKustomizePatchesPatchOutputWithContext(context.Context) HelmReleaseSpecPostRenderersKustomizePatchesPatchOutput +} + +// Patch contains an inline StrategicMerge or JSON6902 patch, and the target the patch should +// be applied to. +type HelmReleaseSpecPostRenderersKustomizePatchesPatchArgs struct { + // Patch contains an inline StrategicMerge patch or an inline JSON6902 patch with + // an array of operation objects. + Patch pulumi.StringPtrInput `pulumi:"patch"` + Target HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchPtrInput `pulumi:"target"` +} + +func (HelmReleaseSpecPostRenderersKustomizePatchesPatchArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecPostRenderersKustomizePatchesPatch)(nil)).Elem() +} + +func (i HelmReleaseSpecPostRenderersKustomizePatchesPatchArgs) ToHelmReleaseSpecPostRenderersKustomizePatchesPatchOutput() HelmReleaseSpecPostRenderersKustomizePatchesPatchOutput { + return i.ToHelmReleaseSpecPostRenderersKustomizePatchesPatchOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecPostRenderersKustomizePatchesPatchArgs) ToHelmReleaseSpecPostRenderersKustomizePatchesPatchOutputWithContext(ctx context.Context) HelmReleaseSpecPostRenderersKustomizePatchesPatchOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecPostRenderersKustomizePatchesPatchOutput) +} + +// HelmReleaseSpecPostRenderersKustomizePatchesPatchArrayInput is an input type that accepts HelmReleaseSpecPostRenderersKustomizePatchesPatchArray and HelmReleaseSpecPostRenderersKustomizePatchesPatchArrayOutput values. +// You can construct a concrete instance of `HelmReleaseSpecPostRenderersKustomizePatchesPatchArrayInput` via: +// +// HelmReleaseSpecPostRenderersKustomizePatchesPatchArray{ HelmReleaseSpecPostRenderersKustomizePatchesPatchArgs{...} } +type HelmReleaseSpecPostRenderersKustomizePatchesPatchArrayInput interface { + pulumi.Input + + ToHelmReleaseSpecPostRenderersKustomizePatchesPatchArrayOutput() HelmReleaseSpecPostRenderersKustomizePatchesPatchArrayOutput + ToHelmReleaseSpecPostRenderersKustomizePatchesPatchArrayOutputWithContext(context.Context) HelmReleaseSpecPostRenderersKustomizePatchesPatchArrayOutput +} + +type HelmReleaseSpecPostRenderersKustomizePatchesPatchArray []HelmReleaseSpecPostRenderersKustomizePatchesPatchInput + +func (HelmReleaseSpecPostRenderersKustomizePatchesPatchArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]HelmReleaseSpecPostRenderersKustomizePatchesPatch)(nil)).Elem() +} + +func (i HelmReleaseSpecPostRenderersKustomizePatchesPatchArray) ToHelmReleaseSpecPostRenderersKustomizePatchesPatchArrayOutput() HelmReleaseSpecPostRenderersKustomizePatchesPatchArrayOutput { + return i.ToHelmReleaseSpecPostRenderersKustomizePatchesPatchArrayOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecPostRenderersKustomizePatchesPatchArray) ToHelmReleaseSpecPostRenderersKustomizePatchesPatchArrayOutputWithContext(ctx context.Context) HelmReleaseSpecPostRenderersKustomizePatchesPatchArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecPostRenderersKustomizePatchesPatchArrayOutput) +} + +// Patch contains an inline StrategicMerge or JSON6902 patch, and the target the patch should +// be applied to. +type HelmReleaseSpecPostRenderersKustomizePatchesPatchOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecPostRenderersKustomizePatchesPatchOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecPostRenderersKustomizePatchesPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecPostRenderersKustomizePatchesPatchOutput) ToHelmReleaseSpecPostRenderersKustomizePatchesPatchOutput() HelmReleaseSpecPostRenderersKustomizePatchesPatchOutput { + return o +} + +func (o HelmReleaseSpecPostRenderersKustomizePatchesPatchOutput) ToHelmReleaseSpecPostRenderersKustomizePatchesPatchOutputWithContext(ctx context.Context) HelmReleaseSpecPostRenderersKustomizePatchesPatchOutput { + return o +} + +// Patch contains an inline StrategicMerge patch or an inline JSON6902 patch with +// an array of operation objects. +func (o HelmReleaseSpecPostRenderersKustomizePatchesPatchOutput) Patch() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecPostRenderersKustomizePatchesPatch) *string { return v.Patch }).(pulumi.StringPtrOutput) +} + +func (o HelmReleaseSpecPostRenderersKustomizePatchesPatchOutput) Target() HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecPostRenderersKustomizePatchesPatch) *HelmReleaseSpecPostRenderersKustomizePatchesTargetPatch { + return v.Target + }).(HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchPtrOutput) +} + +type HelmReleaseSpecPostRenderersKustomizePatchesPatchArrayOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecPostRenderersKustomizePatchesPatchArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]HelmReleaseSpecPostRenderersKustomizePatchesPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecPostRenderersKustomizePatchesPatchArrayOutput) ToHelmReleaseSpecPostRenderersKustomizePatchesPatchArrayOutput() HelmReleaseSpecPostRenderersKustomizePatchesPatchArrayOutput { + return o +} + +func (o HelmReleaseSpecPostRenderersKustomizePatchesPatchArrayOutput) ToHelmReleaseSpecPostRenderersKustomizePatchesPatchArrayOutputWithContext(ctx context.Context) HelmReleaseSpecPostRenderersKustomizePatchesPatchArrayOutput { + return o +} + +func (o HelmReleaseSpecPostRenderersKustomizePatchesPatchArrayOutput) Index(i pulumi.IntInput) HelmReleaseSpecPostRenderersKustomizePatchesPatchOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) HelmReleaseSpecPostRenderersKustomizePatchesPatch { + return vs[0].([]HelmReleaseSpecPostRenderersKustomizePatchesPatch)[vs[1].(int)] + }).(HelmReleaseSpecPostRenderersKustomizePatchesPatchOutput) +} + +// Target points to the resources that the patch document should be applied to. +type HelmReleaseSpecPostRenderersKustomizePatchesTarget struct { + // AnnotationSelector is a string that follows the label selection expression + // https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#api + // It matches with the resource annotations. + AnnotationSelector *string `pulumi:"annotationSelector"` + // Group is the API group to select resources from. + // Together with Version and Kind it is capable of unambiguously identifying and/or selecting resources. + // https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md + Group *string `pulumi:"group"` + // Kind of the API Group to select resources from. + // Together with Group and Version it is capable of unambiguously + // identifying and/or selecting resources. + // https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md + Kind *string `pulumi:"kind"` + // LabelSelector is a string that follows the label selection expression + // https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#api + // It matches with the resource labels. + LabelSelector *string `pulumi:"labelSelector"` + // Name to match resources with. + Name *string `pulumi:"name"` + // Namespace to select resources from. + Namespace *string `pulumi:"namespace"` + // Version of the API Group to select resources from. + // Together with Group and Kind it is capable of unambiguously identifying and/or selecting resources. + // https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md + Version *string `pulumi:"version"` +} + +// HelmReleaseSpecPostRenderersKustomizePatchesTargetInput is an input type that accepts HelmReleaseSpecPostRenderersKustomizePatchesTargetArgs and HelmReleaseSpecPostRenderersKustomizePatchesTargetOutput values. +// You can construct a concrete instance of `HelmReleaseSpecPostRenderersKustomizePatchesTargetInput` via: +// +// HelmReleaseSpecPostRenderersKustomizePatchesTargetArgs{...} +type HelmReleaseSpecPostRenderersKustomizePatchesTargetInput interface { + pulumi.Input + + ToHelmReleaseSpecPostRenderersKustomizePatchesTargetOutput() HelmReleaseSpecPostRenderersKustomizePatchesTargetOutput + ToHelmReleaseSpecPostRenderersKustomizePatchesTargetOutputWithContext(context.Context) HelmReleaseSpecPostRenderersKustomizePatchesTargetOutput +} + +// Target points to the resources that the patch document should be applied to. +type HelmReleaseSpecPostRenderersKustomizePatchesTargetArgs struct { + // AnnotationSelector is a string that follows the label selection expression + // https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#api + // It matches with the resource annotations. + AnnotationSelector pulumi.StringPtrInput `pulumi:"annotationSelector"` + // Group is the API group to select resources from. + // Together with Version and Kind it is capable of unambiguously identifying and/or selecting resources. + // https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md + Group pulumi.StringPtrInput `pulumi:"group"` + // Kind of the API Group to select resources from. + // Together with Group and Version it is capable of unambiguously + // identifying and/or selecting resources. + // https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md + Kind pulumi.StringPtrInput `pulumi:"kind"` + // LabelSelector is a string that follows the label selection expression + // https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#api + // It matches with the resource labels. + LabelSelector pulumi.StringPtrInput `pulumi:"labelSelector"` + // Name to match resources with. + Name pulumi.StringPtrInput `pulumi:"name"` + // Namespace to select resources from. + Namespace pulumi.StringPtrInput `pulumi:"namespace"` + // Version of the API Group to select resources from. + // Together with Group and Kind it is capable of unambiguously identifying and/or selecting resources. + // https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md + Version pulumi.StringPtrInput `pulumi:"version"` +} + +func (HelmReleaseSpecPostRenderersKustomizePatchesTargetArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecPostRenderersKustomizePatchesTarget)(nil)).Elem() +} + +func (i HelmReleaseSpecPostRenderersKustomizePatchesTargetArgs) ToHelmReleaseSpecPostRenderersKustomizePatchesTargetOutput() HelmReleaseSpecPostRenderersKustomizePatchesTargetOutput { + return i.ToHelmReleaseSpecPostRenderersKustomizePatchesTargetOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecPostRenderersKustomizePatchesTargetArgs) ToHelmReleaseSpecPostRenderersKustomizePatchesTargetOutputWithContext(ctx context.Context) HelmReleaseSpecPostRenderersKustomizePatchesTargetOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecPostRenderersKustomizePatchesTargetOutput) +} + +func (i HelmReleaseSpecPostRenderersKustomizePatchesTargetArgs) ToHelmReleaseSpecPostRenderersKustomizePatchesTargetPtrOutput() HelmReleaseSpecPostRenderersKustomizePatchesTargetPtrOutput { + return i.ToHelmReleaseSpecPostRenderersKustomizePatchesTargetPtrOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecPostRenderersKustomizePatchesTargetArgs) ToHelmReleaseSpecPostRenderersKustomizePatchesTargetPtrOutputWithContext(ctx context.Context) HelmReleaseSpecPostRenderersKustomizePatchesTargetPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecPostRenderersKustomizePatchesTargetOutput).ToHelmReleaseSpecPostRenderersKustomizePatchesTargetPtrOutputWithContext(ctx) +} + +// HelmReleaseSpecPostRenderersKustomizePatchesTargetPtrInput is an input type that accepts HelmReleaseSpecPostRenderersKustomizePatchesTargetArgs, HelmReleaseSpecPostRenderersKustomizePatchesTargetPtr and HelmReleaseSpecPostRenderersKustomizePatchesTargetPtrOutput values. +// You can construct a concrete instance of `HelmReleaseSpecPostRenderersKustomizePatchesTargetPtrInput` via: +// +// HelmReleaseSpecPostRenderersKustomizePatchesTargetArgs{...} +// +// or: +// +// nil +type HelmReleaseSpecPostRenderersKustomizePatchesTargetPtrInput interface { + pulumi.Input + + ToHelmReleaseSpecPostRenderersKustomizePatchesTargetPtrOutput() HelmReleaseSpecPostRenderersKustomizePatchesTargetPtrOutput + ToHelmReleaseSpecPostRenderersKustomizePatchesTargetPtrOutputWithContext(context.Context) HelmReleaseSpecPostRenderersKustomizePatchesTargetPtrOutput +} + +type helmReleaseSpecPostRenderersKustomizePatchesTargetPtrType HelmReleaseSpecPostRenderersKustomizePatchesTargetArgs + +func HelmReleaseSpecPostRenderersKustomizePatchesTargetPtr(v *HelmReleaseSpecPostRenderersKustomizePatchesTargetArgs) HelmReleaseSpecPostRenderersKustomizePatchesTargetPtrInput { + return (*helmReleaseSpecPostRenderersKustomizePatchesTargetPtrType)(v) +} + +func (*helmReleaseSpecPostRenderersKustomizePatchesTargetPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecPostRenderersKustomizePatchesTarget)(nil)).Elem() +} + +func (i *helmReleaseSpecPostRenderersKustomizePatchesTargetPtrType) ToHelmReleaseSpecPostRenderersKustomizePatchesTargetPtrOutput() HelmReleaseSpecPostRenderersKustomizePatchesTargetPtrOutput { + return i.ToHelmReleaseSpecPostRenderersKustomizePatchesTargetPtrOutputWithContext(context.Background()) +} + +func (i *helmReleaseSpecPostRenderersKustomizePatchesTargetPtrType) ToHelmReleaseSpecPostRenderersKustomizePatchesTargetPtrOutputWithContext(ctx context.Context) HelmReleaseSpecPostRenderersKustomizePatchesTargetPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecPostRenderersKustomizePatchesTargetPtrOutput) +} + +// Target points to the resources that the patch document should be applied to. +type HelmReleaseSpecPostRenderersKustomizePatchesTargetOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecPostRenderersKustomizePatchesTargetOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecPostRenderersKustomizePatchesTarget)(nil)).Elem() +} + +func (o HelmReleaseSpecPostRenderersKustomizePatchesTargetOutput) ToHelmReleaseSpecPostRenderersKustomizePatchesTargetOutput() HelmReleaseSpecPostRenderersKustomizePatchesTargetOutput { + return o +} + +func (o HelmReleaseSpecPostRenderersKustomizePatchesTargetOutput) ToHelmReleaseSpecPostRenderersKustomizePatchesTargetOutputWithContext(ctx context.Context) HelmReleaseSpecPostRenderersKustomizePatchesTargetOutput { + return o +} + +func (o HelmReleaseSpecPostRenderersKustomizePatchesTargetOutput) ToHelmReleaseSpecPostRenderersKustomizePatchesTargetPtrOutput() HelmReleaseSpecPostRenderersKustomizePatchesTargetPtrOutput { + return o.ToHelmReleaseSpecPostRenderersKustomizePatchesTargetPtrOutputWithContext(context.Background()) +} + +func (o HelmReleaseSpecPostRenderersKustomizePatchesTargetOutput) ToHelmReleaseSpecPostRenderersKustomizePatchesTargetPtrOutputWithContext(ctx context.Context) HelmReleaseSpecPostRenderersKustomizePatchesTargetPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v HelmReleaseSpecPostRenderersKustomizePatchesTarget) *HelmReleaseSpecPostRenderersKustomizePatchesTarget { + return &v + }).(HelmReleaseSpecPostRenderersKustomizePatchesTargetPtrOutput) +} + +// AnnotationSelector is a string that follows the label selection expression +// https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#api +// It matches with the resource annotations. +func (o HelmReleaseSpecPostRenderersKustomizePatchesTargetOutput) AnnotationSelector() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecPostRenderersKustomizePatchesTarget) *string { return v.AnnotationSelector }).(pulumi.StringPtrOutput) +} + +// Group is the API group to select resources from. +// Together with Version and Kind it is capable of unambiguously identifying and/or selecting resources. +// https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md +func (o HelmReleaseSpecPostRenderersKustomizePatchesTargetOutput) Group() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecPostRenderersKustomizePatchesTarget) *string { return v.Group }).(pulumi.StringPtrOutput) +} + +// Kind of the API Group to select resources from. +// Together with Group and Version it is capable of unambiguously +// identifying and/or selecting resources. +// https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md +func (o HelmReleaseSpecPostRenderersKustomizePatchesTargetOutput) Kind() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecPostRenderersKustomizePatchesTarget) *string { return v.Kind }).(pulumi.StringPtrOutput) +} + +// LabelSelector is a string that follows the label selection expression +// https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#api +// It matches with the resource labels. +func (o HelmReleaseSpecPostRenderersKustomizePatchesTargetOutput) LabelSelector() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecPostRenderersKustomizePatchesTarget) *string { return v.LabelSelector }).(pulumi.StringPtrOutput) +} + +// Name to match resources with. +func (o HelmReleaseSpecPostRenderersKustomizePatchesTargetOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecPostRenderersKustomizePatchesTarget) *string { return v.Name }).(pulumi.StringPtrOutput) +} + +// Namespace to select resources from. +func (o HelmReleaseSpecPostRenderersKustomizePatchesTargetOutput) Namespace() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecPostRenderersKustomizePatchesTarget) *string { return v.Namespace }).(pulumi.StringPtrOutput) +} + +// Version of the API Group to select resources from. +// Together with Group and Kind it is capable of unambiguously identifying and/or selecting resources. +// https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md +func (o HelmReleaseSpecPostRenderersKustomizePatchesTargetOutput) Version() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecPostRenderersKustomizePatchesTarget) *string { return v.Version }).(pulumi.StringPtrOutput) +} + +type HelmReleaseSpecPostRenderersKustomizePatchesTargetPtrOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecPostRenderersKustomizePatchesTargetPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecPostRenderersKustomizePatchesTarget)(nil)).Elem() +} + +func (o HelmReleaseSpecPostRenderersKustomizePatchesTargetPtrOutput) ToHelmReleaseSpecPostRenderersKustomizePatchesTargetPtrOutput() HelmReleaseSpecPostRenderersKustomizePatchesTargetPtrOutput { + return o +} + +func (o HelmReleaseSpecPostRenderersKustomizePatchesTargetPtrOutput) ToHelmReleaseSpecPostRenderersKustomizePatchesTargetPtrOutputWithContext(ctx context.Context) HelmReleaseSpecPostRenderersKustomizePatchesTargetPtrOutput { + return o +} + +func (o HelmReleaseSpecPostRenderersKustomizePatchesTargetPtrOutput) Elem() HelmReleaseSpecPostRenderersKustomizePatchesTargetOutput { + return o.ApplyT(func(v *HelmReleaseSpecPostRenderersKustomizePatchesTarget) HelmReleaseSpecPostRenderersKustomizePatchesTarget { + if v != nil { + return *v + } + var ret HelmReleaseSpecPostRenderersKustomizePatchesTarget + return ret + }).(HelmReleaseSpecPostRenderersKustomizePatchesTargetOutput) +} + +// AnnotationSelector is a string that follows the label selection expression +// https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#api +// It matches with the resource annotations. +func (o HelmReleaseSpecPostRenderersKustomizePatchesTargetPtrOutput) AnnotationSelector() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecPostRenderersKustomizePatchesTarget) *string { + if v == nil { + return nil + } + return v.AnnotationSelector + }).(pulumi.StringPtrOutput) +} + +// Group is the API group to select resources from. +// Together with Version and Kind it is capable of unambiguously identifying and/or selecting resources. +// https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md +func (o HelmReleaseSpecPostRenderersKustomizePatchesTargetPtrOutput) Group() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecPostRenderersKustomizePatchesTarget) *string { + if v == nil { + return nil + } + return v.Group + }).(pulumi.StringPtrOutput) +} + +// Kind of the API Group to select resources from. +// Together with Group and Version it is capable of unambiguously +// identifying and/or selecting resources. +// https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md +func (o HelmReleaseSpecPostRenderersKustomizePatchesTargetPtrOutput) Kind() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecPostRenderersKustomizePatchesTarget) *string { + if v == nil { + return nil + } + return v.Kind + }).(pulumi.StringPtrOutput) +} + +// LabelSelector is a string that follows the label selection expression +// https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#api +// It matches with the resource labels. +func (o HelmReleaseSpecPostRenderersKustomizePatchesTargetPtrOutput) LabelSelector() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecPostRenderersKustomizePatchesTarget) *string { + if v == nil { + return nil + } + return v.LabelSelector + }).(pulumi.StringPtrOutput) +} + +// Name to match resources with. +func (o HelmReleaseSpecPostRenderersKustomizePatchesTargetPtrOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecPostRenderersKustomizePatchesTarget) *string { + if v == nil { + return nil + } + return v.Name + }).(pulumi.StringPtrOutput) +} + +// Namespace to select resources from. +func (o HelmReleaseSpecPostRenderersKustomizePatchesTargetPtrOutput) Namespace() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecPostRenderersKustomizePatchesTarget) *string { + if v == nil { + return nil + } + return v.Namespace + }).(pulumi.StringPtrOutput) +} + +// Version of the API Group to select resources from. +// Together with Group and Kind it is capable of unambiguously identifying and/or selecting resources. +// https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md +func (o HelmReleaseSpecPostRenderersKustomizePatchesTargetPtrOutput) Version() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecPostRenderersKustomizePatchesTarget) *string { + if v == nil { + return nil + } + return v.Version + }).(pulumi.StringPtrOutput) +} + +// Target points to the resources that the patch document should be applied to. +type HelmReleaseSpecPostRenderersKustomizePatchesTargetPatch struct { + // AnnotationSelector is a string that follows the label selection expression + // https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#api + // It matches with the resource annotations. + AnnotationSelector *string `pulumi:"annotationSelector"` + // Group is the API group to select resources from. + // Together with Version and Kind it is capable of unambiguously identifying and/or selecting resources. + // https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md + Group *string `pulumi:"group"` + // Kind of the API Group to select resources from. + // Together with Group and Version it is capable of unambiguously + // identifying and/or selecting resources. + // https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md + Kind *string `pulumi:"kind"` + // LabelSelector is a string that follows the label selection expression + // https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#api + // It matches with the resource labels. + LabelSelector *string `pulumi:"labelSelector"` + // Name to match resources with. + Name *string `pulumi:"name"` + // Namespace to select resources from. + Namespace *string `pulumi:"namespace"` + // Version of the API Group to select resources from. + // Together with Group and Kind it is capable of unambiguously identifying and/or selecting resources. + // https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md + Version *string `pulumi:"version"` +} + +// HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchInput is an input type that accepts HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchArgs and HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchOutput values. +// You can construct a concrete instance of `HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchInput` via: +// +// HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchArgs{...} +type HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchInput interface { + pulumi.Input + + ToHelmReleaseSpecPostRenderersKustomizePatchesTargetPatchOutput() HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchOutput + ToHelmReleaseSpecPostRenderersKustomizePatchesTargetPatchOutputWithContext(context.Context) HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchOutput +} + +// Target points to the resources that the patch document should be applied to. +type HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchArgs struct { + // AnnotationSelector is a string that follows the label selection expression + // https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#api + // It matches with the resource annotations. + AnnotationSelector pulumi.StringPtrInput `pulumi:"annotationSelector"` + // Group is the API group to select resources from. + // Together with Version and Kind it is capable of unambiguously identifying and/or selecting resources. + // https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md + Group pulumi.StringPtrInput `pulumi:"group"` + // Kind of the API Group to select resources from. + // Together with Group and Version it is capable of unambiguously + // identifying and/or selecting resources. + // https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md + Kind pulumi.StringPtrInput `pulumi:"kind"` + // LabelSelector is a string that follows the label selection expression + // https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#api + // It matches with the resource labels. + LabelSelector pulumi.StringPtrInput `pulumi:"labelSelector"` + // Name to match resources with. + Name pulumi.StringPtrInput `pulumi:"name"` + // Namespace to select resources from. + Namespace pulumi.StringPtrInput `pulumi:"namespace"` + // Version of the API Group to select resources from. + // Together with Group and Kind it is capable of unambiguously identifying and/or selecting resources. + // https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md + Version pulumi.StringPtrInput `pulumi:"version"` +} + +func (HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecPostRenderersKustomizePatchesTargetPatch)(nil)).Elem() +} + +func (i HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchArgs) ToHelmReleaseSpecPostRenderersKustomizePatchesTargetPatchOutput() HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchOutput { + return i.ToHelmReleaseSpecPostRenderersKustomizePatchesTargetPatchOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchArgs) ToHelmReleaseSpecPostRenderersKustomizePatchesTargetPatchOutputWithContext(ctx context.Context) HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchOutput) +} + +func (i HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchArgs) ToHelmReleaseSpecPostRenderersKustomizePatchesTargetPatchPtrOutput() HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchPtrOutput { + return i.ToHelmReleaseSpecPostRenderersKustomizePatchesTargetPatchPtrOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchArgs) ToHelmReleaseSpecPostRenderersKustomizePatchesTargetPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchOutput).ToHelmReleaseSpecPostRenderersKustomizePatchesTargetPatchPtrOutputWithContext(ctx) +} + +// HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchPtrInput is an input type that accepts HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchArgs, HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchPtr and HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchPtrOutput values. +// You can construct a concrete instance of `HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchPtrInput` via: +// +// HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchArgs{...} +// +// or: +// +// nil +type HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchPtrInput interface { + pulumi.Input + + ToHelmReleaseSpecPostRenderersKustomizePatchesTargetPatchPtrOutput() HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchPtrOutput + ToHelmReleaseSpecPostRenderersKustomizePatchesTargetPatchPtrOutputWithContext(context.Context) HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchPtrOutput +} + +type helmReleaseSpecPostRenderersKustomizePatchesTargetPatchPtrType HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchArgs + +func HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchPtr(v *HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchArgs) HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchPtrInput { + return (*helmReleaseSpecPostRenderersKustomizePatchesTargetPatchPtrType)(v) +} + +func (*helmReleaseSpecPostRenderersKustomizePatchesTargetPatchPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecPostRenderersKustomizePatchesTargetPatch)(nil)).Elem() +} + +func (i *helmReleaseSpecPostRenderersKustomizePatchesTargetPatchPtrType) ToHelmReleaseSpecPostRenderersKustomizePatchesTargetPatchPtrOutput() HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchPtrOutput { + return i.ToHelmReleaseSpecPostRenderersKustomizePatchesTargetPatchPtrOutputWithContext(context.Background()) +} + +func (i *helmReleaseSpecPostRenderersKustomizePatchesTargetPatchPtrType) ToHelmReleaseSpecPostRenderersKustomizePatchesTargetPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchPtrOutput) +} + +// Target points to the resources that the patch document should be applied to. +type HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecPostRenderersKustomizePatchesTargetPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchOutput) ToHelmReleaseSpecPostRenderersKustomizePatchesTargetPatchOutput() HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchOutput { + return o +} + +func (o HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchOutput) ToHelmReleaseSpecPostRenderersKustomizePatchesTargetPatchOutputWithContext(ctx context.Context) HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchOutput { + return o +} + +func (o HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchOutput) ToHelmReleaseSpecPostRenderersKustomizePatchesTargetPatchPtrOutput() HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchPtrOutput { + return o.ToHelmReleaseSpecPostRenderersKustomizePatchesTargetPatchPtrOutputWithContext(context.Background()) +} + +func (o HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchOutput) ToHelmReleaseSpecPostRenderersKustomizePatchesTargetPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v HelmReleaseSpecPostRenderersKustomizePatchesTargetPatch) *HelmReleaseSpecPostRenderersKustomizePatchesTargetPatch { + return &v + }).(HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchPtrOutput) +} + +// AnnotationSelector is a string that follows the label selection expression +// https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#api +// It matches with the resource annotations. +func (o HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchOutput) AnnotationSelector() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecPostRenderersKustomizePatchesTargetPatch) *string { return v.AnnotationSelector }).(pulumi.StringPtrOutput) +} + +// Group is the API group to select resources from. +// Together with Version and Kind it is capable of unambiguously identifying and/or selecting resources. +// https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md +func (o HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchOutput) Group() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecPostRenderersKustomizePatchesTargetPatch) *string { return v.Group }).(pulumi.StringPtrOutput) +} + +// Kind of the API Group to select resources from. +// Together with Group and Version it is capable of unambiguously +// identifying and/or selecting resources. +// https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md +func (o HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchOutput) Kind() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecPostRenderersKustomizePatchesTargetPatch) *string { return v.Kind }).(pulumi.StringPtrOutput) +} + +// LabelSelector is a string that follows the label selection expression +// https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#api +// It matches with the resource labels. +func (o HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchOutput) LabelSelector() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecPostRenderersKustomizePatchesTargetPatch) *string { return v.LabelSelector }).(pulumi.StringPtrOutput) +} + +// Name to match resources with. +func (o HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecPostRenderersKustomizePatchesTargetPatch) *string { return v.Name }).(pulumi.StringPtrOutput) +} + +// Namespace to select resources from. +func (o HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchOutput) Namespace() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecPostRenderersKustomizePatchesTargetPatch) *string { return v.Namespace }).(pulumi.StringPtrOutput) +} + +// Version of the API Group to select resources from. +// Together with Group and Kind it is capable of unambiguously identifying and/or selecting resources. +// https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md +func (o HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchOutput) Version() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecPostRenderersKustomizePatchesTargetPatch) *string { return v.Version }).(pulumi.StringPtrOutput) +} + +type HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchPtrOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecPostRenderersKustomizePatchesTargetPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchPtrOutput) ToHelmReleaseSpecPostRenderersKustomizePatchesTargetPatchPtrOutput() HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchPtrOutput { + return o +} + +func (o HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchPtrOutput) ToHelmReleaseSpecPostRenderersKustomizePatchesTargetPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchPtrOutput { + return o +} + +func (o HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchPtrOutput) Elem() HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchOutput { + return o.ApplyT(func(v *HelmReleaseSpecPostRenderersKustomizePatchesTargetPatch) HelmReleaseSpecPostRenderersKustomizePatchesTargetPatch { + if v != nil { + return *v + } + var ret HelmReleaseSpecPostRenderersKustomizePatchesTargetPatch + return ret + }).(HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchOutput) +} + +// AnnotationSelector is a string that follows the label selection expression +// https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#api +// It matches with the resource annotations. +func (o HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchPtrOutput) AnnotationSelector() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecPostRenderersKustomizePatchesTargetPatch) *string { + if v == nil { + return nil + } + return v.AnnotationSelector + }).(pulumi.StringPtrOutput) +} + +// Group is the API group to select resources from. +// Together with Version and Kind it is capable of unambiguously identifying and/or selecting resources. +// https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md +func (o HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchPtrOutput) Group() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecPostRenderersKustomizePatchesTargetPatch) *string { + if v == nil { + return nil + } + return v.Group + }).(pulumi.StringPtrOutput) +} + +// Kind of the API Group to select resources from. +// Together with Group and Version it is capable of unambiguously +// identifying and/or selecting resources. +// https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md +func (o HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchPtrOutput) Kind() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecPostRenderersKustomizePatchesTargetPatch) *string { + if v == nil { + return nil + } + return v.Kind + }).(pulumi.StringPtrOutput) +} + +// LabelSelector is a string that follows the label selection expression +// https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#api +// It matches with the resource labels. +func (o HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchPtrOutput) LabelSelector() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecPostRenderersKustomizePatchesTargetPatch) *string { + if v == nil { + return nil + } + return v.LabelSelector + }).(pulumi.StringPtrOutput) +} + +// Name to match resources with. +func (o HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchPtrOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecPostRenderersKustomizePatchesTargetPatch) *string { + if v == nil { + return nil + } + return v.Name + }).(pulumi.StringPtrOutput) +} + +// Namespace to select resources from. +func (o HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchPtrOutput) Namespace() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecPostRenderersKustomizePatchesTargetPatch) *string { + if v == nil { + return nil + } + return v.Namespace + }).(pulumi.StringPtrOutput) +} + +// Version of the API Group to select resources from. +// Together with Group and Kind it is capable of unambiguously identifying and/or selecting resources. +// https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md +func (o HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchPtrOutput) Version() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecPostRenderersKustomizePatchesTargetPatch) *string { + if v == nil { + return nil + } + return v.Version + }).(pulumi.StringPtrOutput) +} + +// PostRenderer contains a Helm PostRenderer specification. +type HelmReleaseSpecPostRenderersPatch struct { + Kustomize *HelmReleaseSpecPostRenderersKustomizePatch `pulumi:"kustomize"` +} + +// HelmReleaseSpecPostRenderersPatchInput is an input type that accepts HelmReleaseSpecPostRenderersPatchArgs and HelmReleaseSpecPostRenderersPatchOutput values. +// You can construct a concrete instance of `HelmReleaseSpecPostRenderersPatchInput` via: +// +// HelmReleaseSpecPostRenderersPatchArgs{...} +type HelmReleaseSpecPostRenderersPatchInput interface { + pulumi.Input + + ToHelmReleaseSpecPostRenderersPatchOutput() HelmReleaseSpecPostRenderersPatchOutput + ToHelmReleaseSpecPostRenderersPatchOutputWithContext(context.Context) HelmReleaseSpecPostRenderersPatchOutput +} + +// PostRenderer contains a Helm PostRenderer specification. +type HelmReleaseSpecPostRenderersPatchArgs struct { + Kustomize HelmReleaseSpecPostRenderersKustomizePatchPtrInput `pulumi:"kustomize"` +} + +func (HelmReleaseSpecPostRenderersPatchArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecPostRenderersPatch)(nil)).Elem() +} + +func (i HelmReleaseSpecPostRenderersPatchArgs) ToHelmReleaseSpecPostRenderersPatchOutput() HelmReleaseSpecPostRenderersPatchOutput { + return i.ToHelmReleaseSpecPostRenderersPatchOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecPostRenderersPatchArgs) ToHelmReleaseSpecPostRenderersPatchOutputWithContext(ctx context.Context) HelmReleaseSpecPostRenderersPatchOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecPostRenderersPatchOutput) +} + +// HelmReleaseSpecPostRenderersPatchArrayInput is an input type that accepts HelmReleaseSpecPostRenderersPatchArray and HelmReleaseSpecPostRenderersPatchArrayOutput values. +// You can construct a concrete instance of `HelmReleaseSpecPostRenderersPatchArrayInput` via: +// +// HelmReleaseSpecPostRenderersPatchArray{ HelmReleaseSpecPostRenderersPatchArgs{...} } +type HelmReleaseSpecPostRenderersPatchArrayInput interface { + pulumi.Input + + ToHelmReleaseSpecPostRenderersPatchArrayOutput() HelmReleaseSpecPostRenderersPatchArrayOutput + ToHelmReleaseSpecPostRenderersPatchArrayOutputWithContext(context.Context) HelmReleaseSpecPostRenderersPatchArrayOutput +} + +type HelmReleaseSpecPostRenderersPatchArray []HelmReleaseSpecPostRenderersPatchInput + +func (HelmReleaseSpecPostRenderersPatchArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]HelmReleaseSpecPostRenderersPatch)(nil)).Elem() +} + +func (i HelmReleaseSpecPostRenderersPatchArray) ToHelmReleaseSpecPostRenderersPatchArrayOutput() HelmReleaseSpecPostRenderersPatchArrayOutput { + return i.ToHelmReleaseSpecPostRenderersPatchArrayOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecPostRenderersPatchArray) ToHelmReleaseSpecPostRenderersPatchArrayOutputWithContext(ctx context.Context) HelmReleaseSpecPostRenderersPatchArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecPostRenderersPatchArrayOutput) +} + +// PostRenderer contains a Helm PostRenderer specification. +type HelmReleaseSpecPostRenderersPatchOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecPostRenderersPatchOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecPostRenderersPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecPostRenderersPatchOutput) ToHelmReleaseSpecPostRenderersPatchOutput() HelmReleaseSpecPostRenderersPatchOutput { + return o +} + +func (o HelmReleaseSpecPostRenderersPatchOutput) ToHelmReleaseSpecPostRenderersPatchOutputWithContext(ctx context.Context) HelmReleaseSpecPostRenderersPatchOutput { + return o +} + +func (o HelmReleaseSpecPostRenderersPatchOutput) Kustomize() HelmReleaseSpecPostRenderersKustomizePatchPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecPostRenderersPatch) *HelmReleaseSpecPostRenderersKustomizePatch { + return v.Kustomize + }).(HelmReleaseSpecPostRenderersKustomizePatchPtrOutput) +} + +type HelmReleaseSpecPostRenderersPatchArrayOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecPostRenderersPatchArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]HelmReleaseSpecPostRenderersPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecPostRenderersPatchArrayOutput) ToHelmReleaseSpecPostRenderersPatchArrayOutput() HelmReleaseSpecPostRenderersPatchArrayOutput { + return o +} + +func (o HelmReleaseSpecPostRenderersPatchArrayOutput) ToHelmReleaseSpecPostRenderersPatchArrayOutputWithContext(ctx context.Context) HelmReleaseSpecPostRenderersPatchArrayOutput { + return o +} + +func (o HelmReleaseSpecPostRenderersPatchArrayOutput) Index(i pulumi.IntInput) HelmReleaseSpecPostRenderersPatchOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) HelmReleaseSpecPostRenderersPatch { + return vs[0].([]HelmReleaseSpecPostRenderersPatch)[vs[1].(int)] + }).(HelmReleaseSpecPostRenderersPatchOutput) +} + +// Rollback holds the configuration for Helm rollback actions for this HelmRelease. +type HelmReleaseSpecRollback struct { + // CleanupOnFail allows deletion of new resources created during the Helm + // rollback action when it fails. + CleanupOnFail *bool `pulumi:"cleanupOnFail"` + // DisableHooks prevents hooks from running during the Helm rollback action. + DisableHooks *bool `pulumi:"disableHooks"` + // DisableWait disables the waiting for resources to be ready after a Helm + // rollback has been performed. + DisableWait *bool `pulumi:"disableWait"` + // DisableWaitForJobs disables waiting for jobs to complete after a Helm + // rollback has been performed. + DisableWaitForJobs *bool `pulumi:"disableWaitForJobs"` + // Force forces resource updates through a replacement strategy + // that avoids 3-way merge conflicts on client-side apply. + // This field is ignored for server-side apply (which always + // forces conflicts with other field managers). + Force *bool `pulumi:"force"` + // Recreate performs pod restarts for any managed workloads. + // + // Deprecated: This behavior was deprecated in Helm 3: + // - Deprecation: https://github.com/helm/helm/pull/6463 + // - Removal: https://github.com/helm/helm/pull/31023 + // After helm-controller was upgraded to the Helm 4 SDK, + // this field is no longer functional and will print a + // warning if set to true. It will also be removed in a + // future release. + Recreate *bool `pulumi:"recreate"` + // ServerSideApply enables server-side apply for resources during rollback. + // Can be "enabled", "disabled", or "auto". + // When "auto", server-side apply usage will be based on the release's previous usage. + // Defaults to "auto". + ServerSideApply *string `pulumi:"serverSideApply"` + // Timeout is the time to wait for any individual Kubernetes operation (like + // Jobs for hooks) during the performance of a Helm rollback action. Defaults to + // 'HelmReleaseSpec.Timeout'. + Timeout *string `pulumi:"timeout"` +} + +// HelmReleaseSpecRollbackInput is an input type that accepts HelmReleaseSpecRollbackArgs and HelmReleaseSpecRollbackOutput values. +// You can construct a concrete instance of `HelmReleaseSpecRollbackInput` via: +// +// HelmReleaseSpecRollbackArgs{...} +type HelmReleaseSpecRollbackInput interface { + pulumi.Input + + ToHelmReleaseSpecRollbackOutput() HelmReleaseSpecRollbackOutput + ToHelmReleaseSpecRollbackOutputWithContext(context.Context) HelmReleaseSpecRollbackOutput +} + +// Rollback holds the configuration for Helm rollback actions for this HelmRelease. +type HelmReleaseSpecRollbackArgs struct { + // CleanupOnFail allows deletion of new resources created during the Helm + // rollback action when it fails. + CleanupOnFail pulumi.BoolPtrInput `pulumi:"cleanupOnFail"` + // DisableHooks prevents hooks from running during the Helm rollback action. + DisableHooks pulumi.BoolPtrInput `pulumi:"disableHooks"` + // DisableWait disables the waiting for resources to be ready after a Helm + // rollback has been performed. + DisableWait pulumi.BoolPtrInput `pulumi:"disableWait"` + // DisableWaitForJobs disables waiting for jobs to complete after a Helm + // rollback has been performed. + DisableWaitForJobs pulumi.BoolPtrInput `pulumi:"disableWaitForJobs"` + // Force forces resource updates through a replacement strategy + // that avoids 3-way merge conflicts on client-side apply. + // This field is ignored for server-side apply (which always + // forces conflicts with other field managers). + Force pulumi.BoolPtrInput `pulumi:"force"` + // Recreate performs pod restarts for any managed workloads. + // + // Deprecated: This behavior was deprecated in Helm 3: + // - Deprecation: https://github.com/helm/helm/pull/6463 + // - Removal: https://github.com/helm/helm/pull/31023 + // After helm-controller was upgraded to the Helm 4 SDK, + // this field is no longer functional and will print a + // warning if set to true. It will also be removed in a + // future release. + Recreate pulumi.BoolPtrInput `pulumi:"recreate"` + // ServerSideApply enables server-side apply for resources during rollback. + // Can be "enabled", "disabled", or "auto". + // When "auto", server-side apply usage will be based on the release's previous usage. + // Defaults to "auto". + ServerSideApply pulumi.StringPtrInput `pulumi:"serverSideApply"` + // Timeout is the time to wait for any individual Kubernetes operation (like + // Jobs for hooks) during the performance of a Helm rollback action. Defaults to + // 'HelmReleaseSpec.Timeout'. + Timeout pulumi.StringPtrInput `pulumi:"timeout"` +} + +func (HelmReleaseSpecRollbackArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecRollback)(nil)).Elem() +} + +func (i HelmReleaseSpecRollbackArgs) ToHelmReleaseSpecRollbackOutput() HelmReleaseSpecRollbackOutput { + return i.ToHelmReleaseSpecRollbackOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecRollbackArgs) ToHelmReleaseSpecRollbackOutputWithContext(ctx context.Context) HelmReleaseSpecRollbackOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecRollbackOutput) +} + +func (i HelmReleaseSpecRollbackArgs) ToHelmReleaseSpecRollbackPtrOutput() HelmReleaseSpecRollbackPtrOutput { + return i.ToHelmReleaseSpecRollbackPtrOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecRollbackArgs) ToHelmReleaseSpecRollbackPtrOutputWithContext(ctx context.Context) HelmReleaseSpecRollbackPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecRollbackOutput).ToHelmReleaseSpecRollbackPtrOutputWithContext(ctx) +} + +// HelmReleaseSpecRollbackPtrInput is an input type that accepts HelmReleaseSpecRollbackArgs, HelmReleaseSpecRollbackPtr and HelmReleaseSpecRollbackPtrOutput values. +// You can construct a concrete instance of `HelmReleaseSpecRollbackPtrInput` via: +// +// HelmReleaseSpecRollbackArgs{...} +// +// or: +// +// nil +type HelmReleaseSpecRollbackPtrInput interface { + pulumi.Input + + ToHelmReleaseSpecRollbackPtrOutput() HelmReleaseSpecRollbackPtrOutput + ToHelmReleaseSpecRollbackPtrOutputWithContext(context.Context) HelmReleaseSpecRollbackPtrOutput +} + +type helmReleaseSpecRollbackPtrType HelmReleaseSpecRollbackArgs + +func HelmReleaseSpecRollbackPtr(v *HelmReleaseSpecRollbackArgs) HelmReleaseSpecRollbackPtrInput { + return (*helmReleaseSpecRollbackPtrType)(v) +} + +func (*helmReleaseSpecRollbackPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecRollback)(nil)).Elem() +} + +func (i *helmReleaseSpecRollbackPtrType) ToHelmReleaseSpecRollbackPtrOutput() HelmReleaseSpecRollbackPtrOutput { + return i.ToHelmReleaseSpecRollbackPtrOutputWithContext(context.Background()) +} + +func (i *helmReleaseSpecRollbackPtrType) ToHelmReleaseSpecRollbackPtrOutputWithContext(ctx context.Context) HelmReleaseSpecRollbackPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecRollbackPtrOutput) +} + +// Rollback holds the configuration for Helm rollback actions for this HelmRelease. +type HelmReleaseSpecRollbackOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecRollbackOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecRollback)(nil)).Elem() +} + +func (o HelmReleaseSpecRollbackOutput) ToHelmReleaseSpecRollbackOutput() HelmReleaseSpecRollbackOutput { + return o +} + +func (o HelmReleaseSpecRollbackOutput) ToHelmReleaseSpecRollbackOutputWithContext(ctx context.Context) HelmReleaseSpecRollbackOutput { + return o +} + +func (o HelmReleaseSpecRollbackOutput) ToHelmReleaseSpecRollbackPtrOutput() HelmReleaseSpecRollbackPtrOutput { + return o.ToHelmReleaseSpecRollbackPtrOutputWithContext(context.Background()) +} + +func (o HelmReleaseSpecRollbackOutput) ToHelmReleaseSpecRollbackPtrOutputWithContext(ctx context.Context) HelmReleaseSpecRollbackPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v HelmReleaseSpecRollback) *HelmReleaseSpecRollback { + return &v + }).(HelmReleaseSpecRollbackPtrOutput) +} + +// CleanupOnFail allows deletion of new resources created during the Helm +// rollback action when it fails. +func (o HelmReleaseSpecRollbackOutput) CleanupOnFail() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecRollback) *bool { return v.CleanupOnFail }).(pulumi.BoolPtrOutput) +} + +// DisableHooks prevents hooks from running during the Helm rollback action. +func (o HelmReleaseSpecRollbackOutput) DisableHooks() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecRollback) *bool { return v.DisableHooks }).(pulumi.BoolPtrOutput) +} + +// DisableWait disables the waiting for resources to be ready after a Helm +// rollback has been performed. +func (o HelmReleaseSpecRollbackOutput) DisableWait() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecRollback) *bool { return v.DisableWait }).(pulumi.BoolPtrOutput) +} + +// DisableWaitForJobs disables waiting for jobs to complete after a Helm +// rollback has been performed. +func (o HelmReleaseSpecRollbackOutput) DisableWaitForJobs() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecRollback) *bool { return v.DisableWaitForJobs }).(pulumi.BoolPtrOutput) +} + +// Force forces resource updates through a replacement strategy +// that avoids 3-way merge conflicts on client-side apply. +// This field is ignored for server-side apply (which always +// forces conflicts with other field managers). +func (o HelmReleaseSpecRollbackOutput) Force() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecRollback) *bool { return v.Force }).(pulumi.BoolPtrOutput) +} + +// Recreate performs pod restarts for any managed workloads. +// +// Deprecated: This behavior was deprecated in Helm 3: +// - Deprecation: https://github.com/helm/helm/pull/6463 +// - Removal: https://github.com/helm/helm/pull/31023 +// After helm-controller was upgraded to the Helm 4 SDK, +// this field is no longer functional and will print a +// warning if set to true. It will also be removed in a +// future release. +func (o HelmReleaseSpecRollbackOutput) Recreate() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecRollback) *bool { return v.Recreate }).(pulumi.BoolPtrOutput) +} + +// ServerSideApply enables server-side apply for resources during rollback. +// Can be "enabled", "disabled", or "auto". +// When "auto", server-side apply usage will be based on the release's previous usage. +// Defaults to "auto". +func (o HelmReleaseSpecRollbackOutput) ServerSideApply() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecRollback) *string { return v.ServerSideApply }).(pulumi.StringPtrOutput) +} + +// Timeout is the time to wait for any individual Kubernetes operation (like +// Jobs for hooks) during the performance of a Helm rollback action. Defaults to +// 'HelmReleaseSpec.Timeout'. +func (o HelmReleaseSpecRollbackOutput) Timeout() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecRollback) *string { return v.Timeout }).(pulumi.StringPtrOutput) +} + +type HelmReleaseSpecRollbackPtrOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecRollbackPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecRollback)(nil)).Elem() +} + +func (o HelmReleaseSpecRollbackPtrOutput) ToHelmReleaseSpecRollbackPtrOutput() HelmReleaseSpecRollbackPtrOutput { + return o +} + +func (o HelmReleaseSpecRollbackPtrOutput) ToHelmReleaseSpecRollbackPtrOutputWithContext(ctx context.Context) HelmReleaseSpecRollbackPtrOutput { + return o +} + +func (o HelmReleaseSpecRollbackPtrOutput) Elem() HelmReleaseSpecRollbackOutput { + return o.ApplyT(func(v *HelmReleaseSpecRollback) HelmReleaseSpecRollback { + if v != nil { + return *v + } + var ret HelmReleaseSpecRollback + return ret + }).(HelmReleaseSpecRollbackOutput) +} + +// CleanupOnFail allows deletion of new resources created during the Helm +// rollback action when it fails. +func (o HelmReleaseSpecRollbackPtrOutput) CleanupOnFail() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecRollback) *bool { + if v == nil { + return nil + } + return v.CleanupOnFail + }).(pulumi.BoolPtrOutput) +} + +// DisableHooks prevents hooks from running during the Helm rollback action. +func (o HelmReleaseSpecRollbackPtrOutput) DisableHooks() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecRollback) *bool { + if v == nil { + return nil + } + return v.DisableHooks + }).(pulumi.BoolPtrOutput) +} + +// DisableWait disables the waiting for resources to be ready after a Helm +// rollback has been performed. +func (o HelmReleaseSpecRollbackPtrOutput) DisableWait() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecRollback) *bool { + if v == nil { + return nil + } + return v.DisableWait + }).(pulumi.BoolPtrOutput) +} + +// DisableWaitForJobs disables waiting for jobs to complete after a Helm +// rollback has been performed. +func (o HelmReleaseSpecRollbackPtrOutput) DisableWaitForJobs() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecRollback) *bool { + if v == nil { + return nil + } + return v.DisableWaitForJobs + }).(pulumi.BoolPtrOutput) +} + +// Force forces resource updates through a replacement strategy +// that avoids 3-way merge conflicts on client-side apply. +// This field is ignored for server-side apply (which always +// forces conflicts with other field managers). +func (o HelmReleaseSpecRollbackPtrOutput) Force() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecRollback) *bool { + if v == nil { + return nil + } + return v.Force + }).(pulumi.BoolPtrOutput) +} + +// Recreate performs pod restarts for any managed workloads. +// +// Deprecated: This behavior was deprecated in Helm 3: +// - Deprecation: https://github.com/helm/helm/pull/6463 +// - Removal: https://github.com/helm/helm/pull/31023 +// After helm-controller was upgraded to the Helm 4 SDK, +// this field is no longer functional and will print a +// warning if set to true. It will also be removed in a +// future release. +func (o HelmReleaseSpecRollbackPtrOutput) Recreate() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecRollback) *bool { + if v == nil { + return nil + } + return v.Recreate + }).(pulumi.BoolPtrOutput) +} + +// ServerSideApply enables server-side apply for resources during rollback. +// Can be "enabled", "disabled", or "auto". +// When "auto", server-side apply usage will be based on the release's previous usage. +// Defaults to "auto". +func (o HelmReleaseSpecRollbackPtrOutput) ServerSideApply() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecRollback) *string { + if v == nil { + return nil + } + return v.ServerSideApply + }).(pulumi.StringPtrOutput) +} + +// Timeout is the time to wait for any individual Kubernetes operation (like +// Jobs for hooks) during the performance of a Helm rollback action. Defaults to +// 'HelmReleaseSpec.Timeout'. +func (o HelmReleaseSpecRollbackPtrOutput) Timeout() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecRollback) *string { + if v == nil { + return nil + } + return v.Timeout + }).(pulumi.StringPtrOutput) +} + +// Rollback holds the configuration for Helm rollback actions for this HelmRelease. +type HelmReleaseSpecRollbackPatch struct { + // CleanupOnFail allows deletion of new resources created during the Helm + // rollback action when it fails. + CleanupOnFail *bool `pulumi:"cleanupOnFail"` + // DisableHooks prevents hooks from running during the Helm rollback action. + DisableHooks *bool `pulumi:"disableHooks"` + // DisableWait disables the waiting for resources to be ready after a Helm + // rollback has been performed. + DisableWait *bool `pulumi:"disableWait"` + // DisableWaitForJobs disables waiting for jobs to complete after a Helm + // rollback has been performed. + DisableWaitForJobs *bool `pulumi:"disableWaitForJobs"` + // Force forces resource updates through a replacement strategy + // that avoids 3-way merge conflicts on client-side apply. + // This field is ignored for server-side apply (which always + // forces conflicts with other field managers). + Force *bool `pulumi:"force"` + // Recreate performs pod restarts for any managed workloads. + // + // Deprecated: This behavior was deprecated in Helm 3: + // - Deprecation: https://github.com/helm/helm/pull/6463 + // - Removal: https://github.com/helm/helm/pull/31023 + // After helm-controller was upgraded to the Helm 4 SDK, + // this field is no longer functional and will print a + // warning if set to true. It will also be removed in a + // future release. + Recreate *bool `pulumi:"recreate"` + // ServerSideApply enables server-side apply for resources during rollback. + // Can be "enabled", "disabled", or "auto". + // When "auto", server-side apply usage will be based on the release's previous usage. + // Defaults to "auto". + ServerSideApply *string `pulumi:"serverSideApply"` + // Timeout is the time to wait for any individual Kubernetes operation (like + // Jobs for hooks) during the performance of a Helm rollback action. Defaults to + // 'HelmReleaseSpec.Timeout'. + Timeout *string `pulumi:"timeout"` +} + +// HelmReleaseSpecRollbackPatchInput is an input type that accepts HelmReleaseSpecRollbackPatchArgs and HelmReleaseSpecRollbackPatchOutput values. +// You can construct a concrete instance of `HelmReleaseSpecRollbackPatchInput` via: +// +// HelmReleaseSpecRollbackPatchArgs{...} +type HelmReleaseSpecRollbackPatchInput interface { + pulumi.Input + + ToHelmReleaseSpecRollbackPatchOutput() HelmReleaseSpecRollbackPatchOutput + ToHelmReleaseSpecRollbackPatchOutputWithContext(context.Context) HelmReleaseSpecRollbackPatchOutput +} + +// Rollback holds the configuration for Helm rollback actions for this HelmRelease. +type HelmReleaseSpecRollbackPatchArgs struct { + // CleanupOnFail allows deletion of new resources created during the Helm + // rollback action when it fails. + CleanupOnFail pulumi.BoolPtrInput `pulumi:"cleanupOnFail"` + // DisableHooks prevents hooks from running during the Helm rollback action. + DisableHooks pulumi.BoolPtrInput `pulumi:"disableHooks"` + // DisableWait disables the waiting for resources to be ready after a Helm + // rollback has been performed. + DisableWait pulumi.BoolPtrInput `pulumi:"disableWait"` + // DisableWaitForJobs disables waiting for jobs to complete after a Helm + // rollback has been performed. + DisableWaitForJobs pulumi.BoolPtrInput `pulumi:"disableWaitForJobs"` + // Force forces resource updates through a replacement strategy + // that avoids 3-way merge conflicts on client-side apply. + // This field is ignored for server-side apply (which always + // forces conflicts with other field managers). + Force pulumi.BoolPtrInput `pulumi:"force"` + // Recreate performs pod restarts for any managed workloads. + // + // Deprecated: This behavior was deprecated in Helm 3: + // - Deprecation: https://github.com/helm/helm/pull/6463 + // - Removal: https://github.com/helm/helm/pull/31023 + // After helm-controller was upgraded to the Helm 4 SDK, + // this field is no longer functional and will print a + // warning if set to true. It will also be removed in a + // future release. + Recreate pulumi.BoolPtrInput `pulumi:"recreate"` + // ServerSideApply enables server-side apply for resources during rollback. + // Can be "enabled", "disabled", or "auto". + // When "auto", server-side apply usage will be based on the release's previous usage. + // Defaults to "auto". + ServerSideApply pulumi.StringPtrInput `pulumi:"serverSideApply"` + // Timeout is the time to wait for any individual Kubernetes operation (like + // Jobs for hooks) during the performance of a Helm rollback action. Defaults to + // 'HelmReleaseSpec.Timeout'. + Timeout pulumi.StringPtrInput `pulumi:"timeout"` +} + +func (HelmReleaseSpecRollbackPatchArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecRollbackPatch)(nil)).Elem() +} + +func (i HelmReleaseSpecRollbackPatchArgs) ToHelmReleaseSpecRollbackPatchOutput() HelmReleaseSpecRollbackPatchOutput { + return i.ToHelmReleaseSpecRollbackPatchOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecRollbackPatchArgs) ToHelmReleaseSpecRollbackPatchOutputWithContext(ctx context.Context) HelmReleaseSpecRollbackPatchOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecRollbackPatchOutput) +} + +func (i HelmReleaseSpecRollbackPatchArgs) ToHelmReleaseSpecRollbackPatchPtrOutput() HelmReleaseSpecRollbackPatchPtrOutput { + return i.ToHelmReleaseSpecRollbackPatchPtrOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecRollbackPatchArgs) ToHelmReleaseSpecRollbackPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecRollbackPatchPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecRollbackPatchOutput).ToHelmReleaseSpecRollbackPatchPtrOutputWithContext(ctx) +} + +// HelmReleaseSpecRollbackPatchPtrInput is an input type that accepts HelmReleaseSpecRollbackPatchArgs, HelmReleaseSpecRollbackPatchPtr and HelmReleaseSpecRollbackPatchPtrOutput values. +// You can construct a concrete instance of `HelmReleaseSpecRollbackPatchPtrInput` via: +// +// HelmReleaseSpecRollbackPatchArgs{...} +// +// or: +// +// nil +type HelmReleaseSpecRollbackPatchPtrInput interface { + pulumi.Input + + ToHelmReleaseSpecRollbackPatchPtrOutput() HelmReleaseSpecRollbackPatchPtrOutput + ToHelmReleaseSpecRollbackPatchPtrOutputWithContext(context.Context) HelmReleaseSpecRollbackPatchPtrOutput +} + +type helmReleaseSpecRollbackPatchPtrType HelmReleaseSpecRollbackPatchArgs + +func HelmReleaseSpecRollbackPatchPtr(v *HelmReleaseSpecRollbackPatchArgs) HelmReleaseSpecRollbackPatchPtrInput { + return (*helmReleaseSpecRollbackPatchPtrType)(v) +} + +func (*helmReleaseSpecRollbackPatchPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecRollbackPatch)(nil)).Elem() +} + +func (i *helmReleaseSpecRollbackPatchPtrType) ToHelmReleaseSpecRollbackPatchPtrOutput() HelmReleaseSpecRollbackPatchPtrOutput { + return i.ToHelmReleaseSpecRollbackPatchPtrOutputWithContext(context.Background()) +} + +func (i *helmReleaseSpecRollbackPatchPtrType) ToHelmReleaseSpecRollbackPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecRollbackPatchPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecRollbackPatchPtrOutput) +} + +// Rollback holds the configuration for Helm rollback actions for this HelmRelease. +type HelmReleaseSpecRollbackPatchOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecRollbackPatchOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecRollbackPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecRollbackPatchOutput) ToHelmReleaseSpecRollbackPatchOutput() HelmReleaseSpecRollbackPatchOutput { + return o +} + +func (o HelmReleaseSpecRollbackPatchOutput) ToHelmReleaseSpecRollbackPatchOutputWithContext(ctx context.Context) HelmReleaseSpecRollbackPatchOutput { + return o +} + +func (o HelmReleaseSpecRollbackPatchOutput) ToHelmReleaseSpecRollbackPatchPtrOutput() HelmReleaseSpecRollbackPatchPtrOutput { + return o.ToHelmReleaseSpecRollbackPatchPtrOutputWithContext(context.Background()) +} + +func (o HelmReleaseSpecRollbackPatchOutput) ToHelmReleaseSpecRollbackPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecRollbackPatchPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v HelmReleaseSpecRollbackPatch) *HelmReleaseSpecRollbackPatch { + return &v + }).(HelmReleaseSpecRollbackPatchPtrOutput) +} + +// CleanupOnFail allows deletion of new resources created during the Helm +// rollback action when it fails. +func (o HelmReleaseSpecRollbackPatchOutput) CleanupOnFail() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecRollbackPatch) *bool { return v.CleanupOnFail }).(pulumi.BoolPtrOutput) +} + +// DisableHooks prevents hooks from running during the Helm rollback action. +func (o HelmReleaseSpecRollbackPatchOutput) DisableHooks() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecRollbackPatch) *bool { return v.DisableHooks }).(pulumi.BoolPtrOutput) +} + +// DisableWait disables the waiting for resources to be ready after a Helm +// rollback has been performed. +func (o HelmReleaseSpecRollbackPatchOutput) DisableWait() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecRollbackPatch) *bool { return v.DisableWait }).(pulumi.BoolPtrOutput) +} + +// DisableWaitForJobs disables waiting for jobs to complete after a Helm +// rollback has been performed. +func (o HelmReleaseSpecRollbackPatchOutput) DisableWaitForJobs() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecRollbackPatch) *bool { return v.DisableWaitForJobs }).(pulumi.BoolPtrOutput) +} + +// Force forces resource updates through a replacement strategy +// that avoids 3-way merge conflicts on client-side apply. +// This field is ignored for server-side apply (which always +// forces conflicts with other field managers). +func (o HelmReleaseSpecRollbackPatchOutput) Force() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecRollbackPatch) *bool { return v.Force }).(pulumi.BoolPtrOutput) +} + +// Recreate performs pod restarts for any managed workloads. +// +// Deprecated: This behavior was deprecated in Helm 3: +// - Deprecation: https://github.com/helm/helm/pull/6463 +// - Removal: https://github.com/helm/helm/pull/31023 +// After helm-controller was upgraded to the Helm 4 SDK, +// this field is no longer functional and will print a +// warning if set to true. It will also be removed in a +// future release. +func (o HelmReleaseSpecRollbackPatchOutput) Recreate() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecRollbackPatch) *bool { return v.Recreate }).(pulumi.BoolPtrOutput) +} + +// ServerSideApply enables server-side apply for resources during rollback. +// Can be "enabled", "disabled", or "auto". +// When "auto", server-side apply usage will be based on the release's previous usage. +// Defaults to "auto". +func (o HelmReleaseSpecRollbackPatchOutput) ServerSideApply() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecRollbackPatch) *string { return v.ServerSideApply }).(pulumi.StringPtrOutput) +} + +// Timeout is the time to wait for any individual Kubernetes operation (like +// Jobs for hooks) during the performance of a Helm rollback action. Defaults to +// 'HelmReleaseSpec.Timeout'. +func (o HelmReleaseSpecRollbackPatchOutput) Timeout() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecRollbackPatch) *string { return v.Timeout }).(pulumi.StringPtrOutput) +} + +type HelmReleaseSpecRollbackPatchPtrOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecRollbackPatchPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecRollbackPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecRollbackPatchPtrOutput) ToHelmReleaseSpecRollbackPatchPtrOutput() HelmReleaseSpecRollbackPatchPtrOutput { + return o +} + +func (o HelmReleaseSpecRollbackPatchPtrOutput) ToHelmReleaseSpecRollbackPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecRollbackPatchPtrOutput { + return o +} + +func (o HelmReleaseSpecRollbackPatchPtrOutput) Elem() HelmReleaseSpecRollbackPatchOutput { + return o.ApplyT(func(v *HelmReleaseSpecRollbackPatch) HelmReleaseSpecRollbackPatch { + if v != nil { + return *v + } + var ret HelmReleaseSpecRollbackPatch + return ret + }).(HelmReleaseSpecRollbackPatchOutput) +} + +// CleanupOnFail allows deletion of new resources created during the Helm +// rollback action when it fails. +func (o HelmReleaseSpecRollbackPatchPtrOutput) CleanupOnFail() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecRollbackPatch) *bool { + if v == nil { + return nil + } + return v.CleanupOnFail + }).(pulumi.BoolPtrOutput) +} + +// DisableHooks prevents hooks from running during the Helm rollback action. +func (o HelmReleaseSpecRollbackPatchPtrOutput) DisableHooks() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecRollbackPatch) *bool { + if v == nil { + return nil + } + return v.DisableHooks + }).(pulumi.BoolPtrOutput) +} + +// DisableWait disables the waiting for resources to be ready after a Helm +// rollback has been performed. +func (o HelmReleaseSpecRollbackPatchPtrOutput) DisableWait() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecRollbackPatch) *bool { + if v == nil { + return nil + } + return v.DisableWait + }).(pulumi.BoolPtrOutput) +} + +// DisableWaitForJobs disables waiting for jobs to complete after a Helm +// rollback has been performed. +func (o HelmReleaseSpecRollbackPatchPtrOutput) DisableWaitForJobs() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecRollbackPatch) *bool { + if v == nil { + return nil + } + return v.DisableWaitForJobs + }).(pulumi.BoolPtrOutput) +} + +// Force forces resource updates through a replacement strategy +// that avoids 3-way merge conflicts on client-side apply. +// This field is ignored for server-side apply (which always +// forces conflicts with other field managers). +func (o HelmReleaseSpecRollbackPatchPtrOutput) Force() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecRollbackPatch) *bool { + if v == nil { + return nil + } + return v.Force + }).(pulumi.BoolPtrOutput) +} + +// Recreate performs pod restarts for any managed workloads. +// +// Deprecated: This behavior was deprecated in Helm 3: +// - Deprecation: https://github.com/helm/helm/pull/6463 +// - Removal: https://github.com/helm/helm/pull/31023 +// After helm-controller was upgraded to the Helm 4 SDK, +// this field is no longer functional and will print a +// warning if set to true. It will also be removed in a +// future release. +func (o HelmReleaseSpecRollbackPatchPtrOutput) Recreate() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecRollbackPatch) *bool { + if v == nil { + return nil + } + return v.Recreate + }).(pulumi.BoolPtrOutput) +} + +// ServerSideApply enables server-side apply for resources during rollback. +// Can be "enabled", "disabled", or "auto". +// When "auto", server-side apply usage will be based on the release's previous usage. +// Defaults to "auto". +func (o HelmReleaseSpecRollbackPatchPtrOutput) ServerSideApply() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecRollbackPatch) *string { + if v == nil { + return nil + } + return v.ServerSideApply + }).(pulumi.StringPtrOutput) +} + +// Timeout is the time to wait for any individual Kubernetes operation (like +// Jobs for hooks) during the performance of a Helm rollback action. Defaults to +// 'HelmReleaseSpec.Timeout'. +func (o HelmReleaseSpecRollbackPatchPtrOutput) Timeout() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecRollbackPatch) *string { + if v == nil { + return nil + } + return v.Timeout + }).(pulumi.StringPtrOutput) +} + +// Test holds the configuration for Helm test actions for this HelmRelease. +type HelmReleaseSpecTest struct { + // Enable enables Helm test actions for this HelmRelease after an Helm install + // or upgrade action has been performed. + Enable *bool `pulumi:"enable"` + // Filters is a list of tests to run or exclude from running. + Filters []HelmReleaseSpecTestFilters `pulumi:"filters"` + // IgnoreFailures tells the controller to skip remediation when the Helm tests + // are run but fail. Can be overwritten for tests run after install or upgrade + // actions in 'Install.IgnoreTestFailures' and 'Upgrade.IgnoreTestFailures'. + IgnoreFailures *bool `pulumi:"ignoreFailures"` + // Timeout is the time to wait for any individual Kubernetes operation during + // the performance of a Helm test action. Defaults to 'HelmReleaseSpec.Timeout'. + Timeout *string `pulumi:"timeout"` +} + +// HelmReleaseSpecTestInput is an input type that accepts HelmReleaseSpecTestArgs and HelmReleaseSpecTestOutput values. +// You can construct a concrete instance of `HelmReleaseSpecTestInput` via: +// +// HelmReleaseSpecTestArgs{...} +type HelmReleaseSpecTestInput interface { + pulumi.Input + + ToHelmReleaseSpecTestOutput() HelmReleaseSpecTestOutput + ToHelmReleaseSpecTestOutputWithContext(context.Context) HelmReleaseSpecTestOutput +} + +// Test holds the configuration for Helm test actions for this HelmRelease. +type HelmReleaseSpecTestArgs struct { + // Enable enables Helm test actions for this HelmRelease after an Helm install + // or upgrade action has been performed. + Enable pulumi.BoolPtrInput `pulumi:"enable"` + // Filters is a list of tests to run or exclude from running. + Filters HelmReleaseSpecTestFiltersArrayInput `pulumi:"filters"` + // IgnoreFailures tells the controller to skip remediation when the Helm tests + // are run but fail. Can be overwritten for tests run after install or upgrade + // actions in 'Install.IgnoreTestFailures' and 'Upgrade.IgnoreTestFailures'. + IgnoreFailures pulumi.BoolPtrInput `pulumi:"ignoreFailures"` + // Timeout is the time to wait for any individual Kubernetes operation during + // the performance of a Helm test action. Defaults to 'HelmReleaseSpec.Timeout'. + Timeout pulumi.StringPtrInput `pulumi:"timeout"` +} + +func (HelmReleaseSpecTestArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecTest)(nil)).Elem() +} + +func (i HelmReleaseSpecTestArgs) ToHelmReleaseSpecTestOutput() HelmReleaseSpecTestOutput { + return i.ToHelmReleaseSpecTestOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecTestArgs) ToHelmReleaseSpecTestOutputWithContext(ctx context.Context) HelmReleaseSpecTestOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecTestOutput) +} + +func (i HelmReleaseSpecTestArgs) ToHelmReleaseSpecTestPtrOutput() HelmReleaseSpecTestPtrOutput { + return i.ToHelmReleaseSpecTestPtrOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecTestArgs) ToHelmReleaseSpecTestPtrOutputWithContext(ctx context.Context) HelmReleaseSpecTestPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecTestOutput).ToHelmReleaseSpecTestPtrOutputWithContext(ctx) +} + +// HelmReleaseSpecTestPtrInput is an input type that accepts HelmReleaseSpecTestArgs, HelmReleaseSpecTestPtr and HelmReleaseSpecTestPtrOutput values. +// You can construct a concrete instance of `HelmReleaseSpecTestPtrInput` via: +// +// HelmReleaseSpecTestArgs{...} +// +// or: +// +// nil +type HelmReleaseSpecTestPtrInput interface { + pulumi.Input + + ToHelmReleaseSpecTestPtrOutput() HelmReleaseSpecTestPtrOutput + ToHelmReleaseSpecTestPtrOutputWithContext(context.Context) HelmReleaseSpecTestPtrOutput +} + +type helmReleaseSpecTestPtrType HelmReleaseSpecTestArgs + +func HelmReleaseSpecTestPtr(v *HelmReleaseSpecTestArgs) HelmReleaseSpecTestPtrInput { + return (*helmReleaseSpecTestPtrType)(v) +} + +func (*helmReleaseSpecTestPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecTest)(nil)).Elem() +} + +func (i *helmReleaseSpecTestPtrType) ToHelmReleaseSpecTestPtrOutput() HelmReleaseSpecTestPtrOutput { + return i.ToHelmReleaseSpecTestPtrOutputWithContext(context.Background()) +} + +func (i *helmReleaseSpecTestPtrType) ToHelmReleaseSpecTestPtrOutputWithContext(ctx context.Context) HelmReleaseSpecTestPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecTestPtrOutput) +} + +// Test holds the configuration for Helm test actions for this HelmRelease. +type HelmReleaseSpecTestOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecTestOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecTest)(nil)).Elem() +} + +func (o HelmReleaseSpecTestOutput) ToHelmReleaseSpecTestOutput() HelmReleaseSpecTestOutput { + return o +} + +func (o HelmReleaseSpecTestOutput) ToHelmReleaseSpecTestOutputWithContext(ctx context.Context) HelmReleaseSpecTestOutput { + return o +} + +func (o HelmReleaseSpecTestOutput) ToHelmReleaseSpecTestPtrOutput() HelmReleaseSpecTestPtrOutput { + return o.ToHelmReleaseSpecTestPtrOutputWithContext(context.Background()) +} + +func (o HelmReleaseSpecTestOutput) ToHelmReleaseSpecTestPtrOutputWithContext(ctx context.Context) HelmReleaseSpecTestPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v HelmReleaseSpecTest) *HelmReleaseSpecTest { + return &v + }).(HelmReleaseSpecTestPtrOutput) +} + +// Enable enables Helm test actions for this HelmRelease after an Helm install +// or upgrade action has been performed. +func (o HelmReleaseSpecTestOutput) Enable() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecTest) *bool { return v.Enable }).(pulumi.BoolPtrOutput) +} + +// Filters is a list of tests to run or exclude from running. +func (o HelmReleaseSpecTestOutput) Filters() HelmReleaseSpecTestFiltersArrayOutput { + return o.ApplyT(func(v HelmReleaseSpecTest) []HelmReleaseSpecTestFilters { return v.Filters }).(HelmReleaseSpecTestFiltersArrayOutput) +} + +// IgnoreFailures tells the controller to skip remediation when the Helm tests +// are run but fail. Can be overwritten for tests run after install or upgrade +// actions in 'Install.IgnoreTestFailures' and 'Upgrade.IgnoreTestFailures'. +func (o HelmReleaseSpecTestOutput) IgnoreFailures() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecTest) *bool { return v.IgnoreFailures }).(pulumi.BoolPtrOutput) +} + +// Timeout is the time to wait for any individual Kubernetes operation during +// the performance of a Helm test action. Defaults to 'HelmReleaseSpec.Timeout'. +func (o HelmReleaseSpecTestOutput) Timeout() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecTest) *string { return v.Timeout }).(pulumi.StringPtrOutput) +} + +type HelmReleaseSpecTestPtrOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecTestPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecTest)(nil)).Elem() +} + +func (o HelmReleaseSpecTestPtrOutput) ToHelmReleaseSpecTestPtrOutput() HelmReleaseSpecTestPtrOutput { + return o +} + +func (o HelmReleaseSpecTestPtrOutput) ToHelmReleaseSpecTestPtrOutputWithContext(ctx context.Context) HelmReleaseSpecTestPtrOutput { + return o +} + +func (o HelmReleaseSpecTestPtrOutput) Elem() HelmReleaseSpecTestOutput { + return o.ApplyT(func(v *HelmReleaseSpecTest) HelmReleaseSpecTest { + if v != nil { + return *v + } + var ret HelmReleaseSpecTest + return ret + }).(HelmReleaseSpecTestOutput) +} + +// Enable enables Helm test actions for this HelmRelease after an Helm install +// or upgrade action has been performed. +func (o HelmReleaseSpecTestPtrOutput) Enable() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecTest) *bool { + if v == nil { + return nil + } + return v.Enable + }).(pulumi.BoolPtrOutput) +} + +// Filters is a list of tests to run or exclude from running. +func (o HelmReleaseSpecTestPtrOutput) Filters() HelmReleaseSpecTestFiltersArrayOutput { + return o.ApplyT(func(v *HelmReleaseSpecTest) []HelmReleaseSpecTestFilters { + if v == nil { + return nil + } + return v.Filters + }).(HelmReleaseSpecTestFiltersArrayOutput) +} + +// IgnoreFailures tells the controller to skip remediation when the Helm tests +// are run but fail. Can be overwritten for tests run after install or upgrade +// actions in 'Install.IgnoreTestFailures' and 'Upgrade.IgnoreTestFailures'. +func (o HelmReleaseSpecTestPtrOutput) IgnoreFailures() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecTest) *bool { + if v == nil { + return nil + } + return v.IgnoreFailures + }).(pulumi.BoolPtrOutput) +} + +// Timeout is the time to wait for any individual Kubernetes operation during +// the performance of a Helm test action. Defaults to 'HelmReleaseSpec.Timeout'. +func (o HelmReleaseSpecTestPtrOutput) Timeout() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecTest) *string { + if v == nil { + return nil + } + return v.Timeout + }).(pulumi.StringPtrOutput) +} + +// Filter holds the configuration for individual Helm test filters. +type HelmReleaseSpecTestFilters struct { + // Exclude specifies whether the named test should be excluded. + Exclude *bool `pulumi:"exclude"` + // Name is the name of the test. + Name *string `pulumi:"name"` +} + +// HelmReleaseSpecTestFiltersInput is an input type that accepts HelmReleaseSpecTestFiltersArgs and HelmReleaseSpecTestFiltersOutput values. +// You can construct a concrete instance of `HelmReleaseSpecTestFiltersInput` via: +// +// HelmReleaseSpecTestFiltersArgs{...} +type HelmReleaseSpecTestFiltersInput interface { + pulumi.Input + + ToHelmReleaseSpecTestFiltersOutput() HelmReleaseSpecTestFiltersOutput + ToHelmReleaseSpecTestFiltersOutputWithContext(context.Context) HelmReleaseSpecTestFiltersOutput +} + +// Filter holds the configuration for individual Helm test filters. +type HelmReleaseSpecTestFiltersArgs struct { + // Exclude specifies whether the named test should be excluded. + Exclude pulumi.BoolPtrInput `pulumi:"exclude"` + // Name is the name of the test. + Name pulumi.StringPtrInput `pulumi:"name"` +} + +func (HelmReleaseSpecTestFiltersArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecTestFilters)(nil)).Elem() +} + +func (i HelmReleaseSpecTestFiltersArgs) ToHelmReleaseSpecTestFiltersOutput() HelmReleaseSpecTestFiltersOutput { + return i.ToHelmReleaseSpecTestFiltersOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecTestFiltersArgs) ToHelmReleaseSpecTestFiltersOutputWithContext(ctx context.Context) HelmReleaseSpecTestFiltersOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecTestFiltersOutput) +} + +// HelmReleaseSpecTestFiltersArrayInput is an input type that accepts HelmReleaseSpecTestFiltersArray and HelmReleaseSpecTestFiltersArrayOutput values. +// You can construct a concrete instance of `HelmReleaseSpecTestFiltersArrayInput` via: +// +// HelmReleaseSpecTestFiltersArray{ HelmReleaseSpecTestFiltersArgs{...} } +type HelmReleaseSpecTestFiltersArrayInput interface { + pulumi.Input + + ToHelmReleaseSpecTestFiltersArrayOutput() HelmReleaseSpecTestFiltersArrayOutput + ToHelmReleaseSpecTestFiltersArrayOutputWithContext(context.Context) HelmReleaseSpecTestFiltersArrayOutput +} + +type HelmReleaseSpecTestFiltersArray []HelmReleaseSpecTestFiltersInput + +func (HelmReleaseSpecTestFiltersArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]HelmReleaseSpecTestFilters)(nil)).Elem() +} + +func (i HelmReleaseSpecTestFiltersArray) ToHelmReleaseSpecTestFiltersArrayOutput() HelmReleaseSpecTestFiltersArrayOutput { + return i.ToHelmReleaseSpecTestFiltersArrayOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecTestFiltersArray) ToHelmReleaseSpecTestFiltersArrayOutputWithContext(ctx context.Context) HelmReleaseSpecTestFiltersArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecTestFiltersArrayOutput) +} + +// Filter holds the configuration for individual Helm test filters. +type HelmReleaseSpecTestFiltersOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecTestFiltersOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecTestFilters)(nil)).Elem() +} + +func (o HelmReleaseSpecTestFiltersOutput) ToHelmReleaseSpecTestFiltersOutput() HelmReleaseSpecTestFiltersOutput { + return o +} + +func (o HelmReleaseSpecTestFiltersOutput) ToHelmReleaseSpecTestFiltersOutputWithContext(ctx context.Context) HelmReleaseSpecTestFiltersOutput { + return o +} + +// Exclude specifies whether the named test should be excluded. +func (o HelmReleaseSpecTestFiltersOutput) Exclude() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecTestFilters) *bool { return v.Exclude }).(pulumi.BoolPtrOutput) +} + +// Name is the name of the test. +func (o HelmReleaseSpecTestFiltersOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecTestFilters) *string { return v.Name }).(pulumi.StringPtrOutput) +} + +type HelmReleaseSpecTestFiltersArrayOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecTestFiltersArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]HelmReleaseSpecTestFilters)(nil)).Elem() +} + +func (o HelmReleaseSpecTestFiltersArrayOutput) ToHelmReleaseSpecTestFiltersArrayOutput() HelmReleaseSpecTestFiltersArrayOutput { + return o +} + +func (o HelmReleaseSpecTestFiltersArrayOutput) ToHelmReleaseSpecTestFiltersArrayOutputWithContext(ctx context.Context) HelmReleaseSpecTestFiltersArrayOutput { + return o +} + +func (o HelmReleaseSpecTestFiltersArrayOutput) Index(i pulumi.IntInput) HelmReleaseSpecTestFiltersOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) HelmReleaseSpecTestFilters { + return vs[0].([]HelmReleaseSpecTestFilters)[vs[1].(int)] + }).(HelmReleaseSpecTestFiltersOutput) +} + +// Filter holds the configuration for individual Helm test filters. +type HelmReleaseSpecTestFiltersPatch struct { + // Exclude specifies whether the named test should be excluded. + Exclude *bool `pulumi:"exclude"` + // Name is the name of the test. + Name *string `pulumi:"name"` +} + +// HelmReleaseSpecTestFiltersPatchInput is an input type that accepts HelmReleaseSpecTestFiltersPatchArgs and HelmReleaseSpecTestFiltersPatchOutput values. +// You can construct a concrete instance of `HelmReleaseSpecTestFiltersPatchInput` via: +// +// HelmReleaseSpecTestFiltersPatchArgs{...} +type HelmReleaseSpecTestFiltersPatchInput interface { + pulumi.Input + + ToHelmReleaseSpecTestFiltersPatchOutput() HelmReleaseSpecTestFiltersPatchOutput + ToHelmReleaseSpecTestFiltersPatchOutputWithContext(context.Context) HelmReleaseSpecTestFiltersPatchOutput +} + +// Filter holds the configuration for individual Helm test filters. +type HelmReleaseSpecTestFiltersPatchArgs struct { + // Exclude specifies whether the named test should be excluded. + Exclude pulumi.BoolPtrInput `pulumi:"exclude"` + // Name is the name of the test. + Name pulumi.StringPtrInput `pulumi:"name"` +} + +func (HelmReleaseSpecTestFiltersPatchArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecTestFiltersPatch)(nil)).Elem() +} + +func (i HelmReleaseSpecTestFiltersPatchArgs) ToHelmReleaseSpecTestFiltersPatchOutput() HelmReleaseSpecTestFiltersPatchOutput { + return i.ToHelmReleaseSpecTestFiltersPatchOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecTestFiltersPatchArgs) ToHelmReleaseSpecTestFiltersPatchOutputWithContext(ctx context.Context) HelmReleaseSpecTestFiltersPatchOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecTestFiltersPatchOutput) +} + +// HelmReleaseSpecTestFiltersPatchArrayInput is an input type that accepts HelmReleaseSpecTestFiltersPatchArray and HelmReleaseSpecTestFiltersPatchArrayOutput values. +// You can construct a concrete instance of `HelmReleaseSpecTestFiltersPatchArrayInput` via: +// +// HelmReleaseSpecTestFiltersPatchArray{ HelmReleaseSpecTestFiltersPatchArgs{...} } +type HelmReleaseSpecTestFiltersPatchArrayInput interface { + pulumi.Input + + ToHelmReleaseSpecTestFiltersPatchArrayOutput() HelmReleaseSpecTestFiltersPatchArrayOutput + ToHelmReleaseSpecTestFiltersPatchArrayOutputWithContext(context.Context) HelmReleaseSpecTestFiltersPatchArrayOutput +} + +type HelmReleaseSpecTestFiltersPatchArray []HelmReleaseSpecTestFiltersPatchInput + +func (HelmReleaseSpecTestFiltersPatchArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]HelmReleaseSpecTestFiltersPatch)(nil)).Elem() +} + +func (i HelmReleaseSpecTestFiltersPatchArray) ToHelmReleaseSpecTestFiltersPatchArrayOutput() HelmReleaseSpecTestFiltersPatchArrayOutput { + return i.ToHelmReleaseSpecTestFiltersPatchArrayOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecTestFiltersPatchArray) ToHelmReleaseSpecTestFiltersPatchArrayOutputWithContext(ctx context.Context) HelmReleaseSpecTestFiltersPatchArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecTestFiltersPatchArrayOutput) +} + +// Filter holds the configuration for individual Helm test filters. +type HelmReleaseSpecTestFiltersPatchOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecTestFiltersPatchOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecTestFiltersPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecTestFiltersPatchOutput) ToHelmReleaseSpecTestFiltersPatchOutput() HelmReleaseSpecTestFiltersPatchOutput { + return o +} + +func (o HelmReleaseSpecTestFiltersPatchOutput) ToHelmReleaseSpecTestFiltersPatchOutputWithContext(ctx context.Context) HelmReleaseSpecTestFiltersPatchOutput { + return o +} + +// Exclude specifies whether the named test should be excluded. +func (o HelmReleaseSpecTestFiltersPatchOutput) Exclude() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecTestFiltersPatch) *bool { return v.Exclude }).(pulumi.BoolPtrOutput) +} + +// Name is the name of the test. +func (o HelmReleaseSpecTestFiltersPatchOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecTestFiltersPatch) *string { return v.Name }).(pulumi.StringPtrOutput) +} + +type HelmReleaseSpecTestFiltersPatchArrayOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecTestFiltersPatchArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]HelmReleaseSpecTestFiltersPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecTestFiltersPatchArrayOutput) ToHelmReleaseSpecTestFiltersPatchArrayOutput() HelmReleaseSpecTestFiltersPatchArrayOutput { + return o +} + +func (o HelmReleaseSpecTestFiltersPatchArrayOutput) ToHelmReleaseSpecTestFiltersPatchArrayOutputWithContext(ctx context.Context) HelmReleaseSpecTestFiltersPatchArrayOutput { + return o +} + +func (o HelmReleaseSpecTestFiltersPatchArrayOutput) Index(i pulumi.IntInput) HelmReleaseSpecTestFiltersPatchOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) HelmReleaseSpecTestFiltersPatch { + return vs[0].([]HelmReleaseSpecTestFiltersPatch)[vs[1].(int)] + }).(HelmReleaseSpecTestFiltersPatchOutput) +} + +// Test holds the configuration for Helm test actions for this HelmRelease. +type HelmReleaseSpecTestPatch struct { + // Enable enables Helm test actions for this HelmRelease after an Helm install + // or upgrade action has been performed. + Enable *bool `pulumi:"enable"` + // Filters is a list of tests to run or exclude from running. + Filters []HelmReleaseSpecTestFiltersPatch `pulumi:"filters"` + // IgnoreFailures tells the controller to skip remediation when the Helm tests + // are run but fail. Can be overwritten for tests run after install or upgrade + // actions in 'Install.IgnoreTestFailures' and 'Upgrade.IgnoreTestFailures'. + IgnoreFailures *bool `pulumi:"ignoreFailures"` + // Timeout is the time to wait for any individual Kubernetes operation during + // the performance of a Helm test action. Defaults to 'HelmReleaseSpec.Timeout'. + Timeout *string `pulumi:"timeout"` +} + +// HelmReleaseSpecTestPatchInput is an input type that accepts HelmReleaseSpecTestPatchArgs and HelmReleaseSpecTestPatchOutput values. +// You can construct a concrete instance of `HelmReleaseSpecTestPatchInput` via: +// +// HelmReleaseSpecTestPatchArgs{...} +type HelmReleaseSpecTestPatchInput interface { + pulumi.Input + + ToHelmReleaseSpecTestPatchOutput() HelmReleaseSpecTestPatchOutput + ToHelmReleaseSpecTestPatchOutputWithContext(context.Context) HelmReleaseSpecTestPatchOutput +} + +// Test holds the configuration for Helm test actions for this HelmRelease. +type HelmReleaseSpecTestPatchArgs struct { + // Enable enables Helm test actions for this HelmRelease after an Helm install + // or upgrade action has been performed. + Enable pulumi.BoolPtrInput `pulumi:"enable"` + // Filters is a list of tests to run or exclude from running. + Filters HelmReleaseSpecTestFiltersPatchArrayInput `pulumi:"filters"` + // IgnoreFailures tells the controller to skip remediation when the Helm tests + // are run but fail. Can be overwritten for tests run after install or upgrade + // actions in 'Install.IgnoreTestFailures' and 'Upgrade.IgnoreTestFailures'. + IgnoreFailures pulumi.BoolPtrInput `pulumi:"ignoreFailures"` + // Timeout is the time to wait for any individual Kubernetes operation during + // the performance of a Helm test action. Defaults to 'HelmReleaseSpec.Timeout'. + Timeout pulumi.StringPtrInput `pulumi:"timeout"` +} + +func (HelmReleaseSpecTestPatchArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecTestPatch)(nil)).Elem() +} + +func (i HelmReleaseSpecTestPatchArgs) ToHelmReleaseSpecTestPatchOutput() HelmReleaseSpecTestPatchOutput { + return i.ToHelmReleaseSpecTestPatchOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecTestPatchArgs) ToHelmReleaseSpecTestPatchOutputWithContext(ctx context.Context) HelmReleaseSpecTestPatchOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecTestPatchOutput) +} + +func (i HelmReleaseSpecTestPatchArgs) ToHelmReleaseSpecTestPatchPtrOutput() HelmReleaseSpecTestPatchPtrOutput { + return i.ToHelmReleaseSpecTestPatchPtrOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecTestPatchArgs) ToHelmReleaseSpecTestPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecTestPatchPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecTestPatchOutput).ToHelmReleaseSpecTestPatchPtrOutputWithContext(ctx) +} + +// HelmReleaseSpecTestPatchPtrInput is an input type that accepts HelmReleaseSpecTestPatchArgs, HelmReleaseSpecTestPatchPtr and HelmReleaseSpecTestPatchPtrOutput values. +// You can construct a concrete instance of `HelmReleaseSpecTestPatchPtrInput` via: +// +// HelmReleaseSpecTestPatchArgs{...} +// +// or: +// +// nil +type HelmReleaseSpecTestPatchPtrInput interface { + pulumi.Input + + ToHelmReleaseSpecTestPatchPtrOutput() HelmReleaseSpecTestPatchPtrOutput + ToHelmReleaseSpecTestPatchPtrOutputWithContext(context.Context) HelmReleaseSpecTestPatchPtrOutput +} + +type helmReleaseSpecTestPatchPtrType HelmReleaseSpecTestPatchArgs + +func HelmReleaseSpecTestPatchPtr(v *HelmReleaseSpecTestPatchArgs) HelmReleaseSpecTestPatchPtrInput { + return (*helmReleaseSpecTestPatchPtrType)(v) +} + +func (*helmReleaseSpecTestPatchPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecTestPatch)(nil)).Elem() +} + +func (i *helmReleaseSpecTestPatchPtrType) ToHelmReleaseSpecTestPatchPtrOutput() HelmReleaseSpecTestPatchPtrOutput { + return i.ToHelmReleaseSpecTestPatchPtrOutputWithContext(context.Background()) +} + +func (i *helmReleaseSpecTestPatchPtrType) ToHelmReleaseSpecTestPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecTestPatchPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecTestPatchPtrOutput) +} + +// Test holds the configuration for Helm test actions for this HelmRelease. +type HelmReleaseSpecTestPatchOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecTestPatchOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecTestPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecTestPatchOutput) ToHelmReleaseSpecTestPatchOutput() HelmReleaseSpecTestPatchOutput { + return o +} + +func (o HelmReleaseSpecTestPatchOutput) ToHelmReleaseSpecTestPatchOutputWithContext(ctx context.Context) HelmReleaseSpecTestPatchOutput { + return o +} + +func (o HelmReleaseSpecTestPatchOutput) ToHelmReleaseSpecTestPatchPtrOutput() HelmReleaseSpecTestPatchPtrOutput { + return o.ToHelmReleaseSpecTestPatchPtrOutputWithContext(context.Background()) +} + +func (o HelmReleaseSpecTestPatchOutput) ToHelmReleaseSpecTestPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecTestPatchPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v HelmReleaseSpecTestPatch) *HelmReleaseSpecTestPatch { + return &v + }).(HelmReleaseSpecTestPatchPtrOutput) +} + +// Enable enables Helm test actions for this HelmRelease after an Helm install +// or upgrade action has been performed. +func (o HelmReleaseSpecTestPatchOutput) Enable() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecTestPatch) *bool { return v.Enable }).(pulumi.BoolPtrOutput) +} + +// Filters is a list of tests to run or exclude from running. +func (o HelmReleaseSpecTestPatchOutput) Filters() HelmReleaseSpecTestFiltersPatchArrayOutput { + return o.ApplyT(func(v HelmReleaseSpecTestPatch) []HelmReleaseSpecTestFiltersPatch { return v.Filters }).(HelmReleaseSpecTestFiltersPatchArrayOutput) +} + +// IgnoreFailures tells the controller to skip remediation when the Helm tests +// are run but fail. Can be overwritten for tests run after install or upgrade +// actions in 'Install.IgnoreTestFailures' and 'Upgrade.IgnoreTestFailures'. +func (o HelmReleaseSpecTestPatchOutput) IgnoreFailures() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecTestPatch) *bool { return v.IgnoreFailures }).(pulumi.BoolPtrOutput) +} + +// Timeout is the time to wait for any individual Kubernetes operation during +// the performance of a Helm test action. Defaults to 'HelmReleaseSpec.Timeout'. +func (o HelmReleaseSpecTestPatchOutput) Timeout() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecTestPatch) *string { return v.Timeout }).(pulumi.StringPtrOutput) +} + +type HelmReleaseSpecTestPatchPtrOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecTestPatchPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecTestPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecTestPatchPtrOutput) ToHelmReleaseSpecTestPatchPtrOutput() HelmReleaseSpecTestPatchPtrOutput { + return o +} + +func (o HelmReleaseSpecTestPatchPtrOutput) ToHelmReleaseSpecTestPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecTestPatchPtrOutput { + return o +} + +func (o HelmReleaseSpecTestPatchPtrOutput) Elem() HelmReleaseSpecTestPatchOutput { + return o.ApplyT(func(v *HelmReleaseSpecTestPatch) HelmReleaseSpecTestPatch { + if v != nil { + return *v + } + var ret HelmReleaseSpecTestPatch + return ret + }).(HelmReleaseSpecTestPatchOutput) +} + +// Enable enables Helm test actions for this HelmRelease after an Helm install +// or upgrade action has been performed. +func (o HelmReleaseSpecTestPatchPtrOutput) Enable() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecTestPatch) *bool { + if v == nil { + return nil + } + return v.Enable + }).(pulumi.BoolPtrOutput) +} + +// Filters is a list of tests to run or exclude from running. +func (o HelmReleaseSpecTestPatchPtrOutput) Filters() HelmReleaseSpecTestFiltersPatchArrayOutput { + return o.ApplyT(func(v *HelmReleaseSpecTestPatch) []HelmReleaseSpecTestFiltersPatch { + if v == nil { + return nil + } + return v.Filters + }).(HelmReleaseSpecTestFiltersPatchArrayOutput) +} + +// IgnoreFailures tells the controller to skip remediation when the Helm tests +// are run but fail. Can be overwritten for tests run after install or upgrade +// actions in 'Install.IgnoreTestFailures' and 'Upgrade.IgnoreTestFailures'. +func (o HelmReleaseSpecTestPatchPtrOutput) IgnoreFailures() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecTestPatch) *bool { + if v == nil { + return nil + } + return v.IgnoreFailures + }).(pulumi.BoolPtrOutput) +} + +// Timeout is the time to wait for any individual Kubernetes operation during +// the performance of a Helm test action. Defaults to 'HelmReleaseSpec.Timeout'. +func (o HelmReleaseSpecTestPatchPtrOutput) Timeout() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecTestPatch) *string { + if v == nil { + return nil + } + return v.Timeout + }).(pulumi.StringPtrOutput) +} + +// Uninstall holds the configuration for Helm uninstall actions for this HelmRelease. +type HelmReleaseSpecUninstall struct { + // DeletionPropagation specifies the deletion propagation policy when + // a Helm uninstall is performed. + DeletionPropagation *string `pulumi:"deletionPropagation"` + // DisableHooks prevents hooks from running during the Helm rollback action. + DisableHooks *bool `pulumi:"disableHooks"` + // DisableWait disables waiting for all the resources to be deleted after + // a Helm uninstall is performed. + DisableWait *bool `pulumi:"disableWait"` + // KeepHistory tells Helm to remove all associated resources and mark the + // release as deleted, but retain the release history. + KeepHistory *bool `pulumi:"keepHistory"` + // Timeout is the time to wait for any individual Kubernetes operation (like + // Jobs for hooks) during the performance of a Helm uninstall action. Defaults + // to 'HelmReleaseSpec.Timeout'. + Timeout *string `pulumi:"timeout"` +} + +// HelmReleaseSpecUninstallInput is an input type that accepts HelmReleaseSpecUninstallArgs and HelmReleaseSpecUninstallOutput values. +// You can construct a concrete instance of `HelmReleaseSpecUninstallInput` via: +// +// HelmReleaseSpecUninstallArgs{...} +type HelmReleaseSpecUninstallInput interface { + pulumi.Input + + ToHelmReleaseSpecUninstallOutput() HelmReleaseSpecUninstallOutput + ToHelmReleaseSpecUninstallOutputWithContext(context.Context) HelmReleaseSpecUninstallOutput +} + +// Uninstall holds the configuration for Helm uninstall actions for this HelmRelease. +type HelmReleaseSpecUninstallArgs struct { + // DeletionPropagation specifies the deletion propagation policy when + // a Helm uninstall is performed. + DeletionPropagation pulumi.StringPtrInput `pulumi:"deletionPropagation"` + // DisableHooks prevents hooks from running during the Helm rollback action. + DisableHooks pulumi.BoolPtrInput `pulumi:"disableHooks"` + // DisableWait disables waiting for all the resources to be deleted after + // a Helm uninstall is performed. + DisableWait pulumi.BoolPtrInput `pulumi:"disableWait"` + // KeepHistory tells Helm to remove all associated resources and mark the + // release as deleted, but retain the release history. + KeepHistory pulumi.BoolPtrInput `pulumi:"keepHistory"` + // Timeout is the time to wait for any individual Kubernetes operation (like + // Jobs for hooks) during the performance of a Helm uninstall action. Defaults + // to 'HelmReleaseSpec.Timeout'. + Timeout pulumi.StringPtrInput `pulumi:"timeout"` +} + +func (HelmReleaseSpecUninstallArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecUninstall)(nil)).Elem() +} + +func (i HelmReleaseSpecUninstallArgs) ToHelmReleaseSpecUninstallOutput() HelmReleaseSpecUninstallOutput { + return i.ToHelmReleaseSpecUninstallOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecUninstallArgs) ToHelmReleaseSpecUninstallOutputWithContext(ctx context.Context) HelmReleaseSpecUninstallOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecUninstallOutput) +} + +func (i HelmReleaseSpecUninstallArgs) ToHelmReleaseSpecUninstallPtrOutput() HelmReleaseSpecUninstallPtrOutput { + return i.ToHelmReleaseSpecUninstallPtrOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecUninstallArgs) ToHelmReleaseSpecUninstallPtrOutputWithContext(ctx context.Context) HelmReleaseSpecUninstallPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecUninstallOutput).ToHelmReleaseSpecUninstallPtrOutputWithContext(ctx) +} + +// HelmReleaseSpecUninstallPtrInput is an input type that accepts HelmReleaseSpecUninstallArgs, HelmReleaseSpecUninstallPtr and HelmReleaseSpecUninstallPtrOutput values. +// You can construct a concrete instance of `HelmReleaseSpecUninstallPtrInput` via: +// +// HelmReleaseSpecUninstallArgs{...} +// +// or: +// +// nil +type HelmReleaseSpecUninstallPtrInput interface { + pulumi.Input + + ToHelmReleaseSpecUninstallPtrOutput() HelmReleaseSpecUninstallPtrOutput + ToHelmReleaseSpecUninstallPtrOutputWithContext(context.Context) HelmReleaseSpecUninstallPtrOutput +} + +type helmReleaseSpecUninstallPtrType HelmReleaseSpecUninstallArgs + +func HelmReleaseSpecUninstallPtr(v *HelmReleaseSpecUninstallArgs) HelmReleaseSpecUninstallPtrInput { + return (*helmReleaseSpecUninstallPtrType)(v) +} + +func (*helmReleaseSpecUninstallPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecUninstall)(nil)).Elem() +} + +func (i *helmReleaseSpecUninstallPtrType) ToHelmReleaseSpecUninstallPtrOutput() HelmReleaseSpecUninstallPtrOutput { + return i.ToHelmReleaseSpecUninstallPtrOutputWithContext(context.Background()) +} + +func (i *helmReleaseSpecUninstallPtrType) ToHelmReleaseSpecUninstallPtrOutputWithContext(ctx context.Context) HelmReleaseSpecUninstallPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecUninstallPtrOutput) +} + +// Uninstall holds the configuration for Helm uninstall actions for this HelmRelease. +type HelmReleaseSpecUninstallOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecUninstallOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecUninstall)(nil)).Elem() +} + +func (o HelmReleaseSpecUninstallOutput) ToHelmReleaseSpecUninstallOutput() HelmReleaseSpecUninstallOutput { + return o +} + +func (o HelmReleaseSpecUninstallOutput) ToHelmReleaseSpecUninstallOutputWithContext(ctx context.Context) HelmReleaseSpecUninstallOutput { + return o +} + +func (o HelmReleaseSpecUninstallOutput) ToHelmReleaseSpecUninstallPtrOutput() HelmReleaseSpecUninstallPtrOutput { + return o.ToHelmReleaseSpecUninstallPtrOutputWithContext(context.Background()) +} + +func (o HelmReleaseSpecUninstallOutput) ToHelmReleaseSpecUninstallPtrOutputWithContext(ctx context.Context) HelmReleaseSpecUninstallPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v HelmReleaseSpecUninstall) *HelmReleaseSpecUninstall { + return &v + }).(HelmReleaseSpecUninstallPtrOutput) +} + +// DeletionPropagation specifies the deletion propagation policy when +// a Helm uninstall is performed. +func (o HelmReleaseSpecUninstallOutput) DeletionPropagation() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecUninstall) *string { return v.DeletionPropagation }).(pulumi.StringPtrOutput) +} + +// DisableHooks prevents hooks from running during the Helm rollback action. +func (o HelmReleaseSpecUninstallOutput) DisableHooks() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecUninstall) *bool { return v.DisableHooks }).(pulumi.BoolPtrOutput) +} + +// DisableWait disables waiting for all the resources to be deleted after +// a Helm uninstall is performed. +func (o HelmReleaseSpecUninstallOutput) DisableWait() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecUninstall) *bool { return v.DisableWait }).(pulumi.BoolPtrOutput) +} + +// KeepHistory tells Helm to remove all associated resources and mark the +// release as deleted, but retain the release history. +func (o HelmReleaseSpecUninstallOutput) KeepHistory() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecUninstall) *bool { return v.KeepHistory }).(pulumi.BoolPtrOutput) +} + +// Timeout is the time to wait for any individual Kubernetes operation (like +// Jobs for hooks) during the performance of a Helm uninstall action. Defaults +// to 'HelmReleaseSpec.Timeout'. +func (o HelmReleaseSpecUninstallOutput) Timeout() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecUninstall) *string { return v.Timeout }).(pulumi.StringPtrOutput) +} + +type HelmReleaseSpecUninstallPtrOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecUninstallPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecUninstall)(nil)).Elem() +} + +func (o HelmReleaseSpecUninstallPtrOutput) ToHelmReleaseSpecUninstallPtrOutput() HelmReleaseSpecUninstallPtrOutput { + return o +} + +func (o HelmReleaseSpecUninstallPtrOutput) ToHelmReleaseSpecUninstallPtrOutputWithContext(ctx context.Context) HelmReleaseSpecUninstallPtrOutput { + return o +} + +func (o HelmReleaseSpecUninstallPtrOutput) Elem() HelmReleaseSpecUninstallOutput { + return o.ApplyT(func(v *HelmReleaseSpecUninstall) HelmReleaseSpecUninstall { + if v != nil { + return *v + } + var ret HelmReleaseSpecUninstall + return ret + }).(HelmReleaseSpecUninstallOutput) +} + +// DeletionPropagation specifies the deletion propagation policy when +// a Helm uninstall is performed. +func (o HelmReleaseSpecUninstallPtrOutput) DeletionPropagation() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecUninstall) *string { + if v == nil { + return nil + } + return v.DeletionPropagation + }).(pulumi.StringPtrOutput) +} + +// DisableHooks prevents hooks from running during the Helm rollback action. +func (o HelmReleaseSpecUninstallPtrOutput) DisableHooks() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecUninstall) *bool { + if v == nil { + return nil + } + return v.DisableHooks + }).(pulumi.BoolPtrOutput) +} + +// DisableWait disables waiting for all the resources to be deleted after +// a Helm uninstall is performed. +func (o HelmReleaseSpecUninstallPtrOutput) DisableWait() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecUninstall) *bool { + if v == nil { + return nil + } + return v.DisableWait + }).(pulumi.BoolPtrOutput) +} + +// KeepHistory tells Helm to remove all associated resources and mark the +// release as deleted, but retain the release history. +func (o HelmReleaseSpecUninstallPtrOutput) KeepHistory() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecUninstall) *bool { + if v == nil { + return nil + } + return v.KeepHistory + }).(pulumi.BoolPtrOutput) +} + +// Timeout is the time to wait for any individual Kubernetes operation (like +// Jobs for hooks) during the performance of a Helm uninstall action. Defaults +// to 'HelmReleaseSpec.Timeout'. +func (o HelmReleaseSpecUninstallPtrOutput) Timeout() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecUninstall) *string { + if v == nil { + return nil + } + return v.Timeout + }).(pulumi.StringPtrOutput) +} + +// Uninstall holds the configuration for Helm uninstall actions for this HelmRelease. +type HelmReleaseSpecUninstallPatch struct { + // DeletionPropagation specifies the deletion propagation policy when + // a Helm uninstall is performed. + DeletionPropagation *string `pulumi:"deletionPropagation"` + // DisableHooks prevents hooks from running during the Helm rollback action. + DisableHooks *bool `pulumi:"disableHooks"` + // DisableWait disables waiting for all the resources to be deleted after + // a Helm uninstall is performed. + DisableWait *bool `pulumi:"disableWait"` + // KeepHistory tells Helm to remove all associated resources and mark the + // release as deleted, but retain the release history. + KeepHistory *bool `pulumi:"keepHistory"` + // Timeout is the time to wait for any individual Kubernetes operation (like + // Jobs for hooks) during the performance of a Helm uninstall action. Defaults + // to 'HelmReleaseSpec.Timeout'. + Timeout *string `pulumi:"timeout"` +} + +// HelmReleaseSpecUninstallPatchInput is an input type that accepts HelmReleaseSpecUninstallPatchArgs and HelmReleaseSpecUninstallPatchOutput values. +// You can construct a concrete instance of `HelmReleaseSpecUninstallPatchInput` via: +// +// HelmReleaseSpecUninstallPatchArgs{...} +type HelmReleaseSpecUninstallPatchInput interface { + pulumi.Input + + ToHelmReleaseSpecUninstallPatchOutput() HelmReleaseSpecUninstallPatchOutput + ToHelmReleaseSpecUninstallPatchOutputWithContext(context.Context) HelmReleaseSpecUninstallPatchOutput +} + +// Uninstall holds the configuration for Helm uninstall actions for this HelmRelease. +type HelmReleaseSpecUninstallPatchArgs struct { + // DeletionPropagation specifies the deletion propagation policy when + // a Helm uninstall is performed. + DeletionPropagation pulumi.StringPtrInput `pulumi:"deletionPropagation"` + // DisableHooks prevents hooks from running during the Helm rollback action. + DisableHooks pulumi.BoolPtrInput `pulumi:"disableHooks"` + // DisableWait disables waiting for all the resources to be deleted after + // a Helm uninstall is performed. + DisableWait pulumi.BoolPtrInput `pulumi:"disableWait"` + // KeepHistory tells Helm to remove all associated resources and mark the + // release as deleted, but retain the release history. + KeepHistory pulumi.BoolPtrInput `pulumi:"keepHistory"` + // Timeout is the time to wait for any individual Kubernetes operation (like + // Jobs for hooks) during the performance of a Helm uninstall action. Defaults + // to 'HelmReleaseSpec.Timeout'. + Timeout pulumi.StringPtrInput `pulumi:"timeout"` +} + +func (HelmReleaseSpecUninstallPatchArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecUninstallPatch)(nil)).Elem() +} + +func (i HelmReleaseSpecUninstallPatchArgs) ToHelmReleaseSpecUninstallPatchOutput() HelmReleaseSpecUninstallPatchOutput { + return i.ToHelmReleaseSpecUninstallPatchOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecUninstallPatchArgs) ToHelmReleaseSpecUninstallPatchOutputWithContext(ctx context.Context) HelmReleaseSpecUninstallPatchOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecUninstallPatchOutput) +} + +func (i HelmReleaseSpecUninstallPatchArgs) ToHelmReleaseSpecUninstallPatchPtrOutput() HelmReleaseSpecUninstallPatchPtrOutput { + return i.ToHelmReleaseSpecUninstallPatchPtrOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecUninstallPatchArgs) ToHelmReleaseSpecUninstallPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecUninstallPatchPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecUninstallPatchOutput).ToHelmReleaseSpecUninstallPatchPtrOutputWithContext(ctx) +} + +// HelmReleaseSpecUninstallPatchPtrInput is an input type that accepts HelmReleaseSpecUninstallPatchArgs, HelmReleaseSpecUninstallPatchPtr and HelmReleaseSpecUninstallPatchPtrOutput values. +// You can construct a concrete instance of `HelmReleaseSpecUninstallPatchPtrInput` via: +// +// HelmReleaseSpecUninstallPatchArgs{...} +// +// or: +// +// nil +type HelmReleaseSpecUninstallPatchPtrInput interface { + pulumi.Input + + ToHelmReleaseSpecUninstallPatchPtrOutput() HelmReleaseSpecUninstallPatchPtrOutput + ToHelmReleaseSpecUninstallPatchPtrOutputWithContext(context.Context) HelmReleaseSpecUninstallPatchPtrOutput +} + +type helmReleaseSpecUninstallPatchPtrType HelmReleaseSpecUninstallPatchArgs + +func HelmReleaseSpecUninstallPatchPtr(v *HelmReleaseSpecUninstallPatchArgs) HelmReleaseSpecUninstallPatchPtrInput { + return (*helmReleaseSpecUninstallPatchPtrType)(v) +} + +func (*helmReleaseSpecUninstallPatchPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecUninstallPatch)(nil)).Elem() +} + +func (i *helmReleaseSpecUninstallPatchPtrType) ToHelmReleaseSpecUninstallPatchPtrOutput() HelmReleaseSpecUninstallPatchPtrOutput { + return i.ToHelmReleaseSpecUninstallPatchPtrOutputWithContext(context.Background()) +} + +func (i *helmReleaseSpecUninstallPatchPtrType) ToHelmReleaseSpecUninstallPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecUninstallPatchPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecUninstallPatchPtrOutput) +} + +// Uninstall holds the configuration for Helm uninstall actions for this HelmRelease. +type HelmReleaseSpecUninstallPatchOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecUninstallPatchOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecUninstallPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecUninstallPatchOutput) ToHelmReleaseSpecUninstallPatchOutput() HelmReleaseSpecUninstallPatchOutput { + return o +} + +func (o HelmReleaseSpecUninstallPatchOutput) ToHelmReleaseSpecUninstallPatchOutputWithContext(ctx context.Context) HelmReleaseSpecUninstallPatchOutput { + return o +} + +func (o HelmReleaseSpecUninstallPatchOutput) ToHelmReleaseSpecUninstallPatchPtrOutput() HelmReleaseSpecUninstallPatchPtrOutput { + return o.ToHelmReleaseSpecUninstallPatchPtrOutputWithContext(context.Background()) +} + +func (o HelmReleaseSpecUninstallPatchOutput) ToHelmReleaseSpecUninstallPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecUninstallPatchPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v HelmReleaseSpecUninstallPatch) *HelmReleaseSpecUninstallPatch { + return &v + }).(HelmReleaseSpecUninstallPatchPtrOutput) +} + +// DeletionPropagation specifies the deletion propagation policy when +// a Helm uninstall is performed. +func (o HelmReleaseSpecUninstallPatchOutput) DeletionPropagation() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecUninstallPatch) *string { return v.DeletionPropagation }).(pulumi.StringPtrOutput) +} + +// DisableHooks prevents hooks from running during the Helm rollback action. +func (o HelmReleaseSpecUninstallPatchOutput) DisableHooks() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecUninstallPatch) *bool { return v.DisableHooks }).(pulumi.BoolPtrOutput) +} + +// DisableWait disables waiting for all the resources to be deleted after +// a Helm uninstall is performed. +func (o HelmReleaseSpecUninstallPatchOutput) DisableWait() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecUninstallPatch) *bool { return v.DisableWait }).(pulumi.BoolPtrOutput) +} + +// KeepHistory tells Helm to remove all associated resources and mark the +// release as deleted, but retain the release history. +func (o HelmReleaseSpecUninstallPatchOutput) KeepHistory() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecUninstallPatch) *bool { return v.KeepHistory }).(pulumi.BoolPtrOutput) +} + +// Timeout is the time to wait for any individual Kubernetes operation (like +// Jobs for hooks) during the performance of a Helm uninstall action. Defaults +// to 'HelmReleaseSpec.Timeout'. +func (o HelmReleaseSpecUninstallPatchOutput) Timeout() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecUninstallPatch) *string { return v.Timeout }).(pulumi.StringPtrOutput) +} + +type HelmReleaseSpecUninstallPatchPtrOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecUninstallPatchPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecUninstallPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecUninstallPatchPtrOutput) ToHelmReleaseSpecUninstallPatchPtrOutput() HelmReleaseSpecUninstallPatchPtrOutput { + return o +} + +func (o HelmReleaseSpecUninstallPatchPtrOutput) ToHelmReleaseSpecUninstallPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecUninstallPatchPtrOutput { + return o +} + +func (o HelmReleaseSpecUninstallPatchPtrOutput) Elem() HelmReleaseSpecUninstallPatchOutput { + return o.ApplyT(func(v *HelmReleaseSpecUninstallPatch) HelmReleaseSpecUninstallPatch { + if v != nil { + return *v + } + var ret HelmReleaseSpecUninstallPatch + return ret + }).(HelmReleaseSpecUninstallPatchOutput) +} + +// DeletionPropagation specifies the deletion propagation policy when +// a Helm uninstall is performed. +func (o HelmReleaseSpecUninstallPatchPtrOutput) DeletionPropagation() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecUninstallPatch) *string { + if v == nil { + return nil + } + return v.DeletionPropagation + }).(pulumi.StringPtrOutput) +} + +// DisableHooks prevents hooks from running during the Helm rollback action. +func (o HelmReleaseSpecUninstallPatchPtrOutput) DisableHooks() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecUninstallPatch) *bool { + if v == nil { + return nil + } + return v.DisableHooks + }).(pulumi.BoolPtrOutput) +} + +// DisableWait disables waiting for all the resources to be deleted after +// a Helm uninstall is performed. +func (o HelmReleaseSpecUninstallPatchPtrOutput) DisableWait() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecUninstallPatch) *bool { + if v == nil { + return nil + } + return v.DisableWait + }).(pulumi.BoolPtrOutput) +} + +// KeepHistory tells Helm to remove all associated resources and mark the +// release as deleted, but retain the release history. +func (o HelmReleaseSpecUninstallPatchPtrOutput) KeepHistory() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecUninstallPatch) *bool { + if v == nil { + return nil + } + return v.KeepHistory + }).(pulumi.BoolPtrOutput) +} + +// Timeout is the time to wait for any individual Kubernetes operation (like +// Jobs for hooks) during the performance of a Helm uninstall action. Defaults +// to 'HelmReleaseSpec.Timeout'. +func (o HelmReleaseSpecUninstallPatchPtrOutput) Timeout() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecUninstallPatch) *string { + if v == nil { + return nil + } + return v.Timeout + }).(pulumi.StringPtrOutput) +} + +// Upgrade holds the configuration for Helm upgrade actions for this HelmRelease. +type HelmReleaseSpecUpgrade struct { + // CleanupOnFail allows deletion of new resources created during the Helm + // upgrade action when it fails. + CleanupOnFail *bool `pulumi:"cleanupOnFail"` + // CRDs upgrade CRDs from the Helm Chart's crds directory according + // to the CRD upgrade policy provided here. Valid values are `Skip`, + // `Create` or `CreateReplace`. Default is `Skip` and if omitted + // CRDs are neither installed nor upgraded. + // + // Skip: do neither install nor replace (update) any CRDs. + // + // Create: new CRDs are created, existing CRDs are neither updated nor deleted. + // + // CreateReplace: new CRDs are created, existing CRDs are updated (replaced) + // but not deleted. + // + // By default, CRDs are not applied during Helm upgrade action. With this + // option users can opt-in to CRD upgrade, which is not (yet) natively supported by Helm. + // https://helm.sh/docs/chart_best_practices/custom_resource_definitions. + Crds *string `pulumi:"crds"` + // DisableHooks prevents hooks from running during the Helm upgrade action. + DisableHooks *bool `pulumi:"disableHooks"` + // DisableOpenAPIValidation prevents the Helm upgrade action from validating + // rendered templates against the Kubernetes OpenAPI Schema. + DisableOpenAPIValidation *bool `pulumi:"disableOpenAPIValidation"` + // DisableSchemaValidation prevents the Helm upgrade action from validating + // the values against the JSON Schema. + DisableSchemaValidation *bool `pulumi:"disableSchemaValidation"` + // DisableTakeOwnership disables taking ownership of existing resources + // during the Helm upgrade action. Defaults to false. + DisableTakeOwnership *bool `pulumi:"disableTakeOwnership"` + // DisableWait disables the waiting for resources to be ready after a Helm + // upgrade has been performed. + DisableWait *bool `pulumi:"disableWait"` + // DisableWaitForJobs disables waiting for jobs to complete after a Helm + // upgrade has been performed. + DisableWaitForJobs *bool `pulumi:"disableWaitForJobs"` + // Force forces resource updates through a replacement strategy + // that avoids 3-way merge conflicts on client-side apply. + // This field is ignored for server-side apply (which always + // forces conflicts with other field managers). + Force *bool `pulumi:"force"` + // PreserveValues will make Helm reuse the last release's values and merge in + // overrides from 'Values'. Setting this flag makes the HelmRelease + // non-declarative. + PreserveValues *bool `pulumi:"preserveValues"` + Remediation *HelmReleaseSpecUpgradeRemediation `pulumi:"remediation"` + // ServerSideApply enables server-side apply for resources during upgrade. + // Can be "enabled", "disabled", or "auto". + // When "auto", server-side apply usage will be based on the release's previous usage. + // Defaults to "auto". + ServerSideApply *string `pulumi:"serverSideApply"` + Strategy *HelmReleaseSpecUpgradeStrategy `pulumi:"strategy"` + // Timeout is the time to wait for any individual Kubernetes operation (like + // Jobs for hooks) during the performance of a Helm upgrade action. Defaults to + // 'HelmReleaseSpec.Timeout'. + Timeout *string `pulumi:"timeout"` +} + +// HelmReleaseSpecUpgradeInput is an input type that accepts HelmReleaseSpecUpgradeArgs and HelmReleaseSpecUpgradeOutput values. +// You can construct a concrete instance of `HelmReleaseSpecUpgradeInput` via: +// +// HelmReleaseSpecUpgradeArgs{...} +type HelmReleaseSpecUpgradeInput interface { + pulumi.Input + + ToHelmReleaseSpecUpgradeOutput() HelmReleaseSpecUpgradeOutput + ToHelmReleaseSpecUpgradeOutputWithContext(context.Context) HelmReleaseSpecUpgradeOutput +} + +// Upgrade holds the configuration for Helm upgrade actions for this HelmRelease. +type HelmReleaseSpecUpgradeArgs struct { + // CleanupOnFail allows deletion of new resources created during the Helm + // upgrade action when it fails. + CleanupOnFail pulumi.BoolPtrInput `pulumi:"cleanupOnFail"` + // CRDs upgrade CRDs from the Helm Chart's crds directory according + // to the CRD upgrade policy provided here. Valid values are `Skip`, + // `Create` or `CreateReplace`. Default is `Skip` and if omitted + // CRDs are neither installed nor upgraded. + // + // Skip: do neither install nor replace (update) any CRDs. + // + // Create: new CRDs are created, existing CRDs are neither updated nor deleted. + // + // CreateReplace: new CRDs are created, existing CRDs are updated (replaced) + // but not deleted. + // + // By default, CRDs are not applied during Helm upgrade action. With this + // option users can opt-in to CRD upgrade, which is not (yet) natively supported by Helm. + // https://helm.sh/docs/chart_best_practices/custom_resource_definitions. + Crds pulumi.StringPtrInput `pulumi:"crds"` + // DisableHooks prevents hooks from running during the Helm upgrade action. + DisableHooks pulumi.BoolPtrInput `pulumi:"disableHooks"` + // DisableOpenAPIValidation prevents the Helm upgrade action from validating + // rendered templates against the Kubernetes OpenAPI Schema. + DisableOpenAPIValidation pulumi.BoolPtrInput `pulumi:"disableOpenAPIValidation"` + // DisableSchemaValidation prevents the Helm upgrade action from validating + // the values against the JSON Schema. + DisableSchemaValidation pulumi.BoolPtrInput `pulumi:"disableSchemaValidation"` + // DisableTakeOwnership disables taking ownership of existing resources + // during the Helm upgrade action. Defaults to false. + DisableTakeOwnership pulumi.BoolPtrInput `pulumi:"disableTakeOwnership"` + // DisableWait disables the waiting for resources to be ready after a Helm + // upgrade has been performed. + DisableWait pulumi.BoolPtrInput `pulumi:"disableWait"` + // DisableWaitForJobs disables waiting for jobs to complete after a Helm + // upgrade has been performed. + DisableWaitForJobs pulumi.BoolPtrInput `pulumi:"disableWaitForJobs"` + // Force forces resource updates through a replacement strategy + // that avoids 3-way merge conflicts on client-side apply. + // This field is ignored for server-side apply (which always + // forces conflicts with other field managers). + Force pulumi.BoolPtrInput `pulumi:"force"` + // PreserveValues will make Helm reuse the last release's values and merge in + // overrides from 'Values'. Setting this flag makes the HelmRelease + // non-declarative. + PreserveValues pulumi.BoolPtrInput `pulumi:"preserveValues"` + Remediation HelmReleaseSpecUpgradeRemediationPtrInput `pulumi:"remediation"` + // ServerSideApply enables server-side apply for resources during upgrade. + // Can be "enabled", "disabled", or "auto". + // When "auto", server-side apply usage will be based on the release's previous usage. + // Defaults to "auto". + ServerSideApply pulumi.StringPtrInput `pulumi:"serverSideApply"` + Strategy HelmReleaseSpecUpgradeStrategyPtrInput `pulumi:"strategy"` + // Timeout is the time to wait for any individual Kubernetes operation (like + // Jobs for hooks) during the performance of a Helm upgrade action. Defaults to + // 'HelmReleaseSpec.Timeout'. + Timeout pulumi.StringPtrInput `pulumi:"timeout"` +} + +func (HelmReleaseSpecUpgradeArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecUpgrade)(nil)).Elem() +} + +func (i HelmReleaseSpecUpgradeArgs) ToHelmReleaseSpecUpgradeOutput() HelmReleaseSpecUpgradeOutput { + return i.ToHelmReleaseSpecUpgradeOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecUpgradeArgs) ToHelmReleaseSpecUpgradeOutputWithContext(ctx context.Context) HelmReleaseSpecUpgradeOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecUpgradeOutput) +} + +func (i HelmReleaseSpecUpgradeArgs) ToHelmReleaseSpecUpgradePtrOutput() HelmReleaseSpecUpgradePtrOutput { + return i.ToHelmReleaseSpecUpgradePtrOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecUpgradeArgs) ToHelmReleaseSpecUpgradePtrOutputWithContext(ctx context.Context) HelmReleaseSpecUpgradePtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecUpgradeOutput).ToHelmReleaseSpecUpgradePtrOutputWithContext(ctx) +} + +// HelmReleaseSpecUpgradePtrInput is an input type that accepts HelmReleaseSpecUpgradeArgs, HelmReleaseSpecUpgradePtr and HelmReleaseSpecUpgradePtrOutput values. +// You can construct a concrete instance of `HelmReleaseSpecUpgradePtrInput` via: +// +// HelmReleaseSpecUpgradeArgs{...} +// +// or: +// +// nil +type HelmReleaseSpecUpgradePtrInput interface { + pulumi.Input + + ToHelmReleaseSpecUpgradePtrOutput() HelmReleaseSpecUpgradePtrOutput + ToHelmReleaseSpecUpgradePtrOutputWithContext(context.Context) HelmReleaseSpecUpgradePtrOutput +} + +type helmReleaseSpecUpgradePtrType HelmReleaseSpecUpgradeArgs + +func HelmReleaseSpecUpgradePtr(v *HelmReleaseSpecUpgradeArgs) HelmReleaseSpecUpgradePtrInput { + return (*helmReleaseSpecUpgradePtrType)(v) +} + +func (*helmReleaseSpecUpgradePtrType) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecUpgrade)(nil)).Elem() +} + +func (i *helmReleaseSpecUpgradePtrType) ToHelmReleaseSpecUpgradePtrOutput() HelmReleaseSpecUpgradePtrOutput { + return i.ToHelmReleaseSpecUpgradePtrOutputWithContext(context.Background()) +} + +func (i *helmReleaseSpecUpgradePtrType) ToHelmReleaseSpecUpgradePtrOutputWithContext(ctx context.Context) HelmReleaseSpecUpgradePtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecUpgradePtrOutput) +} + +// Upgrade holds the configuration for Helm upgrade actions for this HelmRelease. +type HelmReleaseSpecUpgradeOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecUpgradeOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecUpgrade)(nil)).Elem() +} + +func (o HelmReleaseSpecUpgradeOutput) ToHelmReleaseSpecUpgradeOutput() HelmReleaseSpecUpgradeOutput { + return o +} + +func (o HelmReleaseSpecUpgradeOutput) ToHelmReleaseSpecUpgradeOutputWithContext(ctx context.Context) HelmReleaseSpecUpgradeOutput { + return o +} + +func (o HelmReleaseSpecUpgradeOutput) ToHelmReleaseSpecUpgradePtrOutput() HelmReleaseSpecUpgradePtrOutput { + return o.ToHelmReleaseSpecUpgradePtrOutputWithContext(context.Background()) +} + +func (o HelmReleaseSpecUpgradeOutput) ToHelmReleaseSpecUpgradePtrOutputWithContext(ctx context.Context) HelmReleaseSpecUpgradePtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v HelmReleaseSpecUpgrade) *HelmReleaseSpecUpgrade { + return &v + }).(HelmReleaseSpecUpgradePtrOutput) +} + +// CleanupOnFail allows deletion of new resources created during the Helm +// upgrade action when it fails. +func (o HelmReleaseSpecUpgradeOutput) CleanupOnFail() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecUpgrade) *bool { return v.CleanupOnFail }).(pulumi.BoolPtrOutput) +} + +// CRDs upgrade CRDs from the Helm Chart's crds directory according +// to the CRD upgrade policy provided here. Valid values are `Skip`, +// `Create` or `CreateReplace`. Default is `Skip` and if omitted +// CRDs are neither installed nor upgraded. +// +// Skip: do neither install nor replace (update) any CRDs. +// +// Create: new CRDs are created, existing CRDs are neither updated nor deleted. +// +// CreateReplace: new CRDs are created, existing CRDs are updated (replaced) +// but not deleted. +// +// By default, CRDs are not applied during Helm upgrade action. With this +// option users can opt-in to CRD upgrade, which is not (yet) natively supported by Helm. +// https://helm.sh/docs/chart_best_practices/custom_resource_definitions. +func (o HelmReleaseSpecUpgradeOutput) Crds() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecUpgrade) *string { return v.Crds }).(pulumi.StringPtrOutput) +} + +// DisableHooks prevents hooks from running during the Helm upgrade action. +func (o HelmReleaseSpecUpgradeOutput) DisableHooks() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecUpgrade) *bool { return v.DisableHooks }).(pulumi.BoolPtrOutput) +} + +// DisableOpenAPIValidation prevents the Helm upgrade action from validating +// rendered templates against the Kubernetes OpenAPI Schema. +func (o HelmReleaseSpecUpgradeOutput) DisableOpenAPIValidation() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecUpgrade) *bool { return v.DisableOpenAPIValidation }).(pulumi.BoolPtrOutput) +} + +// DisableSchemaValidation prevents the Helm upgrade action from validating +// the values against the JSON Schema. +func (o HelmReleaseSpecUpgradeOutput) DisableSchemaValidation() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecUpgrade) *bool { return v.DisableSchemaValidation }).(pulumi.BoolPtrOutput) +} + +// DisableTakeOwnership disables taking ownership of existing resources +// during the Helm upgrade action. Defaults to false. +func (o HelmReleaseSpecUpgradeOutput) DisableTakeOwnership() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecUpgrade) *bool { return v.DisableTakeOwnership }).(pulumi.BoolPtrOutput) +} + +// DisableWait disables the waiting for resources to be ready after a Helm +// upgrade has been performed. +func (o HelmReleaseSpecUpgradeOutput) DisableWait() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecUpgrade) *bool { return v.DisableWait }).(pulumi.BoolPtrOutput) +} + +// DisableWaitForJobs disables waiting for jobs to complete after a Helm +// upgrade has been performed. +func (o HelmReleaseSpecUpgradeOutput) DisableWaitForJobs() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecUpgrade) *bool { return v.DisableWaitForJobs }).(pulumi.BoolPtrOutput) +} + +// Force forces resource updates through a replacement strategy +// that avoids 3-way merge conflicts on client-side apply. +// This field is ignored for server-side apply (which always +// forces conflicts with other field managers). +func (o HelmReleaseSpecUpgradeOutput) Force() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecUpgrade) *bool { return v.Force }).(pulumi.BoolPtrOutput) +} + +// PreserveValues will make Helm reuse the last release's values and merge in +// overrides from 'Values'. Setting this flag makes the HelmRelease +// non-declarative. +func (o HelmReleaseSpecUpgradeOutput) PreserveValues() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecUpgrade) *bool { return v.PreserveValues }).(pulumi.BoolPtrOutput) +} + +func (o HelmReleaseSpecUpgradeOutput) Remediation() HelmReleaseSpecUpgradeRemediationPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecUpgrade) *HelmReleaseSpecUpgradeRemediation { return v.Remediation }).(HelmReleaseSpecUpgradeRemediationPtrOutput) +} + +// ServerSideApply enables server-side apply for resources during upgrade. +// Can be "enabled", "disabled", or "auto". +// When "auto", server-side apply usage will be based on the release's previous usage. +// Defaults to "auto". +func (o HelmReleaseSpecUpgradeOutput) ServerSideApply() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecUpgrade) *string { return v.ServerSideApply }).(pulumi.StringPtrOutput) +} + +func (o HelmReleaseSpecUpgradeOutput) Strategy() HelmReleaseSpecUpgradeStrategyPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecUpgrade) *HelmReleaseSpecUpgradeStrategy { return v.Strategy }).(HelmReleaseSpecUpgradeStrategyPtrOutput) +} + +// Timeout is the time to wait for any individual Kubernetes operation (like +// Jobs for hooks) during the performance of a Helm upgrade action. Defaults to +// 'HelmReleaseSpec.Timeout'. +func (o HelmReleaseSpecUpgradeOutput) Timeout() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecUpgrade) *string { return v.Timeout }).(pulumi.StringPtrOutput) +} + +type HelmReleaseSpecUpgradePtrOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecUpgradePtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecUpgrade)(nil)).Elem() +} + +func (o HelmReleaseSpecUpgradePtrOutput) ToHelmReleaseSpecUpgradePtrOutput() HelmReleaseSpecUpgradePtrOutput { + return o +} + +func (o HelmReleaseSpecUpgradePtrOutput) ToHelmReleaseSpecUpgradePtrOutputWithContext(ctx context.Context) HelmReleaseSpecUpgradePtrOutput { + return o +} + +func (o HelmReleaseSpecUpgradePtrOutput) Elem() HelmReleaseSpecUpgradeOutput { + return o.ApplyT(func(v *HelmReleaseSpecUpgrade) HelmReleaseSpecUpgrade { + if v != nil { + return *v + } + var ret HelmReleaseSpecUpgrade + return ret + }).(HelmReleaseSpecUpgradeOutput) +} + +// CleanupOnFail allows deletion of new resources created during the Helm +// upgrade action when it fails. +func (o HelmReleaseSpecUpgradePtrOutput) CleanupOnFail() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecUpgrade) *bool { + if v == nil { + return nil + } + return v.CleanupOnFail + }).(pulumi.BoolPtrOutput) +} + +// CRDs upgrade CRDs from the Helm Chart's crds directory according +// to the CRD upgrade policy provided here. Valid values are `Skip`, +// `Create` or `CreateReplace`. Default is `Skip` and if omitted +// CRDs are neither installed nor upgraded. +// +// Skip: do neither install nor replace (update) any CRDs. +// +// Create: new CRDs are created, existing CRDs are neither updated nor deleted. +// +// CreateReplace: new CRDs are created, existing CRDs are updated (replaced) +// but not deleted. +// +// By default, CRDs are not applied during Helm upgrade action. With this +// option users can opt-in to CRD upgrade, which is not (yet) natively supported by Helm. +// https://helm.sh/docs/chart_best_practices/custom_resource_definitions. +func (o HelmReleaseSpecUpgradePtrOutput) Crds() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecUpgrade) *string { + if v == nil { + return nil + } + return v.Crds + }).(pulumi.StringPtrOutput) +} + +// DisableHooks prevents hooks from running during the Helm upgrade action. +func (o HelmReleaseSpecUpgradePtrOutput) DisableHooks() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecUpgrade) *bool { + if v == nil { + return nil + } + return v.DisableHooks + }).(pulumi.BoolPtrOutput) +} + +// DisableOpenAPIValidation prevents the Helm upgrade action from validating +// rendered templates against the Kubernetes OpenAPI Schema. +func (o HelmReleaseSpecUpgradePtrOutput) DisableOpenAPIValidation() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecUpgrade) *bool { + if v == nil { + return nil + } + return v.DisableOpenAPIValidation + }).(pulumi.BoolPtrOutput) +} + +// DisableSchemaValidation prevents the Helm upgrade action from validating +// the values against the JSON Schema. +func (o HelmReleaseSpecUpgradePtrOutput) DisableSchemaValidation() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecUpgrade) *bool { + if v == nil { + return nil + } + return v.DisableSchemaValidation + }).(pulumi.BoolPtrOutput) +} + +// DisableTakeOwnership disables taking ownership of existing resources +// during the Helm upgrade action. Defaults to false. +func (o HelmReleaseSpecUpgradePtrOutput) DisableTakeOwnership() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecUpgrade) *bool { + if v == nil { + return nil + } + return v.DisableTakeOwnership + }).(pulumi.BoolPtrOutput) +} + +// DisableWait disables the waiting for resources to be ready after a Helm +// upgrade has been performed. +func (o HelmReleaseSpecUpgradePtrOutput) DisableWait() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecUpgrade) *bool { + if v == nil { + return nil + } + return v.DisableWait + }).(pulumi.BoolPtrOutput) +} + +// DisableWaitForJobs disables waiting for jobs to complete after a Helm +// upgrade has been performed. +func (o HelmReleaseSpecUpgradePtrOutput) DisableWaitForJobs() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecUpgrade) *bool { + if v == nil { + return nil + } + return v.DisableWaitForJobs + }).(pulumi.BoolPtrOutput) +} + +// Force forces resource updates through a replacement strategy +// that avoids 3-way merge conflicts on client-side apply. +// This field is ignored for server-side apply (which always +// forces conflicts with other field managers). +func (o HelmReleaseSpecUpgradePtrOutput) Force() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecUpgrade) *bool { + if v == nil { + return nil + } + return v.Force + }).(pulumi.BoolPtrOutput) +} + +// PreserveValues will make Helm reuse the last release's values and merge in +// overrides from 'Values'. Setting this flag makes the HelmRelease +// non-declarative. +func (o HelmReleaseSpecUpgradePtrOutput) PreserveValues() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecUpgrade) *bool { + if v == nil { + return nil + } + return v.PreserveValues + }).(pulumi.BoolPtrOutput) +} + +func (o HelmReleaseSpecUpgradePtrOutput) Remediation() HelmReleaseSpecUpgradeRemediationPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecUpgrade) *HelmReleaseSpecUpgradeRemediation { + if v == nil { + return nil + } + return v.Remediation + }).(HelmReleaseSpecUpgradeRemediationPtrOutput) +} + +// ServerSideApply enables server-side apply for resources during upgrade. +// Can be "enabled", "disabled", or "auto". +// When "auto", server-side apply usage will be based on the release's previous usage. +// Defaults to "auto". +func (o HelmReleaseSpecUpgradePtrOutput) ServerSideApply() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecUpgrade) *string { + if v == nil { + return nil + } + return v.ServerSideApply + }).(pulumi.StringPtrOutput) +} + +func (o HelmReleaseSpecUpgradePtrOutput) Strategy() HelmReleaseSpecUpgradeStrategyPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecUpgrade) *HelmReleaseSpecUpgradeStrategy { + if v == nil { + return nil + } + return v.Strategy + }).(HelmReleaseSpecUpgradeStrategyPtrOutput) +} + +// Timeout is the time to wait for any individual Kubernetes operation (like +// Jobs for hooks) during the performance of a Helm upgrade action. Defaults to +// 'HelmReleaseSpec.Timeout'. +func (o HelmReleaseSpecUpgradePtrOutput) Timeout() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecUpgrade) *string { + if v == nil { + return nil + } + return v.Timeout + }).(pulumi.StringPtrOutput) +} + +// Upgrade holds the configuration for Helm upgrade actions for this HelmRelease. +type HelmReleaseSpecUpgradePatch struct { + // CleanupOnFail allows deletion of new resources created during the Helm + // upgrade action when it fails. + CleanupOnFail *bool `pulumi:"cleanupOnFail"` + // CRDs upgrade CRDs from the Helm Chart's crds directory according + // to the CRD upgrade policy provided here. Valid values are `Skip`, + // `Create` or `CreateReplace`. Default is `Skip` and if omitted + // CRDs are neither installed nor upgraded. + // + // Skip: do neither install nor replace (update) any CRDs. + // + // Create: new CRDs are created, existing CRDs are neither updated nor deleted. + // + // CreateReplace: new CRDs are created, existing CRDs are updated (replaced) + // but not deleted. + // + // By default, CRDs are not applied during Helm upgrade action. With this + // option users can opt-in to CRD upgrade, which is not (yet) natively supported by Helm. + // https://helm.sh/docs/chart_best_practices/custom_resource_definitions. + Crds *string `pulumi:"crds"` + // DisableHooks prevents hooks from running during the Helm upgrade action. + DisableHooks *bool `pulumi:"disableHooks"` + // DisableOpenAPIValidation prevents the Helm upgrade action from validating + // rendered templates against the Kubernetes OpenAPI Schema. + DisableOpenAPIValidation *bool `pulumi:"disableOpenAPIValidation"` + // DisableSchemaValidation prevents the Helm upgrade action from validating + // the values against the JSON Schema. + DisableSchemaValidation *bool `pulumi:"disableSchemaValidation"` + // DisableTakeOwnership disables taking ownership of existing resources + // during the Helm upgrade action. Defaults to false. + DisableTakeOwnership *bool `pulumi:"disableTakeOwnership"` + // DisableWait disables the waiting for resources to be ready after a Helm + // upgrade has been performed. + DisableWait *bool `pulumi:"disableWait"` + // DisableWaitForJobs disables waiting for jobs to complete after a Helm + // upgrade has been performed. + DisableWaitForJobs *bool `pulumi:"disableWaitForJobs"` + // Force forces resource updates through a replacement strategy + // that avoids 3-way merge conflicts on client-side apply. + // This field is ignored for server-side apply (which always + // forces conflicts with other field managers). + Force *bool `pulumi:"force"` + // PreserveValues will make Helm reuse the last release's values and merge in + // overrides from 'Values'. Setting this flag makes the HelmRelease + // non-declarative. + PreserveValues *bool `pulumi:"preserveValues"` + Remediation *HelmReleaseSpecUpgradeRemediationPatch `pulumi:"remediation"` + // ServerSideApply enables server-side apply for resources during upgrade. + // Can be "enabled", "disabled", or "auto". + // When "auto", server-side apply usage will be based on the release's previous usage. + // Defaults to "auto". + ServerSideApply *string `pulumi:"serverSideApply"` + Strategy *HelmReleaseSpecUpgradeStrategyPatch `pulumi:"strategy"` + // Timeout is the time to wait for any individual Kubernetes operation (like + // Jobs for hooks) during the performance of a Helm upgrade action. Defaults to + // 'HelmReleaseSpec.Timeout'. + Timeout *string `pulumi:"timeout"` +} + +// HelmReleaseSpecUpgradePatchInput is an input type that accepts HelmReleaseSpecUpgradePatchArgs and HelmReleaseSpecUpgradePatchOutput values. +// You can construct a concrete instance of `HelmReleaseSpecUpgradePatchInput` via: +// +// HelmReleaseSpecUpgradePatchArgs{...} +type HelmReleaseSpecUpgradePatchInput interface { + pulumi.Input + + ToHelmReleaseSpecUpgradePatchOutput() HelmReleaseSpecUpgradePatchOutput + ToHelmReleaseSpecUpgradePatchOutputWithContext(context.Context) HelmReleaseSpecUpgradePatchOutput +} + +// Upgrade holds the configuration for Helm upgrade actions for this HelmRelease. +type HelmReleaseSpecUpgradePatchArgs struct { + // CleanupOnFail allows deletion of new resources created during the Helm + // upgrade action when it fails. + CleanupOnFail pulumi.BoolPtrInput `pulumi:"cleanupOnFail"` + // CRDs upgrade CRDs from the Helm Chart's crds directory according + // to the CRD upgrade policy provided here. Valid values are `Skip`, + // `Create` or `CreateReplace`. Default is `Skip` and if omitted + // CRDs are neither installed nor upgraded. + // + // Skip: do neither install nor replace (update) any CRDs. + // + // Create: new CRDs are created, existing CRDs are neither updated nor deleted. + // + // CreateReplace: new CRDs are created, existing CRDs are updated (replaced) + // but not deleted. + // + // By default, CRDs are not applied during Helm upgrade action. With this + // option users can opt-in to CRD upgrade, which is not (yet) natively supported by Helm. + // https://helm.sh/docs/chart_best_practices/custom_resource_definitions. + Crds pulumi.StringPtrInput `pulumi:"crds"` + // DisableHooks prevents hooks from running during the Helm upgrade action. + DisableHooks pulumi.BoolPtrInput `pulumi:"disableHooks"` + // DisableOpenAPIValidation prevents the Helm upgrade action from validating + // rendered templates against the Kubernetes OpenAPI Schema. + DisableOpenAPIValidation pulumi.BoolPtrInput `pulumi:"disableOpenAPIValidation"` + // DisableSchemaValidation prevents the Helm upgrade action from validating + // the values against the JSON Schema. + DisableSchemaValidation pulumi.BoolPtrInput `pulumi:"disableSchemaValidation"` + // DisableTakeOwnership disables taking ownership of existing resources + // during the Helm upgrade action. Defaults to false. + DisableTakeOwnership pulumi.BoolPtrInput `pulumi:"disableTakeOwnership"` + // DisableWait disables the waiting for resources to be ready after a Helm + // upgrade has been performed. + DisableWait pulumi.BoolPtrInput `pulumi:"disableWait"` + // DisableWaitForJobs disables waiting for jobs to complete after a Helm + // upgrade has been performed. + DisableWaitForJobs pulumi.BoolPtrInput `pulumi:"disableWaitForJobs"` + // Force forces resource updates through a replacement strategy + // that avoids 3-way merge conflicts on client-side apply. + // This field is ignored for server-side apply (which always + // forces conflicts with other field managers). + Force pulumi.BoolPtrInput `pulumi:"force"` + // PreserveValues will make Helm reuse the last release's values and merge in + // overrides from 'Values'. Setting this flag makes the HelmRelease + // non-declarative. + PreserveValues pulumi.BoolPtrInput `pulumi:"preserveValues"` + Remediation HelmReleaseSpecUpgradeRemediationPatchPtrInput `pulumi:"remediation"` + // ServerSideApply enables server-side apply for resources during upgrade. + // Can be "enabled", "disabled", or "auto". + // When "auto", server-side apply usage will be based on the release's previous usage. + // Defaults to "auto". + ServerSideApply pulumi.StringPtrInput `pulumi:"serverSideApply"` + Strategy HelmReleaseSpecUpgradeStrategyPatchPtrInput `pulumi:"strategy"` + // Timeout is the time to wait for any individual Kubernetes operation (like + // Jobs for hooks) during the performance of a Helm upgrade action. Defaults to + // 'HelmReleaseSpec.Timeout'. + Timeout pulumi.StringPtrInput `pulumi:"timeout"` +} + +func (HelmReleaseSpecUpgradePatchArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecUpgradePatch)(nil)).Elem() +} + +func (i HelmReleaseSpecUpgradePatchArgs) ToHelmReleaseSpecUpgradePatchOutput() HelmReleaseSpecUpgradePatchOutput { + return i.ToHelmReleaseSpecUpgradePatchOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecUpgradePatchArgs) ToHelmReleaseSpecUpgradePatchOutputWithContext(ctx context.Context) HelmReleaseSpecUpgradePatchOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecUpgradePatchOutput) +} + +func (i HelmReleaseSpecUpgradePatchArgs) ToHelmReleaseSpecUpgradePatchPtrOutput() HelmReleaseSpecUpgradePatchPtrOutput { + return i.ToHelmReleaseSpecUpgradePatchPtrOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecUpgradePatchArgs) ToHelmReleaseSpecUpgradePatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecUpgradePatchPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecUpgradePatchOutput).ToHelmReleaseSpecUpgradePatchPtrOutputWithContext(ctx) +} + +// HelmReleaseSpecUpgradePatchPtrInput is an input type that accepts HelmReleaseSpecUpgradePatchArgs, HelmReleaseSpecUpgradePatchPtr and HelmReleaseSpecUpgradePatchPtrOutput values. +// You can construct a concrete instance of `HelmReleaseSpecUpgradePatchPtrInput` via: +// +// HelmReleaseSpecUpgradePatchArgs{...} +// +// or: +// +// nil +type HelmReleaseSpecUpgradePatchPtrInput interface { + pulumi.Input + + ToHelmReleaseSpecUpgradePatchPtrOutput() HelmReleaseSpecUpgradePatchPtrOutput + ToHelmReleaseSpecUpgradePatchPtrOutputWithContext(context.Context) HelmReleaseSpecUpgradePatchPtrOutput +} + +type helmReleaseSpecUpgradePatchPtrType HelmReleaseSpecUpgradePatchArgs + +func HelmReleaseSpecUpgradePatchPtr(v *HelmReleaseSpecUpgradePatchArgs) HelmReleaseSpecUpgradePatchPtrInput { + return (*helmReleaseSpecUpgradePatchPtrType)(v) +} + +func (*helmReleaseSpecUpgradePatchPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecUpgradePatch)(nil)).Elem() +} + +func (i *helmReleaseSpecUpgradePatchPtrType) ToHelmReleaseSpecUpgradePatchPtrOutput() HelmReleaseSpecUpgradePatchPtrOutput { + return i.ToHelmReleaseSpecUpgradePatchPtrOutputWithContext(context.Background()) +} + +func (i *helmReleaseSpecUpgradePatchPtrType) ToHelmReleaseSpecUpgradePatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecUpgradePatchPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecUpgradePatchPtrOutput) +} + +// Upgrade holds the configuration for Helm upgrade actions for this HelmRelease. +type HelmReleaseSpecUpgradePatchOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecUpgradePatchOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecUpgradePatch)(nil)).Elem() +} + +func (o HelmReleaseSpecUpgradePatchOutput) ToHelmReleaseSpecUpgradePatchOutput() HelmReleaseSpecUpgradePatchOutput { + return o +} + +func (o HelmReleaseSpecUpgradePatchOutput) ToHelmReleaseSpecUpgradePatchOutputWithContext(ctx context.Context) HelmReleaseSpecUpgradePatchOutput { + return o +} + +func (o HelmReleaseSpecUpgradePatchOutput) ToHelmReleaseSpecUpgradePatchPtrOutput() HelmReleaseSpecUpgradePatchPtrOutput { + return o.ToHelmReleaseSpecUpgradePatchPtrOutputWithContext(context.Background()) +} + +func (o HelmReleaseSpecUpgradePatchOutput) ToHelmReleaseSpecUpgradePatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecUpgradePatchPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v HelmReleaseSpecUpgradePatch) *HelmReleaseSpecUpgradePatch { + return &v + }).(HelmReleaseSpecUpgradePatchPtrOutput) +} + +// CleanupOnFail allows deletion of new resources created during the Helm +// upgrade action when it fails. +func (o HelmReleaseSpecUpgradePatchOutput) CleanupOnFail() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecUpgradePatch) *bool { return v.CleanupOnFail }).(pulumi.BoolPtrOutput) +} + +// CRDs upgrade CRDs from the Helm Chart's crds directory according +// to the CRD upgrade policy provided here. Valid values are `Skip`, +// `Create` or `CreateReplace`. Default is `Skip` and if omitted +// CRDs are neither installed nor upgraded. +// +// Skip: do neither install nor replace (update) any CRDs. +// +// Create: new CRDs are created, existing CRDs are neither updated nor deleted. +// +// CreateReplace: new CRDs are created, existing CRDs are updated (replaced) +// but not deleted. +// +// By default, CRDs are not applied during Helm upgrade action. With this +// option users can opt-in to CRD upgrade, which is not (yet) natively supported by Helm. +// https://helm.sh/docs/chart_best_practices/custom_resource_definitions. +func (o HelmReleaseSpecUpgradePatchOutput) Crds() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecUpgradePatch) *string { return v.Crds }).(pulumi.StringPtrOutput) +} + +// DisableHooks prevents hooks from running during the Helm upgrade action. +func (o HelmReleaseSpecUpgradePatchOutput) DisableHooks() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecUpgradePatch) *bool { return v.DisableHooks }).(pulumi.BoolPtrOutput) +} + +// DisableOpenAPIValidation prevents the Helm upgrade action from validating +// rendered templates against the Kubernetes OpenAPI Schema. +func (o HelmReleaseSpecUpgradePatchOutput) DisableOpenAPIValidation() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecUpgradePatch) *bool { return v.DisableOpenAPIValidation }).(pulumi.BoolPtrOutput) +} + +// DisableSchemaValidation prevents the Helm upgrade action from validating +// the values against the JSON Schema. +func (o HelmReleaseSpecUpgradePatchOutput) DisableSchemaValidation() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecUpgradePatch) *bool { return v.DisableSchemaValidation }).(pulumi.BoolPtrOutput) +} + +// DisableTakeOwnership disables taking ownership of existing resources +// during the Helm upgrade action. Defaults to false. +func (o HelmReleaseSpecUpgradePatchOutput) DisableTakeOwnership() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecUpgradePatch) *bool { return v.DisableTakeOwnership }).(pulumi.BoolPtrOutput) +} + +// DisableWait disables the waiting for resources to be ready after a Helm +// upgrade has been performed. +func (o HelmReleaseSpecUpgradePatchOutput) DisableWait() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecUpgradePatch) *bool { return v.DisableWait }).(pulumi.BoolPtrOutput) +} + +// DisableWaitForJobs disables waiting for jobs to complete after a Helm +// upgrade has been performed. +func (o HelmReleaseSpecUpgradePatchOutput) DisableWaitForJobs() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecUpgradePatch) *bool { return v.DisableWaitForJobs }).(pulumi.BoolPtrOutput) +} + +// Force forces resource updates through a replacement strategy +// that avoids 3-way merge conflicts on client-side apply. +// This field is ignored for server-side apply (which always +// forces conflicts with other field managers). +func (o HelmReleaseSpecUpgradePatchOutput) Force() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecUpgradePatch) *bool { return v.Force }).(pulumi.BoolPtrOutput) +} + +// PreserveValues will make Helm reuse the last release's values and merge in +// overrides from 'Values'. Setting this flag makes the HelmRelease +// non-declarative. +func (o HelmReleaseSpecUpgradePatchOutput) PreserveValues() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecUpgradePatch) *bool { return v.PreserveValues }).(pulumi.BoolPtrOutput) +} + +func (o HelmReleaseSpecUpgradePatchOutput) Remediation() HelmReleaseSpecUpgradeRemediationPatchPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecUpgradePatch) *HelmReleaseSpecUpgradeRemediationPatch { return v.Remediation }).(HelmReleaseSpecUpgradeRemediationPatchPtrOutput) +} + +// ServerSideApply enables server-side apply for resources during upgrade. +// Can be "enabled", "disabled", or "auto". +// When "auto", server-side apply usage will be based on the release's previous usage. +// Defaults to "auto". +func (o HelmReleaseSpecUpgradePatchOutput) ServerSideApply() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecUpgradePatch) *string { return v.ServerSideApply }).(pulumi.StringPtrOutput) +} + +func (o HelmReleaseSpecUpgradePatchOutput) Strategy() HelmReleaseSpecUpgradeStrategyPatchPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecUpgradePatch) *HelmReleaseSpecUpgradeStrategyPatch { return v.Strategy }).(HelmReleaseSpecUpgradeStrategyPatchPtrOutput) +} + +// Timeout is the time to wait for any individual Kubernetes operation (like +// Jobs for hooks) during the performance of a Helm upgrade action. Defaults to +// 'HelmReleaseSpec.Timeout'. +func (o HelmReleaseSpecUpgradePatchOutput) Timeout() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecUpgradePatch) *string { return v.Timeout }).(pulumi.StringPtrOutput) +} + +type HelmReleaseSpecUpgradePatchPtrOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecUpgradePatchPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecUpgradePatch)(nil)).Elem() +} + +func (o HelmReleaseSpecUpgradePatchPtrOutput) ToHelmReleaseSpecUpgradePatchPtrOutput() HelmReleaseSpecUpgradePatchPtrOutput { + return o +} + +func (o HelmReleaseSpecUpgradePatchPtrOutput) ToHelmReleaseSpecUpgradePatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecUpgradePatchPtrOutput { + return o +} + +func (o HelmReleaseSpecUpgradePatchPtrOutput) Elem() HelmReleaseSpecUpgradePatchOutput { + return o.ApplyT(func(v *HelmReleaseSpecUpgradePatch) HelmReleaseSpecUpgradePatch { + if v != nil { + return *v + } + var ret HelmReleaseSpecUpgradePatch + return ret + }).(HelmReleaseSpecUpgradePatchOutput) +} + +// CleanupOnFail allows deletion of new resources created during the Helm +// upgrade action when it fails. +func (o HelmReleaseSpecUpgradePatchPtrOutput) CleanupOnFail() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecUpgradePatch) *bool { + if v == nil { + return nil + } + return v.CleanupOnFail + }).(pulumi.BoolPtrOutput) +} + +// CRDs upgrade CRDs from the Helm Chart's crds directory according +// to the CRD upgrade policy provided here. Valid values are `Skip`, +// `Create` or `CreateReplace`. Default is `Skip` and if omitted +// CRDs are neither installed nor upgraded. +// +// Skip: do neither install nor replace (update) any CRDs. +// +// Create: new CRDs are created, existing CRDs are neither updated nor deleted. +// +// CreateReplace: new CRDs are created, existing CRDs are updated (replaced) +// but not deleted. +// +// By default, CRDs are not applied during Helm upgrade action. With this +// option users can opt-in to CRD upgrade, which is not (yet) natively supported by Helm. +// https://helm.sh/docs/chart_best_practices/custom_resource_definitions. +func (o HelmReleaseSpecUpgradePatchPtrOutput) Crds() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecUpgradePatch) *string { + if v == nil { + return nil + } + return v.Crds + }).(pulumi.StringPtrOutput) +} + +// DisableHooks prevents hooks from running during the Helm upgrade action. +func (o HelmReleaseSpecUpgradePatchPtrOutput) DisableHooks() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecUpgradePatch) *bool { + if v == nil { + return nil + } + return v.DisableHooks + }).(pulumi.BoolPtrOutput) +} + +// DisableOpenAPIValidation prevents the Helm upgrade action from validating +// rendered templates against the Kubernetes OpenAPI Schema. +func (o HelmReleaseSpecUpgradePatchPtrOutput) DisableOpenAPIValidation() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecUpgradePatch) *bool { + if v == nil { + return nil + } + return v.DisableOpenAPIValidation + }).(pulumi.BoolPtrOutput) +} + +// DisableSchemaValidation prevents the Helm upgrade action from validating +// the values against the JSON Schema. +func (o HelmReleaseSpecUpgradePatchPtrOutput) DisableSchemaValidation() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecUpgradePatch) *bool { + if v == nil { + return nil + } + return v.DisableSchemaValidation + }).(pulumi.BoolPtrOutput) +} + +// DisableTakeOwnership disables taking ownership of existing resources +// during the Helm upgrade action. Defaults to false. +func (o HelmReleaseSpecUpgradePatchPtrOutput) DisableTakeOwnership() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecUpgradePatch) *bool { + if v == nil { + return nil + } + return v.DisableTakeOwnership + }).(pulumi.BoolPtrOutput) +} + +// DisableWait disables the waiting for resources to be ready after a Helm +// upgrade has been performed. +func (o HelmReleaseSpecUpgradePatchPtrOutput) DisableWait() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecUpgradePatch) *bool { + if v == nil { + return nil + } + return v.DisableWait + }).(pulumi.BoolPtrOutput) +} + +// DisableWaitForJobs disables waiting for jobs to complete after a Helm +// upgrade has been performed. +func (o HelmReleaseSpecUpgradePatchPtrOutput) DisableWaitForJobs() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecUpgradePatch) *bool { + if v == nil { + return nil + } + return v.DisableWaitForJobs + }).(pulumi.BoolPtrOutput) +} + +// Force forces resource updates through a replacement strategy +// that avoids 3-way merge conflicts on client-side apply. +// This field is ignored for server-side apply (which always +// forces conflicts with other field managers). +func (o HelmReleaseSpecUpgradePatchPtrOutput) Force() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecUpgradePatch) *bool { + if v == nil { + return nil + } + return v.Force + }).(pulumi.BoolPtrOutput) +} + +// PreserveValues will make Helm reuse the last release's values and merge in +// overrides from 'Values'. Setting this flag makes the HelmRelease +// non-declarative. +func (o HelmReleaseSpecUpgradePatchPtrOutput) PreserveValues() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecUpgradePatch) *bool { + if v == nil { + return nil + } + return v.PreserveValues + }).(pulumi.BoolPtrOutput) +} + +func (o HelmReleaseSpecUpgradePatchPtrOutput) Remediation() HelmReleaseSpecUpgradeRemediationPatchPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecUpgradePatch) *HelmReleaseSpecUpgradeRemediationPatch { + if v == nil { + return nil + } + return v.Remediation + }).(HelmReleaseSpecUpgradeRemediationPatchPtrOutput) +} + +// ServerSideApply enables server-side apply for resources during upgrade. +// Can be "enabled", "disabled", or "auto". +// When "auto", server-side apply usage will be based on the release's previous usage. +// Defaults to "auto". +func (o HelmReleaseSpecUpgradePatchPtrOutput) ServerSideApply() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecUpgradePatch) *string { + if v == nil { + return nil + } + return v.ServerSideApply + }).(pulumi.StringPtrOutput) +} + +func (o HelmReleaseSpecUpgradePatchPtrOutput) Strategy() HelmReleaseSpecUpgradeStrategyPatchPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecUpgradePatch) *HelmReleaseSpecUpgradeStrategyPatch { + if v == nil { + return nil + } + return v.Strategy + }).(HelmReleaseSpecUpgradeStrategyPatchPtrOutput) +} + +// Timeout is the time to wait for any individual Kubernetes operation (like +// Jobs for hooks) during the performance of a Helm upgrade action. Defaults to +// 'HelmReleaseSpec.Timeout'. +func (o HelmReleaseSpecUpgradePatchPtrOutput) Timeout() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecUpgradePatch) *string { + if v == nil { + return nil + } + return v.Timeout + }).(pulumi.StringPtrOutput) +} + +// Remediation holds the remediation configuration for when the Helm upgrade +// action for the HelmRelease fails. The default is to not perform any action. +type HelmReleaseSpecUpgradeRemediation struct { + // IgnoreTestFailures tells the controller to skip remediation when the Helm + // tests are run after an upgrade action but fail. + // Defaults to 'Test.IgnoreFailures'. + IgnoreTestFailures *bool `pulumi:"ignoreTestFailures"` + // RemediateLastFailure tells the controller to remediate the last failure, when + // no retries remain. Defaults to 'false' unless 'Retries' is greater than 0. + RemediateLastFailure *bool `pulumi:"remediateLastFailure"` + // Retries is the number of retries that should be attempted on failures before + // bailing. Remediation, using 'Strategy', is performed between each attempt. + // Defaults to '0', a negative integer equals to unlimited retries. + Retries *int `pulumi:"retries"` + // Strategy to use for failure remediation. Defaults to 'rollback'. + Strategy *string `pulumi:"strategy"` +} + +// HelmReleaseSpecUpgradeRemediationInput is an input type that accepts HelmReleaseSpecUpgradeRemediationArgs and HelmReleaseSpecUpgradeRemediationOutput values. +// You can construct a concrete instance of `HelmReleaseSpecUpgradeRemediationInput` via: +// +// HelmReleaseSpecUpgradeRemediationArgs{...} +type HelmReleaseSpecUpgradeRemediationInput interface { + pulumi.Input + + ToHelmReleaseSpecUpgradeRemediationOutput() HelmReleaseSpecUpgradeRemediationOutput + ToHelmReleaseSpecUpgradeRemediationOutputWithContext(context.Context) HelmReleaseSpecUpgradeRemediationOutput +} + +// Remediation holds the remediation configuration for when the Helm upgrade +// action for the HelmRelease fails. The default is to not perform any action. +type HelmReleaseSpecUpgradeRemediationArgs struct { + // IgnoreTestFailures tells the controller to skip remediation when the Helm + // tests are run after an upgrade action but fail. + // Defaults to 'Test.IgnoreFailures'. + IgnoreTestFailures pulumi.BoolPtrInput `pulumi:"ignoreTestFailures"` + // RemediateLastFailure tells the controller to remediate the last failure, when + // no retries remain. Defaults to 'false' unless 'Retries' is greater than 0. + RemediateLastFailure pulumi.BoolPtrInput `pulumi:"remediateLastFailure"` + // Retries is the number of retries that should be attempted on failures before + // bailing. Remediation, using 'Strategy', is performed between each attempt. + // Defaults to '0', a negative integer equals to unlimited retries. + Retries pulumi.IntPtrInput `pulumi:"retries"` + // Strategy to use for failure remediation. Defaults to 'rollback'. + Strategy pulumi.StringPtrInput `pulumi:"strategy"` +} + +func (HelmReleaseSpecUpgradeRemediationArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecUpgradeRemediation)(nil)).Elem() +} + +func (i HelmReleaseSpecUpgradeRemediationArgs) ToHelmReleaseSpecUpgradeRemediationOutput() HelmReleaseSpecUpgradeRemediationOutput { + return i.ToHelmReleaseSpecUpgradeRemediationOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecUpgradeRemediationArgs) ToHelmReleaseSpecUpgradeRemediationOutputWithContext(ctx context.Context) HelmReleaseSpecUpgradeRemediationOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecUpgradeRemediationOutput) +} + +func (i HelmReleaseSpecUpgradeRemediationArgs) ToHelmReleaseSpecUpgradeRemediationPtrOutput() HelmReleaseSpecUpgradeRemediationPtrOutput { + return i.ToHelmReleaseSpecUpgradeRemediationPtrOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecUpgradeRemediationArgs) ToHelmReleaseSpecUpgradeRemediationPtrOutputWithContext(ctx context.Context) HelmReleaseSpecUpgradeRemediationPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecUpgradeRemediationOutput).ToHelmReleaseSpecUpgradeRemediationPtrOutputWithContext(ctx) +} + +// HelmReleaseSpecUpgradeRemediationPtrInput is an input type that accepts HelmReleaseSpecUpgradeRemediationArgs, HelmReleaseSpecUpgradeRemediationPtr and HelmReleaseSpecUpgradeRemediationPtrOutput values. +// You can construct a concrete instance of `HelmReleaseSpecUpgradeRemediationPtrInput` via: +// +// HelmReleaseSpecUpgradeRemediationArgs{...} +// +// or: +// +// nil +type HelmReleaseSpecUpgradeRemediationPtrInput interface { + pulumi.Input + + ToHelmReleaseSpecUpgradeRemediationPtrOutput() HelmReleaseSpecUpgradeRemediationPtrOutput + ToHelmReleaseSpecUpgradeRemediationPtrOutputWithContext(context.Context) HelmReleaseSpecUpgradeRemediationPtrOutput +} + +type helmReleaseSpecUpgradeRemediationPtrType HelmReleaseSpecUpgradeRemediationArgs + +func HelmReleaseSpecUpgradeRemediationPtr(v *HelmReleaseSpecUpgradeRemediationArgs) HelmReleaseSpecUpgradeRemediationPtrInput { + return (*helmReleaseSpecUpgradeRemediationPtrType)(v) +} + +func (*helmReleaseSpecUpgradeRemediationPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecUpgradeRemediation)(nil)).Elem() +} + +func (i *helmReleaseSpecUpgradeRemediationPtrType) ToHelmReleaseSpecUpgradeRemediationPtrOutput() HelmReleaseSpecUpgradeRemediationPtrOutput { + return i.ToHelmReleaseSpecUpgradeRemediationPtrOutputWithContext(context.Background()) +} + +func (i *helmReleaseSpecUpgradeRemediationPtrType) ToHelmReleaseSpecUpgradeRemediationPtrOutputWithContext(ctx context.Context) HelmReleaseSpecUpgradeRemediationPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecUpgradeRemediationPtrOutput) +} + +// Remediation holds the remediation configuration for when the Helm upgrade +// action for the HelmRelease fails. The default is to not perform any action. +type HelmReleaseSpecUpgradeRemediationOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecUpgradeRemediationOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecUpgradeRemediation)(nil)).Elem() +} + +func (o HelmReleaseSpecUpgradeRemediationOutput) ToHelmReleaseSpecUpgradeRemediationOutput() HelmReleaseSpecUpgradeRemediationOutput { + return o +} + +func (o HelmReleaseSpecUpgradeRemediationOutput) ToHelmReleaseSpecUpgradeRemediationOutputWithContext(ctx context.Context) HelmReleaseSpecUpgradeRemediationOutput { + return o +} + +func (o HelmReleaseSpecUpgradeRemediationOutput) ToHelmReleaseSpecUpgradeRemediationPtrOutput() HelmReleaseSpecUpgradeRemediationPtrOutput { + return o.ToHelmReleaseSpecUpgradeRemediationPtrOutputWithContext(context.Background()) +} + +func (o HelmReleaseSpecUpgradeRemediationOutput) ToHelmReleaseSpecUpgradeRemediationPtrOutputWithContext(ctx context.Context) HelmReleaseSpecUpgradeRemediationPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v HelmReleaseSpecUpgradeRemediation) *HelmReleaseSpecUpgradeRemediation { + return &v + }).(HelmReleaseSpecUpgradeRemediationPtrOutput) +} + +// IgnoreTestFailures tells the controller to skip remediation when the Helm +// tests are run after an upgrade action but fail. +// Defaults to 'Test.IgnoreFailures'. +func (o HelmReleaseSpecUpgradeRemediationOutput) IgnoreTestFailures() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecUpgradeRemediation) *bool { return v.IgnoreTestFailures }).(pulumi.BoolPtrOutput) +} + +// RemediateLastFailure tells the controller to remediate the last failure, when +// no retries remain. Defaults to 'false' unless 'Retries' is greater than 0. +func (o HelmReleaseSpecUpgradeRemediationOutput) RemediateLastFailure() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecUpgradeRemediation) *bool { return v.RemediateLastFailure }).(pulumi.BoolPtrOutput) +} + +// Retries is the number of retries that should be attempted on failures before +// bailing. Remediation, using 'Strategy', is performed between each attempt. +// Defaults to '0', a negative integer equals to unlimited retries. +func (o HelmReleaseSpecUpgradeRemediationOutput) Retries() pulumi.IntPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecUpgradeRemediation) *int { return v.Retries }).(pulumi.IntPtrOutput) +} + +// Strategy to use for failure remediation. Defaults to 'rollback'. +func (o HelmReleaseSpecUpgradeRemediationOutput) Strategy() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecUpgradeRemediation) *string { return v.Strategy }).(pulumi.StringPtrOutput) +} + +type HelmReleaseSpecUpgradeRemediationPtrOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecUpgradeRemediationPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecUpgradeRemediation)(nil)).Elem() +} + +func (o HelmReleaseSpecUpgradeRemediationPtrOutput) ToHelmReleaseSpecUpgradeRemediationPtrOutput() HelmReleaseSpecUpgradeRemediationPtrOutput { + return o +} + +func (o HelmReleaseSpecUpgradeRemediationPtrOutput) ToHelmReleaseSpecUpgradeRemediationPtrOutputWithContext(ctx context.Context) HelmReleaseSpecUpgradeRemediationPtrOutput { + return o +} + +func (o HelmReleaseSpecUpgradeRemediationPtrOutput) Elem() HelmReleaseSpecUpgradeRemediationOutput { + return o.ApplyT(func(v *HelmReleaseSpecUpgradeRemediation) HelmReleaseSpecUpgradeRemediation { + if v != nil { + return *v + } + var ret HelmReleaseSpecUpgradeRemediation + return ret + }).(HelmReleaseSpecUpgradeRemediationOutput) +} + +// IgnoreTestFailures tells the controller to skip remediation when the Helm +// tests are run after an upgrade action but fail. +// Defaults to 'Test.IgnoreFailures'. +func (o HelmReleaseSpecUpgradeRemediationPtrOutput) IgnoreTestFailures() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecUpgradeRemediation) *bool { + if v == nil { + return nil + } + return v.IgnoreTestFailures + }).(pulumi.BoolPtrOutput) +} + +// RemediateLastFailure tells the controller to remediate the last failure, when +// no retries remain. Defaults to 'false' unless 'Retries' is greater than 0. +func (o HelmReleaseSpecUpgradeRemediationPtrOutput) RemediateLastFailure() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecUpgradeRemediation) *bool { + if v == nil { + return nil + } + return v.RemediateLastFailure + }).(pulumi.BoolPtrOutput) +} + +// Retries is the number of retries that should be attempted on failures before +// bailing. Remediation, using 'Strategy', is performed between each attempt. +// Defaults to '0', a negative integer equals to unlimited retries. +func (o HelmReleaseSpecUpgradeRemediationPtrOutput) Retries() pulumi.IntPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecUpgradeRemediation) *int { + if v == nil { + return nil + } + return v.Retries + }).(pulumi.IntPtrOutput) +} + +// Strategy to use for failure remediation. Defaults to 'rollback'. +func (o HelmReleaseSpecUpgradeRemediationPtrOutput) Strategy() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecUpgradeRemediation) *string { + if v == nil { + return nil + } + return v.Strategy + }).(pulumi.StringPtrOutput) +} + +// Remediation holds the remediation configuration for when the Helm upgrade +// action for the HelmRelease fails. The default is to not perform any action. +type HelmReleaseSpecUpgradeRemediationPatch struct { + // IgnoreTestFailures tells the controller to skip remediation when the Helm + // tests are run after an upgrade action but fail. + // Defaults to 'Test.IgnoreFailures'. + IgnoreTestFailures *bool `pulumi:"ignoreTestFailures"` + // RemediateLastFailure tells the controller to remediate the last failure, when + // no retries remain. Defaults to 'false' unless 'Retries' is greater than 0. + RemediateLastFailure *bool `pulumi:"remediateLastFailure"` + // Retries is the number of retries that should be attempted on failures before + // bailing. Remediation, using 'Strategy', is performed between each attempt. + // Defaults to '0', a negative integer equals to unlimited retries. + Retries *int `pulumi:"retries"` + // Strategy to use for failure remediation. Defaults to 'rollback'. + Strategy *string `pulumi:"strategy"` +} + +// HelmReleaseSpecUpgradeRemediationPatchInput is an input type that accepts HelmReleaseSpecUpgradeRemediationPatchArgs and HelmReleaseSpecUpgradeRemediationPatchOutput values. +// You can construct a concrete instance of `HelmReleaseSpecUpgradeRemediationPatchInput` via: +// +// HelmReleaseSpecUpgradeRemediationPatchArgs{...} +type HelmReleaseSpecUpgradeRemediationPatchInput interface { + pulumi.Input + + ToHelmReleaseSpecUpgradeRemediationPatchOutput() HelmReleaseSpecUpgradeRemediationPatchOutput + ToHelmReleaseSpecUpgradeRemediationPatchOutputWithContext(context.Context) HelmReleaseSpecUpgradeRemediationPatchOutput +} + +// Remediation holds the remediation configuration for when the Helm upgrade +// action for the HelmRelease fails. The default is to not perform any action. +type HelmReleaseSpecUpgradeRemediationPatchArgs struct { + // IgnoreTestFailures tells the controller to skip remediation when the Helm + // tests are run after an upgrade action but fail. + // Defaults to 'Test.IgnoreFailures'. + IgnoreTestFailures pulumi.BoolPtrInput `pulumi:"ignoreTestFailures"` + // RemediateLastFailure tells the controller to remediate the last failure, when + // no retries remain. Defaults to 'false' unless 'Retries' is greater than 0. + RemediateLastFailure pulumi.BoolPtrInput `pulumi:"remediateLastFailure"` + // Retries is the number of retries that should be attempted on failures before + // bailing. Remediation, using 'Strategy', is performed between each attempt. + // Defaults to '0', a negative integer equals to unlimited retries. + Retries pulumi.IntPtrInput `pulumi:"retries"` + // Strategy to use for failure remediation. Defaults to 'rollback'. + Strategy pulumi.StringPtrInput `pulumi:"strategy"` +} + +func (HelmReleaseSpecUpgradeRemediationPatchArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecUpgradeRemediationPatch)(nil)).Elem() +} + +func (i HelmReleaseSpecUpgradeRemediationPatchArgs) ToHelmReleaseSpecUpgradeRemediationPatchOutput() HelmReleaseSpecUpgradeRemediationPatchOutput { + return i.ToHelmReleaseSpecUpgradeRemediationPatchOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecUpgradeRemediationPatchArgs) ToHelmReleaseSpecUpgradeRemediationPatchOutputWithContext(ctx context.Context) HelmReleaseSpecUpgradeRemediationPatchOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecUpgradeRemediationPatchOutput) +} + +func (i HelmReleaseSpecUpgradeRemediationPatchArgs) ToHelmReleaseSpecUpgradeRemediationPatchPtrOutput() HelmReleaseSpecUpgradeRemediationPatchPtrOutput { + return i.ToHelmReleaseSpecUpgradeRemediationPatchPtrOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecUpgradeRemediationPatchArgs) ToHelmReleaseSpecUpgradeRemediationPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecUpgradeRemediationPatchPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecUpgradeRemediationPatchOutput).ToHelmReleaseSpecUpgradeRemediationPatchPtrOutputWithContext(ctx) +} + +// HelmReleaseSpecUpgradeRemediationPatchPtrInput is an input type that accepts HelmReleaseSpecUpgradeRemediationPatchArgs, HelmReleaseSpecUpgradeRemediationPatchPtr and HelmReleaseSpecUpgradeRemediationPatchPtrOutput values. +// You can construct a concrete instance of `HelmReleaseSpecUpgradeRemediationPatchPtrInput` via: +// +// HelmReleaseSpecUpgradeRemediationPatchArgs{...} +// +// or: +// +// nil +type HelmReleaseSpecUpgradeRemediationPatchPtrInput interface { + pulumi.Input + + ToHelmReleaseSpecUpgradeRemediationPatchPtrOutput() HelmReleaseSpecUpgradeRemediationPatchPtrOutput + ToHelmReleaseSpecUpgradeRemediationPatchPtrOutputWithContext(context.Context) HelmReleaseSpecUpgradeRemediationPatchPtrOutput +} + +type helmReleaseSpecUpgradeRemediationPatchPtrType HelmReleaseSpecUpgradeRemediationPatchArgs + +func HelmReleaseSpecUpgradeRemediationPatchPtr(v *HelmReleaseSpecUpgradeRemediationPatchArgs) HelmReleaseSpecUpgradeRemediationPatchPtrInput { + return (*helmReleaseSpecUpgradeRemediationPatchPtrType)(v) +} + +func (*helmReleaseSpecUpgradeRemediationPatchPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecUpgradeRemediationPatch)(nil)).Elem() +} + +func (i *helmReleaseSpecUpgradeRemediationPatchPtrType) ToHelmReleaseSpecUpgradeRemediationPatchPtrOutput() HelmReleaseSpecUpgradeRemediationPatchPtrOutput { + return i.ToHelmReleaseSpecUpgradeRemediationPatchPtrOutputWithContext(context.Background()) +} + +func (i *helmReleaseSpecUpgradeRemediationPatchPtrType) ToHelmReleaseSpecUpgradeRemediationPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecUpgradeRemediationPatchPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecUpgradeRemediationPatchPtrOutput) +} + +// Remediation holds the remediation configuration for when the Helm upgrade +// action for the HelmRelease fails. The default is to not perform any action. +type HelmReleaseSpecUpgradeRemediationPatchOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecUpgradeRemediationPatchOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecUpgradeRemediationPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecUpgradeRemediationPatchOutput) ToHelmReleaseSpecUpgradeRemediationPatchOutput() HelmReleaseSpecUpgradeRemediationPatchOutput { + return o +} + +func (o HelmReleaseSpecUpgradeRemediationPatchOutput) ToHelmReleaseSpecUpgradeRemediationPatchOutputWithContext(ctx context.Context) HelmReleaseSpecUpgradeRemediationPatchOutput { + return o +} + +func (o HelmReleaseSpecUpgradeRemediationPatchOutput) ToHelmReleaseSpecUpgradeRemediationPatchPtrOutput() HelmReleaseSpecUpgradeRemediationPatchPtrOutput { + return o.ToHelmReleaseSpecUpgradeRemediationPatchPtrOutputWithContext(context.Background()) +} + +func (o HelmReleaseSpecUpgradeRemediationPatchOutput) ToHelmReleaseSpecUpgradeRemediationPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecUpgradeRemediationPatchPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v HelmReleaseSpecUpgradeRemediationPatch) *HelmReleaseSpecUpgradeRemediationPatch { + return &v + }).(HelmReleaseSpecUpgradeRemediationPatchPtrOutput) +} + +// IgnoreTestFailures tells the controller to skip remediation when the Helm +// tests are run after an upgrade action but fail. +// Defaults to 'Test.IgnoreFailures'. +func (o HelmReleaseSpecUpgradeRemediationPatchOutput) IgnoreTestFailures() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecUpgradeRemediationPatch) *bool { return v.IgnoreTestFailures }).(pulumi.BoolPtrOutput) +} + +// RemediateLastFailure tells the controller to remediate the last failure, when +// no retries remain. Defaults to 'false' unless 'Retries' is greater than 0. +func (o HelmReleaseSpecUpgradeRemediationPatchOutput) RemediateLastFailure() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecUpgradeRemediationPatch) *bool { return v.RemediateLastFailure }).(pulumi.BoolPtrOutput) +} + +// Retries is the number of retries that should be attempted on failures before +// bailing. Remediation, using 'Strategy', is performed between each attempt. +// Defaults to '0', a negative integer equals to unlimited retries. +func (o HelmReleaseSpecUpgradeRemediationPatchOutput) Retries() pulumi.IntPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecUpgradeRemediationPatch) *int { return v.Retries }).(pulumi.IntPtrOutput) +} + +// Strategy to use for failure remediation. Defaults to 'rollback'. +func (o HelmReleaseSpecUpgradeRemediationPatchOutput) Strategy() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecUpgradeRemediationPatch) *string { return v.Strategy }).(pulumi.StringPtrOutput) +} + +type HelmReleaseSpecUpgradeRemediationPatchPtrOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecUpgradeRemediationPatchPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecUpgradeRemediationPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecUpgradeRemediationPatchPtrOutput) ToHelmReleaseSpecUpgradeRemediationPatchPtrOutput() HelmReleaseSpecUpgradeRemediationPatchPtrOutput { + return o +} + +func (o HelmReleaseSpecUpgradeRemediationPatchPtrOutput) ToHelmReleaseSpecUpgradeRemediationPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecUpgradeRemediationPatchPtrOutput { + return o +} + +func (o HelmReleaseSpecUpgradeRemediationPatchPtrOutput) Elem() HelmReleaseSpecUpgradeRemediationPatchOutput { + return o.ApplyT(func(v *HelmReleaseSpecUpgradeRemediationPatch) HelmReleaseSpecUpgradeRemediationPatch { + if v != nil { + return *v + } + var ret HelmReleaseSpecUpgradeRemediationPatch + return ret + }).(HelmReleaseSpecUpgradeRemediationPatchOutput) +} + +// IgnoreTestFailures tells the controller to skip remediation when the Helm +// tests are run after an upgrade action but fail. +// Defaults to 'Test.IgnoreFailures'. +func (o HelmReleaseSpecUpgradeRemediationPatchPtrOutput) IgnoreTestFailures() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecUpgradeRemediationPatch) *bool { + if v == nil { + return nil + } + return v.IgnoreTestFailures + }).(pulumi.BoolPtrOutput) +} + +// RemediateLastFailure tells the controller to remediate the last failure, when +// no retries remain. Defaults to 'false' unless 'Retries' is greater than 0. +func (o HelmReleaseSpecUpgradeRemediationPatchPtrOutput) RemediateLastFailure() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecUpgradeRemediationPatch) *bool { + if v == nil { + return nil + } + return v.RemediateLastFailure + }).(pulumi.BoolPtrOutput) +} + +// Retries is the number of retries that should be attempted on failures before +// bailing. Remediation, using 'Strategy', is performed between each attempt. +// Defaults to '0', a negative integer equals to unlimited retries. +func (o HelmReleaseSpecUpgradeRemediationPatchPtrOutput) Retries() pulumi.IntPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecUpgradeRemediationPatch) *int { + if v == nil { + return nil + } + return v.Retries + }).(pulumi.IntPtrOutput) +} + +// Strategy to use for failure remediation. Defaults to 'rollback'. +func (o HelmReleaseSpecUpgradeRemediationPatchPtrOutput) Strategy() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecUpgradeRemediationPatch) *string { + if v == nil { + return nil + } + return v.Strategy + }).(pulumi.StringPtrOutput) +} + +// Strategy defines the upgrade strategy to use for this HelmRelease. +// Defaults to 'RemediateOnFailure', or 'RetryOnFailure' when the +// DefaultToRetryOnFailure feature gate is enabled. +type HelmReleaseSpecUpgradeStrategy struct { + // Name of the upgrade strategy. + Name *string `pulumi:"name"` + // RetryInterval is the interval at which to retry a failed upgrade. + // Can be used only when Name is set to RetryOnFailure. + // Defaults to '5m'. + RetryInterval *string `pulumi:"retryInterval"` +} + +// HelmReleaseSpecUpgradeStrategyInput is an input type that accepts HelmReleaseSpecUpgradeStrategyArgs and HelmReleaseSpecUpgradeStrategyOutput values. +// You can construct a concrete instance of `HelmReleaseSpecUpgradeStrategyInput` via: +// +// HelmReleaseSpecUpgradeStrategyArgs{...} +type HelmReleaseSpecUpgradeStrategyInput interface { + pulumi.Input + + ToHelmReleaseSpecUpgradeStrategyOutput() HelmReleaseSpecUpgradeStrategyOutput + ToHelmReleaseSpecUpgradeStrategyOutputWithContext(context.Context) HelmReleaseSpecUpgradeStrategyOutput +} + +// Strategy defines the upgrade strategy to use for this HelmRelease. +// Defaults to 'RemediateOnFailure', or 'RetryOnFailure' when the +// DefaultToRetryOnFailure feature gate is enabled. +type HelmReleaseSpecUpgradeStrategyArgs struct { + // Name of the upgrade strategy. + Name pulumi.StringPtrInput `pulumi:"name"` + // RetryInterval is the interval at which to retry a failed upgrade. + // Can be used only when Name is set to RetryOnFailure. + // Defaults to '5m'. + RetryInterval pulumi.StringPtrInput `pulumi:"retryInterval"` +} + +func (HelmReleaseSpecUpgradeStrategyArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecUpgradeStrategy)(nil)).Elem() +} + +func (i HelmReleaseSpecUpgradeStrategyArgs) ToHelmReleaseSpecUpgradeStrategyOutput() HelmReleaseSpecUpgradeStrategyOutput { + return i.ToHelmReleaseSpecUpgradeStrategyOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecUpgradeStrategyArgs) ToHelmReleaseSpecUpgradeStrategyOutputWithContext(ctx context.Context) HelmReleaseSpecUpgradeStrategyOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecUpgradeStrategyOutput) +} + +func (i HelmReleaseSpecUpgradeStrategyArgs) ToHelmReleaseSpecUpgradeStrategyPtrOutput() HelmReleaseSpecUpgradeStrategyPtrOutput { + return i.ToHelmReleaseSpecUpgradeStrategyPtrOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecUpgradeStrategyArgs) ToHelmReleaseSpecUpgradeStrategyPtrOutputWithContext(ctx context.Context) HelmReleaseSpecUpgradeStrategyPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecUpgradeStrategyOutput).ToHelmReleaseSpecUpgradeStrategyPtrOutputWithContext(ctx) +} + +// HelmReleaseSpecUpgradeStrategyPtrInput is an input type that accepts HelmReleaseSpecUpgradeStrategyArgs, HelmReleaseSpecUpgradeStrategyPtr and HelmReleaseSpecUpgradeStrategyPtrOutput values. +// You can construct a concrete instance of `HelmReleaseSpecUpgradeStrategyPtrInput` via: +// +// HelmReleaseSpecUpgradeStrategyArgs{...} +// +// or: +// +// nil +type HelmReleaseSpecUpgradeStrategyPtrInput interface { + pulumi.Input + + ToHelmReleaseSpecUpgradeStrategyPtrOutput() HelmReleaseSpecUpgradeStrategyPtrOutput + ToHelmReleaseSpecUpgradeStrategyPtrOutputWithContext(context.Context) HelmReleaseSpecUpgradeStrategyPtrOutput +} + +type helmReleaseSpecUpgradeStrategyPtrType HelmReleaseSpecUpgradeStrategyArgs + +func HelmReleaseSpecUpgradeStrategyPtr(v *HelmReleaseSpecUpgradeStrategyArgs) HelmReleaseSpecUpgradeStrategyPtrInput { + return (*helmReleaseSpecUpgradeStrategyPtrType)(v) +} + +func (*helmReleaseSpecUpgradeStrategyPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecUpgradeStrategy)(nil)).Elem() +} + +func (i *helmReleaseSpecUpgradeStrategyPtrType) ToHelmReleaseSpecUpgradeStrategyPtrOutput() HelmReleaseSpecUpgradeStrategyPtrOutput { + return i.ToHelmReleaseSpecUpgradeStrategyPtrOutputWithContext(context.Background()) +} + +func (i *helmReleaseSpecUpgradeStrategyPtrType) ToHelmReleaseSpecUpgradeStrategyPtrOutputWithContext(ctx context.Context) HelmReleaseSpecUpgradeStrategyPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecUpgradeStrategyPtrOutput) +} + +// Strategy defines the upgrade strategy to use for this HelmRelease. +// Defaults to 'RemediateOnFailure', or 'RetryOnFailure' when the +// DefaultToRetryOnFailure feature gate is enabled. +type HelmReleaseSpecUpgradeStrategyOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecUpgradeStrategyOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecUpgradeStrategy)(nil)).Elem() +} + +func (o HelmReleaseSpecUpgradeStrategyOutput) ToHelmReleaseSpecUpgradeStrategyOutput() HelmReleaseSpecUpgradeStrategyOutput { + return o +} + +func (o HelmReleaseSpecUpgradeStrategyOutput) ToHelmReleaseSpecUpgradeStrategyOutputWithContext(ctx context.Context) HelmReleaseSpecUpgradeStrategyOutput { + return o +} + +func (o HelmReleaseSpecUpgradeStrategyOutput) ToHelmReleaseSpecUpgradeStrategyPtrOutput() HelmReleaseSpecUpgradeStrategyPtrOutput { + return o.ToHelmReleaseSpecUpgradeStrategyPtrOutputWithContext(context.Background()) +} + +func (o HelmReleaseSpecUpgradeStrategyOutput) ToHelmReleaseSpecUpgradeStrategyPtrOutputWithContext(ctx context.Context) HelmReleaseSpecUpgradeStrategyPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v HelmReleaseSpecUpgradeStrategy) *HelmReleaseSpecUpgradeStrategy { + return &v + }).(HelmReleaseSpecUpgradeStrategyPtrOutput) +} + +// Name of the upgrade strategy. +func (o HelmReleaseSpecUpgradeStrategyOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecUpgradeStrategy) *string { return v.Name }).(pulumi.StringPtrOutput) +} + +// RetryInterval is the interval at which to retry a failed upgrade. +// Can be used only when Name is set to RetryOnFailure. +// Defaults to '5m'. +func (o HelmReleaseSpecUpgradeStrategyOutput) RetryInterval() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecUpgradeStrategy) *string { return v.RetryInterval }).(pulumi.StringPtrOutput) +} + +type HelmReleaseSpecUpgradeStrategyPtrOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecUpgradeStrategyPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecUpgradeStrategy)(nil)).Elem() +} + +func (o HelmReleaseSpecUpgradeStrategyPtrOutput) ToHelmReleaseSpecUpgradeStrategyPtrOutput() HelmReleaseSpecUpgradeStrategyPtrOutput { + return o +} + +func (o HelmReleaseSpecUpgradeStrategyPtrOutput) ToHelmReleaseSpecUpgradeStrategyPtrOutputWithContext(ctx context.Context) HelmReleaseSpecUpgradeStrategyPtrOutput { + return o +} + +func (o HelmReleaseSpecUpgradeStrategyPtrOutput) Elem() HelmReleaseSpecUpgradeStrategyOutput { + return o.ApplyT(func(v *HelmReleaseSpecUpgradeStrategy) HelmReleaseSpecUpgradeStrategy { + if v != nil { + return *v + } + var ret HelmReleaseSpecUpgradeStrategy + return ret + }).(HelmReleaseSpecUpgradeStrategyOutput) +} + +// Name of the upgrade strategy. +func (o HelmReleaseSpecUpgradeStrategyPtrOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecUpgradeStrategy) *string { + if v == nil { + return nil + } + return v.Name + }).(pulumi.StringPtrOutput) +} + +// RetryInterval is the interval at which to retry a failed upgrade. +// Can be used only when Name is set to RetryOnFailure. +// Defaults to '5m'. +func (o HelmReleaseSpecUpgradeStrategyPtrOutput) RetryInterval() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecUpgradeStrategy) *string { + if v == nil { + return nil + } + return v.RetryInterval + }).(pulumi.StringPtrOutput) +} + +// Strategy defines the upgrade strategy to use for this HelmRelease. +// Defaults to 'RemediateOnFailure', or 'RetryOnFailure' when the +// DefaultToRetryOnFailure feature gate is enabled. +type HelmReleaseSpecUpgradeStrategyPatch struct { + // Name of the upgrade strategy. + Name *string `pulumi:"name"` + // RetryInterval is the interval at which to retry a failed upgrade. + // Can be used only when Name is set to RetryOnFailure. + // Defaults to '5m'. + RetryInterval *string `pulumi:"retryInterval"` +} + +// HelmReleaseSpecUpgradeStrategyPatchInput is an input type that accepts HelmReleaseSpecUpgradeStrategyPatchArgs and HelmReleaseSpecUpgradeStrategyPatchOutput values. +// You can construct a concrete instance of `HelmReleaseSpecUpgradeStrategyPatchInput` via: +// +// HelmReleaseSpecUpgradeStrategyPatchArgs{...} +type HelmReleaseSpecUpgradeStrategyPatchInput interface { + pulumi.Input + + ToHelmReleaseSpecUpgradeStrategyPatchOutput() HelmReleaseSpecUpgradeStrategyPatchOutput + ToHelmReleaseSpecUpgradeStrategyPatchOutputWithContext(context.Context) HelmReleaseSpecUpgradeStrategyPatchOutput +} + +// Strategy defines the upgrade strategy to use for this HelmRelease. +// Defaults to 'RemediateOnFailure', or 'RetryOnFailure' when the +// DefaultToRetryOnFailure feature gate is enabled. +type HelmReleaseSpecUpgradeStrategyPatchArgs struct { + // Name of the upgrade strategy. + Name pulumi.StringPtrInput `pulumi:"name"` + // RetryInterval is the interval at which to retry a failed upgrade. + // Can be used only when Name is set to RetryOnFailure. + // Defaults to '5m'. + RetryInterval pulumi.StringPtrInput `pulumi:"retryInterval"` +} + +func (HelmReleaseSpecUpgradeStrategyPatchArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecUpgradeStrategyPatch)(nil)).Elem() +} + +func (i HelmReleaseSpecUpgradeStrategyPatchArgs) ToHelmReleaseSpecUpgradeStrategyPatchOutput() HelmReleaseSpecUpgradeStrategyPatchOutput { + return i.ToHelmReleaseSpecUpgradeStrategyPatchOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecUpgradeStrategyPatchArgs) ToHelmReleaseSpecUpgradeStrategyPatchOutputWithContext(ctx context.Context) HelmReleaseSpecUpgradeStrategyPatchOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecUpgradeStrategyPatchOutput) +} + +func (i HelmReleaseSpecUpgradeStrategyPatchArgs) ToHelmReleaseSpecUpgradeStrategyPatchPtrOutput() HelmReleaseSpecUpgradeStrategyPatchPtrOutput { + return i.ToHelmReleaseSpecUpgradeStrategyPatchPtrOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecUpgradeStrategyPatchArgs) ToHelmReleaseSpecUpgradeStrategyPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecUpgradeStrategyPatchPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecUpgradeStrategyPatchOutput).ToHelmReleaseSpecUpgradeStrategyPatchPtrOutputWithContext(ctx) +} + +// HelmReleaseSpecUpgradeStrategyPatchPtrInput is an input type that accepts HelmReleaseSpecUpgradeStrategyPatchArgs, HelmReleaseSpecUpgradeStrategyPatchPtr and HelmReleaseSpecUpgradeStrategyPatchPtrOutput values. +// You can construct a concrete instance of `HelmReleaseSpecUpgradeStrategyPatchPtrInput` via: +// +// HelmReleaseSpecUpgradeStrategyPatchArgs{...} +// +// or: +// +// nil +type HelmReleaseSpecUpgradeStrategyPatchPtrInput interface { + pulumi.Input + + ToHelmReleaseSpecUpgradeStrategyPatchPtrOutput() HelmReleaseSpecUpgradeStrategyPatchPtrOutput + ToHelmReleaseSpecUpgradeStrategyPatchPtrOutputWithContext(context.Context) HelmReleaseSpecUpgradeStrategyPatchPtrOutput +} + +type helmReleaseSpecUpgradeStrategyPatchPtrType HelmReleaseSpecUpgradeStrategyPatchArgs + +func HelmReleaseSpecUpgradeStrategyPatchPtr(v *HelmReleaseSpecUpgradeStrategyPatchArgs) HelmReleaseSpecUpgradeStrategyPatchPtrInput { + return (*helmReleaseSpecUpgradeStrategyPatchPtrType)(v) +} + +func (*helmReleaseSpecUpgradeStrategyPatchPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecUpgradeStrategyPatch)(nil)).Elem() +} + +func (i *helmReleaseSpecUpgradeStrategyPatchPtrType) ToHelmReleaseSpecUpgradeStrategyPatchPtrOutput() HelmReleaseSpecUpgradeStrategyPatchPtrOutput { + return i.ToHelmReleaseSpecUpgradeStrategyPatchPtrOutputWithContext(context.Background()) +} + +func (i *helmReleaseSpecUpgradeStrategyPatchPtrType) ToHelmReleaseSpecUpgradeStrategyPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecUpgradeStrategyPatchPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecUpgradeStrategyPatchPtrOutput) +} + +// Strategy defines the upgrade strategy to use for this HelmRelease. +// Defaults to 'RemediateOnFailure', or 'RetryOnFailure' when the +// DefaultToRetryOnFailure feature gate is enabled. +type HelmReleaseSpecUpgradeStrategyPatchOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecUpgradeStrategyPatchOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecUpgradeStrategyPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecUpgradeStrategyPatchOutput) ToHelmReleaseSpecUpgradeStrategyPatchOutput() HelmReleaseSpecUpgradeStrategyPatchOutput { + return o +} + +func (o HelmReleaseSpecUpgradeStrategyPatchOutput) ToHelmReleaseSpecUpgradeStrategyPatchOutputWithContext(ctx context.Context) HelmReleaseSpecUpgradeStrategyPatchOutput { + return o +} + +func (o HelmReleaseSpecUpgradeStrategyPatchOutput) ToHelmReleaseSpecUpgradeStrategyPatchPtrOutput() HelmReleaseSpecUpgradeStrategyPatchPtrOutput { + return o.ToHelmReleaseSpecUpgradeStrategyPatchPtrOutputWithContext(context.Background()) +} + +func (o HelmReleaseSpecUpgradeStrategyPatchOutput) ToHelmReleaseSpecUpgradeStrategyPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecUpgradeStrategyPatchPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v HelmReleaseSpecUpgradeStrategyPatch) *HelmReleaseSpecUpgradeStrategyPatch { + return &v + }).(HelmReleaseSpecUpgradeStrategyPatchPtrOutput) +} + +// Name of the upgrade strategy. +func (o HelmReleaseSpecUpgradeStrategyPatchOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecUpgradeStrategyPatch) *string { return v.Name }).(pulumi.StringPtrOutput) +} + +// RetryInterval is the interval at which to retry a failed upgrade. +// Can be used only when Name is set to RetryOnFailure. +// Defaults to '5m'. +func (o HelmReleaseSpecUpgradeStrategyPatchOutput) RetryInterval() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecUpgradeStrategyPatch) *string { return v.RetryInterval }).(pulumi.StringPtrOutput) +} + +type HelmReleaseSpecUpgradeStrategyPatchPtrOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecUpgradeStrategyPatchPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecUpgradeStrategyPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecUpgradeStrategyPatchPtrOutput) ToHelmReleaseSpecUpgradeStrategyPatchPtrOutput() HelmReleaseSpecUpgradeStrategyPatchPtrOutput { + return o +} + +func (o HelmReleaseSpecUpgradeStrategyPatchPtrOutput) ToHelmReleaseSpecUpgradeStrategyPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecUpgradeStrategyPatchPtrOutput { + return o +} + +func (o HelmReleaseSpecUpgradeStrategyPatchPtrOutput) Elem() HelmReleaseSpecUpgradeStrategyPatchOutput { + return o.ApplyT(func(v *HelmReleaseSpecUpgradeStrategyPatch) HelmReleaseSpecUpgradeStrategyPatch { + if v != nil { + return *v + } + var ret HelmReleaseSpecUpgradeStrategyPatch + return ret + }).(HelmReleaseSpecUpgradeStrategyPatchOutput) +} + +// Name of the upgrade strategy. +func (o HelmReleaseSpecUpgradeStrategyPatchPtrOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecUpgradeStrategyPatch) *string { + if v == nil { + return nil + } + return v.Name + }).(pulumi.StringPtrOutput) +} + +// RetryInterval is the interval at which to retry a failed upgrade. +// Can be used only when Name is set to RetryOnFailure. +// Defaults to '5m'. +func (o HelmReleaseSpecUpgradeStrategyPatchPtrOutput) RetryInterval() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecUpgradeStrategyPatch) *string { + if v == nil { + return nil + } + return v.RetryInterval + }).(pulumi.StringPtrOutput) +} + +// ValuesReference contains a reference to a resource containing Helm values, +// and optionally the key they can be found at. +type HelmReleaseSpecValuesFrom struct { + // Kind of the values referent, valid values are ('Secret', 'ConfigMap'). + Kind *string `pulumi:"kind"` + // Name of the values referent. Should reside in the same namespace as the + // referring resource. + Name *string `pulumi:"name"` + // Optional marks this ValuesReference as optional. When set, a not found error + // for the values reference is ignored, but any ValuesKey, TargetPath or + // transient error will still result in a reconciliation failure. + Optional *bool `pulumi:"optional"` + // TargetPath is the YAML dot notation path the value should be merged at. When + // set, the ValuesKey is expected to be a single flat value. Defaults to 'None', + // which results in the values getting merged at the root. + TargetPath *string `pulumi:"targetPath"` + // ValuesKey is the data key where the values.yaml or a specific value can be + // found at. Defaults to 'values.yaml'. + ValuesKey *string `pulumi:"valuesKey"` +} + +// HelmReleaseSpecValuesFromInput is an input type that accepts HelmReleaseSpecValuesFromArgs and HelmReleaseSpecValuesFromOutput values. +// You can construct a concrete instance of `HelmReleaseSpecValuesFromInput` via: +// +// HelmReleaseSpecValuesFromArgs{...} +type HelmReleaseSpecValuesFromInput interface { + pulumi.Input + + ToHelmReleaseSpecValuesFromOutput() HelmReleaseSpecValuesFromOutput + ToHelmReleaseSpecValuesFromOutputWithContext(context.Context) HelmReleaseSpecValuesFromOutput +} + +// ValuesReference contains a reference to a resource containing Helm values, +// and optionally the key they can be found at. +type HelmReleaseSpecValuesFromArgs struct { + // Kind of the values referent, valid values are ('Secret', 'ConfigMap'). + Kind pulumi.StringPtrInput `pulumi:"kind"` + // Name of the values referent. Should reside in the same namespace as the + // referring resource. + Name pulumi.StringPtrInput `pulumi:"name"` + // Optional marks this ValuesReference as optional. When set, a not found error + // for the values reference is ignored, but any ValuesKey, TargetPath or + // transient error will still result in a reconciliation failure. + Optional pulumi.BoolPtrInput `pulumi:"optional"` + // TargetPath is the YAML dot notation path the value should be merged at. When + // set, the ValuesKey is expected to be a single flat value. Defaults to 'None', + // which results in the values getting merged at the root. + TargetPath pulumi.StringPtrInput `pulumi:"targetPath"` + // ValuesKey is the data key where the values.yaml or a specific value can be + // found at. Defaults to 'values.yaml'. + ValuesKey pulumi.StringPtrInput `pulumi:"valuesKey"` +} + +func (HelmReleaseSpecValuesFromArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecValuesFrom)(nil)).Elem() +} + +func (i HelmReleaseSpecValuesFromArgs) ToHelmReleaseSpecValuesFromOutput() HelmReleaseSpecValuesFromOutput { + return i.ToHelmReleaseSpecValuesFromOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecValuesFromArgs) ToHelmReleaseSpecValuesFromOutputWithContext(ctx context.Context) HelmReleaseSpecValuesFromOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecValuesFromOutput) +} + +// HelmReleaseSpecValuesFromArrayInput is an input type that accepts HelmReleaseSpecValuesFromArray and HelmReleaseSpecValuesFromArrayOutput values. +// You can construct a concrete instance of `HelmReleaseSpecValuesFromArrayInput` via: +// +// HelmReleaseSpecValuesFromArray{ HelmReleaseSpecValuesFromArgs{...} } +type HelmReleaseSpecValuesFromArrayInput interface { + pulumi.Input + + ToHelmReleaseSpecValuesFromArrayOutput() HelmReleaseSpecValuesFromArrayOutput + ToHelmReleaseSpecValuesFromArrayOutputWithContext(context.Context) HelmReleaseSpecValuesFromArrayOutput +} + +type HelmReleaseSpecValuesFromArray []HelmReleaseSpecValuesFromInput + +func (HelmReleaseSpecValuesFromArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]HelmReleaseSpecValuesFrom)(nil)).Elem() +} + +func (i HelmReleaseSpecValuesFromArray) ToHelmReleaseSpecValuesFromArrayOutput() HelmReleaseSpecValuesFromArrayOutput { + return i.ToHelmReleaseSpecValuesFromArrayOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecValuesFromArray) ToHelmReleaseSpecValuesFromArrayOutputWithContext(ctx context.Context) HelmReleaseSpecValuesFromArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecValuesFromArrayOutput) +} + +// ValuesReference contains a reference to a resource containing Helm values, +// and optionally the key they can be found at. +type HelmReleaseSpecValuesFromOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecValuesFromOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecValuesFrom)(nil)).Elem() +} + +func (o HelmReleaseSpecValuesFromOutput) ToHelmReleaseSpecValuesFromOutput() HelmReleaseSpecValuesFromOutput { + return o +} + +func (o HelmReleaseSpecValuesFromOutput) ToHelmReleaseSpecValuesFromOutputWithContext(ctx context.Context) HelmReleaseSpecValuesFromOutput { + return o +} + +// Kind of the values referent, valid values are ('Secret', 'ConfigMap'). +func (o HelmReleaseSpecValuesFromOutput) Kind() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecValuesFrom) *string { return v.Kind }).(pulumi.StringPtrOutput) +} + +// Name of the values referent. Should reside in the same namespace as the +// referring resource. +func (o HelmReleaseSpecValuesFromOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecValuesFrom) *string { return v.Name }).(pulumi.StringPtrOutput) +} + +// Optional marks this ValuesReference as optional. When set, a not found error +// for the values reference is ignored, but any ValuesKey, TargetPath or +// transient error will still result in a reconciliation failure. +func (o HelmReleaseSpecValuesFromOutput) Optional() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecValuesFrom) *bool { return v.Optional }).(pulumi.BoolPtrOutput) +} + +// TargetPath is the YAML dot notation path the value should be merged at. When +// set, the ValuesKey is expected to be a single flat value. Defaults to 'None', +// which results in the values getting merged at the root. +func (o HelmReleaseSpecValuesFromOutput) TargetPath() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecValuesFrom) *string { return v.TargetPath }).(pulumi.StringPtrOutput) +} + +// ValuesKey is the data key where the values.yaml or a specific value can be +// found at. Defaults to 'values.yaml'. +func (o HelmReleaseSpecValuesFromOutput) ValuesKey() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecValuesFrom) *string { return v.ValuesKey }).(pulumi.StringPtrOutput) +} + +type HelmReleaseSpecValuesFromArrayOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecValuesFromArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]HelmReleaseSpecValuesFrom)(nil)).Elem() +} + +func (o HelmReleaseSpecValuesFromArrayOutput) ToHelmReleaseSpecValuesFromArrayOutput() HelmReleaseSpecValuesFromArrayOutput { + return o +} + +func (o HelmReleaseSpecValuesFromArrayOutput) ToHelmReleaseSpecValuesFromArrayOutputWithContext(ctx context.Context) HelmReleaseSpecValuesFromArrayOutput { + return o +} + +func (o HelmReleaseSpecValuesFromArrayOutput) Index(i pulumi.IntInput) HelmReleaseSpecValuesFromOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) HelmReleaseSpecValuesFrom { + return vs[0].([]HelmReleaseSpecValuesFrom)[vs[1].(int)] + }).(HelmReleaseSpecValuesFromOutput) +} + +// ValuesReference contains a reference to a resource containing Helm values, +// and optionally the key they can be found at. +type HelmReleaseSpecValuesFromPatch struct { + // Kind of the values referent, valid values are ('Secret', 'ConfigMap'). + Kind *string `pulumi:"kind"` + // Name of the values referent. Should reside in the same namespace as the + // referring resource. + Name *string `pulumi:"name"` + // Optional marks this ValuesReference as optional. When set, a not found error + // for the values reference is ignored, but any ValuesKey, TargetPath or + // transient error will still result in a reconciliation failure. + Optional *bool `pulumi:"optional"` + // TargetPath is the YAML dot notation path the value should be merged at. When + // set, the ValuesKey is expected to be a single flat value. Defaults to 'None', + // which results in the values getting merged at the root. + TargetPath *string `pulumi:"targetPath"` + // ValuesKey is the data key where the values.yaml or a specific value can be + // found at. Defaults to 'values.yaml'. + ValuesKey *string `pulumi:"valuesKey"` +} + +// HelmReleaseSpecValuesFromPatchInput is an input type that accepts HelmReleaseSpecValuesFromPatchArgs and HelmReleaseSpecValuesFromPatchOutput values. +// You can construct a concrete instance of `HelmReleaseSpecValuesFromPatchInput` via: +// +// HelmReleaseSpecValuesFromPatchArgs{...} +type HelmReleaseSpecValuesFromPatchInput interface { + pulumi.Input + + ToHelmReleaseSpecValuesFromPatchOutput() HelmReleaseSpecValuesFromPatchOutput + ToHelmReleaseSpecValuesFromPatchOutputWithContext(context.Context) HelmReleaseSpecValuesFromPatchOutput +} + +// ValuesReference contains a reference to a resource containing Helm values, +// and optionally the key they can be found at. +type HelmReleaseSpecValuesFromPatchArgs struct { + // Kind of the values referent, valid values are ('Secret', 'ConfigMap'). + Kind pulumi.StringPtrInput `pulumi:"kind"` + // Name of the values referent. Should reside in the same namespace as the + // referring resource. + Name pulumi.StringPtrInput `pulumi:"name"` + // Optional marks this ValuesReference as optional. When set, a not found error + // for the values reference is ignored, but any ValuesKey, TargetPath or + // transient error will still result in a reconciliation failure. + Optional pulumi.BoolPtrInput `pulumi:"optional"` + // TargetPath is the YAML dot notation path the value should be merged at. When + // set, the ValuesKey is expected to be a single flat value. Defaults to 'None', + // which results in the values getting merged at the root. + TargetPath pulumi.StringPtrInput `pulumi:"targetPath"` + // ValuesKey is the data key where the values.yaml or a specific value can be + // found at. Defaults to 'values.yaml'. + ValuesKey pulumi.StringPtrInput `pulumi:"valuesKey"` +} + +func (HelmReleaseSpecValuesFromPatchArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecValuesFromPatch)(nil)).Elem() +} + +func (i HelmReleaseSpecValuesFromPatchArgs) ToHelmReleaseSpecValuesFromPatchOutput() HelmReleaseSpecValuesFromPatchOutput { + return i.ToHelmReleaseSpecValuesFromPatchOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecValuesFromPatchArgs) ToHelmReleaseSpecValuesFromPatchOutputWithContext(ctx context.Context) HelmReleaseSpecValuesFromPatchOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecValuesFromPatchOutput) +} + +// HelmReleaseSpecValuesFromPatchArrayInput is an input type that accepts HelmReleaseSpecValuesFromPatchArray and HelmReleaseSpecValuesFromPatchArrayOutput values. +// You can construct a concrete instance of `HelmReleaseSpecValuesFromPatchArrayInput` via: +// +// HelmReleaseSpecValuesFromPatchArray{ HelmReleaseSpecValuesFromPatchArgs{...} } +type HelmReleaseSpecValuesFromPatchArrayInput interface { + pulumi.Input + + ToHelmReleaseSpecValuesFromPatchArrayOutput() HelmReleaseSpecValuesFromPatchArrayOutput + ToHelmReleaseSpecValuesFromPatchArrayOutputWithContext(context.Context) HelmReleaseSpecValuesFromPatchArrayOutput +} + +type HelmReleaseSpecValuesFromPatchArray []HelmReleaseSpecValuesFromPatchInput + +func (HelmReleaseSpecValuesFromPatchArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]HelmReleaseSpecValuesFromPatch)(nil)).Elem() +} + +func (i HelmReleaseSpecValuesFromPatchArray) ToHelmReleaseSpecValuesFromPatchArrayOutput() HelmReleaseSpecValuesFromPatchArrayOutput { + return i.ToHelmReleaseSpecValuesFromPatchArrayOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecValuesFromPatchArray) ToHelmReleaseSpecValuesFromPatchArrayOutputWithContext(ctx context.Context) HelmReleaseSpecValuesFromPatchArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecValuesFromPatchArrayOutput) +} + +// ValuesReference contains a reference to a resource containing Helm values, +// and optionally the key they can be found at. +type HelmReleaseSpecValuesFromPatchOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecValuesFromPatchOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecValuesFromPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecValuesFromPatchOutput) ToHelmReleaseSpecValuesFromPatchOutput() HelmReleaseSpecValuesFromPatchOutput { + return o +} + +func (o HelmReleaseSpecValuesFromPatchOutput) ToHelmReleaseSpecValuesFromPatchOutputWithContext(ctx context.Context) HelmReleaseSpecValuesFromPatchOutput { + return o +} + +// Kind of the values referent, valid values are ('Secret', 'ConfigMap'). +func (o HelmReleaseSpecValuesFromPatchOutput) Kind() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecValuesFromPatch) *string { return v.Kind }).(pulumi.StringPtrOutput) +} + +// Name of the values referent. Should reside in the same namespace as the +// referring resource. +func (o HelmReleaseSpecValuesFromPatchOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecValuesFromPatch) *string { return v.Name }).(pulumi.StringPtrOutput) +} + +// Optional marks this ValuesReference as optional. When set, a not found error +// for the values reference is ignored, but any ValuesKey, TargetPath or +// transient error will still result in a reconciliation failure. +func (o HelmReleaseSpecValuesFromPatchOutput) Optional() pulumi.BoolPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecValuesFromPatch) *bool { return v.Optional }).(pulumi.BoolPtrOutput) +} + +// TargetPath is the YAML dot notation path the value should be merged at. When +// set, the ValuesKey is expected to be a single flat value. Defaults to 'None', +// which results in the values getting merged at the root. +func (o HelmReleaseSpecValuesFromPatchOutput) TargetPath() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecValuesFromPatch) *string { return v.TargetPath }).(pulumi.StringPtrOutput) +} + +// ValuesKey is the data key where the values.yaml or a specific value can be +// found at. Defaults to 'values.yaml'. +func (o HelmReleaseSpecValuesFromPatchOutput) ValuesKey() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecValuesFromPatch) *string { return v.ValuesKey }).(pulumi.StringPtrOutput) +} + +type HelmReleaseSpecValuesFromPatchArrayOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecValuesFromPatchArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]HelmReleaseSpecValuesFromPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecValuesFromPatchArrayOutput) ToHelmReleaseSpecValuesFromPatchArrayOutput() HelmReleaseSpecValuesFromPatchArrayOutput { + return o +} + +func (o HelmReleaseSpecValuesFromPatchArrayOutput) ToHelmReleaseSpecValuesFromPatchArrayOutputWithContext(ctx context.Context) HelmReleaseSpecValuesFromPatchArrayOutput { + return o +} + +func (o HelmReleaseSpecValuesFromPatchArrayOutput) Index(i pulumi.IntInput) HelmReleaseSpecValuesFromPatchOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) HelmReleaseSpecValuesFromPatch { + return vs[0].([]HelmReleaseSpecValuesFromPatch)[vs[1].(int)] + }).(HelmReleaseSpecValuesFromPatchOutput) +} + +// WaitStrategy defines Helm's wait strategy for waiting for applied +// resources to become ready. +type HelmReleaseSpecWaitStrategy struct { + // Name is Helm's wait strategy for waiting for applied resources to + // become ready. One of 'poller' or 'legacy'. The 'poller' strategy uses + // kstatus to poll resource statuses, while the 'legacy' strategy uses + // Helm v3's waiting logic. + // Defaults to 'poller', or to 'legacy' when UseHelm3Defaults feature + // gate is enabled. + Name *string `pulumi:"name"` +} + +// HelmReleaseSpecWaitStrategyInput is an input type that accepts HelmReleaseSpecWaitStrategyArgs and HelmReleaseSpecWaitStrategyOutput values. +// You can construct a concrete instance of `HelmReleaseSpecWaitStrategyInput` via: +// +// HelmReleaseSpecWaitStrategyArgs{...} +type HelmReleaseSpecWaitStrategyInput interface { + pulumi.Input + + ToHelmReleaseSpecWaitStrategyOutput() HelmReleaseSpecWaitStrategyOutput + ToHelmReleaseSpecWaitStrategyOutputWithContext(context.Context) HelmReleaseSpecWaitStrategyOutput +} + +// WaitStrategy defines Helm's wait strategy for waiting for applied +// resources to become ready. +type HelmReleaseSpecWaitStrategyArgs struct { + // Name is Helm's wait strategy for waiting for applied resources to + // become ready. One of 'poller' or 'legacy'. The 'poller' strategy uses + // kstatus to poll resource statuses, while the 'legacy' strategy uses + // Helm v3's waiting logic. + // Defaults to 'poller', or to 'legacy' when UseHelm3Defaults feature + // gate is enabled. + Name pulumi.StringPtrInput `pulumi:"name"` +} + +func (HelmReleaseSpecWaitStrategyArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecWaitStrategy)(nil)).Elem() +} + +func (i HelmReleaseSpecWaitStrategyArgs) ToHelmReleaseSpecWaitStrategyOutput() HelmReleaseSpecWaitStrategyOutput { + return i.ToHelmReleaseSpecWaitStrategyOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecWaitStrategyArgs) ToHelmReleaseSpecWaitStrategyOutputWithContext(ctx context.Context) HelmReleaseSpecWaitStrategyOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecWaitStrategyOutput) +} + +func (i HelmReleaseSpecWaitStrategyArgs) ToHelmReleaseSpecWaitStrategyPtrOutput() HelmReleaseSpecWaitStrategyPtrOutput { + return i.ToHelmReleaseSpecWaitStrategyPtrOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecWaitStrategyArgs) ToHelmReleaseSpecWaitStrategyPtrOutputWithContext(ctx context.Context) HelmReleaseSpecWaitStrategyPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecWaitStrategyOutput).ToHelmReleaseSpecWaitStrategyPtrOutputWithContext(ctx) +} + +// HelmReleaseSpecWaitStrategyPtrInput is an input type that accepts HelmReleaseSpecWaitStrategyArgs, HelmReleaseSpecWaitStrategyPtr and HelmReleaseSpecWaitStrategyPtrOutput values. +// You can construct a concrete instance of `HelmReleaseSpecWaitStrategyPtrInput` via: +// +// HelmReleaseSpecWaitStrategyArgs{...} +// +// or: +// +// nil +type HelmReleaseSpecWaitStrategyPtrInput interface { + pulumi.Input + + ToHelmReleaseSpecWaitStrategyPtrOutput() HelmReleaseSpecWaitStrategyPtrOutput + ToHelmReleaseSpecWaitStrategyPtrOutputWithContext(context.Context) HelmReleaseSpecWaitStrategyPtrOutput +} + +type helmReleaseSpecWaitStrategyPtrType HelmReleaseSpecWaitStrategyArgs + +func HelmReleaseSpecWaitStrategyPtr(v *HelmReleaseSpecWaitStrategyArgs) HelmReleaseSpecWaitStrategyPtrInput { + return (*helmReleaseSpecWaitStrategyPtrType)(v) +} + +func (*helmReleaseSpecWaitStrategyPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecWaitStrategy)(nil)).Elem() +} + +func (i *helmReleaseSpecWaitStrategyPtrType) ToHelmReleaseSpecWaitStrategyPtrOutput() HelmReleaseSpecWaitStrategyPtrOutput { + return i.ToHelmReleaseSpecWaitStrategyPtrOutputWithContext(context.Background()) +} + +func (i *helmReleaseSpecWaitStrategyPtrType) ToHelmReleaseSpecWaitStrategyPtrOutputWithContext(ctx context.Context) HelmReleaseSpecWaitStrategyPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecWaitStrategyPtrOutput) +} + +// WaitStrategy defines Helm's wait strategy for waiting for applied +// resources to become ready. +type HelmReleaseSpecWaitStrategyOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecWaitStrategyOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecWaitStrategy)(nil)).Elem() +} + +func (o HelmReleaseSpecWaitStrategyOutput) ToHelmReleaseSpecWaitStrategyOutput() HelmReleaseSpecWaitStrategyOutput { + return o +} + +func (o HelmReleaseSpecWaitStrategyOutput) ToHelmReleaseSpecWaitStrategyOutputWithContext(ctx context.Context) HelmReleaseSpecWaitStrategyOutput { + return o +} + +func (o HelmReleaseSpecWaitStrategyOutput) ToHelmReleaseSpecWaitStrategyPtrOutput() HelmReleaseSpecWaitStrategyPtrOutput { + return o.ToHelmReleaseSpecWaitStrategyPtrOutputWithContext(context.Background()) +} + +func (o HelmReleaseSpecWaitStrategyOutput) ToHelmReleaseSpecWaitStrategyPtrOutputWithContext(ctx context.Context) HelmReleaseSpecWaitStrategyPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v HelmReleaseSpecWaitStrategy) *HelmReleaseSpecWaitStrategy { + return &v + }).(HelmReleaseSpecWaitStrategyPtrOutput) +} + +// Name is Helm's wait strategy for waiting for applied resources to +// become ready. One of 'poller' or 'legacy'. The 'poller' strategy uses +// kstatus to poll resource statuses, while the 'legacy' strategy uses +// Helm v3's waiting logic. +// Defaults to 'poller', or to 'legacy' when UseHelm3Defaults feature +// gate is enabled. +func (o HelmReleaseSpecWaitStrategyOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecWaitStrategy) *string { return v.Name }).(pulumi.StringPtrOutput) +} + +type HelmReleaseSpecWaitStrategyPtrOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecWaitStrategyPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecWaitStrategy)(nil)).Elem() +} + +func (o HelmReleaseSpecWaitStrategyPtrOutput) ToHelmReleaseSpecWaitStrategyPtrOutput() HelmReleaseSpecWaitStrategyPtrOutput { + return o +} + +func (o HelmReleaseSpecWaitStrategyPtrOutput) ToHelmReleaseSpecWaitStrategyPtrOutputWithContext(ctx context.Context) HelmReleaseSpecWaitStrategyPtrOutput { + return o +} + +func (o HelmReleaseSpecWaitStrategyPtrOutput) Elem() HelmReleaseSpecWaitStrategyOutput { + return o.ApplyT(func(v *HelmReleaseSpecWaitStrategy) HelmReleaseSpecWaitStrategy { + if v != nil { + return *v + } + var ret HelmReleaseSpecWaitStrategy + return ret + }).(HelmReleaseSpecWaitStrategyOutput) +} + +// Name is Helm's wait strategy for waiting for applied resources to +// become ready. One of 'poller' or 'legacy'. The 'poller' strategy uses +// kstatus to poll resource statuses, while the 'legacy' strategy uses +// Helm v3's waiting logic. +// Defaults to 'poller', or to 'legacy' when UseHelm3Defaults feature +// gate is enabled. +func (o HelmReleaseSpecWaitStrategyPtrOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecWaitStrategy) *string { + if v == nil { + return nil + } + return v.Name + }).(pulumi.StringPtrOutput) +} + +// WaitStrategy defines Helm's wait strategy for waiting for applied +// resources to become ready. +type HelmReleaseSpecWaitStrategyPatch struct { + // Name is Helm's wait strategy for waiting for applied resources to + // become ready. One of 'poller' or 'legacy'. The 'poller' strategy uses + // kstatus to poll resource statuses, while the 'legacy' strategy uses + // Helm v3's waiting logic. + // Defaults to 'poller', or to 'legacy' when UseHelm3Defaults feature + // gate is enabled. + Name *string `pulumi:"name"` +} + +// HelmReleaseSpecWaitStrategyPatchInput is an input type that accepts HelmReleaseSpecWaitStrategyPatchArgs and HelmReleaseSpecWaitStrategyPatchOutput values. +// You can construct a concrete instance of `HelmReleaseSpecWaitStrategyPatchInput` via: +// +// HelmReleaseSpecWaitStrategyPatchArgs{...} +type HelmReleaseSpecWaitStrategyPatchInput interface { + pulumi.Input + + ToHelmReleaseSpecWaitStrategyPatchOutput() HelmReleaseSpecWaitStrategyPatchOutput + ToHelmReleaseSpecWaitStrategyPatchOutputWithContext(context.Context) HelmReleaseSpecWaitStrategyPatchOutput +} + +// WaitStrategy defines Helm's wait strategy for waiting for applied +// resources to become ready. +type HelmReleaseSpecWaitStrategyPatchArgs struct { + // Name is Helm's wait strategy for waiting for applied resources to + // become ready. One of 'poller' or 'legacy'. The 'poller' strategy uses + // kstatus to poll resource statuses, while the 'legacy' strategy uses + // Helm v3's waiting logic. + // Defaults to 'poller', or to 'legacy' when UseHelm3Defaults feature + // gate is enabled. + Name pulumi.StringPtrInput `pulumi:"name"` +} + +func (HelmReleaseSpecWaitStrategyPatchArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecWaitStrategyPatch)(nil)).Elem() +} + +func (i HelmReleaseSpecWaitStrategyPatchArgs) ToHelmReleaseSpecWaitStrategyPatchOutput() HelmReleaseSpecWaitStrategyPatchOutput { + return i.ToHelmReleaseSpecWaitStrategyPatchOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecWaitStrategyPatchArgs) ToHelmReleaseSpecWaitStrategyPatchOutputWithContext(ctx context.Context) HelmReleaseSpecWaitStrategyPatchOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecWaitStrategyPatchOutput) +} + +func (i HelmReleaseSpecWaitStrategyPatchArgs) ToHelmReleaseSpecWaitStrategyPatchPtrOutput() HelmReleaseSpecWaitStrategyPatchPtrOutput { + return i.ToHelmReleaseSpecWaitStrategyPatchPtrOutputWithContext(context.Background()) +} + +func (i HelmReleaseSpecWaitStrategyPatchArgs) ToHelmReleaseSpecWaitStrategyPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecWaitStrategyPatchPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecWaitStrategyPatchOutput).ToHelmReleaseSpecWaitStrategyPatchPtrOutputWithContext(ctx) +} + +// HelmReleaseSpecWaitStrategyPatchPtrInput is an input type that accepts HelmReleaseSpecWaitStrategyPatchArgs, HelmReleaseSpecWaitStrategyPatchPtr and HelmReleaseSpecWaitStrategyPatchPtrOutput values. +// You can construct a concrete instance of `HelmReleaseSpecWaitStrategyPatchPtrInput` via: +// +// HelmReleaseSpecWaitStrategyPatchArgs{...} +// +// or: +// +// nil +type HelmReleaseSpecWaitStrategyPatchPtrInput interface { + pulumi.Input + + ToHelmReleaseSpecWaitStrategyPatchPtrOutput() HelmReleaseSpecWaitStrategyPatchPtrOutput + ToHelmReleaseSpecWaitStrategyPatchPtrOutputWithContext(context.Context) HelmReleaseSpecWaitStrategyPatchPtrOutput +} + +type helmReleaseSpecWaitStrategyPatchPtrType HelmReleaseSpecWaitStrategyPatchArgs + +func HelmReleaseSpecWaitStrategyPatchPtr(v *HelmReleaseSpecWaitStrategyPatchArgs) HelmReleaseSpecWaitStrategyPatchPtrInput { + return (*helmReleaseSpecWaitStrategyPatchPtrType)(v) +} + +func (*helmReleaseSpecWaitStrategyPatchPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecWaitStrategyPatch)(nil)).Elem() +} + +func (i *helmReleaseSpecWaitStrategyPatchPtrType) ToHelmReleaseSpecWaitStrategyPatchPtrOutput() HelmReleaseSpecWaitStrategyPatchPtrOutput { + return i.ToHelmReleaseSpecWaitStrategyPatchPtrOutputWithContext(context.Background()) +} + +func (i *helmReleaseSpecWaitStrategyPatchPtrType) ToHelmReleaseSpecWaitStrategyPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecWaitStrategyPatchPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseSpecWaitStrategyPatchPtrOutput) +} + +// WaitStrategy defines Helm's wait strategy for waiting for applied +// resources to become ready. +type HelmReleaseSpecWaitStrategyPatchOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecWaitStrategyPatchOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseSpecWaitStrategyPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecWaitStrategyPatchOutput) ToHelmReleaseSpecWaitStrategyPatchOutput() HelmReleaseSpecWaitStrategyPatchOutput { + return o +} + +func (o HelmReleaseSpecWaitStrategyPatchOutput) ToHelmReleaseSpecWaitStrategyPatchOutputWithContext(ctx context.Context) HelmReleaseSpecWaitStrategyPatchOutput { + return o +} + +func (o HelmReleaseSpecWaitStrategyPatchOutput) ToHelmReleaseSpecWaitStrategyPatchPtrOutput() HelmReleaseSpecWaitStrategyPatchPtrOutput { + return o.ToHelmReleaseSpecWaitStrategyPatchPtrOutputWithContext(context.Background()) +} + +func (o HelmReleaseSpecWaitStrategyPatchOutput) ToHelmReleaseSpecWaitStrategyPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecWaitStrategyPatchPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v HelmReleaseSpecWaitStrategyPatch) *HelmReleaseSpecWaitStrategyPatch { + return &v + }).(HelmReleaseSpecWaitStrategyPatchPtrOutput) +} + +// Name is Helm's wait strategy for waiting for applied resources to +// become ready. One of 'poller' or 'legacy'. The 'poller' strategy uses +// kstatus to poll resource statuses, while the 'legacy' strategy uses +// Helm v3's waiting logic. +// Defaults to 'poller', or to 'legacy' when UseHelm3Defaults feature +// gate is enabled. +func (o HelmReleaseSpecWaitStrategyPatchOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseSpecWaitStrategyPatch) *string { return v.Name }).(pulumi.StringPtrOutput) +} + +type HelmReleaseSpecWaitStrategyPatchPtrOutput struct{ *pulumi.OutputState } + +func (HelmReleaseSpecWaitStrategyPatchPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseSpecWaitStrategyPatch)(nil)).Elem() +} + +func (o HelmReleaseSpecWaitStrategyPatchPtrOutput) ToHelmReleaseSpecWaitStrategyPatchPtrOutput() HelmReleaseSpecWaitStrategyPatchPtrOutput { + return o +} + +func (o HelmReleaseSpecWaitStrategyPatchPtrOutput) ToHelmReleaseSpecWaitStrategyPatchPtrOutputWithContext(ctx context.Context) HelmReleaseSpecWaitStrategyPatchPtrOutput { + return o +} + +func (o HelmReleaseSpecWaitStrategyPatchPtrOutput) Elem() HelmReleaseSpecWaitStrategyPatchOutput { + return o.ApplyT(func(v *HelmReleaseSpecWaitStrategyPatch) HelmReleaseSpecWaitStrategyPatch { + if v != nil { + return *v + } + var ret HelmReleaseSpecWaitStrategyPatch + return ret + }).(HelmReleaseSpecWaitStrategyPatchOutput) +} + +// Name is Helm's wait strategy for waiting for applied resources to +// become ready. One of 'poller' or 'legacy'. The 'poller' strategy uses +// kstatus to poll resource statuses, while the 'legacy' strategy uses +// Helm v3's waiting logic. +// Defaults to 'poller', or to 'legacy' when UseHelm3Defaults feature +// gate is enabled. +func (o HelmReleaseSpecWaitStrategyPatchPtrOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseSpecWaitStrategyPatch) *string { + if v == nil { + return nil + } + return v.Name + }).(pulumi.StringPtrOutput) +} + +// HelmReleaseStatus defines the observed state of a HelmRelease. +type HelmReleaseStatus struct { + // Conditions holds the conditions for the HelmRelease. + Conditions []HelmReleaseStatusConditions `pulumi:"conditions"` + // Failures is the reconciliation failure count against the latest desired + // state. It is reset after a successful reconciliation. + Failures *int `pulumi:"failures"` + // HelmChart is the namespaced name of the HelmChart resource created by + // the controller for the HelmRelease. + HelmChart *string `pulumi:"helmChart"` + // History holds the history of Helm releases performed for this HelmRelease + // up to the last successfully completed release. + History []HelmReleaseStatusHistory `pulumi:"history"` + // InstallFailures is the install failure count against the latest desired + // state. It is reset after a successful reconciliation. + InstallFailures *int `pulumi:"installFailures"` + Inventory *HelmReleaseStatusInventory `pulumi:"inventory"` + // LastAttemptedConfigDigest is the digest for the config (better known as + // "values") of the last reconciliation attempt. + LastAttemptedConfigDigest *string `pulumi:"lastAttemptedConfigDigest"` + // LastAttemptedGeneration is the last generation the controller attempted + // to reconcile. + LastAttemptedGeneration *int `pulumi:"lastAttemptedGeneration"` + // LastAttemptedReleaseAction is the last release action performed for this + // HelmRelease. It is used to determine the active retry or remediation + // strategy. + LastAttemptedReleaseAction *string `pulumi:"lastAttemptedReleaseAction"` + // LastAttemptedReleaseActionDuration is the duration of the last + // release action performed for this HelmRelease. + LastAttemptedReleaseActionDuration *string `pulumi:"lastAttemptedReleaseActionDuration"` + // LastAttemptedRevision is the Source revision of the last reconciliation + // attempt. For OCIRepository sources, the 12 first characters of the digest are + // appended to the chart version e.g. "1.2.3+1234567890ab". + LastAttemptedRevision *string `pulumi:"lastAttemptedRevision"` + // LastAttemptedRevisionDigest is the digest of the last reconciliation attempt. + // This is only set for OCIRepository sources. + LastAttemptedRevisionDigest *string `pulumi:"lastAttemptedRevisionDigest"` + // LastAttemptedValuesChecksum is the SHA1 checksum for the values of the last + // reconciliation attempt. + // + // Deprecated: Use LastAttemptedConfigDigest instead. + LastAttemptedValuesChecksum *string `pulumi:"lastAttemptedValuesChecksum"` + // LastHandledForceAt holds the value of the most recent + // force request value, so a change of the annotation value + // can be detected. + LastHandledForceAt *string `pulumi:"lastHandledForceAt"` + // LastHandledReconcileAt holds the value of the most recent + // reconcile request value, so a change of the annotation value + // can be detected. + LastHandledReconcileAt *string `pulumi:"lastHandledReconcileAt"` + // LastHandledResetAt holds the value of the most recent reset request + // value, so a change of the annotation value can be detected. + LastHandledResetAt *string `pulumi:"lastHandledResetAt"` + // LastReleaseRevision is the revision of the last successful Helm release. + // + // Deprecated: Use History instead. + LastReleaseRevision *int `pulumi:"lastReleaseRevision"` + // ObservedCommonMetadataDigest is the digest for the common metadata of + // the last successful reconciliation attempt. + ObservedCommonMetadataDigest *string `pulumi:"observedCommonMetadataDigest"` + // ObservedGeneration is the last observed generation. + ObservedGeneration *int `pulumi:"observedGeneration"` + // ObservedPostRenderersDigest is the digest for the post-renderers of + // the last successful reconciliation attempt. + ObservedPostRenderersDigest *string `pulumi:"observedPostRenderersDigest"` + // StorageNamespace is the namespace of the Helm release storage for the + // current release. + StorageNamespace *string `pulumi:"storageNamespace"` + // UpgradeFailures is the upgrade failure count against the latest desired + // state. It is reset after a successful reconciliation. + UpgradeFailures *int `pulumi:"upgradeFailures"` +} + +// HelmReleaseStatusInput is an input type that accepts HelmReleaseStatusArgs and HelmReleaseStatusOutput values. +// You can construct a concrete instance of `HelmReleaseStatusInput` via: +// +// HelmReleaseStatusArgs{...} +type HelmReleaseStatusInput interface { + pulumi.Input + + ToHelmReleaseStatusOutput() HelmReleaseStatusOutput + ToHelmReleaseStatusOutputWithContext(context.Context) HelmReleaseStatusOutput +} + +// HelmReleaseStatus defines the observed state of a HelmRelease. +type HelmReleaseStatusArgs struct { + // Conditions holds the conditions for the HelmRelease. + Conditions HelmReleaseStatusConditionsArrayInput `pulumi:"conditions"` + // Failures is the reconciliation failure count against the latest desired + // state. It is reset after a successful reconciliation. + Failures pulumi.IntPtrInput `pulumi:"failures"` + // HelmChart is the namespaced name of the HelmChart resource created by + // the controller for the HelmRelease. + HelmChart pulumi.StringPtrInput `pulumi:"helmChart"` + // History holds the history of Helm releases performed for this HelmRelease + // up to the last successfully completed release. + History HelmReleaseStatusHistoryArrayInput `pulumi:"history"` + // InstallFailures is the install failure count against the latest desired + // state. It is reset after a successful reconciliation. + InstallFailures pulumi.IntPtrInput `pulumi:"installFailures"` + Inventory HelmReleaseStatusInventoryPtrInput `pulumi:"inventory"` + // LastAttemptedConfigDigest is the digest for the config (better known as + // "values") of the last reconciliation attempt. + LastAttemptedConfigDigest pulumi.StringPtrInput `pulumi:"lastAttemptedConfigDigest"` + // LastAttemptedGeneration is the last generation the controller attempted + // to reconcile. + LastAttemptedGeneration pulumi.IntPtrInput `pulumi:"lastAttemptedGeneration"` + // LastAttemptedReleaseAction is the last release action performed for this + // HelmRelease. It is used to determine the active retry or remediation + // strategy. + LastAttemptedReleaseAction pulumi.StringPtrInput `pulumi:"lastAttemptedReleaseAction"` + // LastAttemptedReleaseActionDuration is the duration of the last + // release action performed for this HelmRelease. + LastAttemptedReleaseActionDuration pulumi.StringPtrInput `pulumi:"lastAttemptedReleaseActionDuration"` + // LastAttemptedRevision is the Source revision of the last reconciliation + // attempt. For OCIRepository sources, the 12 first characters of the digest are + // appended to the chart version e.g. "1.2.3+1234567890ab". + LastAttemptedRevision pulumi.StringPtrInput `pulumi:"lastAttemptedRevision"` + // LastAttemptedRevisionDigest is the digest of the last reconciliation attempt. + // This is only set for OCIRepository sources. + LastAttemptedRevisionDigest pulumi.StringPtrInput `pulumi:"lastAttemptedRevisionDigest"` + // LastAttemptedValuesChecksum is the SHA1 checksum for the values of the last + // reconciliation attempt. + // + // Deprecated: Use LastAttemptedConfigDigest instead. + LastAttemptedValuesChecksum pulumi.StringPtrInput `pulumi:"lastAttemptedValuesChecksum"` + // LastHandledForceAt holds the value of the most recent + // force request value, so a change of the annotation value + // can be detected. + LastHandledForceAt pulumi.StringPtrInput `pulumi:"lastHandledForceAt"` + // LastHandledReconcileAt holds the value of the most recent + // reconcile request value, so a change of the annotation value + // can be detected. + LastHandledReconcileAt pulumi.StringPtrInput `pulumi:"lastHandledReconcileAt"` + // LastHandledResetAt holds the value of the most recent reset request + // value, so a change of the annotation value can be detected. + LastHandledResetAt pulumi.StringPtrInput `pulumi:"lastHandledResetAt"` + // LastReleaseRevision is the revision of the last successful Helm release. + // + // Deprecated: Use History instead. + LastReleaseRevision pulumi.IntPtrInput `pulumi:"lastReleaseRevision"` + // ObservedCommonMetadataDigest is the digest for the common metadata of + // the last successful reconciliation attempt. + ObservedCommonMetadataDigest pulumi.StringPtrInput `pulumi:"observedCommonMetadataDigest"` + // ObservedGeneration is the last observed generation. + ObservedGeneration pulumi.IntPtrInput `pulumi:"observedGeneration"` + // ObservedPostRenderersDigest is the digest for the post-renderers of + // the last successful reconciliation attempt. + ObservedPostRenderersDigest pulumi.StringPtrInput `pulumi:"observedPostRenderersDigest"` + // StorageNamespace is the namespace of the Helm release storage for the + // current release. + StorageNamespace pulumi.StringPtrInput `pulumi:"storageNamespace"` + // UpgradeFailures is the upgrade failure count against the latest desired + // state. It is reset after a successful reconciliation. + UpgradeFailures pulumi.IntPtrInput `pulumi:"upgradeFailures"` +} + +func (HelmReleaseStatusArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseStatus)(nil)).Elem() +} + +func (i HelmReleaseStatusArgs) ToHelmReleaseStatusOutput() HelmReleaseStatusOutput { + return i.ToHelmReleaseStatusOutputWithContext(context.Background()) +} + +func (i HelmReleaseStatusArgs) ToHelmReleaseStatusOutputWithContext(ctx context.Context) HelmReleaseStatusOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseStatusOutput) +} + +func (i HelmReleaseStatusArgs) ToHelmReleaseStatusPtrOutput() HelmReleaseStatusPtrOutput { + return i.ToHelmReleaseStatusPtrOutputWithContext(context.Background()) +} + +func (i HelmReleaseStatusArgs) ToHelmReleaseStatusPtrOutputWithContext(ctx context.Context) HelmReleaseStatusPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseStatusOutput).ToHelmReleaseStatusPtrOutputWithContext(ctx) +} + +// HelmReleaseStatusPtrInput is an input type that accepts HelmReleaseStatusArgs, HelmReleaseStatusPtr and HelmReleaseStatusPtrOutput values. +// You can construct a concrete instance of `HelmReleaseStatusPtrInput` via: +// +// HelmReleaseStatusArgs{...} +// +// or: +// +// nil +type HelmReleaseStatusPtrInput interface { + pulumi.Input + + ToHelmReleaseStatusPtrOutput() HelmReleaseStatusPtrOutput + ToHelmReleaseStatusPtrOutputWithContext(context.Context) HelmReleaseStatusPtrOutput +} + +type helmReleaseStatusPtrType HelmReleaseStatusArgs + +func HelmReleaseStatusPtr(v *HelmReleaseStatusArgs) HelmReleaseStatusPtrInput { + return (*helmReleaseStatusPtrType)(v) +} + +func (*helmReleaseStatusPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseStatus)(nil)).Elem() +} + +func (i *helmReleaseStatusPtrType) ToHelmReleaseStatusPtrOutput() HelmReleaseStatusPtrOutput { + return i.ToHelmReleaseStatusPtrOutputWithContext(context.Background()) +} + +func (i *helmReleaseStatusPtrType) ToHelmReleaseStatusPtrOutputWithContext(ctx context.Context) HelmReleaseStatusPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseStatusPtrOutput) +} + +// HelmReleaseStatus defines the observed state of a HelmRelease. +type HelmReleaseStatusOutput struct{ *pulumi.OutputState } + +func (HelmReleaseStatusOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseStatus)(nil)).Elem() +} + +func (o HelmReleaseStatusOutput) ToHelmReleaseStatusOutput() HelmReleaseStatusOutput { + return o +} + +func (o HelmReleaseStatusOutput) ToHelmReleaseStatusOutputWithContext(ctx context.Context) HelmReleaseStatusOutput { + return o +} + +func (o HelmReleaseStatusOutput) ToHelmReleaseStatusPtrOutput() HelmReleaseStatusPtrOutput { + return o.ToHelmReleaseStatusPtrOutputWithContext(context.Background()) +} + +func (o HelmReleaseStatusOutput) ToHelmReleaseStatusPtrOutputWithContext(ctx context.Context) HelmReleaseStatusPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v HelmReleaseStatus) *HelmReleaseStatus { + return &v + }).(HelmReleaseStatusPtrOutput) +} + +// Conditions holds the conditions for the HelmRelease. +func (o HelmReleaseStatusOutput) Conditions() HelmReleaseStatusConditionsArrayOutput { + return o.ApplyT(func(v HelmReleaseStatus) []HelmReleaseStatusConditions { return v.Conditions }).(HelmReleaseStatusConditionsArrayOutput) +} + +// Failures is the reconciliation failure count against the latest desired +// state. It is reset after a successful reconciliation. +func (o HelmReleaseStatusOutput) Failures() pulumi.IntPtrOutput { + return o.ApplyT(func(v HelmReleaseStatus) *int { return v.Failures }).(pulumi.IntPtrOutput) +} + +// HelmChart is the namespaced name of the HelmChart resource created by +// the controller for the HelmRelease. +func (o HelmReleaseStatusOutput) HelmChart() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatus) *string { return v.HelmChart }).(pulumi.StringPtrOutput) +} + +// History holds the history of Helm releases performed for this HelmRelease +// up to the last successfully completed release. +func (o HelmReleaseStatusOutput) History() HelmReleaseStatusHistoryArrayOutput { + return o.ApplyT(func(v HelmReleaseStatus) []HelmReleaseStatusHistory { return v.History }).(HelmReleaseStatusHistoryArrayOutput) +} + +// InstallFailures is the install failure count against the latest desired +// state. It is reset after a successful reconciliation. +func (o HelmReleaseStatusOutput) InstallFailures() pulumi.IntPtrOutput { + return o.ApplyT(func(v HelmReleaseStatus) *int { return v.InstallFailures }).(pulumi.IntPtrOutput) +} + +func (o HelmReleaseStatusOutput) Inventory() HelmReleaseStatusInventoryPtrOutput { + return o.ApplyT(func(v HelmReleaseStatus) *HelmReleaseStatusInventory { return v.Inventory }).(HelmReleaseStatusInventoryPtrOutput) +} + +// LastAttemptedConfigDigest is the digest for the config (better known as +// "values") of the last reconciliation attempt. +func (o HelmReleaseStatusOutput) LastAttemptedConfigDigest() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatus) *string { return v.LastAttemptedConfigDigest }).(pulumi.StringPtrOutput) +} + +// LastAttemptedGeneration is the last generation the controller attempted +// to reconcile. +func (o HelmReleaseStatusOutput) LastAttemptedGeneration() pulumi.IntPtrOutput { + return o.ApplyT(func(v HelmReleaseStatus) *int { return v.LastAttemptedGeneration }).(pulumi.IntPtrOutput) +} + +// LastAttemptedReleaseAction is the last release action performed for this +// HelmRelease. It is used to determine the active retry or remediation +// strategy. +func (o HelmReleaseStatusOutput) LastAttemptedReleaseAction() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatus) *string { return v.LastAttemptedReleaseAction }).(pulumi.StringPtrOutput) +} + +// LastAttemptedReleaseActionDuration is the duration of the last +// release action performed for this HelmRelease. +func (o HelmReleaseStatusOutput) LastAttemptedReleaseActionDuration() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatus) *string { return v.LastAttemptedReleaseActionDuration }).(pulumi.StringPtrOutput) +} + +// LastAttemptedRevision is the Source revision of the last reconciliation +// attempt. For OCIRepository sources, the 12 first characters of the digest are +// appended to the chart version e.g. "1.2.3+1234567890ab". +func (o HelmReleaseStatusOutput) LastAttemptedRevision() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatus) *string { return v.LastAttemptedRevision }).(pulumi.StringPtrOutput) +} + +// LastAttemptedRevisionDigest is the digest of the last reconciliation attempt. +// This is only set for OCIRepository sources. +func (o HelmReleaseStatusOutput) LastAttemptedRevisionDigest() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatus) *string { return v.LastAttemptedRevisionDigest }).(pulumi.StringPtrOutput) +} + +// LastAttemptedValuesChecksum is the SHA1 checksum for the values of the last +// reconciliation attempt. +// +// Deprecated: Use LastAttemptedConfigDigest instead. +func (o HelmReleaseStatusOutput) LastAttemptedValuesChecksum() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatus) *string { return v.LastAttemptedValuesChecksum }).(pulumi.StringPtrOutput) +} + +// LastHandledForceAt holds the value of the most recent +// force request value, so a change of the annotation value +// can be detected. +func (o HelmReleaseStatusOutput) LastHandledForceAt() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatus) *string { return v.LastHandledForceAt }).(pulumi.StringPtrOutput) +} + +// LastHandledReconcileAt holds the value of the most recent +// reconcile request value, so a change of the annotation value +// can be detected. +func (o HelmReleaseStatusOutput) LastHandledReconcileAt() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatus) *string { return v.LastHandledReconcileAt }).(pulumi.StringPtrOutput) +} + +// LastHandledResetAt holds the value of the most recent reset request +// value, so a change of the annotation value can be detected. +func (o HelmReleaseStatusOutput) LastHandledResetAt() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatus) *string { return v.LastHandledResetAt }).(pulumi.StringPtrOutput) +} + +// LastReleaseRevision is the revision of the last successful Helm release. +// +// Deprecated: Use History instead. +func (o HelmReleaseStatusOutput) LastReleaseRevision() pulumi.IntPtrOutput { + return o.ApplyT(func(v HelmReleaseStatus) *int { return v.LastReleaseRevision }).(pulumi.IntPtrOutput) +} + +// ObservedCommonMetadataDigest is the digest for the common metadata of +// the last successful reconciliation attempt. +func (o HelmReleaseStatusOutput) ObservedCommonMetadataDigest() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatus) *string { return v.ObservedCommonMetadataDigest }).(pulumi.StringPtrOutput) +} + +// ObservedGeneration is the last observed generation. +func (o HelmReleaseStatusOutput) ObservedGeneration() pulumi.IntPtrOutput { + return o.ApplyT(func(v HelmReleaseStatus) *int { return v.ObservedGeneration }).(pulumi.IntPtrOutput) +} + +// ObservedPostRenderersDigest is the digest for the post-renderers of +// the last successful reconciliation attempt. +func (o HelmReleaseStatusOutput) ObservedPostRenderersDigest() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatus) *string { return v.ObservedPostRenderersDigest }).(pulumi.StringPtrOutput) +} + +// StorageNamespace is the namespace of the Helm release storage for the +// current release. +func (o HelmReleaseStatusOutput) StorageNamespace() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatus) *string { return v.StorageNamespace }).(pulumi.StringPtrOutput) +} + +// UpgradeFailures is the upgrade failure count against the latest desired +// state. It is reset after a successful reconciliation. +func (o HelmReleaseStatusOutput) UpgradeFailures() pulumi.IntPtrOutput { + return o.ApplyT(func(v HelmReleaseStatus) *int { return v.UpgradeFailures }).(pulumi.IntPtrOutput) +} + +type HelmReleaseStatusPtrOutput struct{ *pulumi.OutputState } + +func (HelmReleaseStatusPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseStatus)(nil)).Elem() +} + +func (o HelmReleaseStatusPtrOutput) ToHelmReleaseStatusPtrOutput() HelmReleaseStatusPtrOutput { + return o +} + +func (o HelmReleaseStatusPtrOutput) ToHelmReleaseStatusPtrOutputWithContext(ctx context.Context) HelmReleaseStatusPtrOutput { + return o +} + +func (o HelmReleaseStatusPtrOutput) Elem() HelmReleaseStatusOutput { + return o.ApplyT(func(v *HelmReleaseStatus) HelmReleaseStatus { + if v != nil { + return *v + } + var ret HelmReleaseStatus + return ret + }).(HelmReleaseStatusOutput) +} + +// Conditions holds the conditions for the HelmRelease. +func (o HelmReleaseStatusPtrOutput) Conditions() HelmReleaseStatusConditionsArrayOutput { + return o.ApplyT(func(v *HelmReleaseStatus) []HelmReleaseStatusConditions { + if v == nil { + return nil + } + return v.Conditions + }).(HelmReleaseStatusConditionsArrayOutput) +} + +// Failures is the reconciliation failure count against the latest desired +// state. It is reset after a successful reconciliation. +func (o HelmReleaseStatusPtrOutput) Failures() pulumi.IntPtrOutput { + return o.ApplyT(func(v *HelmReleaseStatus) *int { + if v == nil { + return nil + } + return v.Failures + }).(pulumi.IntPtrOutput) +} + +// HelmChart is the namespaced name of the HelmChart resource created by +// the controller for the HelmRelease. +func (o HelmReleaseStatusPtrOutput) HelmChart() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseStatus) *string { + if v == nil { + return nil + } + return v.HelmChart + }).(pulumi.StringPtrOutput) +} + +// History holds the history of Helm releases performed for this HelmRelease +// up to the last successfully completed release. +func (o HelmReleaseStatusPtrOutput) History() HelmReleaseStatusHistoryArrayOutput { + return o.ApplyT(func(v *HelmReleaseStatus) []HelmReleaseStatusHistory { + if v == nil { + return nil + } + return v.History + }).(HelmReleaseStatusHistoryArrayOutput) +} + +// InstallFailures is the install failure count against the latest desired +// state. It is reset after a successful reconciliation. +func (o HelmReleaseStatusPtrOutput) InstallFailures() pulumi.IntPtrOutput { + return o.ApplyT(func(v *HelmReleaseStatus) *int { + if v == nil { + return nil + } + return v.InstallFailures + }).(pulumi.IntPtrOutput) +} + +func (o HelmReleaseStatusPtrOutput) Inventory() HelmReleaseStatusInventoryPtrOutput { + return o.ApplyT(func(v *HelmReleaseStatus) *HelmReleaseStatusInventory { + if v == nil { + return nil + } + return v.Inventory + }).(HelmReleaseStatusInventoryPtrOutput) +} + +// LastAttemptedConfigDigest is the digest for the config (better known as +// "values") of the last reconciliation attempt. +func (o HelmReleaseStatusPtrOutput) LastAttemptedConfigDigest() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseStatus) *string { + if v == nil { + return nil + } + return v.LastAttemptedConfigDigest + }).(pulumi.StringPtrOutput) +} + +// LastAttemptedGeneration is the last generation the controller attempted +// to reconcile. +func (o HelmReleaseStatusPtrOutput) LastAttemptedGeneration() pulumi.IntPtrOutput { + return o.ApplyT(func(v *HelmReleaseStatus) *int { + if v == nil { + return nil + } + return v.LastAttemptedGeneration + }).(pulumi.IntPtrOutput) +} + +// LastAttemptedReleaseAction is the last release action performed for this +// HelmRelease. It is used to determine the active retry or remediation +// strategy. +func (o HelmReleaseStatusPtrOutput) LastAttemptedReleaseAction() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseStatus) *string { + if v == nil { + return nil + } + return v.LastAttemptedReleaseAction + }).(pulumi.StringPtrOutput) +} + +// LastAttemptedReleaseActionDuration is the duration of the last +// release action performed for this HelmRelease. +func (o HelmReleaseStatusPtrOutput) LastAttemptedReleaseActionDuration() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseStatus) *string { + if v == nil { + return nil + } + return v.LastAttemptedReleaseActionDuration + }).(pulumi.StringPtrOutput) +} + +// LastAttemptedRevision is the Source revision of the last reconciliation +// attempt. For OCIRepository sources, the 12 first characters of the digest are +// appended to the chart version e.g. "1.2.3+1234567890ab". +func (o HelmReleaseStatusPtrOutput) LastAttemptedRevision() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseStatus) *string { + if v == nil { + return nil + } + return v.LastAttemptedRevision + }).(pulumi.StringPtrOutput) +} + +// LastAttemptedRevisionDigest is the digest of the last reconciliation attempt. +// This is only set for OCIRepository sources. +func (o HelmReleaseStatusPtrOutput) LastAttemptedRevisionDigest() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseStatus) *string { + if v == nil { + return nil + } + return v.LastAttemptedRevisionDigest + }).(pulumi.StringPtrOutput) +} + +// LastAttemptedValuesChecksum is the SHA1 checksum for the values of the last +// reconciliation attempt. +// +// Deprecated: Use LastAttemptedConfigDigest instead. +func (o HelmReleaseStatusPtrOutput) LastAttemptedValuesChecksum() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseStatus) *string { + if v == nil { + return nil + } + return v.LastAttemptedValuesChecksum + }).(pulumi.StringPtrOutput) +} + +// LastHandledForceAt holds the value of the most recent +// force request value, so a change of the annotation value +// can be detected. +func (o HelmReleaseStatusPtrOutput) LastHandledForceAt() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseStatus) *string { + if v == nil { + return nil + } + return v.LastHandledForceAt + }).(pulumi.StringPtrOutput) +} + +// LastHandledReconcileAt holds the value of the most recent +// reconcile request value, so a change of the annotation value +// can be detected. +func (o HelmReleaseStatusPtrOutput) LastHandledReconcileAt() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseStatus) *string { + if v == nil { + return nil + } + return v.LastHandledReconcileAt + }).(pulumi.StringPtrOutput) +} + +// LastHandledResetAt holds the value of the most recent reset request +// value, so a change of the annotation value can be detected. +func (o HelmReleaseStatusPtrOutput) LastHandledResetAt() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseStatus) *string { + if v == nil { + return nil + } + return v.LastHandledResetAt + }).(pulumi.StringPtrOutput) +} + +// LastReleaseRevision is the revision of the last successful Helm release. +// +// Deprecated: Use History instead. +func (o HelmReleaseStatusPtrOutput) LastReleaseRevision() pulumi.IntPtrOutput { + return o.ApplyT(func(v *HelmReleaseStatus) *int { + if v == nil { + return nil + } + return v.LastReleaseRevision + }).(pulumi.IntPtrOutput) +} + +// ObservedCommonMetadataDigest is the digest for the common metadata of +// the last successful reconciliation attempt. +func (o HelmReleaseStatusPtrOutput) ObservedCommonMetadataDigest() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseStatus) *string { + if v == nil { + return nil + } + return v.ObservedCommonMetadataDigest + }).(pulumi.StringPtrOutput) +} + +// ObservedGeneration is the last observed generation. +func (o HelmReleaseStatusPtrOutput) ObservedGeneration() pulumi.IntPtrOutput { + return o.ApplyT(func(v *HelmReleaseStatus) *int { + if v == nil { + return nil + } + return v.ObservedGeneration + }).(pulumi.IntPtrOutput) +} + +// ObservedPostRenderersDigest is the digest for the post-renderers of +// the last successful reconciliation attempt. +func (o HelmReleaseStatusPtrOutput) ObservedPostRenderersDigest() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseStatus) *string { + if v == nil { + return nil + } + return v.ObservedPostRenderersDigest + }).(pulumi.StringPtrOutput) +} + +// StorageNamespace is the namespace of the Helm release storage for the +// current release. +func (o HelmReleaseStatusPtrOutput) StorageNamespace() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseStatus) *string { + if v == nil { + return nil + } + return v.StorageNamespace + }).(pulumi.StringPtrOutput) +} + +// UpgradeFailures is the upgrade failure count against the latest desired +// state. It is reset after a successful reconciliation. +func (o HelmReleaseStatusPtrOutput) UpgradeFailures() pulumi.IntPtrOutput { + return o.ApplyT(func(v *HelmReleaseStatus) *int { + if v == nil { + return nil + } + return v.UpgradeFailures + }).(pulumi.IntPtrOutput) +} + +// Condition contains details for one aspect of the current state of this API Resource. +type HelmReleaseStatusConditions struct { + // lastTransitionTime is the last time the condition transitioned from one status to another. + // This should be when the underlying condition changed. If that is not known, then using the time when the API field changed is acceptable. + LastTransitionTime *string `pulumi:"lastTransitionTime"` + // message is a human readable message indicating details about the transition. + // This may be an empty string. + Message *string `pulumi:"message"` + // observedGeneration represents the .metadata.generation that the condition was set based upon. + // For instance, if .metadata.generation is currently 12, but the .status.conditions[x].observedGeneration is 9, the condition is out of date + // with respect to the current state of the instance. + ObservedGeneration *int `pulumi:"observedGeneration"` + // reason contains a programmatic identifier indicating the reason for the condition's last transition. + // Producers of specific condition types may define expected values and meanings for this field, + // and whether the values are considered a guaranteed API. + // The value should be a CamelCase string. + // This field may not be empty. + Reason *string `pulumi:"reason"` + // status of the condition, one of True, False, Unknown. + Status *string `pulumi:"status"` + // type of condition in CamelCase or in foo.example.com/CamelCase. + Type *string `pulumi:"type"` +} + +// HelmReleaseStatusConditionsInput is an input type that accepts HelmReleaseStatusConditionsArgs and HelmReleaseStatusConditionsOutput values. +// You can construct a concrete instance of `HelmReleaseStatusConditionsInput` via: +// +// HelmReleaseStatusConditionsArgs{...} +type HelmReleaseStatusConditionsInput interface { + pulumi.Input + + ToHelmReleaseStatusConditionsOutput() HelmReleaseStatusConditionsOutput + ToHelmReleaseStatusConditionsOutputWithContext(context.Context) HelmReleaseStatusConditionsOutput +} + +// Condition contains details for one aspect of the current state of this API Resource. +type HelmReleaseStatusConditionsArgs struct { + // lastTransitionTime is the last time the condition transitioned from one status to another. + // This should be when the underlying condition changed. If that is not known, then using the time when the API field changed is acceptable. + LastTransitionTime pulumi.StringPtrInput `pulumi:"lastTransitionTime"` + // message is a human readable message indicating details about the transition. + // This may be an empty string. + Message pulumi.StringPtrInput `pulumi:"message"` + // observedGeneration represents the .metadata.generation that the condition was set based upon. + // For instance, if .metadata.generation is currently 12, but the .status.conditions[x].observedGeneration is 9, the condition is out of date + // with respect to the current state of the instance. + ObservedGeneration pulumi.IntPtrInput `pulumi:"observedGeneration"` + // reason contains a programmatic identifier indicating the reason for the condition's last transition. + // Producers of specific condition types may define expected values and meanings for this field, + // and whether the values are considered a guaranteed API. + // The value should be a CamelCase string. + // This field may not be empty. + Reason pulumi.StringPtrInput `pulumi:"reason"` + // status of the condition, one of True, False, Unknown. + Status pulumi.StringPtrInput `pulumi:"status"` + // type of condition in CamelCase or in foo.example.com/CamelCase. + Type pulumi.StringPtrInput `pulumi:"type"` +} + +func (HelmReleaseStatusConditionsArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseStatusConditions)(nil)).Elem() +} + +func (i HelmReleaseStatusConditionsArgs) ToHelmReleaseStatusConditionsOutput() HelmReleaseStatusConditionsOutput { + return i.ToHelmReleaseStatusConditionsOutputWithContext(context.Background()) +} + +func (i HelmReleaseStatusConditionsArgs) ToHelmReleaseStatusConditionsOutputWithContext(ctx context.Context) HelmReleaseStatusConditionsOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseStatusConditionsOutput) +} + +// HelmReleaseStatusConditionsArrayInput is an input type that accepts HelmReleaseStatusConditionsArray and HelmReleaseStatusConditionsArrayOutput values. +// You can construct a concrete instance of `HelmReleaseStatusConditionsArrayInput` via: +// +// HelmReleaseStatusConditionsArray{ HelmReleaseStatusConditionsArgs{...} } +type HelmReleaseStatusConditionsArrayInput interface { + pulumi.Input + + ToHelmReleaseStatusConditionsArrayOutput() HelmReleaseStatusConditionsArrayOutput + ToHelmReleaseStatusConditionsArrayOutputWithContext(context.Context) HelmReleaseStatusConditionsArrayOutput +} + +type HelmReleaseStatusConditionsArray []HelmReleaseStatusConditionsInput + +func (HelmReleaseStatusConditionsArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]HelmReleaseStatusConditions)(nil)).Elem() +} + +func (i HelmReleaseStatusConditionsArray) ToHelmReleaseStatusConditionsArrayOutput() HelmReleaseStatusConditionsArrayOutput { + return i.ToHelmReleaseStatusConditionsArrayOutputWithContext(context.Background()) +} + +func (i HelmReleaseStatusConditionsArray) ToHelmReleaseStatusConditionsArrayOutputWithContext(ctx context.Context) HelmReleaseStatusConditionsArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseStatusConditionsArrayOutput) +} + +// Condition contains details for one aspect of the current state of this API Resource. +type HelmReleaseStatusConditionsOutput struct{ *pulumi.OutputState } + +func (HelmReleaseStatusConditionsOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseStatusConditions)(nil)).Elem() +} + +func (o HelmReleaseStatusConditionsOutput) ToHelmReleaseStatusConditionsOutput() HelmReleaseStatusConditionsOutput { + return o +} + +func (o HelmReleaseStatusConditionsOutput) ToHelmReleaseStatusConditionsOutputWithContext(ctx context.Context) HelmReleaseStatusConditionsOutput { + return o +} + +// lastTransitionTime is the last time the condition transitioned from one status to another. +// This should be when the underlying condition changed. If that is not known, then using the time when the API field changed is acceptable. +func (o HelmReleaseStatusConditionsOutput) LastTransitionTime() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusConditions) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) +} + +// message is a human readable message indicating details about the transition. +// This may be an empty string. +func (o HelmReleaseStatusConditionsOutput) Message() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusConditions) *string { return v.Message }).(pulumi.StringPtrOutput) +} + +// observedGeneration represents the .metadata.generation that the condition was set based upon. +// For instance, if .metadata.generation is currently 12, but the .status.conditions[x].observedGeneration is 9, the condition is out of date +// with respect to the current state of the instance. +func (o HelmReleaseStatusConditionsOutput) ObservedGeneration() pulumi.IntPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusConditions) *int { return v.ObservedGeneration }).(pulumi.IntPtrOutput) +} + +// reason contains a programmatic identifier indicating the reason for the condition's last transition. +// Producers of specific condition types may define expected values and meanings for this field, +// and whether the values are considered a guaranteed API. +// The value should be a CamelCase string. +// This field may not be empty. +func (o HelmReleaseStatusConditionsOutput) Reason() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusConditions) *string { return v.Reason }).(pulumi.StringPtrOutput) +} + +// status of the condition, one of True, False, Unknown. +func (o HelmReleaseStatusConditionsOutput) Status() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusConditions) *string { return v.Status }).(pulumi.StringPtrOutput) +} + +// type of condition in CamelCase or in foo.example.com/CamelCase. +func (o HelmReleaseStatusConditionsOutput) Type() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusConditions) *string { return v.Type }).(pulumi.StringPtrOutput) +} + +type HelmReleaseStatusConditionsArrayOutput struct{ *pulumi.OutputState } + +func (HelmReleaseStatusConditionsArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]HelmReleaseStatusConditions)(nil)).Elem() +} + +func (o HelmReleaseStatusConditionsArrayOutput) ToHelmReleaseStatusConditionsArrayOutput() HelmReleaseStatusConditionsArrayOutput { + return o +} + +func (o HelmReleaseStatusConditionsArrayOutput) ToHelmReleaseStatusConditionsArrayOutputWithContext(ctx context.Context) HelmReleaseStatusConditionsArrayOutput { + return o +} + +func (o HelmReleaseStatusConditionsArrayOutput) Index(i pulumi.IntInput) HelmReleaseStatusConditionsOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) HelmReleaseStatusConditions { + return vs[0].([]HelmReleaseStatusConditions)[vs[1].(int)] + }).(HelmReleaseStatusConditionsOutput) +} + +// Condition contains details for one aspect of the current state of this API Resource. +type HelmReleaseStatusConditionsPatch struct { + // lastTransitionTime is the last time the condition transitioned from one status to another. + // This should be when the underlying condition changed. If that is not known, then using the time when the API field changed is acceptable. + LastTransitionTime *string `pulumi:"lastTransitionTime"` + // message is a human readable message indicating details about the transition. + // This may be an empty string. + Message *string `pulumi:"message"` + // observedGeneration represents the .metadata.generation that the condition was set based upon. + // For instance, if .metadata.generation is currently 12, but the .status.conditions[x].observedGeneration is 9, the condition is out of date + // with respect to the current state of the instance. + ObservedGeneration *int `pulumi:"observedGeneration"` + // reason contains a programmatic identifier indicating the reason for the condition's last transition. + // Producers of specific condition types may define expected values and meanings for this field, + // and whether the values are considered a guaranteed API. + // The value should be a CamelCase string. + // This field may not be empty. + Reason *string `pulumi:"reason"` + // status of the condition, one of True, False, Unknown. + Status *string `pulumi:"status"` + // type of condition in CamelCase or in foo.example.com/CamelCase. + Type *string `pulumi:"type"` +} + +// HelmReleaseStatusConditionsPatchInput is an input type that accepts HelmReleaseStatusConditionsPatchArgs and HelmReleaseStatusConditionsPatchOutput values. +// You can construct a concrete instance of `HelmReleaseStatusConditionsPatchInput` via: +// +// HelmReleaseStatusConditionsPatchArgs{...} +type HelmReleaseStatusConditionsPatchInput interface { + pulumi.Input + + ToHelmReleaseStatusConditionsPatchOutput() HelmReleaseStatusConditionsPatchOutput + ToHelmReleaseStatusConditionsPatchOutputWithContext(context.Context) HelmReleaseStatusConditionsPatchOutput +} + +// Condition contains details for one aspect of the current state of this API Resource. +type HelmReleaseStatusConditionsPatchArgs struct { + // lastTransitionTime is the last time the condition transitioned from one status to another. + // This should be when the underlying condition changed. If that is not known, then using the time when the API field changed is acceptable. + LastTransitionTime pulumi.StringPtrInput `pulumi:"lastTransitionTime"` + // message is a human readable message indicating details about the transition. + // This may be an empty string. + Message pulumi.StringPtrInput `pulumi:"message"` + // observedGeneration represents the .metadata.generation that the condition was set based upon. + // For instance, if .metadata.generation is currently 12, but the .status.conditions[x].observedGeneration is 9, the condition is out of date + // with respect to the current state of the instance. + ObservedGeneration pulumi.IntPtrInput `pulumi:"observedGeneration"` + // reason contains a programmatic identifier indicating the reason for the condition's last transition. + // Producers of specific condition types may define expected values and meanings for this field, + // and whether the values are considered a guaranteed API. + // The value should be a CamelCase string. + // This field may not be empty. + Reason pulumi.StringPtrInput `pulumi:"reason"` + // status of the condition, one of True, False, Unknown. + Status pulumi.StringPtrInput `pulumi:"status"` + // type of condition in CamelCase or in foo.example.com/CamelCase. + Type pulumi.StringPtrInput `pulumi:"type"` +} + +func (HelmReleaseStatusConditionsPatchArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseStatusConditionsPatch)(nil)).Elem() +} + +func (i HelmReleaseStatusConditionsPatchArgs) ToHelmReleaseStatusConditionsPatchOutput() HelmReleaseStatusConditionsPatchOutput { + return i.ToHelmReleaseStatusConditionsPatchOutputWithContext(context.Background()) +} + +func (i HelmReleaseStatusConditionsPatchArgs) ToHelmReleaseStatusConditionsPatchOutputWithContext(ctx context.Context) HelmReleaseStatusConditionsPatchOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseStatusConditionsPatchOutput) +} + +// HelmReleaseStatusConditionsPatchArrayInput is an input type that accepts HelmReleaseStatusConditionsPatchArray and HelmReleaseStatusConditionsPatchArrayOutput values. +// You can construct a concrete instance of `HelmReleaseStatusConditionsPatchArrayInput` via: +// +// HelmReleaseStatusConditionsPatchArray{ HelmReleaseStatusConditionsPatchArgs{...} } +type HelmReleaseStatusConditionsPatchArrayInput interface { + pulumi.Input + + ToHelmReleaseStatusConditionsPatchArrayOutput() HelmReleaseStatusConditionsPatchArrayOutput + ToHelmReleaseStatusConditionsPatchArrayOutputWithContext(context.Context) HelmReleaseStatusConditionsPatchArrayOutput +} + +type HelmReleaseStatusConditionsPatchArray []HelmReleaseStatusConditionsPatchInput + +func (HelmReleaseStatusConditionsPatchArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]HelmReleaseStatusConditionsPatch)(nil)).Elem() +} + +func (i HelmReleaseStatusConditionsPatchArray) ToHelmReleaseStatusConditionsPatchArrayOutput() HelmReleaseStatusConditionsPatchArrayOutput { + return i.ToHelmReleaseStatusConditionsPatchArrayOutputWithContext(context.Background()) +} + +func (i HelmReleaseStatusConditionsPatchArray) ToHelmReleaseStatusConditionsPatchArrayOutputWithContext(ctx context.Context) HelmReleaseStatusConditionsPatchArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseStatusConditionsPatchArrayOutput) +} + +// Condition contains details for one aspect of the current state of this API Resource. +type HelmReleaseStatusConditionsPatchOutput struct{ *pulumi.OutputState } + +func (HelmReleaseStatusConditionsPatchOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseStatusConditionsPatch)(nil)).Elem() +} + +func (o HelmReleaseStatusConditionsPatchOutput) ToHelmReleaseStatusConditionsPatchOutput() HelmReleaseStatusConditionsPatchOutput { + return o +} + +func (o HelmReleaseStatusConditionsPatchOutput) ToHelmReleaseStatusConditionsPatchOutputWithContext(ctx context.Context) HelmReleaseStatusConditionsPatchOutput { + return o +} + +// lastTransitionTime is the last time the condition transitioned from one status to another. +// This should be when the underlying condition changed. If that is not known, then using the time when the API field changed is acceptable. +func (o HelmReleaseStatusConditionsPatchOutput) LastTransitionTime() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusConditionsPatch) *string { return v.LastTransitionTime }).(pulumi.StringPtrOutput) +} + +// message is a human readable message indicating details about the transition. +// This may be an empty string. +func (o HelmReleaseStatusConditionsPatchOutput) Message() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusConditionsPatch) *string { return v.Message }).(pulumi.StringPtrOutput) +} + +// observedGeneration represents the .metadata.generation that the condition was set based upon. +// For instance, if .metadata.generation is currently 12, but the .status.conditions[x].observedGeneration is 9, the condition is out of date +// with respect to the current state of the instance. +func (o HelmReleaseStatusConditionsPatchOutput) ObservedGeneration() pulumi.IntPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusConditionsPatch) *int { return v.ObservedGeneration }).(pulumi.IntPtrOutput) +} + +// reason contains a programmatic identifier indicating the reason for the condition's last transition. +// Producers of specific condition types may define expected values and meanings for this field, +// and whether the values are considered a guaranteed API. +// The value should be a CamelCase string. +// This field may not be empty. +func (o HelmReleaseStatusConditionsPatchOutput) Reason() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusConditionsPatch) *string { return v.Reason }).(pulumi.StringPtrOutput) +} + +// status of the condition, one of True, False, Unknown. +func (o HelmReleaseStatusConditionsPatchOutput) Status() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusConditionsPatch) *string { return v.Status }).(pulumi.StringPtrOutput) +} + +// type of condition in CamelCase or in foo.example.com/CamelCase. +func (o HelmReleaseStatusConditionsPatchOutput) Type() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusConditionsPatch) *string { return v.Type }).(pulumi.StringPtrOutput) +} + +type HelmReleaseStatusConditionsPatchArrayOutput struct{ *pulumi.OutputState } + +func (HelmReleaseStatusConditionsPatchArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]HelmReleaseStatusConditionsPatch)(nil)).Elem() +} + +func (o HelmReleaseStatusConditionsPatchArrayOutput) ToHelmReleaseStatusConditionsPatchArrayOutput() HelmReleaseStatusConditionsPatchArrayOutput { + return o +} + +func (o HelmReleaseStatusConditionsPatchArrayOutput) ToHelmReleaseStatusConditionsPatchArrayOutputWithContext(ctx context.Context) HelmReleaseStatusConditionsPatchArrayOutput { + return o +} + +func (o HelmReleaseStatusConditionsPatchArrayOutput) Index(i pulumi.IntInput) HelmReleaseStatusConditionsPatchOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) HelmReleaseStatusConditionsPatch { + return vs[0].([]HelmReleaseStatusConditionsPatch)[vs[1].(int)] + }).(HelmReleaseStatusConditionsPatchOutput) +} + +// Snapshot captures a point-in-time copy of the status information for a Helm release, +// as managed by the controller. +type HelmReleaseStatusHistory struct { + // Action is the action that resulted in this snapshot being created. + Action *string `pulumi:"action"` + // APIVersion is the API version of the Snapshot. + // When the calculation method of the Digest field is changed, this + // field will be used to distinguish between the old and new methods. + ApiVersion *string `pulumi:"apiVersion"` + // AppVersion is the chart app version of the release object in storage. + AppVersion *string `pulumi:"appVersion"` + // ChartName is the chart name of the release object in storage. + ChartName *string `pulumi:"chartName"` + // ChartVersion is the chart version of the release object in + // storage. + ChartVersion *string `pulumi:"chartVersion"` + // ConfigDigest is the checksum of the config (better known as + // "values") of the release object in storage. + // It has the format of `:`. + ConfigDigest *string `pulumi:"configDigest"` + // Deleted is when the release was deleted. + Deleted *string `pulumi:"deleted"` + // Digest is the checksum of the release object in storage. + // It has the format of `:`. + Digest *string `pulumi:"digest"` + // FirstDeployed is when the release was first deployed. + FirstDeployed *string `pulumi:"firstDeployed"` + // LastDeployed is when the release was last deployed. + LastDeployed *string `pulumi:"lastDeployed"` + // Name is the name of the release. + Name *string `pulumi:"name"` + // Namespace is the namespace the release is deployed to. + Namespace *string `pulumi:"namespace"` + // OCIDigest is the digest of the OCI artifact associated with the release. + OciDigest *string `pulumi:"ociDigest"` + // Status is the current state of the release. + Status *string `pulumi:"status"` + // TestHooks is the list of test hooks for the release as observed to be + // run by the controller. + TestHooks map[string]map[string]string `pulumi:"testHooks"` + // Version is the version of the release object in storage. + Version *int `pulumi:"version"` +} + +// HelmReleaseStatusHistoryInput is an input type that accepts HelmReleaseStatusHistoryArgs and HelmReleaseStatusHistoryOutput values. +// You can construct a concrete instance of `HelmReleaseStatusHistoryInput` via: +// +// HelmReleaseStatusHistoryArgs{...} +type HelmReleaseStatusHistoryInput interface { + pulumi.Input + + ToHelmReleaseStatusHistoryOutput() HelmReleaseStatusHistoryOutput + ToHelmReleaseStatusHistoryOutputWithContext(context.Context) HelmReleaseStatusHistoryOutput +} + +// Snapshot captures a point-in-time copy of the status information for a Helm release, +// as managed by the controller. +type HelmReleaseStatusHistoryArgs struct { + // Action is the action that resulted in this snapshot being created. + Action pulumi.StringPtrInput `pulumi:"action"` + // APIVersion is the API version of the Snapshot. + // When the calculation method of the Digest field is changed, this + // field will be used to distinguish between the old and new methods. + ApiVersion pulumi.StringPtrInput `pulumi:"apiVersion"` + // AppVersion is the chart app version of the release object in storage. + AppVersion pulumi.StringPtrInput `pulumi:"appVersion"` + // ChartName is the chart name of the release object in storage. + ChartName pulumi.StringPtrInput `pulumi:"chartName"` + // ChartVersion is the chart version of the release object in + // storage. + ChartVersion pulumi.StringPtrInput `pulumi:"chartVersion"` + // ConfigDigest is the checksum of the config (better known as + // "values") of the release object in storage. + // It has the format of `:`. + ConfigDigest pulumi.StringPtrInput `pulumi:"configDigest"` + // Deleted is when the release was deleted. + Deleted pulumi.StringPtrInput `pulumi:"deleted"` + // Digest is the checksum of the release object in storage. + // It has the format of `:`. + Digest pulumi.StringPtrInput `pulumi:"digest"` + // FirstDeployed is when the release was first deployed. + FirstDeployed pulumi.StringPtrInput `pulumi:"firstDeployed"` + // LastDeployed is when the release was last deployed. + LastDeployed pulumi.StringPtrInput `pulumi:"lastDeployed"` + // Name is the name of the release. + Name pulumi.StringPtrInput `pulumi:"name"` + // Namespace is the namespace the release is deployed to. + Namespace pulumi.StringPtrInput `pulumi:"namespace"` + // OCIDigest is the digest of the OCI artifact associated with the release. + OciDigest pulumi.StringPtrInput `pulumi:"ociDigest"` + // Status is the current state of the release. + Status pulumi.StringPtrInput `pulumi:"status"` + // TestHooks is the list of test hooks for the release as observed to be + // run by the controller. + TestHooks pulumi.StringMapMapInput `pulumi:"testHooks"` + // Version is the version of the release object in storage. + Version pulumi.IntPtrInput `pulumi:"version"` +} + +func (HelmReleaseStatusHistoryArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseStatusHistory)(nil)).Elem() +} + +func (i HelmReleaseStatusHistoryArgs) ToHelmReleaseStatusHistoryOutput() HelmReleaseStatusHistoryOutput { + return i.ToHelmReleaseStatusHistoryOutputWithContext(context.Background()) +} + +func (i HelmReleaseStatusHistoryArgs) ToHelmReleaseStatusHistoryOutputWithContext(ctx context.Context) HelmReleaseStatusHistoryOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseStatusHistoryOutput) +} + +// HelmReleaseStatusHistoryArrayInput is an input type that accepts HelmReleaseStatusHistoryArray and HelmReleaseStatusHistoryArrayOutput values. +// You can construct a concrete instance of `HelmReleaseStatusHistoryArrayInput` via: +// +// HelmReleaseStatusHistoryArray{ HelmReleaseStatusHistoryArgs{...} } +type HelmReleaseStatusHistoryArrayInput interface { + pulumi.Input + + ToHelmReleaseStatusHistoryArrayOutput() HelmReleaseStatusHistoryArrayOutput + ToHelmReleaseStatusHistoryArrayOutputWithContext(context.Context) HelmReleaseStatusHistoryArrayOutput +} + +type HelmReleaseStatusHistoryArray []HelmReleaseStatusHistoryInput + +func (HelmReleaseStatusHistoryArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]HelmReleaseStatusHistory)(nil)).Elem() +} + +func (i HelmReleaseStatusHistoryArray) ToHelmReleaseStatusHistoryArrayOutput() HelmReleaseStatusHistoryArrayOutput { + return i.ToHelmReleaseStatusHistoryArrayOutputWithContext(context.Background()) +} + +func (i HelmReleaseStatusHistoryArray) ToHelmReleaseStatusHistoryArrayOutputWithContext(ctx context.Context) HelmReleaseStatusHistoryArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseStatusHistoryArrayOutput) +} + +// Snapshot captures a point-in-time copy of the status information for a Helm release, +// as managed by the controller. +type HelmReleaseStatusHistoryOutput struct{ *pulumi.OutputState } + +func (HelmReleaseStatusHistoryOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseStatusHistory)(nil)).Elem() +} + +func (o HelmReleaseStatusHistoryOutput) ToHelmReleaseStatusHistoryOutput() HelmReleaseStatusHistoryOutput { + return o +} + +func (o HelmReleaseStatusHistoryOutput) ToHelmReleaseStatusHistoryOutputWithContext(ctx context.Context) HelmReleaseStatusHistoryOutput { + return o +} + +// Action is the action that resulted in this snapshot being created. +func (o HelmReleaseStatusHistoryOutput) Action() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusHistory) *string { return v.Action }).(pulumi.StringPtrOutput) +} + +// APIVersion is the API version of the Snapshot. +// When the calculation method of the Digest field is changed, this +// field will be used to distinguish between the old and new methods. +func (o HelmReleaseStatusHistoryOutput) ApiVersion() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusHistory) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) +} + +// AppVersion is the chart app version of the release object in storage. +func (o HelmReleaseStatusHistoryOutput) AppVersion() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusHistory) *string { return v.AppVersion }).(pulumi.StringPtrOutput) +} + +// ChartName is the chart name of the release object in storage. +func (o HelmReleaseStatusHistoryOutput) ChartName() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusHistory) *string { return v.ChartName }).(pulumi.StringPtrOutput) +} + +// ChartVersion is the chart version of the release object in +// storage. +func (o HelmReleaseStatusHistoryOutput) ChartVersion() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusHistory) *string { return v.ChartVersion }).(pulumi.StringPtrOutput) +} + +// ConfigDigest is the checksum of the config (better known as +// "values") of the release object in storage. +// It has the format of `:`. +func (o HelmReleaseStatusHistoryOutput) ConfigDigest() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusHistory) *string { return v.ConfigDigest }).(pulumi.StringPtrOutput) +} + +// Deleted is when the release was deleted. +func (o HelmReleaseStatusHistoryOutput) Deleted() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusHistory) *string { return v.Deleted }).(pulumi.StringPtrOutput) +} + +// Digest is the checksum of the release object in storage. +// It has the format of `:`. +func (o HelmReleaseStatusHistoryOutput) Digest() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusHistory) *string { return v.Digest }).(pulumi.StringPtrOutput) +} + +// FirstDeployed is when the release was first deployed. +func (o HelmReleaseStatusHistoryOutput) FirstDeployed() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusHistory) *string { return v.FirstDeployed }).(pulumi.StringPtrOutput) +} + +// LastDeployed is when the release was last deployed. +func (o HelmReleaseStatusHistoryOutput) LastDeployed() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusHistory) *string { return v.LastDeployed }).(pulumi.StringPtrOutput) +} + +// Name is the name of the release. +func (o HelmReleaseStatusHistoryOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusHistory) *string { return v.Name }).(pulumi.StringPtrOutput) +} + +// Namespace is the namespace the release is deployed to. +func (o HelmReleaseStatusHistoryOutput) Namespace() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusHistory) *string { return v.Namespace }).(pulumi.StringPtrOutput) +} + +// OCIDigest is the digest of the OCI artifact associated with the release. +func (o HelmReleaseStatusHistoryOutput) OciDigest() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusHistory) *string { return v.OciDigest }).(pulumi.StringPtrOutput) +} + +// Status is the current state of the release. +func (o HelmReleaseStatusHistoryOutput) Status() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusHistory) *string { return v.Status }).(pulumi.StringPtrOutput) +} + +// TestHooks is the list of test hooks for the release as observed to be +// run by the controller. +func (o HelmReleaseStatusHistoryOutput) TestHooks() pulumi.StringMapMapOutput { + return o.ApplyT(func(v HelmReleaseStatusHistory) map[string]map[string]string { return v.TestHooks }).(pulumi.StringMapMapOutput) +} + +// Version is the version of the release object in storage. +func (o HelmReleaseStatusHistoryOutput) Version() pulumi.IntPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusHistory) *int { return v.Version }).(pulumi.IntPtrOutput) +} + +type HelmReleaseStatusHistoryArrayOutput struct{ *pulumi.OutputState } + +func (HelmReleaseStatusHistoryArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]HelmReleaseStatusHistory)(nil)).Elem() +} + +func (o HelmReleaseStatusHistoryArrayOutput) ToHelmReleaseStatusHistoryArrayOutput() HelmReleaseStatusHistoryArrayOutput { + return o +} + +func (o HelmReleaseStatusHistoryArrayOutput) ToHelmReleaseStatusHistoryArrayOutputWithContext(ctx context.Context) HelmReleaseStatusHistoryArrayOutput { + return o +} + +func (o HelmReleaseStatusHistoryArrayOutput) Index(i pulumi.IntInput) HelmReleaseStatusHistoryOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) HelmReleaseStatusHistory { + return vs[0].([]HelmReleaseStatusHistory)[vs[1].(int)] + }).(HelmReleaseStatusHistoryOutput) +} + +// Snapshot captures a point-in-time copy of the status information for a Helm release, +// as managed by the controller. +type HelmReleaseStatusHistoryPatch struct { + // Action is the action that resulted in this snapshot being created. + Action *string `pulumi:"action"` + // APIVersion is the API version of the Snapshot. + // When the calculation method of the Digest field is changed, this + // field will be used to distinguish between the old and new methods. + ApiVersion *string `pulumi:"apiVersion"` + // AppVersion is the chart app version of the release object in storage. + AppVersion *string `pulumi:"appVersion"` + // ChartName is the chart name of the release object in storage. + ChartName *string `pulumi:"chartName"` + // ChartVersion is the chart version of the release object in + // storage. + ChartVersion *string `pulumi:"chartVersion"` + // ConfigDigest is the checksum of the config (better known as + // "values") of the release object in storage. + // It has the format of `:`. + ConfigDigest *string `pulumi:"configDigest"` + // Deleted is when the release was deleted. + Deleted *string `pulumi:"deleted"` + // Digest is the checksum of the release object in storage. + // It has the format of `:`. + Digest *string `pulumi:"digest"` + // FirstDeployed is when the release was first deployed. + FirstDeployed *string `pulumi:"firstDeployed"` + // LastDeployed is when the release was last deployed. + LastDeployed *string `pulumi:"lastDeployed"` + // Name is the name of the release. + Name *string `pulumi:"name"` + // Namespace is the namespace the release is deployed to. + Namespace *string `pulumi:"namespace"` + // OCIDigest is the digest of the OCI artifact associated with the release. + OciDigest *string `pulumi:"ociDigest"` + // Status is the current state of the release. + Status *string `pulumi:"status"` + // TestHooks is the list of test hooks for the release as observed to be + // run by the controller. + TestHooks map[string]map[string]string `pulumi:"testHooks"` + // Version is the version of the release object in storage. + Version *int `pulumi:"version"` +} + +// HelmReleaseStatusHistoryPatchInput is an input type that accepts HelmReleaseStatusHistoryPatchArgs and HelmReleaseStatusHistoryPatchOutput values. +// You can construct a concrete instance of `HelmReleaseStatusHistoryPatchInput` via: +// +// HelmReleaseStatusHistoryPatchArgs{...} +type HelmReleaseStatusHistoryPatchInput interface { + pulumi.Input + + ToHelmReleaseStatusHistoryPatchOutput() HelmReleaseStatusHistoryPatchOutput + ToHelmReleaseStatusHistoryPatchOutputWithContext(context.Context) HelmReleaseStatusHistoryPatchOutput +} + +// Snapshot captures a point-in-time copy of the status information for a Helm release, +// as managed by the controller. +type HelmReleaseStatusHistoryPatchArgs struct { + // Action is the action that resulted in this snapshot being created. + Action pulumi.StringPtrInput `pulumi:"action"` + // APIVersion is the API version of the Snapshot. + // When the calculation method of the Digest field is changed, this + // field will be used to distinguish between the old and new methods. + ApiVersion pulumi.StringPtrInput `pulumi:"apiVersion"` + // AppVersion is the chart app version of the release object in storage. + AppVersion pulumi.StringPtrInput `pulumi:"appVersion"` + // ChartName is the chart name of the release object in storage. + ChartName pulumi.StringPtrInput `pulumi:"chartName"` + // ChartVersion is the chart version of the release object in + // storage. + ChartVersion pulumi.StringPtrInput `pulumi:"chartVersion"` + // ConfigDigest is the checksum of the config (better known as + // "values") of the release object in storage. + // It has the format of `:`. + ConfigDigest pulumi.StringPtrInput `pulumi:"configDigest"` + // Deleted is when the release was deleted. + Deleted pulumi.StringPtrInput `pulumi:"deleted"` + // Digest is the checksum of the release object in storage. + // It has the format of `:`. + Digest pulumi.StringPtrInput `pulumi:"digest"` + // FirstDeployed is when the release was first deployed. + FirstDeployed pulumi.StringPtrInput `pulumi:"firstDeployed"` + // LastDeployed is when the release was last deployed. + LastDeployed pulumi.StringPtrInput `pulumi:"lastDeployed"` + // Name is the name of the release. + Name pulumi.StringPtrInput `pulumi:"name"` + // Namespace is the namespace the release is deployed to. + Namespace pulumi.StringPtrInput `pulumi:"namespace"` + // OCIDigest is the digest of the OCI artifact associated with the release. + OciDigest pulumi.StringPtrInput `pulumi:"ociDigest"` + // Status is the current state of the release. + Status pulumi.StringPtrInput `pulumi:"status"` + // TestHooks is the list of test hooks for the release as observed to be + // run by the controller. + TestHooks pulumi.StringMapMapInput `pulumi:"testHooks"` + // Version is the version of the release object in storage. + Version pulumi.IntPtrInput `pulumi:"version"` +} + +func (HelmReleaseStatusHistoryPatchArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseStatusHistoryPatch)(nil)).Elem() +} + +func (i HelmReleaseStatusHistoryPatchArgs) ToHelmReleaseStatusHistoryPatchOutput() HelmReleaseStatusHistoryPatchOutput { + return i.ToHelmReleaseStatusHistoryPatchOutputWithContext(context.Background()) +} + +func (i HelmReleaseStatusHistoryPatchArgs) ToHelmReleaseStatusHistoryPatchOutputWithContext(ctx context.Context) HelmReleaseStatusHistoryPatchOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseStatusHistoryPatchOutput) +} + +// HelmReleaseStatusHistoryPatchArrayInput is an input type that accepts HelmReleaseStatusHistoryPatchArray and HelmReleaseStatusHistoryPatchArrayOutput values. +// You can construct a concrete instance of `HelmReleaseStatusHistoryPatchArrayInput` via: +// +// HelmReleaseStatusHistoryPatchArray{ HelmReleaseStatusHistoryPatchArgs{...} } +type HelmReleaseStatusHistoryPatchArrayInput interface { + pulumi.Input + + ToHelmReleaseStatusHistoryPatchArrayOutput() HelmReleaseStatusHistoryPatchArrayOutput + ToHelmReleaseStatusHistoryPatchArrayOutputWithContext(context.Context) HelmReleaseStatusHistoryPatchArrayOutput +} + +type HelmReleaseStatusHistoryPatchArray []HelmReleaseStatusHistoryPatchInput + +func (HelmReleaseStatusHistoryPatchArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]HelmReleaseStatusHistoryPatch)(nil)).Elem() +} + +func (i HelmReleaseStatusHistoryPatchArray) ToHelmReleaseStatusHistoryPatchArrayOutput() HelmReleaseStatusHistoryPatchArrayOutput { + return i.ToHelmReleaseStatusHistoryPatchArrayOutputWithContext(context.Background()) +} + +func (i HelmReleaseStatusHistoryPatchArray) ToHelmReleaseStatusHistoryPatchArrayOutputWithContext(ctx context.Context) HelmReleaseStatusHistoryPatchArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseStatusHistoryPatchArrayOutput) +} + +// Snapshot captures a point-in-time copy of the status information for a Helm release, +// as managed by the controller. +type HelmReleaseStatusHistoryPatchOutput struct{ *pulumi.OutputState } + +func (HelmReleaseStatusHistoryPatchOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseStatusHistoryPatch)(nil)).Elem() +} + +func (o HelmReleaseStatusHistoryPatchOutput) ToHelmReleaseStatusHistoryPatchOutput() HelmReleaseStatusHistoryPatchOutput { + return o +} + +func (o HelmReleaseStatusHistoryPatchOutput) ToHelmReleaseStatusHistoryPatchOutputWithContext(ctx context.Context) HelmReleaseStatusHistoryPatchOutput { + return o +} + +// Action is the action that resulted in this snapshot being created. +func (o HelmReleaseStatusHistoryPatchOutput) Action() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusHistoryPatch) *string { return v.Action }).(pulumi.StringPtrOutput) +} + +// APIVersion is the API version of the Snapshot. +// When the calculation method of the Digest field is changed, this +// field will be used to distinguish between the old and new methods. +func (o HelmReleaseStatusHistoryPatchOutput) ApiVersion() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusHistoryPatch) *string { return v.ApiVersion }).(pulumi.StringPtrOutput) +} + +// AppVersion is the chart app version of the release object in storage. +func (o HelmReleaseStatusHistoryPatchOutput) AppVersion() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusHistoryPatch) *string { return v.AppVersion }).(pulumi.StringPtrOutput) +} + +// ChartName is the chart name of the release object in storage. +func (o HelmReleaseStatusHistoryPatchOutput) ChartName() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusHistoryPatch) *string { return v.ChartName }).(pulumi.StringPtrOutput) +} + +// ChartVersion is the chart version of the release object in +// storage. +func (o HelmReleaseStatusHistoryPatchOutput) ChartVersion() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusHistoryPatch) *string { return v.ChartVersion }).(pulumi.StringPtrOutput) +} + +// ConfigDigest is the checksum of the config (better known as +// "values") of the release object in storage. +// It has the format of `:`. +func (o HelmReleaseStatusHistoryPatchOutput) ConfigDigest() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusHistoryPatch) *string { return v.ConfigDigest }).(pulumi.StringPtrOutput) +} + +// Deleted is when the release was deleted. +func (o HelmReleaseStatusHistoryPatchOutput) Deleted() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusHistoryPatch) *string { return v.Deleted }).(pulumi.StringPtrOutput) +} + +// Digest is the checksum of the release object in storage. +// It has the format of `:`. +func (o HelmReleaseStatusHistoryPatchOutput) Digest() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusHistoryPatch) *string { return v.Digest }).(pulumi.StringPtrOutput) +} + +// FirstDeployed is when the release was first deployed. +func (o HelmReleaseStatusHistoryPatchOutput) FirstDeployed() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusHistoryPatch) *string { return v.FirstDeployed }).(pulumi.StringPtrOutput) +} + +// LastDeployed is when the release was last deployed. +func (o HelmReleaseStatusHistoryPatchOutput) LastDeployed() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusHistoryPatch) *string { return v.LastDeployed }).(pulumi.StringPtrOutput) +} + +// Name is the name of the release. +func (o HelmReleaseStatusHistoryPatchOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusHistoryPatch) *string { return v.Name }).(pulumi.StringPtrOutput) +} + +// Namespace is the namespace the release is deployed to. +func (o HelmReleaseStatusHistoryPatchOutput) Namespace() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusHistoryPatch) *string { return v.Namespace }).(pulumi.StringPtrOutput) +} + +// OCIDigest is the digest of the OCI artifact associated with the release. +func (o HelmReleaseStatusHistoryPatchOutput) OciDigest() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusHistoryPatch) *string { return v.OciDigest }).(pulumi.StringPtrOutput) +} + +// Status is the current state of the release. +func (o HelmReleaseStatusHistoryPatchOutput) Status() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusHistoryPatch) *string { return v.Status }).(pulumi.StringPtrOutput) +} + +// TestHooks is the list of test hooks for the release as observed to be +// run by the controller. +func (o HelmReleaseStatusHistoryPatchOutput) TestHooks() pulumi.StringMapMapOutput { + return o.ApplyT(func(v HelmReleaseStatusHistoryPatch) map[string]map[string]string { return v.TestHooks }).(pulumi.StringMapMapOutput) +} + +// Version is the version of the release object in storage. +func (o HelmReleaseStatusHistoryPatchOutput) Version() pulumi.IntPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusHistoryPatch) *int { return v.Version }).(pulumi.IntPtrOutput) +} + +type HelmReleaseStatusHistoryPatchArrayOutput struct{ *pulumi.OutputState } + +func (HelmReleaseStatusHistoryPatchArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]HelmReleaseStatusHistoryPatch)(nil)).Elem() +} + +func (o HelmReleaseStatusHistoryPatchArrayOutput) ToHelmReleaseStatusHistoryPatchArrayOutput() HelmReleaseStatusHistoryPatchArrayOutput { + return o +} + +func (o HelmReleaseStatusHistoryPatchArrayOutput) ToHelmReleaseStatusHistoryPatchArrayOutputWithContext(ctx context.Context) HelmReleaseStatusHistoryPatchArrayOutput { + return o +} + +func (o HelmReleaseStatusHistoryPatchArrayOutput) Index(i pulumi.IntInput) HelmReleaseStatusHistoryPatchOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) HelmReleaseStatusHistoryPatch { + return vs[0].([]HelmReleaseStatusHistoryPatch)[vs[1].(int)] + }).(HelmReleaseStatusHistoryPatchOutput) +} + +// Inventory contains the list of Kubernetes resource object references +// that have been applied for this release. +type HelmReleaseStatusInventory struct { + // Entries of Kubernetes resource object references. + Entries []HelmReleaseStatusInventoryEntries `pulumi:"entries"` +} + +// HelmReleaseStatusInventoryInput is an input type that accepts HelmReleaseStatusInventoryArgs and HelmReleaseStatusInventoryOutput values. +// You can construct a concrete instance of `HelmReleaseStatusInventoryInput` via: +// +// HelmReleaseStatusInventoryArgs{...} +type HelmReleaseStatusInventoryInput interface { + pulumi.Input + + ToHelmReleaseStatusInventoryOutput() HelmReleaseStatusInventoryOutput + ToHelmReleaseStatusInventoryOutputWithContext(context.Context) HelmReleaseStatusInventoryOutput +} + +// Inventory contains the list of Kubernetes resource object references +// that have been applied for this release. +type HelmReleaseStatusInventoryArgs struct { + // Entries of Kubernetes resource object references. + Entries HelmReleaseStatusInventoryEntriesArrayInput `pulumi:"entries"` +} + +func (HelmReleaseStatusInventoryArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseStatusInventory)(nil)).Elem() +} + +func (i HelmReleaseStatusInventoryArgs) ToHelmReleaseStatusInventoryOutput() HelmReleaseStatusInventoryOutput { + return i.ToHelmReleaseStatusInventoryOutputWithContext(context.Background()) +} + +func (i HelmReleaseStatusInventoryArgs) ToHelmReleaseStatusInventoryOutputWithContext(ctx context.Context) HelmReleaseStatusInventoryOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseStatusInventoryOutput) +} + +func (i HelmReleaseStatusInventoryArgs) ToHelmReleaseStatusInventoryPtrOutput() HelmReleaseStatusInventoryPtrOutput { + return i.ToHelmReleaseStatusInventoryPtrOutputWithContext(context.Background()) +} + +func (i HelmReleaseStatusInventoryArgs) ToHelmReleaseStatusInventoryPtrOutputWithContext(ctx context.Context) HelmReleaseStatusInventoryPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseStatusInventoryOutput).ToHelmReleaseStatusInventoryPtrOutputWithContext(ctx) +} + +// HelmReleaseStatusInventoryPtrInput is an input type that accepts HelmReleaseStatusInventoryArgs, HelmReleaseStatusInventoryPtr and HelmReleaseStatusInventoryPtrOutput values. +// You can construct a concrete instance of `HelmReleaseStatusInventoryPtrInput` via: +// +// HelmReleaseStatusInventoryArgs{...} +// +// or: +// +// nil +type HelmReleaseStatusInventoryPtrInput interface { + pulumi.Input + + ToHelmReleaseStatusInventoryPtrOutput() HelmReleaseStatusInventoryPtrOutput + ToHelmReleaseStatusInventoryPtrOutputWithContext(context.Context) HelmReleaseStatusInventoryPtrOutput +} + +type helmReleaseStatusInventoryPtrType HelmReleaseStatusInventoryArgs + +func HelmReleaseStatusInventoryPtr(v *HelmReleaseStatusInventoryArgs) HelmReleaseStatusInventoryPtrInput { + return (*helmReleaseStatusInventoryPtrType)(v) +} + +func (*helmReleaseStatusInventoryPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseStatusInventory)(nil)).Elem() +} + +func (i *helmReleaseStatusInventoryPtrType) ToHelmReleaseStatusInventoryPtrOutput() HelmReleaseStatusInventoryPtrOutput { + return i.ToHelmReleaseStatusInventoryPtrOutputWithContext(context.Background()) +} + +func (i *helmReleaseStatusInventoryPtrType) ToHelmReleaseStatusInventoryPtrOutputWithContext(ctx context.Context) HelmReleaseStatusInventoryPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseStatusInventoryPtrOutput) +} + +// Inventory contains the list of Kubernetes resource object references +// that have been applied for this release. +type HelmReleaseStatusInventoryOutput struct{ *pulumi.OutputState } + +func (HelmReleaseStatusInventoryOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseStatusInventory)(nil)).Elem() +} + +func (o HelmReleaseStatusInventoryOutput) ToHelmReleaseStatusInventoryOutput() HelmReleaseStatusInventoryOutput { + return o +} + +func (o HelmReleaseStatusInventoryOutput) ToHelmReleaseStatusInventoryOutputWithContext(ctx context.Context) HelmReleaseStatusInventoryOutput { + return o +} + +func (o HelmReleaseStatusInventoryOutput) ToHelmReleaseStatusInventoryPtrOutput() HelmReleaseStatusInventoryPtrOutput { + return o.ToHelmReleaseStatusInventoryPtrOutputWithContext(context.Background()) +} + +func (o HelmReleaseStatusInventoryOutput) ToHelmReleaseStatusInventoryPtrOutputWithContext(ctx context.Context) HelmReleaseStatusInventoryPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v HelmReleaseStatusInventory) *HelmReleaseStatusInventory { + return &v + }).(HelmReleaseStatusInventoryPtrOutput) +} + +// Entries of Kubernetes resource object references. +func (o HelmReleaseStatusInventoryOutput) Entries() HelmReleaseStatusInventoryEntriesArrayOutput { + return o.ApplyT(func(v HelmReleaseStatusInventory) []HelmReleaseStatusInventoryEntries { return v.Entries }).(HelmReleaseStatusInventoryEntriesArrayOutput) +} + +type HelmReleaseStatusInventoryPtrOutput struct{ *pulumi.OutputState } + +func (HelmReleaseStatusInventoryPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseStatusInventory)(nil)).Elem() +} + +func (o HelmReleaseStatusInventoryPtrOutput) ToHelmReleaseStatusInventoryPtrOutput() HelmReleaseStatusInventoryPtrOutput { + return o +} + +func (o HelmReleaseStatusInventoryPtrOutput) ToHelmReleaseStatusInventoryPtrOutputWithContext(ctx context.Context) HelmReleaseStatusInventoryPtrOutput { + return o +} + +func (o HelmReleaseStatusInventoryPtrOutput) Elem() HelmReleaseStatusInventoryOutput { + return o.ApplyT(func(v *HelmReleaseStatusInventory) HelmReleaseStatusInventory { + if v != nil { + return *v + } + var ret HelmReleaseStatusInventory + return ret + }).(HelmReleaseStatusInventoryOutput) +} + +// Entries of Kubernetes resource object references. +func (o HelmReleaseStatusInventoryPtrOutput) Entries() HelmReleaseStatusInventoryEntriesArrayOutput { + return o.ApplyT(func(v *HelmReleaseStatusInventory) []HelmReleaseStatusInventoryEntries { + if v == nil { + return nil + } + return v.Entries + }).(HelmReleaseStatusInventoryEntriesArrayOutput) +} + +// ResourceRef contains the information necessary to locate a resource within a cluster. +type HelmReleaseStatusInventoryEntries struct { + // ID is the string representation of the Kubernetes resource object's metadata, + // in the format '___'. + Id *string `pulumi:"id"` + // Version is the API version of the Kubernetes resource object's kind. + V *string `pulumi:"v"` +} + +// HelmReleaseStatusInventoryEntriesInput is an input type that accepts HelmReleaseStatusInventoryEntriesArgs and HelmReleaseStatusInventoryEntriesOutput values. +// You can construct a concrete instance of `HelmReleaseStatusInventoryEntriesInput` via: +// +// HelmReleaseStatusInventoryEntriesArgs{...} +type HelmReleaseStatusInventoryEntriesInput interface { + pulumi.Input + + ToHelmReleaseStatusInventoryEntriesOutput() HelmReleaseStatusInventoryEntriesOutput + ToHelmReleaseStatusInventoryEntriesOutputWithContext(context.Context) HelmReleaseStatusInventoryEntriesOutput +} + +// ResourceRef contains the information necessary to locate a resource within a cluster. +type HelmReleaseStatusInventoryEntriesArgs struct { + // ID is the string representation of the Kubernetes resource object's metadata, + // in the format '___'. + Id pulumi.StringPtrInput `pulumi:"id"` + // Version is the API version of the Kubernetes resource object's kind. + V pulumi.StringPtrInput `pulumi:"v"` +} + +func (HelmReleaseStatusInventoryEntriesArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseStatusInventoryEntries)(nil)).Elem() +} + +func (i HelmReleaseStatusInventoryEntriesArgs) ToHelmReleaseStatusInventoryEntriesOutput() HelmReleaseStatusInventoryEntriesOutput { + return i.ToHelmReleaseStatusInventoryEntriesOutputWithContext(context.Background()) +} + +func (i HelmReleaseStatusInventoryEntriesArgs) ToHelmReleaseStatusInventoryEntriesOutputWithContext(ctx context.Context) HelmReleaseStatusInventoryEntriesOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseStatusInventoryEntriesOutput) +} + +// HelmReleaseStatusInventoryEntriesArrayInput is an input type that accepts HelmReleaseStatusInventoryEntriesArray and HelmReleaseStatusInventoryEntriesArrayOutput values. +// You can construct a concrete instance of `HelmReleaseStatusInventoryEntriesArrayInput` via: +// +// HelmReleaseStatusInventoryEntriesArray{ HelmReleaseStatusInventoryEntriesArgs{...} } +type HelmReleaseStatusInventoryEntriesArrayInput interface { + pulumi.Input + + ToHelmReleaseStatusInventoryEntriesArrayOutput() HelmReleaseStatusInventoryEntriesArrayOutput + ToHelmReleaseStatusInventoryEntriesArrayOutputWithContext(context.Context) HelmReleaseStatusInventoryEntriesArrayOutput +} + +type HelmReleaseStatusInventoryEntriesArray []HelmReleaseStatusInventoryEntriesInput + +func (HelmReleaseStatusInventoryEntriesArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]HelmReleaseStatusInventoryEntries)(nil)).Elem() +} + +func (i HelmReleaseStatusInventoryEntriesArray) ToHelmReleaseStatusInventoryEntriesArrayOutput() HelmReleaseStatusInventoryEntriesArrayOutput { + return i.ToHelmReleaseStatusInventoryEntriesArrayOutputWithContext(context.Background()) +} + +func (i HelmReleaseStatusInventoryEntriesArray) ToHelmReleaseStatusInventoryEntriesArrayOutputWithContext(ctx context.Context) HelmReleaseStatusInventoryEntriesArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseStatusInventoryEntriesArrayOutput) +} + +// ResourceRef contains the information necessary to locate a resource within a cluster. +type HelmReleaseStatusInventoryEntriesOutput struct{ *pulumi.OutputState } + +func (HelmReleaseStatusInventoryEntriesOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseStatusInventoryEntries)(nil)).Elem() +} + +func (o HelmReleaseStatusInventoryEntriesOutput) ToHelmReleaseStatusInventoryEntriesOutput() HelmReleaseStatusInventoryEntriesOutput { + return o +} + +func (o HelmReleaseStatusInventoryEntriesOutput) ToHelmReleaseStatusInventoryEntriesOutputWithContext(ctx context.Context) HelmReleaseStatusInventoryEntriesOutput { + return o +} + +// ID is the string representation of the Kubernetes resource object's metadata, +// in the format '___'. +func (o HelmReleaseStatusInventoryEntriesOutput) Id() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusInventoryEntries) *string { return v.Id }).(pulumi.StringPtrOutput) +} + +// Version is the API version of the Kubernetes resource object's kind. +func (o HelmReleaseStatusInventoryEntriesOutput) V() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusInventoryEntries) *string { return v.V }).(pulumi.StringPtrOutput) +} + +type HelmReleaseStatusInventoryEntriesArrayOutput struct{ *pulumi.OutputState } + +func (HelmReleaseStatusInventoryEntriesArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]HelmReleaseStatusInventoryEntries)(nil)).Elem() +} + +func (o HelmReleaseStatusInventoryEntriesArrayOutput) ToHelmReleaseStatusInventoryEntriesArrayOutput() HelmReleaseStatusInventoryEntriesArrayOutput { + return o +} + +func (o HelmReleaseStatusInventoryEntriesArrayOutput) ToHelmReleaseStatusInventoryEntriesArrayOutputWithContext(ctx context.Context) HelmReleaseStatusInventoryEntriesArrayOutput { + return o +} + +func (o HelmReleaseStatusInventoryEntriesArrayOutput) Index(i pulumi.IntInput) HelmReleaseStatusInventoryEntriesOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) HelmReleaseStatusInventoryEntries { + return vs[0].([]HelmReleaseStatusInventoryEntries)[vs[1].(int)] + }).(HelmReleaseStatusInventoryEntriesOutput) +} + +// ResourceRef contains the information necessary to locate a resource within a cluster. +type HelmReleaseStatusInventoryEntriesPatch struct { + // ID is the string representation of the Kubernetes resource object's metadata, + // in the format '___'. + Id *string `pulumi:"id"` + // Version is the API version of the Kubernetes resource object's kind. + V *string `pulumi:"v"` +} + +// HelmReleaseStatusInventoryEntriesPatchInput is an input type that accepts HelmReleaseStatusInventoryEntriesPatchArgs and HelmReleaseStatusInventoryEntriesPatchOutput values. +// You can construct a concrete instance of `HelmReleaseStatusInventoryEntriesPatchInput` via: +// +// HelmReleaseStatusInventoryEntriesPatchArgs{...} +type HelmReleaseStatusInventoryEntriesPatchInput interface { + pulumi.Input + + ToHelmReleaseStatusInventoryEntriesPatchOutput() HelmReleaseStatusInventoryEntriesPatchOutput + ToHelmReleaseStatusInventoryEntriesPatchOutputWithContext(context.Context) HelmReleaseStatusInventoryEntriesPatchOutput +} + +// ResourceRef contains the information necessary to locate a resource within a cluster. +type HelmReleaseStatusInventoryEntriesPatchArgs struct { + // ID is the string representation of the Kubernetes resource object's metadata, + // in the format '___'. + Id pulumi.StringPtrInput `pulumi:"id"` + // Version is the API version of the Kubernetes resource object's kind. + V pulumi.StringPtrInput `pulumi:"v"` +} + +func (HelmReleaseStatusInventoryEntriesPatchArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseStatusInventoryEntriesPatch)(nil)).Elem() +} + +func (i HelmReleaseStatusInventoryEntriesPatchArgs) ToHelmReleaseStatusInventoryEntriesPatchOutput() HelmReleaseStatusInventoryEntriesPatchOutput { + return i.ToHelmReleaseStatusInventoryEntriesPatchOutputWithContext(context.Background()) +} + +func (i HelmReleaseStatusInventoryEntriesPatchArgs) ToHelmReleaseStatusInventoryEntriesPatchOutputWithContext(ctx context.Context) HelmReleaseStatusInventoryEntriesPatchOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseStatusInventoryEntriesPatchOutput) +} + +// HelmReleaseStatusInventoryEntriesPatchArrayInput is an input type that accepts HelmReleaseStatusInventoryEntriesPatchArray and HelmReleaseStatusInventoryEntriesPatchArrayOutput values. +// You can construct a concrete instance of `HelmReleaseStatusInventoryEntriesPatchArrayInput` via: +// +// HelmReleaseStatusInventoryEntriesPatchArray{ HelmReleaseStatusInventoryEntriesPatchArgs{...} } +type HelmReleaseStatusInventoryEntriesPatchArrayInput interface { + pulumi.Input + + ToHelmReleaseStatusInventoryEntriesPatchArrayOutput() HelmReleaseStatusInventoryEntriesPatchArrayOutput + ToHelmReleaseStatusInventoryEntriesPatchArrayOutputWithContext(context.Context) HelmReleaseStatusInventoryEntriesPatchArrayOutput +} + +type HelmReleaseStatusInventoryEntriesPatchArray []HelmReleaseStatusInventoryEntriesPatchInput + +func (HelmReleaseStatusInventoryEntriesPatchArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]HelmReleaseStatusInventoryEntriesPatch)(nil)).Elem() +} + +func (i HelmReleaseStatusInventoryEntriesPatchArray) ToHelmReleaseStatusInventoryEntriesPatchArrayOutput() HelmReleaseStatusInventoryEntriesPatchArrayOutput { + return i.ToHelmReleaseStatusInventoryEntriesPatchArrayOutputWithContext(context.Background()) +} + +func (i HelmReleaseStatusInventoryEntriesPatchArray) ToHelmReleaseStatusInventoryEntriesPatchArrayOutputWithContext(ctx context.Context) HelmReleaseStatusInventoryEntriesPatchArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseStatusInventoryEntriesPatchArrayOutput) +} + +// ResourceRef contains the information necessary to locate a resource within a cluster. +type HelmReleaseStatusInventoryEntriesPatchOutput struct{ *pulumi.OutputState } + +func (HelmReleaseStatusInventoryEntriesPatchOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseStatusInventoryEntriesPatch)(nil)).Elem() +} + +func (o HelmReleaseStatusInventoryEntriesPatchOutput) ToHelmReleaseStatusInventoryEntriesPatchOutput() HelmReleaseStatusInventoryEntriesPatchOutput { + return o +} + +func (o HelmReleaseStatusInventoryEntriesPatchOutput) ToHelmReleaseStatusInventoryEntriesPatchOutputWithContext(ctx context.Context) HelmReleaseStatusInventoryEntriesPatchOutput { + return o +} + +// ID is the string representation of the Kubernetes resource object's metadata, +// in the format '___'. +func (o HelmReleaseStatusInventoryEntriesPatchOutput) Id() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusInventoryEntriesPatch) *string { return v.Id }).(pulumi.StringPtrOutput) +} + +// Version is the API version of the Kubernetes resource object's kind. +func (o HelmReleaseStatusInventoryEntriesPatchOutput) V() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusInventoryEntriesPatch) *string { return v.V }).(pulumi.StringPtrOutput) +} + +type HelmReleaseStatusInventoryEntriesPatchArrayOutput struct{ *pulumi.OutputState } + +func (HelmReleaseStatusInventoryEntriesPatchArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]HelmReleaseStatusInventoryEntriesPatch)(nil)).Elem() +} + +func (o HelmReleaseStatusInventoryEntriesPatchArrayOutput) ToHelmReleaseStatusInventoryEntriesPatchArrayOutput() HelmReleaseStatusInventoryEntriesPatchArrayOutput { + return o +} + +func (o HelmReleaseStatusInventoryEntriesPatchArrayOutput) ToHelmReleaseStatusInventoryEntriesPatchArrayOutputWithContext(ctx context.Context) HelmReleaseStatusInventoryEntriesPatchArrayOutput { + return o +} + +func (o HelmReleaseStatusInventoryEntriesPatchArrayOutput) Index(i pulumi.IntInput) HelmReleaseStatusInventoryEntriesPatchOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) HelmReleaseStatusInventoryEntriesPatch { + return vs[0].([]HelmReleaseStatusInventoryEntriesPatch)[vs[1].(int)] + }).(HelmReleaseStatusInventoryEntriesPatchOutput) +} + +// Inventory contains the list of Kubernetes resource object references +// that have been applied for this release. +type HelmReleaseStatusInventoryPatch struct { + // Entries of Kubernetes resource object references. + Entries []HelmReleaseStatusInventoryEntriesPatch `pulumi:"entries"` +} + +// HelmReleaseStatusInventoryPatchInput is an input type that accepts HelmReleaseStatusInventoryPatchArgs and HelmReleaseStatusInventoryPatchOutput values. +// You can construct a concrete instance of `HelmReleaseStatusInventoryPatchInput` via: +// +// HelmReleaseStatusInventoryPatchArgs{...} +type HelmReleaseStatusInventoryPatchInput interface { + pulumi.Input + + ToHelmReleaseStatusInventoryPatchOutput() HelmReleaseStatusInventoryPatchOutput + ToHelmReleaseStatusInventoryPatchOutputWithContext(context.Context) HelmReleaseStatusInventoryPatchOutput +} + +// Inventory contains the list of Kubernetes resource object references +// that have been applied for this release. +type HelmReleaseStatusInventoryPatchArgs struct { + // Entries of Kubernetes resource object references. + Entries HelmReleaseStatusInventoryEntriesPatchArrayInput `pulumi:"entries"` +} + +func (HelmReleaseStatusInventoryPatchArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseStatusInventoryPatch)(nil)).Elem() +} + +func (i HelmReleaseStatusInventoryPatchArgs) ToHelmReleaseStatusInventoryPatchOutput() HelmReleaseStatusInventoryPatchOutput { + return i.ToHelmReleaseStatusInventoryPatchOutputWithContext(context.Background()) +} + +func (i HelmReleaseStatusInventoryPatchArgs) ToHelmReleaseStatusInventoryPatchOutputWithContext(ctx context.Context) HelmReleaseStatusInventoryPatchOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseStatusInventoryPatchOutput) +} + +func (i HelmReleaseStatusInventoryPatchArgs) ToHelmReleaseStatusInventoryPatchPtrOutput() HelmReleaseStatusInventoryPatchPtrOutput { + return i.ToHelmReleaseStatusInventoryPatchPtrOutputWithContext(context.Background()) +} + +func (i HelmReleaseStatusInventoryPatchArgs) ToHelmReleaseStatusInventoryPatchPtrOutputWithContext(ctx context.Context) HelmReleaseStatusInventoryPatchPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseStatusInventoryPatchOutput).ToHelmReleaseStatusInventoryPatchPtrOutputWithContext(ctx) +} + +// HelmReleaseStatusInventoryPatchPtrInput is an input type that accepts HelmReleaseStatusInventoryPatchArgs, HelmReleaseStatusInventoryPatchPtr and HelmReleaseStatusInventoryPatchPtrOutput values. +// You can construct a concrete instance of `HelmReleaseStatusInventoryPatchPtrInput` via: +// +// HelmReleaseStatusInventoryPatchArgs{...} +// +// or: +// +// nil +type HelmReleaseStatusInventoryPatchPtrInput interface { + pulumi.Input + + ToHelmReleaseStatusInventoryPatchPtrOutput() HelmReleaseStatusInventoryPatchPtrOutput + ToHelmReleaseStatusInventoryPatchPtrOutputWithContext(context.Context) HelmReleaseStatusInventoryPatchPtrOutput +} + +type helmReleaseStatusInventoryPatchPtrType HelmReleaseStatusInventoryPatchArgs + +func HelmReleaseStatusInventoryPatchPtr(v *HelmReleaseStatusInventoryPatchArgs) HelmReleaseStatusInventoryPatchPtrInput { + return (*helmReleaseStatusInventoryPatchPtrType)(v) +} + +func (*helmReleaseStatusInventoryPatchPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseStatusInventoryPatch)(nil)).Elem() +} + +func (i *helmReleaseStatusInventoryPatchPtrType) ToHelmReleaseStatusInventoryPatchPtrOutput() HelmReleaseStatusInventoryPatchPtrOutput { + return i.ToHelmReleaseStatusInventoryPatchPtrOutputWithContext(context.Background()) +} + +func (i *helmReleaseStatusInventoryPatchPtrType) ToHelmReleaseStatusInventoryPatchPtrOutputWithContext(ctx context.Context) HelmReleaseStatusInventoryPatchPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseStatusInventoryPatchPtrOutput) +} + +// Inventory contains the list of Kubernetes resource object references +// that have been applied for this release. +type HelmReleaseStatusInventoryPatchOutput struct{ *pulumi.OutputState } + +func (HelmReleaseStatusInventoryPatchOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseStatusInventoryPatch)(nil)).Elem() +} + +func (o HelmReleaseStatusInventoryPatchOutput) ToHelmReleaseStatusInventoryPatchOutput() HelmReleaseStatusInventoryPatchOutput { + return o +} + +func (o HelmReleaseStatusInventoryPatchOutput) ToHelmReleaseStatusInventoryPatchOutputWithContext(ctx context.Context) HelmReleaseStatusInventoryPatchOutput { + return o +} + +func (o HelmReleaseStatusInventoryPatchOutput) ToHelmReleaseStatusInventoryPatchPtrOutput() HelmReleaseStatusInventoryPatchPtrOutput { + return o.ToHelmReleaseStatusInventoryPatchPtrOutputWithContext(context.Background()) +} + +func (o HelmReleaseStatusInventoryPatchOutput) ToHelmReleaseStatusInventoryPatchPtrOutputWithContext(ctx context.Context) HelmReleaseStatusInventoryPatchPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v HelmReleaseStatusInventoryPatch) *HelmReleaseStatusInventoryPatch { + return &v + }).(HelmReleaseStatusInventoryPatchPtrOutput) +} + +// Entries of Kubernetes resource object references. +func (o HelmReleaseStatusInventoryPatchOutput) Entries() HelmReleaseStatusInventoryEntriesPatchArrayOutput { + return o.ApplyT(func(v HelmReleaseStatusInventoryPatch) []HelmReleaseStatusInventoryEntriesPatch { return v.Entries }).(HelmReleaseStatusInventoryEntriesPatchArrayOutput) +} + +type HelmReleaseStatusInventoryPatchPtrOutput struct{ *pulumi.OutputState } + +func (HelmReleaseStatusInventoryPatchPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseStatusInventoryPatch)(nil)).Elem() +} + +func (o HelmReleaseStatusInventoryPatchPtrOutput) ToHelmReleaseStatusInventoryPatchPtrOutput() HelmReleaseStatusInventoryPatchPtrOutput { + return o +} + +func (o HelmReleaseStatusInventoryPatchPtrOutput) ToHelmReleaseStatusInventoryPatchPtrOutputWithContext(ctx context.Context) HelmReleaseStatusInventoryPatchPtrOutput { + return o +} + +func (o HelmReleaseStatusInventoryPatchPtrOutput) Elem() HelmReleaseStatusInventoryPatchOutput { + return o.ApplyT(func(v *HelmReleaseStatusInventoryPatch) HelmReleaseStatusInventoryPatch { + if v != nil { + return *v + } + var ret HelmReleaseStatusInventoryPatch + return ret + }).(HelmReleaseStatusInventoryPatchOutput) +} + +// Entries of Kubernetes resource object references. +func (o HelmReleaseStatusInventoryPatchPtrOutput) Entries() HelmReleaseStatusInventoryEntriesPatchArrayOutput { + return o.ApplyT(func(v *HelmReleaseStatusInventoryPatch) []HelmReleaseStatusInventoryEntriesPatch { + if v == nil { + return nil + } + return v.Entries + }).(HelmReleaseStatusInventoryEntriesPatchArrayOutput) +} + +// HelmReleaseStatus defines the observed state of a HelmRelease. +type HelmReleaseStatusPatch struct { + // Conditions holds the conditions for the HelmRelease. + Conditions []HelmReleaseStatusConditionsPatch `pulumi:"conditions"` + // Failures is the reconciliation failure count against the latest desired + // state. It is reset after a successful reconciliation. + Failures *int `pulumi:"failures"` + // HelmChart is the namespaced name of the HelmChart resource created by + // the controller for the HelmRelease. + HelmChart *string `pulumi:"helmChart"` + // History holds the history of Helm releases performed for this HelmRelease + // up to the last successfully completed release. + History []HelmReleaseStatusHistoryPatch `pulumi:"history"` + // InstallFailures is the install failure count against the latest desired + // state. It is reset after a successful reconciliation. + InstallFailures *int `pulumi:"installFailures"` + Inventory *HelmReleaseStatusInventoryPatch `pulumi:"inventory"` + // LastAttemptedConfigDigest is the digest for the config (better known as + // "values") of the last reconciliation attempt. + LastAttemptedConfigDigest *string `pulumi:"lastAttemptedConfigDigest"` + // LastAttemptedGeneration is the last generation the controller attempted + // to reconcile. + LastAttemptedGeneration *int `pulumi:"lastAttemptedGeneration"` + // LastAttemptedReleaseAction is the last release action performed for this + // HelmRelease. It is used to determine the active retry or remediation + // strategy. + LastAttemptedReleaseAction *string `pulumi:"lastAttemptedReleaseAction"` + // LastAttemptedReleaseActionDuration is the duration of the last + // release action performed for this HelmRelease. + LastAttemptedReleaseActionDuration *string `pulumi:"lastAttemptedReleaseActionDuration"` + // LastAttemptedRevision is the Source revision of the last reconciliation + // attempt. For OCIRepository sources, the 12 first characters of the digest are + // appended to the chart version e.g. "1.2.3+1234567890ab". + LastAttemptedRevision *string `pulumi:"lastAttemptedRevision"` + // LastAttemptedRevisionDigest is the digest of the last reconciliation attempt. + // This is only set for OCIRepository sources. + LastAttemptedRevisionDigest *string `pulumi:"lastAttemptedRevisionDigest"` + // LastAttemptedValuesChecksum is the SHA1 checksum for the values of the last + // reconciliation attempt. + // + // Deprecated: Use LastAttemptedConfigDigest instead. + LastAttemptedValuesChecksum *string `pulumi:"lastAttemptedValuesChecksum"` + // LastHandledForceAt holds the value of the most recent + // force request value, so a change of the annotation value + // can be detected. + LastHandledForceAt *string `pulumi:"lastHandledForceAt"` + // LastHandledReconcileAt holds the value of the most recent + // reconcile request value, so a change of the annotation value + // can be detected. + LastHandledReconcileAt *string `pulumi:"lastHandledReconcileAt"` + // LastHandledResetAt holds the value of the most recent reset request + // value, so a change of the annotation value can be detected. + LastHandledResetAt *string `pulumi:"lastHandledResetAt"` + // LastReleaseRevision is the revision of the last successful Helm release. + // + // Deprecated: Use History instead. + LastReleaseRevision *int `pulumi:"lastReleaseRevision"` + // ObservedCommonMetadataDigest is the digest for the common metadata of + // the last successful reconciliation attempt. + ObservedCommonMetadataDigest *string `pulumi:"observedCommonMetadataDigest"` + // ObservedGeneration is the last observed generation. + ObservedGeneration *int `pulumi:"observedGeneration"` + // ObservedPostRenderersDigest is the digest for the post-renderers of + // the last successful reconciliation attempt. + ObservedPostRenderersDigest *string `pulumi:"observedPostRenderersDigest"` + // StorageNamespace is the namespace of the Helm release storage for the + // current release. + StorageNamespace *string `pulumi:"storageNamespace"` + // UpgradeFailures is the upgrade failure count against the latest desired + // state. It is reset after a successful reconciliation. + UpgradeFailures *int `pulumi:"upgradeFailures"` +} + +// HelmReleaseStatusPatchInput is an input type that accepts HelmReleaseStatusPatchArgs and HelmReleaseStatusPatchOutput values. +// You can construct a concrete instance of `HelmReleaseStatusPatchInput` via: +// +// HelmReleaseStatusPatchArgs{...} +type HelmReleaseStatusPatchInput interface { + pulumi.Input + + ToHelmReleaseStatusPatchOutput() HelmReleaseStatusPatchOutput + ToHelmReleaseStatusPatchOutputWithContext(context.Context) HelmReleaseStatusPatchOutput +} + +// HelmReleaseStatus defines the observed state of a HelmRelease. +type HelmReleaseStatusPatchArgs struct { + // Conditions holds the conditions for the HelmRelease. + Conditions HelmReleaseStatusConditionsPatchArrayInput `pulumi:"conditions"` + // Failures is the reconciliation failure count against the latest desired + // state. It is reset after a successful reconciliation. + Failures pulumi.IntPtrInput `pulumi:"failures"` + // HelmChart is the namespaced name of the HelmChart resource created by + // the controller for the HelmRelease. + HelmChart pulumi.StringPtrInput `pulumi:"helmChart"` + // History holds the history of Helm releases performed for this HelmRelease + // up to the last successfully completed release. + History HelmReleaseStatusHistoryPatchArrayInput `pulumi:"history"` + // InstallFailures is the install failure count against the latest desired + // state. It is reset after a successful reconciliation. + InstallFailures pulumi.IntPtrInput `pulumi:"installFailures"` + Inventory HelmReleaseStatusInventoryPatchPtrInput `pulumi:"inventory"` + // LastAttemptedConfigDigest is the digest for the config (better known as + // "values") of the last reconciliation attempt. + LastAttemptedConfigDigest pulumi.StringPtrInput `pulumi:"lastAttemptedConfigDigest"` + // LastAttemptedGeneration is the last generation the controller attempted + // to reconcile. + LastAttemptedGeneration pulumi.IntPtrInput `pulumi:"lastAttemptedGeneration"` + // LastAttemptedReleaseAction is the last release action performed for this + // HelmRelease. It is used to determine the active retry or remediation + // strategy. + LastAttemptedReleaseAction pulumi.StringPtrInput `pulumi:"lastAttemptedReleaseAction"` + // LastAttemptedReleaseActionDuration is the duration of the last + // release action performed for this HelmRelease. + LastAttemptedReleaseActionDuration pulumi.StringPtrInput `pulumi:"lastAttemptedReleaseActionDuration"` + // LastAttemptedRevision is the Source revision of the last reconciliation + // attempt. For OCIRepository sources, the 12 first characters of the digest are + // appended to the chart version e.g. "1.2.3+1234567890ab". + LastAttemptedRevision pulumi.StringPtrInput `pulumi:"lastAttemptedRevision"` + // LastAttemptedRevisionDigest is the digest of the last reconciliation attempt. + // This is only set for OCIRepository sources. + LastAttemptedRevisionDigest pulumi.StringPtrInput `pulumi:"lastAttemptedRevisionDigest"` + // LastAttemptedValuesChecksum is the SHA1 checksum for the values of the last + // reconciliation attempt. + // + // Deprecated: Use LastAttemptedConfigDigest instead. + LastAttemptedValuesChecksum pulumi.StringPtrInput `pulumi:"lastAttemptedValuesChecksum"` + // LastHandledForceAt holds the value of the most recent + // force request value, so a change of the annotation value + // can be detected. + LastHandledForceAt pulumi.StringPtrInput `pulumi:"lastHandledForceAt"` + // LastHandledReconcileAt holds the value of the most recent + // reconcile request value, so a change of the annotation value + // can be detected. + LastHandledReconcileAt pulumi.StringPtrInput `pulumi:"lastHandledReconcileAt"` + // LastHandledResetAt holds the value of the most recent reset request + // value, so a change of the annotation value can be detected. + LastHandledResetAt pulumi.StringPtrInput `pulumi:"lastHandledResetAt"` + // LastReleaseRevision is the revision of the last successful Helm release. + // + // Deprecated: Use History instead. + LastReleaseRevision pulumi.IntPtrInput `pulumi:"lastReleaseRevision"` + // ObservedCommonMetadataDigest is the digest for the common metadata of + // the last successful reconciliation attempt. + ObservedCommonMetadataDigest pulumi.StringPtrInput `pulumi:"observedCommonMetadataDigest"` + // ObservedGeneration is the last observed generation. + ObservedGeneration pulumi.IntPtrInput `pulumi:"observedGeneration"` + // ObservedPostRenderersDigest is the digest for the post-renderers of + // the last successful reconciliation attempt. + ObservedPostRenderersDigest pulumi.StringPtrInput `pulumi:"observedPostRenderersDigest"` + // StorageNamespace is the namespace of the Helm release storage for the + // current release. + StorageNamespace pulumi.StringPtrInput `pulumi:"storageNamespace"` + // UpgradeFailures is the upgrade failure count against the latest desired + // state. It is reset after a successful reconciliation. + UpgradeFailures pulumi.IntPtrInput `pulumi:"upgradeFailures"` +} + +func (HelmReleaseStatusPatchArgs) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseStatusPatch)(nil)).Elem() +} + +func (i HelmReleaseStatusPatchArgs) ToHelmReleaseStatusPatchOutput() HelmReleaseStatusPatchOutput { + return i.ToHelmReleaseStatusPatchOutputWithContext(context.Background()) +} + +func (i HelmReleaseStatusPatchArgs) ToHelmReleaseStatusPatchOutputWithContext(ctx context.Context) HelmReleaseStatusPatchOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseStatusPatchOutput) +} + +func (i HelmReleaseStatusPatchArgs) ToHelmReleaseStatusPatchPtrOutput() HelmReleaseStatusPatchPtrOutput { + return i.ToHelmReleaseStatusPatchPtrOutputWithContext(context.Background()) +} + +func (i HelmReleaseStatusPatchArgs) ToHelmReleaseStatusPatchPtrOutputWithContext(ctx context.Context) HelmReleaseStatusPatchPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseStatusPatchOutput).ToHelmReleaseStatusPatchPtrOutputWithContext(ctx) +} + +// HelmReleaseStatusPatchPtrInput is an input type that accepts HelmReleaseStatusPatchArgs, HelmReleaseStatusPatchPtr and HelmReleaseStatusPatchPtrOutput values. +// You can construct a concrete instance of `HelmReleaseStatusPatchPtrInput` via: +// +// HelmReleaseStatusPatchArgs{...} +// +// or: +// +// nil +type HelmReleaseStatusPatchPtrInput interface { + pulumi.Input + + ToHelmReleaseStatusPatchPtrOutput() HelmReleaseStatusPatchPtrOutput + ToHelmReleaseStatusPatchPtrOutputWithContext(context.Context) HelmReleaseStatusPatchPtrOutput +} + +type helmReleaseStatusPatchPtrType HelmReleaseStatusPatchArgs + +func HelmReleaseStatusPatchPtr(v *HelmReleaseStatusPatchArgs) HelmReleaseStatusPatchPtrInput { + return (*helmReleaseStatusPatchPtrType)(v) +} + +func (*helmReleaseStatusPatchPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseStatusPatch)(nil)).Elem() +} + +func (i *helmReleaseStatusPatchPtrType) ToHelmReleaseStatusPatchPtrOutput() HelmReleaseStatusPatchPtrOutput { + return i.ToHelmReleaseStatusPatchPtrOutputWithContext(context.Background()) +} + +func (i *helmReleaseStatusPatchPtrType) ToHelmReleaseStatusPatchPtrOutputWithContext(ctx context.Context) HelmReleaseStatusPatchPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(HelmReleaseStatusPatchPtrOutput) +} + +// HelmReleaseStatus defines the observed state of a HelmRelease. +type HelmReleaseStatusPatchOutput struct{ *pulumi.OutputState } + +func (HelmReleaseStatusPatchOutput) ElementType() reflect.Type { + return reflect.TypeOf((*HelmReleaseStatusPatch)(nil)).Elem() +} + +func (o HelmReleaseStatusPatchOutput) ToHelmReleaseStatusPatchOutput() HelmReleaseStatusPatchOutput { + return o +} + +func (o HelmReleaseStatusPatchOutput) ToHelmReleaseStatusPatchOutputWithContext(ctx context.Context) HelmReleaseStatusPatchOutput { + return o +} + +func (o HelmReleaseStatusPatchOutput) ToHelmReleaseStatusPatchPtrOutput() HelmReleaseStatusPatchPtrOutput { + return o.ToHelmReleaseStatusPatchPtrOutputWithContext(context.Background()) +} + +func (o HelmReleaseStatusPatchOutput) ToHelmReleaseStatusPatchPtrOutputWithContext(ctx context.Context) HelmReleaseStatusPatchPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v HelmReleaseStatusPatch) *HelmReleaseStatusPatch { + return &v + }).(HelmReleaseStatusPatchPtrOutput) +} + +// Conditions holds the conditions for the HelmRelease. +func (o HelmReleaseStatusPatchOutput) Conditions() HelmReleaseStatusConditionsPatchArrayOutput { + return o.ApplyT(func(v HelmReleaseStatusPatch) []HelmReleaseStatusConditionsPatch { return v.Conditions }).(HelmReleaseStatusConditionsPatchArrayOutput) +} + +// Failures is the reconciliation failure count against the latest desired +// state. It is reset after a successful reconciliation. +func (o HelmReleaseStatusPatchOutput) Failures() pulumi.IntPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusPatch) *int { return v.Failures }).(pulumi.IntPtrOutput) +} + +// HelmChart is the namespaced name of the HelmChart resource created by +// the controller for the HelmRelease. +func (o HelmReleaseStatusPatchOutput) HelmChart() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusPatch) *string { return v.HelmChart }).(pulumi.StringPtrOutput) +} + +// History holds the history of Helm releases performed for this HelmRelease +// up to the last successfully completed release. +func (o HelmReleaseStatusPatchOutput) History() HelmReleaseStatusHistoryPatchArrayOutput { + return o.ApplyT(func(v HelmReleaseStatusPatch) []HelmReleaseStatusHistoryPatch { return v.History }).(HelmReleaseStatusHistoryPatchArrayOutput) +} + +// InstallFailures is the install failure count against the latest desired +// state. It is reset after a successful reconciliation. +func (o HelmReleaseStatusPatchOutput) InstallFailures() pulumi.IntPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusPatch) *int { return v.InstallFailures }).(pulumi.IntPtrOutput) +} + +func (o HelmReleaseStatusPatchOutput) Inventory() HelmReleaseStatusInventoryPatchPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusPatch) *HelmReleaseStatusInventoryPatch { return v.Inventory }).(HelmReleaseStatusInventoryPatchPtrOutput) +} + +// LastAttemptedConfigDigest is the digest for the config (better known as +// "values") of the last reconciliation attempt. +func (o HelmReleaseStatusPatchOutput) LastAttemptedConfigDigest() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusPatch) *string { return v.LastAttemptedConfigDigest }).(pulumi.StringPtrOutput) +} + +// LastAttemptedGeneration is the last generation the controller attempted +// to reconcile. +func (o HelmReleaseStatusPatchOutput) LastAttemptedGeneration() pulumi.IntPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusPatch) *int { return v.LastAttemptedGeneration }).(pulumi.IntPtrOutput) +} + +// LastAttemptedReleaseAction is the last release action performed for this +// HelmRelease. It is used to determine the active retry or remediation +// strategy. +func (o HelmReleaseStatusPatchOutput) LastAttemptedReleaseAction() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusPatch) *string { return v.LastAttemptedReleaseAction }).(pulumi.StringPtrOutput) +} + +// LastAttemptedReleaseActionDuration is the duration of the last +// release action performed for this HelmRelease. +func (o HelmReleaseStatusPatchOutput) LastAttemptedReleaseActionDuration() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusPatch) *string { return v.LastAttemptedReleaseActionDuration }).(pulumi.StringPtrOutput) +} + +// LastAttemptedRevision is the Source revision of the last reconciliation +// attempt. For OCIRepository sources, the 12 first characters of the digest are +// appended to the chart version e.g. "1.2.3+1234567890ab". +func (o HelmReleaseStatusPatchOutput) LastAttemptedRevision() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusPatch) *string { return v.LastAttemptedRevision }).(pulumi.StringPtrOutput) +} + +// LastAttemptedRevisionDigest is the digest of the last reconciliation attempt. +// This is only set for OCIRepository sources. +func (o HelmReleaseStatusPatchOutput) LastAttemptedRevisionDigest() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusPatch) *string { return v.LastAttemptedRevisionDigest }).(pulumi.StringPtrOutput) +} + +// LastAttemptedValuesChecksum is the SHA1 checksum for the values of the last +// reconciliation attempt. +// +// Deprecated: Use LastAttemptedConfigDigest instead. +func (o HelmReleaseStatusPatchOutput) LastAttemptedValuesChecksum() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusPatch) *string { return v.LastAttemptedValuesChecksum }).(pulumi.StringPtrOutput) +} + +// LastHandledForceAt holds the value of the most recent +// force request value, so a change of the annotation value +// can be detected. +func (o HelmReleaseStatusPatchOutput) LastHandledForceAt() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusPatch) *string { return v.LastHandledForceAt }).(pulumi.StringPtrOutput) +} + +// LastHandledReconcileAt holds the value of the most recent +// reconcile request value, so a change of the annotation value +// can be detected. +func (o HelmReleaseStatusPatchOutput) LastHandledReconcileAt() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusPatch) *string { return v.LastHandledReconcileAt }).(pulumi.StringPtrOutput) +} + +// LastHandledResetAt holds the value of the most recent reset request +// value, so a change of the annotation value can be detected. +func (o HelmReleaseStatusPatchOutput) LastHandledResetAt() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusPatch) *string { return v.LastHandledResetAt }).(pulumi.StringPtrOutput) +} + +// LastReleaseRevision is the revision of the last successful Helm release. +// +// Deprecated: Use History instead. +func (o HelmReleaseStatusPatchOutput) LastReleaseRevision() pulumi.IntPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusPatch) *int { return v.LastReleaseRevision }).(pulumi.IntPtrOutput) +} + +// ObservedCommonMetadataDigest is the digest for the common metadata of +// the last successful reconciliation attempt. +func (o HelmReleaseStatusPatchOutput) ObservedCommonMetadataDigest() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusPatch) *string { return v.ObservedCommonMetadataDigest }).(pulumi.StringPtrOutput) +} + +// ObservedGeneration is the last observed generation. +func (o HelmReleaseStatusPatchOutput) ObservedGeneration() pulumi.IntPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusPatch) *int { return v.ObservedGeneration }).(pulumi.IntPtrOutput) +} + +// ObservedPostRenderersDigest is the digest for the post-renderers of +// the last successful reconciliation attempt. +func (o HelmReleaseStatusPatchOutput) ObservedPostRenderersDigest() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusPatch) *string { return v.ObservedPostRenderersDigest }).(pulumi.StringPtrOutput) +} + +// StorageNamespace is the namespace of the Helm release storage for the +// current release. +func (o HelmReleaseStatusPatchOutput) StorageNamespace() pulumi.StringPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusPatch) *string { return v.StorageNamespace }).(pulumi.StringPtrOutput) +} + +// UpgradeFailures is the upgrade failure count against the latest desired +// state. It is reset after a successful reconciliation. +func (o HelmReleaseStatusPatchOutput) UpgradeFailures() pulumi.IntPtrOutput { + return o.ApplyT(func(v HelmReleaseStatusPatch) *int { return v.UpgradeFailures }).(pulumi.IntPtrOutput) +} + +type HelmReleaseStatusPatchPtrOutput struct{ *pulumi.OutputState } + +func (HelmReleaseStatusPatchPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**HelmReleaseStatusPatch)(nil)).Elem() +} + +func (o HelmReleaseStatusPatchPtrOutput) ToHelmReleaseStatusPatchPtrOutput() HelmReleaseStatusPatchPtrOutput { + return o +} + +func (o HelmReleaseStatusPatchPtrOutput) ToHelmReleaseStatusPatchPtrOutputWithContext(ctx context.Context) HelmReleaseStatusPatchPtrOutput { + return o +} + +func (o HelmReleaseStatusPatchPtrOutput) Elem() HelmReleaseStatusPatchOutput { + return o.ApplyT(func(v *HelmReleaseStatusPatch) HelmReleaseStatusPatch { + if v != nil { + return *v + } + var ret HelmReleaseStatusPatch + return ret + }).(HelmReleaseStatusPatchOutput) +} + +// Conditions holds the conditions for the HelmRelease. +func (o HelmReleaseStatusPatchPtrOutput) Conditions() HelmReleaseStatusConditionsPatchArrayOutput { + return o.ApplyT(func(v *HelmReleaseStatusPatch) []HelmReleaseStatusConditionsPatch { + if v == nil { + return nil + } + return v.Conditions + }).(HelmReleaseStatusConditionsPatchArrayOutput) +} + +// Failures is the reconciliation failure count against the latest desired +// state. It is reset after a successful reconciliation. +func (o HelmReleaseStatusPatchPtrOutput) Failures() pulumi.IntPtrOutput { + return o.ApplyT(func(v *HelmReleaseStatusPatch) *int { + if v == nil { + return nil + } + return v.Failures + }).(pulumi.IntPtrOutput) +} + +// HelmChart is the namespaced name of the HelmChart resource created by +// the controller for the HelmRelease. +func (o HelmReleaseStatusPatchPtrOutput) HelmChart() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseStatusPatch) *string { + if v == nil { + return nil + } + return v.HelmChart + }).(pulumi.StringPtrOutput) +} + +// History holds the history of Helm releases performed for this HelmRelease +// up to the last successfully completed release. +func (o HelmReleaseStatusPatchPtrOutput) History() HelmReleaseStatusHistoryPatchArrayOutput { + return o.ApplyT(func(v *HelmReleaseStatusPatch) []HelmReleaseStatusHistoryPatch { + if v == nil { + return nil + } + return v.History + }).(HelmReleaseStatusHistoryPatchArrayOutput) +} + +// InstallFailures is the install failure count against the latest desired +// state. It is reset after a successful reconciliation. +func (o HelmReleaseStatusPatchPtrOutput) InstallFailures() pulumi.IntPtrOutput { + return o.ApplyT(func(v *HelmReleaseStatusPatch) *int { + if v == nil { + return nil + } + return v.InstallFailures + }).(pulumi.IntPtrOutput) +} + +func (o HelmReleaseStatusPatchPtrOutput) Inventory() HelmReleaseStatusInventoryPatchPtrOutput { + return o.ApplyT(func(v *HelmReleaseStatusPatch) *HelmReleaseStatusInventoryPatch { + if v == nil { + return nil + } + return v.Inventory + }).(HelmReleaseStatusInventoryPatchPtrOutput) +} + +// LastAttemptedConfigDigest is the digest for the config (better known as +// "values") of the last reconciliation attempt. +func (o HelmReleaseStatusPatchPtrOutput) LastAttemptedConfigDigest() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseStatusPatch) *string { + if v == nil { + return nil + } + return v.LastAttemptedConfigDigest + }).(pulumi.StringPtrOutput) +} + +// LastAttemptedGeneration is the last generation the controller attempted +// to reconcile. +func (o HelmReleaseStatusPatchPtrOutput) LastAttemptedGeneration() pulumi.IntPtrOutput { + return o.ApplyT(func(v *HelmReleaseStatusPatch) *int { + if v == nil { + return nil + } + return v.LastAttemptedGeneration + }).(pulumi.IntPtrOutput) +} + +// LastAttemptedReleaseAction is the last release action performed for this +// HelmRelease. It is used to determine the active retry or remediation +// strategy. +func (o HelmReleaseStatusPatchPtrOutput) LastAttemptedReleaseAction() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseStatusPatch) *string { + if v == nil { + return nil + } + return v.LastAttemptedReleaseAction + }).(pulumi.StringPtrOutput) +} + +// LastAttemptedReleaseActionDuration is the duration of the last +// release action performed for this HelmRelease. +func (o HelmReleaseStatusPatchPtrOutput) LastAttemptedReleaseActionDuration() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseStatusPatch) *string { + if v == nil { + return nil + } + return v.LastAttemptedReleaseActionDuration + }).(pulumi.StringPtrOutput) +} + +// LastAttemptedRevision is the Source revision of the last reconciliation +// attempt. For OCIRepository sources, the 12 first characters of the digest are +// appended to the chart version e.g. "1.2.3+1234567890ab". +func (o HelmReleaseStatusPatchPtrOutput) LastAttemptedRevision() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseStatusPatch) *string { + if v == nil { + return nil + } + return v.LastAttemptedRevision + }).(pulumi.StringPtrOutput) +} + +// LastAttemptedRevisionDigest is the digest of the last reconciliation attempt. +// This is only set for OCIRepository sources. +func (o HelmReleaseStatusPatchPtrOutput) LastAttemptedRevisionDigest() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseStatusPatch) *string { + if v == nil { + return nil + } + return v.LastAttemptedRevisionDigest + }).(pulumi.StringPtrOutput) +} + +// LastAttemptedValuesChecksum is the SHA1 checksum for the values of the last +// reconciliation attempt. +// +// Deprecated: Use LastAttemptedConfigDigest instead. +func (o HelmReleaseStatusPatchPtrOutput) LastAttemptedValuesChecksum() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseStatusPatch) *string { + if v == nil { + return nil + } + return v.LastAttemptedValuesChecksum + }).(pulumi.StringPtrOutput) +} + +// LastHandledForceAt holds the value of the most recent +// force request value, so a change of the annotation value +// can be detected. +func (o HelmReleaseStatusPatchPtrOutput) LastHandledForceAt() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseStatusPatch) *string { + if v == nil { + return nil + } + return v.LastHandledForceAt + }).(pulumi.StringPtrOutput) +} + +// LastHandledReconcileAt holds the value of the most recent +// reconcile request value, so a change of the annotation value +// can be detected. +func (o HelmReleaseStatusPatchPtrOutput) LastHandledReconcileAt() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseStatusPatch) *string { + if v == nil { + return nil + } + return v.LastHandledReconcileAt + }).(pulumi.StringPtrOutput) +} + +// LastHandledResetAt holds the value of the most recent reset request +// value, so a change of the annotation value can be detected. +func (o HelmReleaseStatusPatchPtrOutput) LastHandledResetAt() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseStatusPatch) *string { + if v == nil { + return nil + } + return v.LastHandledResetAt + }).(pulumi.StringPtrOutput) +} + +// LastReleaseRevision is the revision of the last successful Helm release. +// +// Deprecated: Use History instead. +func (o HelmReleaseStatusPatchPtrOutput) LastReleaseRevision() pulumi.IntPtrOutput { + return o.ApplyT(func(v *HelmReleaseStatusPatch) *int { + if v == nil { + return nil + } + return v.LastReleaseRevision + }).(pulumi.IntPtrOutput) +} + +// ObservedCommonMetadataDigest is the digest for the common metadata of +// the last successful reconciliation attempt. +func (o HelmReleaseStatusPatchPtrOutput) ObservedCommonMetadataDigest() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseStatusPatch) *string { + if v == nil { + return nil + } + return v.ObservedCommonMetadataDigest + }).(pulumi.StringPtrOutput) +} + +// ObservedGeneration is the last observed generation. +func (o HelmReleaseStatusPatchPtrOutput) ObservedGeneration() pulumi.IntPtrOutput { + return o.ApplyT(func(v *HelmReleaseStatusPatch) *int { + if v == nil { + return nil + } + return v.ObservedGeneration + }).(pulumi.IntPtrOutput) +} + +// ObservedPostRenderersDigest is the digest for the post-renderers of +// the last successful reconciliation attempt. +func (o HelmReleaseStatusPatchPtrOutput) ObservedPostRenderersDigest() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseStatusPatch) *string { + if v == nil { + return nil + } + return v.ObservedPostRenderersDigest + }).(pulumi.StringPtrOutput) +} + +// StorageNamespace is the namespace of the Helm release storage for the +// current release. +func (o HelmReleaseStatusPatchPtrOutput) StorageNamespace() pulumi.StringPtrOutput { + return o.ApplyT(func(v *HelmReleaseStatusPatch) *string { + if v == nil { + return nil + } + return v.StorageNamespace + }).(pulumi.StringPtrOutput) +} + +// UpgradeFailures is the upgrade failure count against the latest desired +// state. It is reset after a successful reconciliation. +func (o HelmReleaseStatusPatchPtrOutput) UpgradeFailures() pulumi.IntPtrOutput { + return o.ApplyT(func(v *HelmReleaseStatusPatch) *int { + if v == nil { + return nil + } + return v.UpgradeFailures + }).(pulumi.IntPtrOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseTypeInput)(nil)).Elem(), HelmReleaseTypeArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseTypeArrayInput)(nil)).Elem(), HelmReleaseTypeArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseListTypeInput)(nil)).Elem(), HelmReleaseListTypeArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleasePatchTypeInput)(nil)).Elem(), HelmReleasePatchTypeArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecInput)(nil)).Elem(), HelmReleaseSpecArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecPtrInput)(nil)).Elem(), HelmReleaseSpecArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecChartInput)(nil)).Elem(), HelmReleaseSpecChartArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecChartPtrInput)(nil)).Elem(), HelmReleaseSpecChartArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecChartMetadataInput)(nil)).Elem(), HelmReleaseSpecChartMetadataArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecChartMetadataPtrInput)(nil)).Elem(), HelmReleaseSpecChartMetadataArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecChartMetadataPatchInput)(nil)).Elem(), HelmReleaseSpecChartMetadataPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecChartMetadataPatchPtrInput)(nil)).Elem(), HelmReleaseSpecChartMetadataPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecChartPatchInput)(nil)).Elem(), HelmReleaseSpecChartPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecChartPatchPtrInput)(nil)).Elem(), HelmReleaseSpecChartPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecChartRefInput)(nil)).Elem(), HelmReleaseSpecChartRefArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecChartRefPtrInput)(nil)).Elem(), HelmReleaseSpecChartRefArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecChartRefPatchInput)(nil)).Elem(), HelmReleaseSpecChartRefPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecChartRefPatchPtrInput)(nil)).Elem(), HelmReleaseSpecChartRefPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecChartSpecInput)(nil)).Elem(), HelmReleaseSpecChartSpecArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecChartSpecPtrInput)(nil)).Elem(), HelmReleaseSpecChartSpecArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecChartSpecPatchInput)(nil)).Elem(), HelmReleaseSpecChartSpecPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecChartSpecPatchPtrInput)(nil)).Elem(), HelmReleaseSpecChartSpecPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecChartSpecSourceRefInput)(nil)).Elem(), HelmReleaseSpecChartSpecSourceRefArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecChartSpecSourceRefPtrInput)(nil)).Elem(), HelmReleaseSpecChartSpecSourceRefArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecChartSpecSourceRefPatchInput)(nil)).Elem(), HelmReleaseSpecChartSpecSourceRefPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecChartSpecSourceRefPatchPtrInput)(nil)).Elem(), HelmReleaseSpecChartSpecSourceRefPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecChartSpecVerifyInput)(nil)).Elem(), HelmReleaseSpecChartSpecVerifyArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecChartSpecVerifyPtrInput)(nil)).Elem(), HelmReleaseSpecChartSpecVerifyArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecChartSpecVerifyPatchInput)(nil)).Elem(), HelmReleaseSpecChartSpecVerifyPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecChartSpecVerifyPatchPtrInput)(nil)).Elem(), HelmReleaseSpecChartSpecVerifyPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecChartSpecVerifySecretRefInput)(nil)).Elem(), HelmReleaseSpecChartSpecVerifySecretRefArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecChartSpecVerifySecretRefPtrInput)(nil)).Elem(), HelmReleaseSpecChartSpecVerifySecretRefArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecChartSpecVerifySecretRefPatchInput)(nil)).Elem(), HelmReleaseSpecChartSpecVerifySecretRefPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecChartSpecVerifySecretRefPatchPtrInput)(nil)).Elem(), HelmReleaseSpecChartSpecVerifySecretRefPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecCommonMetadataInput)(nil)).Elem(), HelmReleaseSpecCommonMetadataArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecCommonMetadataPtrInput)(nil)).Elem(), HelmReleaseSpecCommonMetadataArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecCommonMetadataPatchInput)(nil)).Elem(), HelmReleaseSpecCommonMetadataPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecCommonMetadataPatchPtrInput)(nil)).Elem(), HelmReleaseSpecCommonMetadataPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecDependsOnInput)(nil)).Elem(), HelmReleaseSpecDependsOnArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecDependsOnArrayInput)(nil)).Elem(), HelmReleaseSpecDependsOnArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecDependsOnPatchInput)(nil)).Elem(), HelmReleaseSpecDependsOnPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecDependsOnPatchArrayInput)(nil)).Elem(), HelmReleaseSpecDependsOnPatchArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecDriftDetectionInput)(nil)).Elem(), HelmReleaseSpecDriftDetectionArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecDriftDetectionPtrInput)(nil)).Elem(), HelmReleaseSpecDriftDetectionArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecDriftDetectionIgnoreInput)(nil)).Elem(), HelmReleaseSpecDriftDetectionIgnoreArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecDriftDetectionIgnoreArrayInput)(nil)).Elem(), HelmReleaseSpecDriftDetectionIgnoreArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecDriftDetectionIgnorePatchInput)(nil)).Elem(), HelmReleaseSpecDriftDetectionIgnorePatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecDriftDetectionIgnorePatchArrayInput)(nil)).Elem(), HelmReleaseSpecDriftDetectionIgnorePatchArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecDriftDetectionIgnoreTargetInput)(nil)).Elem(), HelmReleaseSpecDriftDetectionIgnoreTargetArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecDriftDetectionIgnoreTargetPtrInput)(nil)).Elem(), HelmReleaseSpecDriftDetectionIgnoreTargetArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecDriftDetectionIgnoreTargetPatchInput)(nil)).Elem(), HelmReleaseSpecDriftDetectionIgnoreTargetPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecDriftDetectionIgnoreTargetPatchPtrInput)(nil)).Elem(), HelmReleaseSpecDriftDetectionIgnoreTargetPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecDriftDetectionPatchInput)(nil)).Elem(), HelmReleaseSpecDriftDetectionPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecDriftDetectionPatchPtrInput)(nil)).Elem(), HelmReleaseSpecDriftDetectionPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecHealthCheckExprsInput)(nil)).Elem(), HelmReleaseSpecHealthCheckExprsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecHealthCheckExprsArrayInput)(nil)).Elem(), HelmReleaseSpecHealthCheckExprsArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecHealthCheckExprsPatchInput)(nil)).Elem(), HelmReleaseSpecHealthCheckExprsPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecHealthCheckExprsPatchArrayInput)(nil)).Elem(), HelmReleaseSpecHealthCheckExprsPatchArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecInstallInput)(nil)).Elem(), HelmReleaseSpecInstallArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecInstallPtrInput)(nil)).Elem(), HelmReleaseSpecInstallArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecInstallPatchInput)(nil)).Elem(), HelmReleaseSpecInstallPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecInstallPatchPtrInput)(nil)).Elem(), HelmReleaseSpecInstallPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecInstallRemediationInput)(nil)).Elem(), HelmReleaseSpecInstallRemediationArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecInstallRemediationPtrInput)(nil)).Elem(), HelmReleaseSpecInstallRemediationArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecInstallRemediationPatchInput)(nil)).Elem(), HelmReleaseSpecInstallRemediationPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecInstallRemediationPatchPtrInput)(nil)).Elem(), HelmReleaseSpecInstallRemediationPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecInstallStrategyInput)(nil)).Elem(), HelmReleaseSpecInstallStrategyArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecInstallStrategyPtrInput)(nil)).Elem(), HelmReleaseSpecInstallStrategyArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecInstallStrategyPatchInput)(nil)).Elem(), HelmReleaseSpecInstallStrategyPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecInstallStrategyPatchPtrInput)(nil)).Elem(), HelmReleaseSpecInstallStrategyPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecKubeConfigInput)(nil)).Elem(), HelmReleaseSpecKubeConfigArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecKubeConfigPtrInput)(nil)).Elem(), HelmReleaseSpecKubeConfigArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecKubeConfigConfigMapRefInput)(nil)).Elem(), HelmReleaseSpecKubeConfigConfigMapRefArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecKubeConfigConfigMapRefPtrInput)(nil)).Elem(), HelmReleaseSpecKubeConfigConfigMapRefArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecKubeConfigConfigMapRefPatchInput)(nil)).Elem(), HelmReleaseSpecKubeConfigConfigMapRefPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecKubeConfigConfigMapRefPatchPtrInput)(nil)).Elem(), HelmReleaseSpecKubeConfigConfigMapRefPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecKubeConfigPatchInput)(nil)).Elem(), HelmReleaseSpecKubeConfigPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecKubeConfigPatchPtrInput)(nil)).Elem(), HelmReleaseSpecKubeConfigPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecKubeConfigSecretRefInput)(nil)).Elem(), HelmReleaseSpecKubeConfigSecretRefArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecKubeConfigSecretRefPtrInput)(nil)).Elem(), HelmReleaseSpecKubeConfigSecretRefArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecKubeConfigSecretRefPatchInput)(nil)).Elem(), HelmReleaseSpecKubeConfigSecretRefPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecKubeConfigSecretRefPatchPtrInput)(nil)).Elem(), HelmReleaseSpecKubeConfigSecretRefPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecPatchInput)(nil)).Elem(), HelmReleaseSpecPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecPatchPtrInput)(nil)).Elem(), HelmReleaseSpecPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecPostRenderersInput)(nil)).Elem(), HelmReleaseSpecPostRenderersArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecPostRenderersArrayInput)(nil)).Elem(), HelmReleaseSpecPostRenderersArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecPostRenderersKustomizeInput)(nil)).Elem(), HelmReleaseSpecPostRenderersKustomizeArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecPostRenderersKustomizePtrInput)(nil)).Elem(), HelmReleaseSpecPostRenderersKustomizeArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecPostRenderersKustomizeImagesInput)(nil)).Elem(), HelmReleaseSpecPostRenderersKustomizeImagesArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecPostRenderersKustomizeImagesArrayInput)(nil)).Elem(), HelmReleaseSpecPostRenderersKustomizeImagesArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecPostRenderersKustomizeImagesPatchInput)(nil)).Elem(), HelmReleaseSpecPostRenderersKustomizeImagesPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecPostRenderersKustomizeImagesPatchArrayInput)(nil)).Elem(), HelmReleaseSpecPostRenderersKustomizeImagesPatchArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecPostRenderersKustomizePatchInput)(nil)).Elem(), HelmReleaseSpecPostRenderersKustomizePatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecPostRenderersKustomizePatchPtrInput)(nil)).Elem(), HelmReleaseSpecPostRenderersKustomizePatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecPostRenderersKustomizePatchesInput)(nil)).Elem(), HelmReleaseSpecPostRenderersKustomizePatchesArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecPostRenderersKustomizePatchesArrayInput)(nil)).Elem(), HelmReleaseSpecPostRenderersKustomizePatchesArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecPostRenderersKustomizePatchesPatchInput)(nil)).Elem(), HelmReleaseSpecPostRenderersKustomizePatchesPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecPostRenderersKustomizePatchesPatchArrayInput)(nil)).Elem(), HelmReleaseSpecPostRenderersKustomizePatchesPatchArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecPostRenderersKustomizePatchesTargetInput)(nil)).Elem(), HelmReleaseSpecPostRenderersKustomizePatchesTargetArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecPostRenderersKustomizePatchesTargetPtrInput)(nil)).Elem(), HelmReleaseSpecPostRenderersKustomizePatchesTargetArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchInput)(nil)).Elem(), HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchPtrInput)(nil)).Elem(), HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecPostRenderersPatchInput)(nil)).Elem(), HelmReleaseSpecPostRenderersPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecPostRenderersPatchArrayInput)(nil)).Elem(), HelmReleaseSpecPostRenderersPatchArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecRollbackInput)(nil)).Elem(), HelmReleaseSpecRollbackArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecRollbackPtrInput)(nil)).Elem(), HelmReleaseSpecRollbackArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecRollbackPatchInput)(nil)).Elem(), HelmReleaseSpecRollbackPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecRollbackPatchPtrInput)(nil)).Elem(), HelmReleaseSpecRollbackPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecTestInput)(nil)).Elem(), HelmReleaseSpecTestArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecTestPtrInput)(nil)).Elem(), HelmReleaseSpecTestArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecTestFiltersInput)(nil)).Elem(), HelmReleaseSpecTestFiltersArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecTestFiltersArrayInput)(nil)).Elem(), HelmReleaseSpecTestFiltersArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecTestFiltersPatchInput)(nil)).Elem(), HelmReleaseSpecTestFiltersPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecTestFiltersPatchArrayInput)(nil)).Elem(), HelmReleaseSpecTestFiltersPatchArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecTestPatchInput)(nil)).Elem(), HelmReleaseSpecTestPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecTestPatchPtrInput)(nil)).Elem(), HelmReleaseSpecTestPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecUninstallInput)(nil)).Elem(), HelmReleaseSpecUninstallArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecUninstallPtrInput)(nil)).Elem(), HelmReleaseSpecUninstallArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecUninstallPatchInput)(nil)).Elem(), HelmReleaseSpecUninstallPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecUninstallPatchPtrInput)(nil)).Elem(), HelmReleaseSpecUninstallPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecUpgradeInput)(nil)).Elem(), HelmReleaseSpecUpgradeArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecUpgradePtrInput)(nil)).Elem(), HelmReleaseSpecUpgradeArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecUpgradePatchInput)(nil)).Elem(), HelmReleaseSpecUpgradePatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecUpgradePatchPtrInput)(nil)).Elem(), HelmReleaseSpecUpgradePatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecUpgradeRemediationInput)(nil)).Elem(), HelmReleaseSpecUpgradeRemediationArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecUpgradeRemediationPtrInput)(nil)).Elem(), HelmReleaseSpecUpgradeRemediationArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecUpgradeRemediationPatchInput)(nil)).Elem(), HelmReleaseSpecUpgradeRemediationPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecUpgradeRemediationPatchPtrInput)(nil)).Elem(), HelmReleaseSpecUpgradeRemediationPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecUpgradeStrategyInput)(nil)).Elem(), HelmReleaseSpecUpgradeStrategyArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecUpgradeStrategyPtrInput)(nil)).Elem(), HelmReleaseSpecUpgradeStrategyArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecUpgradeStrategyPatchInput)(nil)).Elem(), HelmReleaseSpecUpgradeStrategyPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecUpgradeStrategyPatchPtrInput)(nil)).Elem(), HelmReleaseSpecUpgradeStrategyPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecValuesFromInput)(nil)).Elem(), HelmReleaseSpecValuesFromArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecValuesFromArrayInput)(nil)).Elem(), HelmReleaseSpecValuesFromArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecValuesFromPatchInput)(nil)).Elem(), HelmReleaseSpecValuesFromPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecValuesFromPatchArrayInput)(nil)).Elem(), HelmReleaseSpecValuesFromPatchArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecWaitStrategyInput)(nil)).Elem(), HelmReleaseSpecWaitStrategyArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecWaitStrategyPtrInput)(nil)).Elem(), HelmReleaseSpecWaitStrategyArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecWaitStrategyPatchInput)(nil)).Elem(), HelmReleaseSpecWaitStrategyPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseSpecWaitStrategyPatchPtrInput)(nil)).Elem(), HelmReleaseSpecWaitStrategyPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseStatusInput)(nil)).Elem(), HelmReleaseStatusArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseStatusPtrInput)(nil)).Elem(), HelmReleaseStatusArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseStatusConditionsInput)(nil)).Elem(), HelmReleaseStatusConditionsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseStatusConditionsArrayInput)(nil)).Elem(), HelmReleaseStatusConditionsArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseStatusConditionsPatchInput)(nil)).Elem(), HelmReleaseStatusConditionsPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseStatusConditionsPatchArrayInput)(nil)).Elem(), HelmReleaseStatusConditionsPatchArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseStatusHistoryInput)(nil)).Elem(), HelmReleaseStatusHistoryArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseStatusHistoryArrayInput)(nil)).Elem(), HelmReleaseStatusHistoryArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseStatusHistoryPatchInput)(nil)).Elem(), HelmReleaseStatusHistoryPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseStatusHistoryPatchArrayInput)(nil)).Elem(), HelmReleaseStatusHistoryPatchArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseStatusInventoryInput)(nil)).Elem(), HelmReleaseStatusInventoryArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseStatusInventoryPtrInput)(nil)).Elem(), HelmReleaseStatusInventoryArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseStatusInventoryEntriesInput)(nil)).Elem(), HelmReleaseStatusInventoryEntriesArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseStatusInventoryEntriesArrayInput)(nil)).Elem(), HelmReleaseStatusInventoryEntriesArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseStatusInventoryEntriesPatchInput)(nil)).Elem(), HelmReleaseStatusInventoryEntriesPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseStatusInventoryEntriesPatchArrayInput)(nil)).Elem(), HelmReleaseStatusInventoryEntriesPatchArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseStatusInventoryPatchInput)(nil)).Elem(), HelmReleaseStatusInventoryPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseStatusInventoryPatchPtrInput)(nil)).Elem(), HelmReleaseStatusInventoryPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseStatusPatchInput)(nil)).Elem(), HelmReleaseStatusPatchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*HelmReleaseStatusPatchPtrInput)(nil)).Elem(), HelmReleaseStatusPatchArgs{}) + pulumi.RegisterOutputType(HelmReleaseTypeOutput{}) + pulumi.RegisterOutputType(HelmReleaseTypeArrayOutput{}) + pulumi.RegisterOutputType(HelmReleaseListTypeOutput{}) + pulumi.RegisterOutputType(HelmReleasePatchTypeOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecPtrOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecChartOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecChartPtrOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecChartMetadataOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecChartMetadataPtrOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecChartMetadataPatchOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecChartMetadataPatchPtrOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecChartPatchOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecChartPatchPtrOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecChartRefOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecChartRefPtrOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecChartRefPatchOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecChartRefPatchPtrOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecChartSpecOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecChartSpecPtrOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecChartSpecPatchOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecChartSpecPatchPtrOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecChartSpecSourceRefOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecChartSpecSourceRefPtrOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecChartSpecSourceRefPatchOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecChartSpecSourceRefPatchPtrOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecChartSpecVerifyOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecChartSpecVerifyPtrOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecChartSpecVerifyPatchOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecChartSpecVerifyPatchPtrOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecChartSpecVerifySecretRefOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecChartSpecVerifySecretRefPtrOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecChartSpecVerifySecretRefPatchOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecChartSpecVerifySecretRefPatchPtrOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecCommonMetadataOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecCommonMetadataPtrOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecCommonMetadataPatchOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecCommonMetadataPatchPtrOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecDependsOnOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecDependsOnArrayOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecDependsOnPatchOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecDependsOnPatchArrayOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecDriftDetectionOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecDriftDetectionPtrOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecDriftDetectionIgnoreOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecDriftDetectionIgnoreArrayOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecDriftDetectionIgnorePatchOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecDriftDetectionIgnorePatchArrayOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecDriftDetectionIgnoreTargetOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecDriftDetectionIgnoreTargetPtrOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecDriftDetectionIgnoreTargetPatchOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecDriftDetectionIgnoreTargetPatchPtrOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecDriftDetectionPatchOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecDriftDetectionPatchPtrOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecHealthCheckExprsOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecHealthCheckExprsArrayOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecHealthCheckExprsPatchOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecHealthCheckExprsPatchArrayOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecInstallOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecInstallPtrOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecInstallPatchOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecInstallPatchPtrOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecInstallRemediationOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecInstallRemediationPtrOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecInstallRemediationPatchOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecInstallRemediationPatchPtrOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecInstallStrategyOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecInstallStrategyPtrOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecInstallStrategyPatchOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecInstallStrategyPatchPtrOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecKubeConfigOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecKubeConfigPtrOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecKubeConfigConfigMapRefOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecKubeConfigConfigMapRefPtrOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecKubeConfigConfigMapRefPatchOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecKubeConfigConfigMapRefPatchPtrOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecKubeConfigPatchOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecKubeConfigPatchPtrOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecKubeConfigSecretRefOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecKubeConfigSecretRefPtrOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecKubeConfigSecretRefPatchOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecKubeConfigSecretRefPatchPtrOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecPatchOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecPatchPtrOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecPostRenderersOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecPostRenderersArrayOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecPostRenderersKustomizeOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecPostRenderersKustomizePtrOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecPostRenderersKustomizeImagesOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecPostRenderersKustomizeImagesArrayOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecPostRenderersKustomizeImagesPatchOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecPostRenderersKustomizeImagesPatchArrayOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecPostRenderersKustomizePatchOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecPostRenderersKustomizePatchPtrOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecPostRenderersKustomizePatchesOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecPostRenderersKustomizePatchesArrayOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecPostRenderersKustomizePatchesPatchOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecPostRenderersKustomizePatchesPatchArrayOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecPostRenderersKustomizePatchesTargetOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecPostRenderersKustomizePatchesTargetPtrOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecPostRenderersKustomizePatchesTargetPatchPtrOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecPostRenderersPatchOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecPostRenderersPatchArrayOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecRollbackOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecRollbackPtrOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecRollbackPatchOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecRollbackPatchPtrOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecTestOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecTestPtrOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecTestFiltersOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecTestFiltersArrayOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecTestFiltersPatchOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecTestFiltersPatchArrayOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecTestPatchOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecTestPatchPtrOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecUninstallOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecUninstallPtrOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecUninstallPatchOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecUninstallPatchPtrOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecUpgradeOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecUpgradePtrOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecUpgradePatchOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecUpgradePatchPtrOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecUpgradeRemediationOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecUpgradeRemediationPtrOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecUpgradeRemediationPatchOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecUpgradeRemediationPatchPtrOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecUpgradeStrategyOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecUpgradeStrategyPtrOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecUpgradeStrategyPatchOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecUpgradeStrategyPatchPtrOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecValuesFromOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecValuesFromArrayOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecValuesFromPatchOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecValuesFromPatchArrayOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecWaitStrategyOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecWaitStrategyPtrOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecWaitStrategyPatchOutput{}) + pulumi.RegisterOutputType(HelmReleaseSpecWaitStrategyPatchPtrOutput{}) + pulumi.RegisterOutputType(HelmReleaseStatusOutput{}) + pulumi.RegisterOutputType(HelmReleaseStatusPtrOutput{}) + pulumi.RegisterOutputType(HelmReleaseStatusConditionsOutput{}) + pulumi.RegisterOutputType(HelmReleaseStatusConditionsArrayOutput{}) + pulumi.RegisterOutputType(HelmReleaseStatusConditionsPatchOutput{}) + pulumi.RegisterOutputType(HelmReleaseStatusConditionsPatchArrayOutput{}) + pulumi.RegisterOutputType(HelmReleaseStatusHistoryOutput{}) + pulumi.RegisterOutputType(HelmReleaseStatusHistoryArrayOutput{}) + pulumi.RegisterOutputType(HelmReleaseStatusHistoryPatchOutput{}) + pulumi.RegisterOutputType(HelmReleaseStatusHistoryPatchArrayOutput{}) + pulumi.RegisterOutputType(HelmReleaseStatusInventoryOutput{}) + pulumi.RegisterOutputType(HelmReleaseStatusInventoryPtrOutput{}) + pulumi.RegisterOutputType(HelmReleaseStatusInventoryEntriesOutput{}) + pulumi.RegisterOutputType(HelmReleaseStatusInventoryEntriesArrayOutput{}) + pulumi.RegisterOutputType(HelmReleaseStatusInventoryEntriesPatchOutput{}) + pulumi.RegisterOutputType(HelmReleaseStatusInventoryEntriesPatchArrayOutput{}) + pulumi.RegisterOutputType(HelmReleaseStatusInventoryPatchOutput{}) + pulumi.RegisterOutputType(HelmReleaseStatusInventoryPatchPtrOutput{}) + pulumi.RegisterOutputType(HelmReleaseStatusPatchOutput{}) + pulumi.RegisterOutputType(HelmReleaseStatusPatchPtrOutput{}) +} diff --git a/internal/controllers/provisioning/provisioners/pulumi/fluxcd/helm.toolkit.fluxcd.io_helmreleases_v2.yaml b/internal/controllers/provisioning/provisioners/pulumi/fluxcd/helm.toolkit.fluxcd.io_helmreleases_v2.yaml new file mode 100644 index 0000000..dad0918 --- /dev/null +++ b/internal/controllers/provisioning/provisioners/pulumi/fluxcd/helm.toolkit.fluxcd.io_helmreleases_v2.yaml @@ -0,0 +1,1447 @@ +--- +apiVersion: apiextensions.k8s.io/v1 +kind: CustomResourceDefinition +metadata: + annotations: + controller-gen.kubebuilder.io/version: v0.20.1 + name: helmreleases.helm.toolkit.fluxcd.io +spec: + group: helm.toolkit.fluxcd.io + names: + kind: HelmRelease + listKind: HelmReleaseList + plural: helmreleases + shortNames: + - hr + singular: helmrelease + scope: Namespaced + versions: + - additionalPrinterColumns: + - jsonPath: .metadata.creationTimestamp + name: Age + type: date + - jsonPath: .status.conditions[?(@.type=="Ready")].status + name: Ready + type: string + - jsonPath: .status.conditions[?(@.type=="Ready")].message + name: Status + type: string + name: v2 + schema: + openAPIV3Schema: + description: HelmRelease is the Schema for the helmreleases API + properties: + apiVersion: + description: |- + 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 + type: string + kind: + description: |- + 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 + type: string + metadata: + type: object + spec: + description: HelmReleaseSpec defines the desired state of a Helm release. + properties: + chart: + description: |- + Chart defines the template of the v1.HelmChart that should be created + for this HelmRelease. + properties: + metadata: + description: ObjectMeta holds the template for metadata like labels + and annotations. + properties: + annotations: + additionalProperties: + type: string + description: |- + Annotations is an unstructured key value map stored with a resource that may be + set by external tools to store and retrieve arbitrary metadata. They are not + queryable and should be preserved when modifying objects. + More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations/ + type: object + labels: + additionalProperties: + type: string + description: |- + Map of string keys and values that can be used to organize and categorize + (scope and select) objects. + More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/ + type: object + type: object + spec: + description: Spec holds the template for the v1.HelmChartSpec + for this HelmRelease. + properties: + chart: + description: The name or path the Helm chart is available + at in the SourceRef. + maxLength: 2048 + minLength: 1 + type: string + ignoreMissingValuesFiles: + description: IgnoreMissingValuesFiles controls whether to + silently ignore missing values files rather than failing. + type: boolean + interval: + description: |- + Interval at which to check the v1.Source for updates. Defaults to + 'HelmReleaseSpec.Interval'. + pattern: ^([0-9]+(\.[0-9]+)?(ms|s|m|h))+$ + type: string + reconcileStrategy: + default: ChartVersion + description: |- + Determines what enables the creation of a new artifact. Valid values are + ('ChartVersion', 'Revision'). + See the documentation of the values for an explanation on their behavior. + Defaults to ChartVersion when omitted. + enum: + - ChartVersion + - Revision + type: string + sourceRef: + description: The name and namespace of the v1.Source the chart + is available at. + properties: + apiVersion: + description: APIVersion of the referent. + type: string + kind: + description: Kind of the referent. + enum: + - HelmRepository + - GitRepository + - Bucket + type: string + name: + description: Name of the referent. + maxLength: 253 + minLength: 1 + type: string + namespace: + description: Namespace of the referent. + maxLength: 63 + minLength: 1 + type: string + required: + - kind + - name + type: object + valuesFiles: + description: |- + Alternative list of values files to use as the chart values (values.yaml + is not included by default), expected to be a relative path in the SourceRef. + Values files are merged in the order of this list with the last file overriding + the first. Ignored when omitted. + items: + type: string + type: array + verify: + description: |- + Verify contains the secret name containing the trusted public keys + used to verify the signature and specifies which provider to use to check + whether OCI image is authentic. + This field is only supported for OCI sources. + Chart dependencies, which are not bundled in the umbrella chart artifact, + are not verified. + properties: + provider: + default: cosign + description: Provider specifies the technology used to + sign the OCI Helm chart. + enum: + - cosign + - notation + type: string + secretRef: + description: |- + SecretRef specifies the Kubernetes Secret containing the + trusted public keys. + properties: + name: + description: Name of the referent. + type: string + required: + - name + type: object + required: + - provider + type: object + version: + default: '*' + description: |- + Version semver expression, ignored for charts from v1.GitRepository and + v1beta2.Bucket sources. Defaults to latest when omitted. + type: string + required: + - chart + - sourceRef + type: object + required: + - spec + type: object + chartRef: + description: |- + ChartRef holds a reference to a source controller resource containing the + Helm chart artifact. + properties: + apiVersion: + description: APIVersion of the referent. + type: string + kind: + description: Kind of the referent. + enum: + - OCIRepository + - HelmChart + - ExternalArtifact + type: string + name: + description: Name of the referent. + maxLength: 253 + minLength: 1 + type: string + namespace: + description: |- + Namespace of the referent, defaults to the namespace of the Kubernetes + resource object that contains the reference. + maxLength: 63 + minLength: 1 + type: string + required: + - kind + - name + type: object + commonMetadata: + description: |- + CommonMetadata specifies the common labels and annotations that are + applied to all resources. Any existing label or annotation will be + overridden if its key matches a common one. + properties: + annotations: + additionalProperties: + type: string + description: Annotations to be added to the object's metadata. + type: object + labels: + additionalProperties: + type: string + description: Labels to be added to the object's metadata. + type: object + type: object + dependsOn: + description: |- + DependsOn may contain a DependencyReference slice with + references to HelmRelease resources that must be ready before this HelmRelease + can be reconciled. + items: + description: DependencyReference defines a HelmRelease dependency + on another HelmRelease resource. + properties: + name: + description: Name of the referent. + type: string + namespace: + description: |- + Namespace of the referent, defaults to the namespace of the HelmRelease + resource object that contains the reference. + type: string + readyExpr: + description: |- + ReadyExpr is a CEL expression that can be used to assess the readiness + of a dependency. When specified, the built-in readiness check + is replaced by the logic defined in the CEL expression. + To make the CEL expression additive to the built-in readiness check, + the feature gate `AdditiveCELDependencyCheck` must be set to `true`. + type: string + required: + - name + type: object + type: array + driftDetection: + description: |- + DriftDetection holds the configuration for detecting and handling + differences between the manifest in the Helm storage and the resources + currently existing in the cluster. + properties: + ignore: + description: |- + Ignore contains a list of rules for specifying which changes to ignore + during diffing. + items: + description: |- + IgnoreRule defines a rule to selectively disregard specific changes during + the drift detection process. + properties: + paths: + description: |- + Paths is a list of JSON Pointer (RFC 6901) paths to be excluded from + consideration in a Kubernetes object. + items: + type: string + type: array + target: + description: |- + Target is a selector for specifying Kubernetes objects to which this + rule applies. + If Target is not set, the Paths will be ignored for all Kubernetes + objects within the manifest of the Helm release. + properties: + annotationSelector: + description: |- + AnnotationSelector is a string that follows the label selection expression + https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#api + It matches with the resource annotations. + type: string + group: + description: |- + Group is the API group to select resources from. + Together with Version and Kind it is capable of unambiguously identifying and/or selecting resources. + https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md + type: string + kind: + description: |- + Kind of the API Group to select resources from. + Together with Group and Version it is capable of unambiguously + identifying and/or selecting resources. + https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md + type: string + labelSelector: + description: |- + LabelSelector is a string that follows the label selection expression + https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#api + It matches with the resource labels. + type: string + name: + description: Name to match resources with. + type: string + namespace: + description: Namespace to select resources from. + type: string + version: + description: |- + Version of the API Group to select resources from. + Together with Group and Kind it is capable of unambiguously identifying and/or selecting resources. + https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md + type: string + type: object + required: + - paths + type: object + type: array + mode: + description: |- + Mode defines how differences should be handled between the Helm manifest + and the manifest currently applied to the cluster. + If not explicitly set, it defaults to DiffModeDisabled. + enum: + - enabled + - warn + - disabled + type: string + type: object + healthCheckExprs: + description: |- + HealthCheckExprs is a list of healthcheck expressions for evaluating the + health of custom resources using Common Expression Language (CEL). + The expressions are evaluated only when the specific Helm action + taking place has wait enabled, i.e. DisableWait is false, and the + 'poller' WaitStrategy is used. + items: + description: CustomHealthCheck defines the health check for custom + resources. + properties: + apiVersion: + description: APIVersion of the custom resource under evaluation. + type: string + current: + description: |- + Current is the CEL expression that determines if the status + of the custom resource has reached the desired state. + type: string + failed: + description: |- + Failed is the CEL expression that determines if the status + of the custom resource has failed to reach the desired state. + type: string + inProgress: + description: |- + InProgress is the CEL expression that determines if the status + of the custom resource has not yet reached the desired state. + type: string + kind: + description: Kind of the custom resource under evaluation. + type: string + required: + - apiVersion + - current + - kind + type: object + type: array + install: + description: Install holds the configuration for Helm install actions + for this HelmRelease. + properties: + crds: + description: |- + CRDs upgrade CRDs from the Helm Chart's crds directory according + to the CRD upgrade policy provided here. Valid values are `Skip`, + `Create` or `CreateReplace`. Default is `Create` and if omitted + CRDs are installed but not updated. + + Skip: do neither install nor replace (update) any CRDs. + + Create: new CRDs are created, existing CRDs are neither updated nor deleted. + + CreateReplace: new CRDs are created, existing CRDs are updated (replaced) + but not deleted. + + By default, CRDs are applied (installed) during Helm install action. + With this option users can opt in to CRD replace existing CRDs on Helm + install actions, which is not (yet) natively supported by Helm. + https://helm.sh/docs/chart_best_practices/custom_resource_definitions. + enum: + - Skip + - Create + - CreateReplace + type: string + createNamespace: + description: |- + CreateNamespace tells the Helm install action to create the + HelmReleaseSpec.TargetNamespace if it does not exist yet. + On uninstall, the namespace will not be garbage collected. + type: boolean + disableHooks: + description: DisableHooks prevents hooks from running during the + Helm install action. + type: boolean + disableOpenAPIValidation: + description: |- + DisableOpenAPIValidation prevents the Helm install action from validating + rendered templates against the Kubernetes OpenAPI Schema. + type: boolean + disableSchemaValidation: + description: |- + DisableSchemaValidation prevents the Helm install action from validating + the values against the JSON Schema. + type: boolean + disableTakeOwnership: + description: |- + DisableTakeOwnership disables taking ownership of existing resources + during the Helm install action. Defaults to false. + type: boolean + disableWait: + description: |- + DisableWait disables the waiting for resources to be ready after a Helm + install has been performed. + type: boolean + disableWaitForJobs: + description: |- + DisableWaitForJobs disables waiting for jobs to complete after a Helm + install has been performed. + type: boolean + remediation: + description: |- + Remediation holds the remediation configuration for when the Helm install + action for the HelmRelease fails. The default is to not perform any action. + properties: + ignoreTestFailures: + description: |- + IgnoreTestFailures tells the controller to skip remediation when the Helm + tests are run after an install action but fail. Defaults to + 'Test.IgnoreFailures'. + type: boolean + remediateLastFailure: + description: |- + RemediateLastFailure tells the controller to remediate the last failure, when + no retries remain. Defaults to 'false'. + type: boolean + retries: + description: |- + Retries is the number of retries that should be attempted on failures before + bailing. Remediation, using an uninstall, is performed between each attempt. + Defaults to '0', a negative integer equals to unlimited retries. + type: integer + type: object + replace: + description: |- + Replace tells the Helm install action to re-use the 'ReleaseName', but only + if that name is a deleted release which remains in the history. + type: boolean + serverSideApply: + description: |- + ServerSideApply enables server-side apply for resources during install. + Defaults to true (or false when UseHelm3Defaults feature gate is enabled). + type: boolean + skipCRDs: + description: |- + SkipCRDs tells the Helm install action to not install any CRDs. By default, + CRDs are installed if not already present. + + Deprecated use CRD policy (`crds`) attribute with value `Skip` instead. + type: boolean + strategy: + description: |- + Strategy defines the install strategy to use for this HelmRelease. + Defaults to 'RemediateOnFailure', or 'RetryOnFailure' when the + DefaultToRetryOnFailure feature gate is enabled. + properties: + name: + description: Name of the install strategy. + enum: + - RemediateOnFailure + - RetryOnFailure + type: string + retryInterval: + description: |- + RetryInterval is the interval at which to retry a failed install. + Can be used only when Name is set to RetryOnFailure. + Defaults to '5m'. + pattern: ^([0-9]+(\.[0-9]+)?(ms|s|m|h))+$ + type: string + required: + - name + type: object + x-kubernetes-validations: + - message: .retryInterval cannot be set when .name is 'RemediateOnFailure' + rule: '!has(self.retryInterval) || self.name != ''RemediateOnFailure''' + timeout: + description: |- + Timeout is the time to wait for any individual Kubernetes operation (like + Jobs for hooks) during the performance of a Helm install action. Defaults to + 'HelmReleaseSpec.Timeout'. + pattern: ^([0-9]+(\.[0-9]+)?(ms|s|m|h))+$ + type: string + type: object + interval: + description: Interval at which to reconcile the Helm release. + pattern: ^([0-9]+(\.[0-9]+)?(ms|s|m|h))+$ + type: string + kubeConfig: + description: |- + KubeConfig for reconciling the HelmRelease on a remote cluster. + When used in combination with HelmReleaseSpec.ServiceAccountName, + forces the controller to act on behalf of that Service Account at the + target cluster. + If the --default-service-account flag is set, its value will be used as + a controller level fallback for when HelmReleaseSpec.ServiceAccountName + is empty. + properties: + configMapRef: + description: |- + ConfigMapRef holds an optional name of a ConfigMap that contains + the following keys: + + - `provider`: the provider to use. One of `aws`, `azure`, `gcp`, or + `generic`. Required. + - `cluster`: the fully qualified resource name of the Kubernetes + cluster in the cloud provider API. Not used by the `generic` + provider. Required when one of `address` or `ca.crt` is not set. + - `address`: the address of the Kubernetes API server. Required + for `generic`. For the other providers, if not specified, the + first address in the cluster resource will be used, and if + specified, it must match one of the addresses in the cluster + resource. + If audiences is not set, will be used as the audience for the + `generic` provider. + - `ca.crt`: the optional PEM-encoded CA certificate for the + Kubernetes API server. If not set, the controller will use the + CA certificate from the cluster resource. + - `audiences`: the optional audiences as a list of + line-break-separated strings for the Kubernetes ServiceAccount + token. Defaults to the `address` for the `generic` provider, or + to specific values for the other providers depending on the + provider. + - `serviceAccountName`: the optional name of the Kubernetes + ServiceAccount in the same namespace that should be used + for authentication. If not specified, the controller + ServiceAccount will be used. + + Mutually exclusive with SecretRef. + properties: + name: + description: Name of the referent. + type: string + required: + - name + type: object + secretRef: + description: |- + SecretRef holds an optional name of a secret that contains a key with + the kubeconfig file as the value. If no key is set, the key will default + to 'value'. Mutually exclusive with ConfigMapRef. + It is recommended that the kubeconfig is self-contained, and the secret + is regularly updated if credentials such as a cloud-access-token expire. + Cloud specific `cmd-path` auth helpers will not function without adding + binaries and credentials to the Pod that is responsible for reconciling + Kubernetes resources. Supported only for the generic provider. + properties: + key: + description: Key in the Secret, when not specified an implementation-specific + default key is used. + type: string + name: + description: Name of the Secret. + type: string + required: + - name + type: object + type: object + x-kubernetes-validations: + - message: exactly one of spec.kubeConfig.configMapRef or spec.kubeConfig.secretRef + must be specified + rule: has(self.configMapRef) || has(self.secretRef) + - message: exactly one of spec.kubeConfig.configMapRef or spec.kubeConfig.secretRef + must be specified + rule: '!has(self.configMapRef) || !has(self.secretRef)' + maxHistory: + description: |- + MaxHistory is the number of revisions saved by Helm for this HelmRelease. + Use '0' for an unlimited number of revisions; defaults to '5'. + type: integer + persistentClient: + description: |- + PersistentClient tells the controller to use a persistent Kubernetes + client for this release. When enabled, the client will be reused for the + duration of the reconciliation, instead of being created and destroyed + for each (step of a) Helm action. + + This can improve performance, but may cause issues with some Helm charts + that for example do create Custom Resource Definitions during installation + outside Helm's CRD lifecycle hooks, which are then not observed to be + available by e.g. post-install hooks. + + If not set, it defaults to true. + type: boolean + postRenderers: + description: |- + PostRenderers holds an array of Helm PostRenderers, which will be applied in order + of their definition. + items: + description: PostRenderer contains a Helm PostRenderer specification. + properties: + kustomize: + description: Kustomization to apply as PostRenderer. + properties: + images: + description: |- + Images is a list of (image name, new name, new tag or digest) + for changing image names, tags or digests. This can also be achieved with a + patch, but this operator is simpler to specify. + items: + description: Image contains an image name, a new name, + a new tag or digest, which will replace the original + name and tag. + properties: + digest: + description: |- + Digest is the value used to replace the original image tag. + If digest is present NewTag value is ignored. + type: string + name: + description: Name is a tag-less image name. + type: string + newName: + description: NewName is the value used to replace + the original name. + type: string + newTag: + description: NewTag is the value used to replace the + original tag. + type: string + required: + - name + type: object + type: array + patches: + description: |- + Strategic merge and JSON patches, defined as inline YAML objects, + capable of targeting objects based on kind, label and annotation selectors. + items: + description: |- + Patch contains an inline StrategicMerge or JSON6902 patch, and the target the patch should + be applied to. + properties: + patch: + description: |- + Patch contains an inline StrategicMerge patch or an inline JSON6902 patch with + an array of operation objects. + type: string + target: + description: Target points to the resources that the + patch document should be applied to. + properties: + annotationSelector: + description: |- + AnnotationSelector is a string that follows the label selection expression + https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#api + It matches with the resource annotations. + type: string + group: + description: |- + Group is the API group to select resources from. + Together with Version and Kind it is capable of unambiguously identifying and/or selecting resources. + https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md + type: string + kind: + description: |- + Kind of the API Group to select resources from. + Together with Group and Version it is capable of unambiguously + identifying and/or selecting resources. + https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md + type: string + labelSelector: + description: |- + LabelSelector is a string that follows the label selection expression + https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#api + It matches with the resource labels. + type: string + name: + description: Name to match resources with. + type: string + namespace: + description: Namespace to select resources from. + type: string + version: + description: |- + Version of the API Group to select resources from. + Together with Group and Kind it is capable of unambiguously identifying and/or selecting resources. + https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/api-group.md + type: string + type: object + required: + - patch + type: object + type: array + type: object + type: object + type: array + releaseName: + description: |- + ReleaseName used for the Helm release. Defaults to a composition of + '[TargetNamespace-]Name'. + maxLength: 53 + minLength: 1 + type: string + rollback: + description: Rollback holds the configuration for Helm rollback actions + for this HelmRelease. + properties: + cleanupOnFail: + description: |- + CleanupOnFail allows deletion of new resources created during the Helm + rollback action when it fails. + type: boolean + disableHooks: + description: DisableHooks prevents hooks from running during the + Helm rollback action. + type: boolean + disableWait: + description: |- + DisableWait disables the waiting for resources to be ready after a Helm + rollback has been performed. + type: boolean + disableWaitForJobs: + description: |- + DisableWaitForJobs disables waiting for jobs to complete after a Helm + rollback has been performed. + type: boolean + force: + description: |- + Force forces resource updates through a replacement strategy + that avoids 3-way merge conflicts on client-side apply. + This field is ignored for server-side apply (which always + forces conflicts with other field managers). + type: boolean + recreate: + description: |- + Recreate performs pod restarts for any managed workloads. + + Deprecated: This behavior was deprecated in Helm 3: + - Deprecation: https://github.com/helm/helm/pull/6463 + - Removal: https://github.com/helm/helm/pull/31023 + After helm-controller was upgraded to the Helm 4 SDK, + this field is no longer functional and will print a + warning if set to true. It will also be removed in a + future release. + type: boolean + serverSideApply: + description: |- + ServerSideApply enables server-side apply for resources during rollback. + Can be "enabled", "disabled", or "auto". + When "auto", server-side apply usage will be based on the release's previous usage. + Defaults to "auto". + enum: + - enabled + - disabled + - auto + type: string + timeout: + description: |- + Timeout is the time to wait for any individual Kubernetes operation (like + Jobs for hooks) during the performance of a Helm rollback action. Defaults to + 'HelmReleaseSpec.Timeout'. + pattern: ^([0-9]+(\.[0-9]+)?(ms|s|m|h))+$ + type: string + type: object + serviceAccountName: + description: |- + The name of the Kubernetes service account to impersonate + when reconciling this HelmRelease. + maxLength: 253 + minLength: 1 + type: string + storageNamespace: + description: |- + StorageNamespace used for the Helm storage. + Defaults to the namespace of the HelmRelease. + maxLength: 63 + minLength: 1 + type: string + suspend: + description: |- + Suspend tells the controller to suspend reconciliation for this HelmRelease, + it does not apply to already started reconciliations. Defaults to false. + type: boolean + targetNamespace: + description: |- + TargetNamespace to target when performing operations for the HelmRelease. + Defaults to the namespace of the HelmRelease. + maxLength: 63 + minLength: 1 + type: string + test: + description: Test holds the configuration for Helm test actions for + this HelmRelease. + properties: + enable: + description: |- + Enable enables Helm test actions for this HelmRelease after an Helm install + or upgrade action has been performed. + type: boolean + filters: + description: Filters is a list of tests to run or exclude from + running. + items: + description: Filter holds the configuration for individual Helm + test filters. + properties: + exclude: + description: Exclude specifies whether the named test should + be excluded. + type: boolean + name: + description: Name is the name of the test. + maxLength: 253 + minLength: 1 + type: string + required: + - name + type: object + type: array + ignoreFailures: + description: |- + IgnoreFailures tells the controller to skip remediation when the Helm tests + are run but fail. Can be overwritten for tests run after install or upgrade + actions in 'Install.IgnoreTestFailures' and 'Upgrade.IgnoreTestFailures'. + type: boolean + timeout: + description: |- + Timeout is the time to wait for any individual Kubernetes operation during + the performance of a Helm test action. Defaults to 'HelmReleaseSpec.Timeout'. + pattern: ^([0-9]+(\.[0-9]+)?(ms|s|m|h))+$ + type: string + type: object + timeout: + description: |- + Timeout is the time to wait for any individual Kubernetes operation (like Jobs + for hooks) during the performance of a Helm action. Defaults to '5m0s'. + pattern: ^([0-9]+(\.[0-9]+)?(ms|s|m|h))+$ + type: string + uninstall: + description: Uninstall holds the configuration for Helm uninstall + actions for this HelmRelease. + properties: + deletionPropagation: + default: background + description: |- + DeletionPropagation specifies the deletion propagation policy when + a Helm uninstall is performed. + enum: + - background + - foreground + - orphan + type: string + disableHooks: + description: DisableHooks prevents hooks from running during the + Helm rollback action. + type: boolean + disableWait: + description: |- + DisableWait disables waiting for all the resources to be deleted after + a Helm uninstall is performed. + type: boolean + keepHistory: + description: |- + KeepHistory tells Helm to remove all associated resources and mark the + release as deleted, but retain the release history. + type: boolean + timeout: + description: |- + Timeout is the time to wait for any individual Kubernetes operation (like + Jobs for hooks) during the performance of a Helm uninstall action. Defaults + to 'HelmReleaseSpec.Timeout'. + pattern: ^([0-9]+(\.[0-9]+)?(ms|s|m|h))+$ + type: string + type: object + upgrade: + description: Upgrade holds the configuration for Helm upgrade actions + for this HelmRelease. + properties: + cleanupOnFail: + description: |- + CleanupOnFail allows deletion of new resources created during the Helm + upgrade action when it fails. + type: boolean + crds: + description: |- + CRDs upgrade CRDs from the Helm Chart's crds directory according + to the CRD upgrade policy provided here. Valid values are `Skip`, + `Create` or `CreateReplace`. Default is `Skip` and if omitted + CRDs are neither installed nor upgraded. + + Skip: do neither install nor replace (update) any CRDs. + + Create: new CRDs are created, existing CRDs are neither updated nor deleted. + + CreateReplace: new CRDs are created, existing CRDs are updated (replaced) + but not deleted. + + By default, CRDs are not applied during Helm upgrade action. With this + option users can opt-in to CRD upgrade, which is not (yet) natively supported by Helm. + https://helm.sh/docs/chart_best_practices/custom_resource_definitions. + enum: + - Skip + - Create + - CreateReplace + type: string + disableHooks: + description: DisableHooks prevents hooks from running during the + Helm upgrade action. + type: boolean + disableOpenAPIValidation: + description: |- + DisableOpenAPIValidation prevents the Helm upgrade action from validating + rendered templates against the Kubernetes OpenAPI Schema. + type: boolean + disableSchemaValidation: + description: |- + DisableSchemaValidation prevents the Helm upgrade action from validating + the values against the JSON Schema. + type: boolean + disableTakeOwnership: + description: |- + DisableTakeOwnership disables taking ownership of existing resources + during the Helm upgrade action. Defaults to false. + type: boolean + disableWait: + description: |- + DisableWait disables the waiting for resources to be ready after a Helm + upgrade has been performed. + type: boolean + disableWaitForJobs: + description: |- + DisableWaitForJobs disables waiting for jobs to complete after a Helm + upgrade has been performed. + type: boolean + force: + description: |- + Force forces resource updates through a replacement strategy + that avoids 3-way merge conflicts on client-side apply. + This field is ignored for server-side apply (which always + forces conflicts with other field managers). + type: boolean + preserveValues: + description: |- + PreserveValues will make Helm reuse the last release's values and merge in + overrides from 'Values'. Setting this flag makes the HelmRelease + non-declarative. + type: boolean + remediation: + description: |- + Remediation holds the remediation configuration for when the Helm upgrade + action for the HelmRelease fails. The default is to not perform any action. + properties: + ignoreTestFailures: + description: |- + IgnoreTestFailures tells the controller to skip remediation when the Helm + tests are run after an upgrade action but fail. + Defaults to 'Test.IgnoreFailures'. + type: boolean + remediateLastFailure: + description: |- + RemediateLastFailure tells the controller to remediate the last failure, when + no retries remain. Defaults to 'false' unless 'Retries' is greater than 0. + type: boolean + retries: + description: |- + Retries is the number of retries that should be attempted on failures before + bailing. Remediation, using 'Strategy', is performed between each attempt. + Defaults to '0', a negative integer equals to unlimited retries. + type: integer + strategy: + description: Strategy to use for failure remediation. Defaults + to 'rollback'. + enum: + - rollback + - uninstall + type: string + type: object + serverSideApply: + description: |- + ServerSideApply enables server-side apply for resources during upgrade. + Can be "enabled", "disabled", or "auto". + When "auto", server-side apply usage will be based on the release's previous usage. + Defaults to "auto". + enum: + - enabled + - disabled + - auto + type: string + strategy: + description: |- + Strategy defines the upgrade strategy to use for this HelmRelease. + Defaults to 'RemediateOnFailure', or 'RetryOnFailure' when the + DefaultToRetryOnFailure feature gate is enabled. + properties: + name: + description: Name of the upgrade strategy. + enum: + - RemediateOnFailure + - RetryOnFailure + type: string + retryInterval: + description: |- + RetryInterval is the interval at which to retry a failed upgrade. + Can be used only when Name is set to RetryOnFailure. + Defaults to '5m'. + pattern: ^([0-9]+(\.[0-9]+)?(ms|s|m|h))+$ + type: string + required: + - name + type: object + x-kubernetes-validations: + - message: .retryInterval can only be set when .name is 'RetryOnFailure' + rule: '!has(self.retryInterval) || self.name == ''RetryOnFailure''' + timeout: + description: |- + Timeout is the time to wait for any individual Kubernetes operation (like + Jobs for hooks) during the performance of a Helm upgrade action. Defaults to + 'HelmReleaseSpec.Timeout'. + pattern: ^([0-9]+(\.[0-9]+)?(ms|s|m|h))+$ + type: string + type: object + values: + description: Values holds the values for this Helm release. + x-kubernetes-preserve-unknown-fields: true + valuesFrom: + description: |- + ValuesFrom holds references to resources containing Helm values for this HelmRelease, + and information about how they should be merged. + items: + description: |- + ValuesReference contains a reference to a resource containing Helm values, + and optionally the key they can be found at. + properties: + kind: + description: Kind of the values referent, valid values are ('Secret', + 'ConfigMap'). + enum: + - Secret + - ConfigMap + type: string + name: + description: |- + Name of the values referent. Should reside in the same namespace as the + referring resource. + maxLength: 253 + minLength: 1 + type: string + optional: + description: |- + Optional marks this ValuesReference as optional. When set, a not found error + for the values reference is ignored, but any ValuesKey, TargetPath or + transient error will still result in a reconciliation failure. + type: boolean + targetPath: + description: |- + TargetPath is the YAML dot notation path the value should be merged at. When + set, the ValuesKey is expected to be a single flat value. Defaults to 'None', + which results in the values getting merged at the root. + maxLength: 250 + pattern: ^([a-zA-Z0-9_\-.\\\/]|\[[0-9]{1,5}\])+$ + type: string + valuesKey: + description: |- + ValuesKey is the data key where the values.yaml or a specific value can be + found at. Defaults to 'values.yaml'. + maxLength: 253 + pattern: ^[\-._a-zA-Z0-9]+$ + type: string + required: + - kind + - name + type: object + type: array + waitStrategy: + description: |- + WaitStrategy defines Helm's wait strategy for waiting for applied + resources to become ready. + properties: + name: + description: |- + Name is Helm's wait strategy for waiting for applied resources to + become ready. One of 'poller' or 'legacy'. The 'poller' strategy uses + kstatus to poll resource statuses, while the 'legacy' strategy uses + Helm v3's waiting logic. + Defaults to 'poller', or to 'legacy' when UseHelm3Defaults feature + gate is enabled. + enum: + - poller + - legacy + type: string + required: + - name + type: object + required: + - interval + type: object + x-kubernetes-validations: + - message: either chart or chartRef must be set + rule: (has(self.chart) && !has(self.chartRef)) || (!has(self.chart) + && has(self.chartRef)) + status: + default: + observedGeneration: -1 + description: HelmReleaseStatus defines the observed state of a HelmRelease. + properties: + conditions: + description: Conditions holds the conditions for the HelmRelease. + items: + description: Condition contains details for one aspect of the current + state of this API Resource. + properties: + lastTransitionTime: + description: |- + lastTransitionTime is the last time the condition transitioned from one status to another. + This should be when the underlying condition changed. If that is not known, then using the time when the API field changed is acceptable. + format: date-time + type: string + message: + description: |- + message is a human readable message indicating details about the transition. + This may be an empty string. + maxLength: 32768 + type: string + observedGeneration: + description: |- + observedGeneration represents the .metadata.generation that the condition was set based upon. + For instance, if .metadata.generation is currently 12, but the .status.conditions[x].observedGeneration is 9, the condition is out of date + with respect to the current state of the instance. + format: int64 + minimum: 0 + type: integer + reason: + description: |- + reason contains a programmatic identifier indicating the reason for the condition's last transition. + Producers of specific condition types may define expected values and meanings for this field, + and whether the values are considered a guaranteed API. + The value should be a CamelCase string. + This field may not be empty. + maxLength: 1024 + minLength: 1 + pattern: ^[A-Za-z]([A-Za-z0-9_,:]*[A-Za-z0-9_])?$ + type: string + status: + description: status of the condition, one of True, False, Unknown. + enum: + - "True" + - "False" + - Unknown + type: string + type: + description: type of condition in CamelCase or in foo.example.com/CamelCase. + maxLength: 316 + pattern: ^([a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*/)?(([A-Za-z0-9][-A-Za-z0-9_.]*)?[A-Za-z0-9])$ + type: string + required: + - lastTransitionTime + - message + - reason + - status + - type + type: object + type: array + failures: + description: |- + Failures is the reconciliation failure count against the latest desired + state. It is reset after a successful reconciliation. + format: int64 + type: integer + helmChart: + description: |- + HelmChart is the namespaced name of the HelmChart resource created by + the controller for the HelmRelease. + type: string + history: + description: |- + History holds the history of Helm releases performed for this HelmRelease + up to the last successfully completed release. + items: + description: |- + Snapshot captures a point-in-time copy of the status information for a Helm release, + as managed by the controller. + properties: + action: + description: Action is the action that resulted in this snapshot + being created. + type: string + apiVersion: + description: |- + APIVersion is the API version of the Snapshot. + When the calculation method of the Digest field is changed, this + field will be used to distinguish between the old and new methods. + type: string + appVersion: + description: AppVersion is the chart app version of the release + object in storage. + type: string + chartName: + description: ChartName is the chart name of the release object + in storage. + type: string + chartVersion: + description: |- + ChartVersion is the chart version of the release object in + storage. + type: string + configDigest: + description: |- + ConfigDigest is the checksum of the config (better known as + "values") of the release object in storage. + It has the format of `:`. + type: string + deleted: + description: Deleted is when the release was deleted. + format: date-time + type: string + digest: + description: |- + Digest is the checksum of the release object in storage. + It has the format of `:`. + type: string + firstDeployed: + description: FirstDeployed is when the release was first deployed. + format: date-time + type: string + lastDeployed: + description: LastDeployed is when the release was last deployed. + format: date-time + type: string + name: + description: Name is the name of the release. + type: string + namespace: + description: Namespace is the namespace the release is deployed + to. + type: string + ociDigest: + description: OCIDigest is the digest of the OCI artifact associated + with the release. + type: string + status: + description: Status is the current state of the release. + type: string + testHooks: + additionalProperties: + description: |- + TestHookStatus holds the status information for a test hook as observed + to be run by the controller. + properties: + lastCompleted: + description: LastCompleted is the time the test hook last + completed. + format: date-time + type: string + lastStarted: + description: LastStarted is the time the test hook was + last started. + format: date-time + type: string + phase: + description: Phase the test hook was observed to be in. + type: string + type: object + description: |- + TestHooks is the list of test hooks for the release as observed to be + run by the controller. + type: object + version: + description: Version is the version of the release object in + storage. + type: integer + required: + - chartName + - chartVersion + - configDigest + - digest + - firstDeployed + - lastDeployed + - name + - namespace + - status + - version + type: object + type: array + installFailures: + description: |- + InstallFailures is the install failure count against the latest desired + state. It is reset after a successful reconciliation. + format: int64 + type: integer + inventory: + description: |- + Inventory contains the list of Kubernetes resource object references + that have been applied for this release. + properties: + entries: + description: Entries of Kubernetes resource object references. + items: + description: ResourceRef contains the information necessary + to locate a resource within a cluster. + properties: + id: + description: |- + ID is the string representation of the Kubernetes resource object's metadata, + in the format '___'. + type: string + v: + description: Version is the API version of the Kubernetes + resource object's kind. + type: string + required: + - id + - v + type: object + type: array + required: + - entries + type: object + lastAttemptedConfigDigest: + description: |- + LastAttemptedConfigDigest is the digest for the config (better known as + "values") of the last reconciliation attempt. + type: string + lastAttemptedGeneration: + description: |- + LastAttemptedGeneration is the last generation the controller attempted + to reconcile. + format: int64 + type: integer + lastAttemptedReleaseAction: + description: |- + LastAttemptedReleaseAction is the last release action performed for this + HelmRelease. It is used to determine the active retry or remediation + strategy. + enum: + - install + - upgrade + type: string + lastAttemptedReleaseActionDuration: + description: |- + LastAttemptedReleaseActionDuration is the duration of the last + release action performed for this HelmRelease. + type: string + lastAttemptedRevision: + description: |- + LastAttemptedRevision is the Source revision of the last reconciliation + attempt. For OCIRepository sources, the 12 first characters of the digest are + appended to the chart version e.g. "1.2.3+1234567890ab". + type: string + lastAttemptedRevisionDigest: + description: |- + LastAttemptedRevisionDigest is the digest of the last reconciliation attempt. + This is only set for OCIRepository sources. + type: string + lastAttemptedValuesChecksum: + description: |- + LastAttemptedValuesChecksum is the SHA1 checksum for the values of the last + reconciliation attempt. + + Deprecated: Use LastAttemptedConfigDigest instead. + type: string + lastHandledForceAt: + description: |- + LastHandledForceAt holds the value of the most recent + force request value, so a change of the annotation value + can be detected. + type: string + lastHandledReconcileAt: + description: |- + LastHandledReconcileAt holds the value of the most recent + reconcile request value, so a change of the annotation value + can be detected. + type: string + lastHandledResetAt: + description: |- + LastHandledResetAt holds the value of the most recent reset request + value, so a change of the annotation value can be detected. + type: string + lastReleaseRevision: + description: |- + LastReleaseRevision is the revision of the last successful Helm release. + + Deprecated: Use History instead. + type: integer + observedCommonMetadataDigest: + description: |- + ObservedCommonMetadataDigest is the digest for the common metadata of + the last successful reconciliation attempt. + type: string + observedGeneration: + description: ObservedGeneration is the last observed generation. + format: int64 + type: integer + observedPostRenderersDigest: + description: |- + ObservedPostRenderersDigest is the digest for the post-renderers of + the last successful reconciliation attempt. + type: string + storageNamespace: + description: |- + StorageNamespace is the namespace of the Helm release storage for the + current release. + maxLength: 63 + minLength: 1 + type: string + upgradeFailures: + description: |- + UpgradeFailures is the upgrade failure count against the latest desired + state. It is reset after a successful reconciliation. + format: int64 + type: integer + type: object + type: object + served: true + storage: true + subresources: + status: {} diff --git a/internal/controllers/provisioning/provisioners/pulumi/helm_release_v2.go b/internal/controllers/provisioning/provisioners/pulumi/helm_release_v2.go new file mode 100644 index 0000000..b4960bf --- /dev/null +++ b/internal/controllers/provisioning/provisioners/pulumi/helm_release_v2.go @@ -0,0 +1,128 @@ +package pulumi + +import ( + "encoding/json" + "fmt" + + metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "totalsoft.ro/platform-controllers/internal/controllers/provisioning" + fluxcd "totalsoft.ro/platform-controllers/internal/controllers/provisioning/provisioners/pulumi/fluxcd/generated/kubernetes/helm/v2" + "totalsoft.ro/platform-controllers/internal/template" + "totalsoft.ro/platform-controllers/internal/tuple" + platformv1 "totalsoft.ro/platform-controllers/pkg/apis/platform/v1alpha1" + provisioningv1 "totalsoft.ro/platform-controllers/pkg/apis/provisioning/v1alpha1" +) + +func deployHelmReleaseV2(target provisioning.ProvisioningTarget, + hr *provisioningv1.HelmReleaseV2, + dependencies []pulumi.Resource, + ctx *pulumi.Context) (*fluxcd.HelmRelease, error) { + + valueExporter := handleValueExport(target) + gvk := provisioningv1.SchemeGroupVersion.WithKind("HelmReleaseV2") + + args, err := pulumiFluxHrV2Args(target, hr) + if err != nil { + return nil, err + } + + fluxHr, err := fluxcd.NewHelmRelease(ctx, hr.Name, args, pulumi.DependsOn(dependencies)) + if err != nil { + return nil, err + } + + for _, exp := range hr.Spec.Exports { + err = valueExporter(newExportContext(ctx, exp.Domain, hr.Name, hr.ObjectMeta, gvk), + map[string]exportTemplateWithValue{"releaseName": {exp.ReleaseName, fluxHr.Spec.ReleaseName().Elem()}}) + if err != nil { + return nil, err + } + } + ctx.Export(fmt.Sprintf("helmReleaseV2:%s", hr.Name), fluxHr.Spec.ReleaseName().Elem()) + + return fluxHr, nil +} + +func pulumiFluxHrV2Args(target provisioning.ProvisioningTarget, hr *provisioningv1.HelmReleaseV2) (*fluxcd.HelmReleaseArgs, error) { + helmReleaseName, fluxHelmReleaseName := provisioning.MatchTarget(target, + func(tenant *platformv1.Tenant) tuple.T2[string, string] { + helmReleaseName := fmt.Sprintf("%s-%s", hr.Spec.Release.ReleaseName, tenant.GetName()) + fluxHelmReleaseName := fmt.Sprintf("%s-%s", hr.Name, tenant.GetName()) + return tuple.New2(helmReleaseName, fluxHelmReleaseName) + }, func(*platformv1.Platform) tuple.T2[string, string] { + helmReleaseName := hr.Spec.Release.ReleaseName + fluxHelmReleaseName := hr.Name + return tuple.New2(helmReleaseName, fluxHelmReleaseName) + }, + ).Values() + + pulumiValues := pulumi.Map{} + if hr.Spec.Release.Values != nil { + tc := provisioning.GetTemplateContext(target) + valuesJson := string(hr.Spec.Release.Values.Raw) + valuesJson, err := template.ParseTemplate(valuesJson, tc) + if err != nil { + return nil, err + } + + var values map[string]interface{} + if err := json.Unmarshal([]byte(valuesJson), &values); err != nil { + return nil, fmt.Errorf("failed to unmarshal templated Helm values as JSON: %w", err) + } + pulumiValues = pulumi.ToMap(values) + } + + spec := fluxcd.HelmReleaseSpecArgs{ + Interval: pulumi.String(hr.Spec.Release.Interval.Duration.String()), + ReleaseName: pulumi.String(helmReleaseName), + Values: pulumiValues, + } + + switch { + case hr.Spec.Release.Chart != nil: + spec.Chart = fluxcd.HelmReleaseSpecChartArgs{ + Spec: fluxcd.HelmReleaseSpecChartSpecArgs{ + Chart: pulumi.String(hr.Spec.Release.Chart.Spec.Chart), + Version: pulumi.String(hr.Spec.Release.Chart.Spec.Version), + SourceRef: fluxcd.HelmReleaseSpecChartSpecSourceRefArgs{ + Kind: pulumi.String(hr.Spec.Release.Chart.Spec.SourceRef.Kind), + Name: pulumi.String(hr.Spec.Release.Chart.Spec.SourceRef.Name), + Namespace: pulumi.String(hr.Spec.Release.Chart.Spec.SourceRef.Namespace), + }, + }, + } + case hr.Spec.Release.ChartRef != nil: + chartRef := fluxcd.HelmReleaseSpecChartRefArgs{ + Kind: pulumi.StringPtr(hr.Spec.Release.ChartRef.Kind), + Name: pulumi.StringPtr(hr.Spec.Release.ChartRef.Name), + } + if hr.Spec.Release.ChartRef.APIVersion != "" { + chartRef.ApiVersion = pulumi.StringPtr(hr.Spec.Release.ChartRef.APIVersion) + } + if hr.Spec.Release.ChartRef.Namespace != "" { + chartRef.Namespace = pulumi.StringPtr(hr.Spec.Release.ChartRef.Namespace) + } + spec.ChartRef = chartRef + default: + return nil, fmt.Errorf("helm release %q must define either spec.release.chart or spec.release.chartRef", hr.Name) + } + + if hr.Spec.Release.Upgrade != nil { + spec.Upgrade = fluxcd.HelmReleaseSpecUpgradeArgs{ + Remediation: fluxcd.HelmReleaseSpecUpgradeRemediationArgs{ + RemediateLastFailure: pulumi.Bool(hr.Spec.Release.Upgrade.GetRemediation().MustRemediateLastFailure()), + }, + } + } + + args := fluxcd.HelmReleaseArgs{ + Metadata: &metav1.ObjectMetaArgs{ + Name: pulumi.String(fluxHelmReleaseName), + Namespace: pulumi.String(hr.Namespace), + }, + Spec: spec, + } + + return &args, nil +} diff --git a/internal/controllers/provisioning/provisioners/pulumi/helm_release_v2_test.go b/internal/controllers/provisioning/provisioners/pulumi/helm_release_v2_test.go new file mode 100644 index 0000000..36cb971 --- /dev/null +++ b/internal/controllers/provisioning/provisioners/pulumi/helm_release_v2_test.go @@ -0,0 +1,157 @@ +package pulumi + +import ( + "encoding/json" + "testing" + "time" + + fluxv2 "github.com/fluxcd/helm-controller/api/v2" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stretchr/testify/assert" + apiextensionsv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + fluxcd "totalsoft.ro/platform-controllers/internal/controllers/provisioning/provisioners/pulumi/fluxcd/generated/kubernetes/helm/v2" + provisioningv1 "totalsoft.ro/platform-controllers/pkg/apis/provisioning/v1alpha1" +) + +func TestHelmReleaseV2DeployFunc(t *testing.T) { + platform := "dev" + tenant := newTenant("tenant1", platform) + hr := newHrV2("my-helm-release-v2", platform) + + t.Run("maximal helm release v2 spec", func(t *testing.T) { + err := pulumi.RunErr(func(ctx *pulumi.Context) error { + _, err := deployHelmReleaseV2(tenant, hr, []pulumi.Resource{}, ctx) + assert.NoError(t, err) + return nil + }, pulumi.WithMocks("project", "stack", mocks(0))) + assert.NoError(t, err) + }) + + t.Run("helm release v2 with nil upgrade spec", func(t *testing.T) { + err := pulumi.RunErr(func(ctx *pulumi.Context) error { + hr := hr.DeepCopy() + hr.Spec.Release.Upgrade = nil + _, err := deployHelmReleaseV2(tenant, hr, []pulumi.Resource{}, ctx) + assert.NoError(t, err) + return nil + }, pulumi.WithMocks("project", "stack", mocks(0))) + assert.NoError(t, err) + }) + + t.Run("helm release v2 with nil exports spec", func(t *testing.T) { + err := pulumi.RunErr(func(ctx *pulumi.Context) error { + hr := hr.DeepCopy() + hr.Spec.Exports = nil + _, err := deployHelmReleaseV2(tenant, hr, []pulumi.Resource{}, ctx) + assert.NoError(t, err) + return nil + }, pulumi.WithMocks("project", "stack", mocks(0))) + assert.NoError(t, err) + }) + + t.Run("helm release v2 with nil values spec", func(t *testing.T) { + err := pulumi.RunErr(func(ctx *pulumi.Context) error { + hr := hr.DeepCopy() + hr.Spec.Release.Values = nil + _, err := deployHelmReleaseV2(tenant, hr, []pulumi.Resource{}, ctx) + assert.NoError(t, err) + return nil + }, pulumi.WithMocks("project", "stack", mocks(0))) + assert.NoError(t, err) + }) +} + +func TestPulumiFluxHrV2ArgsOmitsUpgradeWhenNotConfigured(t *testing.T) { + tenant := newTenant("tenant1", "dev") + hr := newHrV2("my-helm-release-v2", "dev") + hr.Spec.Release.Upgrade = nil + + args, err := pulumiFluxHrV2Args(tenant, hr) + + assert.NoError(t, err) + spec, ok := args.Spec.(fluxcd.HelmReleaseSpecArgs) + assert.True(t, ok) + assert.Nil(t, spec.Upgrade) +} + +func TestPulumiFluxHrV2ArgsUsesChartRefWhenConfigured(t *testing.T) { + tenant := newTenant("tenant1", "dev") + hr := newHrV2("my-helm-release-v2", "dev") + hr.Spec.Release.Chart = nil + hr.Spec.Release.ChartRef = &fluxv2.CrossNamespaceSourceReference{ + APIVersion: "source.toolkit.fluxcd.io/v1", + Kind: "OCIRepository", + Name: "my-chart", + Namespace: "flux-system", + } + + args, err := pulumiFluxHrV2Args(tenant, hr) + + assert.NoError(t, err) + spec, ok := args.Spec.(fluxcd.HelmReleaseSpecArgs) + assert.True(t, ok) + assert.Nil(t, spec.Chart) + assert.IsType(t, fluxcd.HelmReleaseSpecChartRefArgs{}, spec.ChartRef) +} + +func TestPulumiFluxHrV2ArgsErrorsWhenChartConfigurationMissing(t *testing.T) { + tenant := newTenant("tenant1", "dev") + hr := newHrV2("my-helm-release-v2", "dev") + hr.Spec.Release.Chart = nil + hr.Spec.Release.ChartRef = nil + + args, err := pulumiFluxHrV2Args(tenant, hr) + + assert.Nil(t, args) + assert.ErrorContains(t, err, "must define either spec.release.chart or spec.release.chartRef") +} + +func newHrV2(name, platform string) *provisioningv1.HelmReleaseV2 { + remediateLastFailure := false + values := map[string]interface{}{ + "val1": "", + "val2": 8, + "val3": map[string]interface{}{ + "val1": "", + "val2": 8, + }, + } + valuesBytes, _ := json.Marshal(values) + + hr := provisioningv1.HelmReleaseV2{ + ObjectMeta: metav1.ObjectMeta{ + Name: name, + Namespace: metav1.NamespaceDefault, + }, + Spec: provisioningv1.HelmReleaseV2Spec{ + ProvisioningMeta: provisioningv1.ProvisioningMeta{ + PlatformRef: platform, + }, + Release: fluxv2.HelmReleaseSpec{ + Interval: metav1.Duration{Duration: 10 * time.Second}, + Chart: &fluxv2.HelmChartTemplate{ + Spec: fluxv2.HelmChartTemplateSpec{ + Chart: "my-chart", + Version: "1.0.0", + SourceRef: fluxv2.CrossNamespaceObjectReference{ + Kind: "HelmRepository", + Name: "my-helm-repo", + Namespace: metav1.NamespaceDefault, + }, + }, + }, + ReleaseName: "my-helm-release", + Upgrade: &fluxv2.Upgrade{ + Remediation: &fluxv2.UpgradeRemediation{ + RemediateLastFailure: &remediateLastFailure, + }, + }, + Values: &apiextensionsv1.JSON{ + Raw: valuesBytes, + }, + }, + }, + } + return &hr +} diff --git a/internal/controllers/provisioning/provisioners/pulumi/pulumi.go b/internal/controllers/provisioning/provisioners/pulumi/pulumi.go index 58114f8..6b6c01a 100644 --- a/internal/controllers/provisioning/provisioners/pulumi/pulumi.go +++ b/internal/controllers/provisioning/provisioners/pulumi/pulumi.go @@ -40,6 +40,7 @@ func Create(target provisioning.ProvisioningTarget, domain string, infra *provis anyManagedAzureDb := len(infra.AzureManagedDbs) > 0 anyAzurePowerShellScript := len(infra.AzurePowerShellScripts) > 0 anyHelmRelease := len(infra.HelmReleases) > 0 + anyHelmReleaseV2 := len(infra.HelmReleaseV2s) > 0 anyVirtualMachine := len(infra.AzureVirtualMachines) > 0 anyVirtualDesktop := len(infra.AzureVirtualDesktops) > 0 anyEntraUser := len(infra.EntraUsers) > 0 @@ -47,7 +48,7 @@ func Create(target provisioning.ProvisioningTarget, domain string, infra *provis anyMssqlDb := len(infra.MsSqlDbs) > 0 anyLocalScript := len(infra.LocalScripts) > 0 - anyResource := anyAzureDb || anyManagedAzureDb || anyHelmRelease || anyVirtualMachine || anyVirtualDesktop || anyEntraUser || anyAzurePowerShellScript || anyMssqlDb || anyMinioBucket || anyLocalScript + anyResource := anyAzureDb || anyManagedAzureDb || anyHelmRelease || anyHelmReleaseV2 || anyVirtualMachine || anyVirtualDesktop || anyEntraUser || anyAzurePowerShellScript || anyMssqlDb || anyMinioBucket || anyLocalScript needsResourceGroup := anyVirtualMachine || anyVirtualDesktop || anyAzurePowerShellScript stackName := provisioning.MatchTarget(target, @@ -289,6 +290,8 @@ func deployResource(target provisioning.ProvisioningTarget, return deployAzurePowerShellScript(target, *rgName, res.(*provisioningv1.AzurePowerShellScript), dependencies, ctx) case string(provisioning.ProvisioningResourceKindHelmRelease): return deployHelmRelease(target, res.(*provisioningv1.HelmRelease), dependencies, ctx) + case string(provisioning.ProvisioningResourceKindHelmReleaseV2): + return deployHelmReleaseV2(target, res.(*provisioningv1.HelmReleaseV2), dependencies, ctx) case string(provisioning.ProvisioningResourceKindAzureVirtualMachine): return deployAzureVirtualMachine(target, *rgName, res.(*provisioningv1.AzureVirtualMachine), dependencies, ctx) case string(provisioning.ProvisioningResourceKindAzureVirtualDesktop): diff --git a/internal/controllers/provisioning/provisioning_controller.go b/internal/controllers/provisioning/provisioning_controller.go index c44daa8..524a26d 100644 --- a/internal/controllers/provisioning/provisioning_controller.go +++ b/internal/controllers/provisioning/provisioning_controller.go @@ -73,6 +73,7 @@ type ProvisioningController struct { azureManagedDbInformer provisioningInformersv1.AzureManagedDatabaseInformer azurePowerShellScriptInformer provisioningInformersv1.AzurePowerShellScriptInformer helmReleaseInformer provisioningInformersv1.HelmReleaseInformer + helmReleaseV2Informer provisioningInformersv1.HelmReleaseV2Informer azureVirtualMachineInformer provisioningInformersv1.AzureVirtualMachineInformer azureVirtualDesktopInformer provisioningInformersv1.AzureVirtualDesktopInformer entraUserInformer provisioningInformersv1.EntraUserInformer @@ -115,6 +116,7 @@ func NewProvisioningController(clientSet clientset.Interface, azureManagedDbInformer: factory.Provisioning().V1alpha1().AzureManagedDatabases(), azurePowerShellScriptInformer: factory.Provisioning().V1alpha1().AzurePowerShellScripts(), helmReleaseInformer: factory.Provisioning().V1alpha1().HelmReleases(), + helmReleaseV2Informer: factory.Provisioning().V1alpha1().HelmReleaseV2s(), azureVirtualMachineInformer: factory.Provisioning().V1alpha1().AzureVirtualMachines(), azureVirtualDesktopInformer: factory.Provisioning().V1alpha1().AzureVirtualDesktops(), entraUserInformer: factory.Provisioning().V1alpha1().EntraUsers(), @@ -138,6 +140,7 @@ func NewProvisioningController(clientSet clientset.Interface, addPlatformHandlers(c.platformInformer) addResourceHandlers[*provisioningv1.HelmRelease]("Helm release", c.helmReleaseInformer.Informer(), c.enqueueDomain) + addResourceHandlers[*provisioningv1.HelmReleaseV2]("Helm release v2", c.helmReleaseV2Informer.Informer(), c.enqueueDomain) addResourceHandlers[*provisioningv1.MsSqlDatabase]("MsSql database", c.mssqlDbInformer.Informer(), c.enqueueDomain) addResourceHandlers[*provisioningv1.LocalScript]("Local script", c.localScriptInformer.Informer(), c.enqueueDomain) addResourceHandlers[*provisioningv1.MinioBucket]("Minio bucket", c.minioBucketInformer.Informer(), c.enqueueDomain) @@ -283,6 +286,7 @@ func (c *ProvisioningController) syncHandler(key string) error { AzureDbs: []*provisioningv1.AzureDatabase{}, AzureManagedDbs: []*provisioningv1.AzureManagedDatabase{}, HelmReleases: []*provisioningv1.HelmRelease{}, + HelmReleaseV2s: []*provisioningv1.HelmReleaseV2{}, AzureVirtualMachines: []*provisioningv1.AzureVirtualMachine{}, AzureVirtualDesktops: []*provisioningv1.AzureVirtualDesktop{}, MsSqlDbs: []*provisioningv1.MsSqlDatabase{}, @@ -318,6 +322,16 @@ func (c *ProvisioningController) syncTarget(target ProvisioningTarget, domain st return err } + helmReleaseV2s, err := c.helmReleaseV2Informer.Lister().List(labels.Everything()) + if err != nil { + return err + } + helmReleaseV2s = selectItemsInTarget(target.GetPlatformName(), domain, helmReleaseV2s, target) + helmReleaseV2s, err = applyTargetOverrides(helmReleaseV2s, target) + if err != nil { + return err + } + mssqlDbs, err := c.mssqlDbInformer.Lister().List(labels.Everything()) if err != nil { return err @@ -422,6 +436,7 @@ func (c *ProvisioningController) syncTarget(target ProvisioningTarget, domain st AzureManagedDbs: azureManagedDbs, AzurePowerShellScripts: azurePowerShellScripts, HelmReleases: helmReleases, + HelmReleaseV2s: helmReleaseV2s, AzureVirtualMachines: azureVirtualMachines, AzureVirtualDesktops: azureVirtualDesktops, EntraUsers: entraUsers, diff --git a/internal/controllers/provisioning/provisioning_resources.go b/internal/controllers/provisioning/provisioning_resources.go index a1da145..0a1ca08 100644 --- a/internal/controllers/provisioning/provisioning_resources.go +++ b/internal/controllers/provisioning/provisioning_resources.go @@ -16,6 +16,7 @@ const ( ProvisioningResourceKindAzureVirtualDesktop = provisioningv1.ProvisioningResourceKind("AzureVirtualDesktop") ProvisioningResourceKindAzureVirtualMachine = provisioningv1.ProvisioningResourceKind("AzureVirtualMachine") ProvisioningResourceKindHelmRelease = provisioningv1.ProvisioningResourceKind("HelmRelease") + ProvisioningResourceKindHelmReleaseV2 = provisioningv1.ProvisioningResourceKind("HelmReleaseV2") ProvisioningResourceKindMsSqlDatabase = provisioningv1.ProvisioningResourceKind("MsSqlDatabase") ProvisioningResourceKindLocalScript = provisioningv1.ProvisioningResourceKind("LocalScript") ) @@ -27,6 +28,7 @@ type InfrastructureManifests struct { AzureManagedDbs []*provisioningv1.AzureManagedDatabase AzurePowerShellScripts []*provisioningv1.AzurePowerShellScript HelmReleases []*provisioningv1.HelmRelease + HelmReleaseV2s []*provisioningv1.HelmReleaseV2 AzureVirtualMachines []*provisioningv1.AzureVirtualMachine AzureVirtualDesktops []*provisioningv1.AzureVirtualDesktop MsSqlDbs []*provisioningv1.MsSqlDatabase @@ -55,6 +57,8 @@ func (infra *InfrastructureManifests) Get(id provisioningv1.ProvisioningResource return findByName(id.Name, infra.AzurePowerShellScripts) case ProvisioningResourceKindHelmRelease: return findByName(id.Name, infra.HelmReleases) + case ProvisioningResourceKindHelmReleaseV2: + return findByName(id.Name, infra.HelmReleaseV2s) case ProvisioningResourceKindAzureVirtualMachine: return findByName(id.Name, infra.AzureVirtualMachines) case ProvisioningResourceKindAzureVirtualDesktop: diff --git a/pkg/apis/provisioning/v1alpha1/helmReleaseV2Types.go b/pkg/apis/provisioning/v1alpha1/helmReleaseV2Types.go new file mode 100644 index 0000000..6d8d279 --- /dev/null +++ b/pkg/apis/provisioning/v1alpha1/helmReleaseV2Types.go @@ -0,0 +1,48 @@ +package v1alpha1 + +import ( + flux "github.com/fluxcd/helm-controller/api/v2" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" +) + +// +genclient +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object +// +kubebuilder:printcolumn:name="Platform",type=string,JSONPath=`.spec.platformRef` +type HelmReleaseV2 struct { + metav1.TypeMeta `json:",inline"` + // +optional + metav1.ObjectMeta `json:"metadata,omitempty"` + + Spec HelmReleaseV2Spec `json:"spec"` +} + +type HelmReleaseV2Spec struct { + // helm release spec + Release flux.HelmReleaseSpec `json:"release"` + // +optional + Exports []HelmReleaseV2ExportsSpec `json:"exports,omitempty"` + ProvisioningMeta `json:",inline"` +} + +type HelmReleaseV2ExportsSpec struct { + // The domain or bounded-context for which HelmReleaseV2 values are exported. + Domain string `json:"domain"` + // +optional + ReleaseName ValueExport `json:"releaseName,omitempty"` +} + +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object +type HelmReleaseV2List struct { + metav1.TypeMeta `json:",inline"` + metav1.ListMeta `json:"metadata"` + + Items []HelmReleaseV2 `json:"items"` +} + +func (hr *HelmReleaseV2) GetProvisioningMeta() *ProvisioningMeta { + return &hr.Spec.ProvisioningMeta +} + +func (hr *HelmReleaseV2) GetSpec() any { + return &hr.Spec +} diff --git a/pkg/apis/provisioning/v1alpha1/register.go b/pkg/apis/provisioning/v1alpha1/register.go index e884aaf..0957e6a 100644 --- a/pkg/apis/provisioning/v1alpha1/register.go +++ b/pkg/apis/provisioning/v1alpha1/register.go @@ -43,6 +43,8 @@ func addKnownTypes(scheme *runtime.Scheme) error { &EntraUserList{}, &HelmRelease{}, &HelmReleaseList{}, + &HelmReleaseV2{}, + &HelmReleaseV2List{}, &MsSqlDatabase{}, &MsSqlDatabaseList{}, &LocalScript{}, diff --git a/pkg/apis/provisioning/v1alpha1/zz_generated.deepcopy.go b/pkg/apis/provisioning/v1alpha1/zz_generated.deepcopy.go index 33eb8e6..78ddc40 100644 --- a/pkg/apis/provisioning/v1alpha1/zz_generated.deepcopy.go +++ b/pkg/apis/provisioning/v1alpha1/zz_generated.deepcopy.go @@ -898,6 +898,106 @@ func (in *HelmReleaseSpec) DeepCopy() *HelmReleaseSpec { return out } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *HelmReleaseV2) DeepCopyInto(out *HelmReleaseV2) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ObjectMeta.DeepCopyInto(&out.ObjectMeta) + in.Spec.DeepCopyInto(&out.Spec) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new HelmReleaseV2. +func (in *HelmReleaseV2) DeepCopy() *HelmReleaseV2 { + if in == nil { + return nil + } + out := new(HelmReleaseV2) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *HelmReleaseV2) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *HelmReleaseV2ExportsSpec) DeepCopyInto(out *HelmReleaseV2ExportsSpec) { + *out = *in + out.ReleaseName = in.ReleaseName + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new HelmReleaseV2ExportsSpec. +func (in *HelmReleaseV2ExportsSpec) DeepCopy() *HelmReleaseV2ExportsSpec { + if in == nil { + return nil + } + out := new(HelmReleaseV2ExportsSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *HelmReleaseV2List) DeepCopyInto(out *HelmReleaseV2List) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ListMeta.DeepCopyInto(&out.ListMeta) + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = make([]HelmReleaseV2, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new HelmReleaseV2List. +func (in *HelmReleaseV2List) DeepCopy() *HelmReleaseV2List { + if in == nil { + return nil + } + out := new(HelmReleaseV2List) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *HelmReleaseV2List) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *HelmReleaseV2Spec) DeepCopyInto(out *HelmReleaseV2Spec) { + *out = *in + in.Release.DeepCopyInto(&out.Release) + if in.Exports != nil { + in, out := &in.Exports, &out.Exports + *out = make([]HelmReleaseV2ExportsSpec, len(*in)) + copy(*out, *in) + } + in.ProvisioningMeta.DeepCopyInto(&out.ProvisioningMeta) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new HelmReleaseV2Spec. +func (in *HelmReleaseV2Spec) DeepCopy() *HelmReleaseV2Spec { + if in == nil { + return nil + } + out := new(HelmReleaseV2Spec) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *InitScriptArgs) DeepCopyInto(out *InitScriptArgs) { *out = *in diff --git a/pkg/generated/applyconfiguration/provisioning/v1alpha1/helmreleasev2.go b/pkg/generated/applyconfiguration/provisioning/v1alpha1/helmreleasev2.go new file mode 100644 index 0000000..b9b6fb3 --- /dev/null +++ b/pkg/generated/applyconfiguration/provisioning/v1alpha1/helmreleasev2.go @@ -0,0 +1,210 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1alpha1 + +import ( + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + types "k8s.io/apimachinery/pkg/types" + v1 "k8s.io/client-go/applyconfigurations/meta/v1" +) + +// HelmReleaseV2ApplyConfiguration represents an declarative configuration of the HelmReleaseV2 type for use +// with apply. +type HelmReleaseV2ApplyConfiguration struct { + v1.TypeMetaApplyConfiguration `json:",inline"` + *v1.ObjectMetaApplyConfiguration `json:"metadata,omitempty"` + Spec *HelmReleaseV2SpecApplyConfiguration `json:"spec,omitempty"` +} + +// HelmReleaseV2 constructs an declarative configuration of the HelmReleaseV2 type for use with +// apply. +func HelmReleaseV2(name, namespace string) *HelmReleaseV2ApplyConfiguration { + b := &HelmReleaseV2ApplyConfiguration{} + b.WithName(name) + b.WithNamespace(namespace) + b.WithKind("HelmReleaseV2") + b.WithAPIVersion("provisioning.totalsoft.ro/v1alpha1") + return b +} + +// WithKind sets the Kind field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Kind field is set to the value of the last call. +func (b *HelmReleaseV2ApplyConfiguration) WithKind(value string) *HelmReleaseV2ApplyConfiguration { + b.Kind = &value + return b +} + +// WithAPIVersion sets the APIVersion field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the APIVersion field is set to the value of the last call. +func (b *HelmReleaseV2ApplyConfiguration) WithAPIVersion(value string) *HelmReleaseV2ApplyConfiguration { + b.APIVersion = &value + return b +} + +// WithName sets the Name field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Name field is set to the value of the last call. +func (b *HelmReleaseV2ApplyConfiguration) WithName(value string) *HelmReleaseV2ApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.Name = &value + return b +} + +// WithGenerateName sets the GenerateName field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the GenerateName field is set to the value of the last call. +func (b *HelmReleaseV2ApplyConfiguration) WithGenerateName(value string) *HelmReleaseV2ApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.GenerateName = &value + return b +} + +// WithNamespace sets the Namespace field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Namespace field is set to the value of the last call. +func (b *HelmReleaseV2ApplyConfiguration) WithNamespace(value string) *HelmReleaseV2ApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.Namespace = &value + return b +} + +// WithUID sets the UID field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the UID field is set to the value of the last call. +func (b *HelmReleaseV2ApplyConfiguration) WithUID(value types.UID) *HelmReleaseV2ApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.UID = &value + return b +} + +// WithResourceVersion sets the ResourceVersion field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the ResourceVersion field is set to the value of the last call. +func (b *HelmReleaseV2ApplyConfiguration) WithResourceVersion(value string) *HelmReleaseV2ApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.ResourceVersion = &value + return b +} + +// WithGeneration sets the Generation field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Generation field is set to the value of the last call. +func (b *HelmReleaseV2ApplyConfiguration) WithGeneration(value int64) *HelmReleaseV2ApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.Generation = &value + return b +} + +// WithCreationTimestamp sets the CreationTimestamp field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the CreationTimestamp field is set to the value of the last call. +func (b *HelmReleaseV2ApplyConfiguration) WithCreationTimestamp(value metav1.Time) *HelmReleaseV2ApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.CreationTimestamp = &value + return b +} + +// WithDeletionTimestamp sets the DeletionTimestamp field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the DeletionTimestamp field is set to the value of the last call. +func (b *HelmReleaseV2ApplyConfiguration) WithDeletionTimestamp(value metav1.Time) *HelmReleaseV2ApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.DeletionTimestamp = &value + return b +} + +// WithDeletionGracePeriodSeconds sets the DeletionGracePeriodSeconds field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the DeletionGracePeriodSeconds field is set to the value of the last call. +func (b *HelmReleaseV2ApplyConfiguration) WithDeletionGracePeriodSeconds(value int64) *HelmReleaseV2ApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.DeletionGracePeriodSeconds = &value + return b +} + +// WithLabels puts the entries into the Labels field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, the entries provided by each call will be put on the Labels field, +// overwriting an existing map entries in Labels field with the same key. +func (b *HelmReleaseV2ApplyConfiguration) WithLabels(entries map[string]string) *HelmReleaseV2ApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + if b.Labels == nil && len(entries) > 0 { + b.Labels = make(map[string]string, len(entries)) + } + for k, v := range entries { + b.Labels[k] = v + } + return b +} + +// WithAnnotations puts the entries into the Annotations field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, the entries provided by each call will be put on the Annotations field, +// overwriting an existing map entries in Annotations field with the same key. +func (b *HelmReleaseV2ApplyConfiguration) WithAnnotations(entries map[string]string) *HelmReleaseV2ApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + if b.Annotations == nil && len(entries) > 0 { + b.Annotations = make(map[string]string, len(entries)) + } + for k, v := range entries { + b.Annotations[k] = v + } + return b +} + +// WithOwnerReferences adds the given value to the OwnerReferences field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, values provided by each call will be appended to the OwnerReferences field. +func (b *HelmReleaseV2ApplyConfiguration) WithOwnerReferences(values ...*v1.OwnerReferenceApplyConfiguration) *HelmReleaseV2ApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + for i := range values { + if values[i] == nil { + panic("nil value passed to WithOwnerReferences") + } + b.OwnerReferences = append(b.OwnerReferences, *values[i]) + } + return b +} + +// WithFinalizers adds the given value to the Finalizers field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, values provided by each call will be appended to the Finalizers field. +func (b *HelmReleaseV2ApplyConfiguration) WithFinalizers(values ...string) *HelmReleaseV2ApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + for i := range values { + b.Finalizers = append(b.Finalizers, values[i]) + } + return b +} + +func (b *HelmReleaseV2ApplyConfiguration) ensureObjectMetaApplyConfigurationExists() { + if b.ObjectMetaApplyConfiguration == nil { + b.ObjectMetaApplyConfiguration = &v1.ObjectMetaApplyConfiguration{} + } +} + +// WithSpec sets the Spec field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Spec field is set to the value of the last call. +func (b *HelmReleaseV2ApplyConfiguration) WithSpec(value *HelmReleaseV2SpecApplyConfiguration) *HelmReleaseV2ApplyConfiguration { + b.Spec = value + return b +} diff --git a/pkg/generated/applyconfiguration/provisioning/v1alpha1/helmreleasev2exportsspec.go b/pkg/generated/applyconfiguration/provisioning/v1alpha1/helmreleasev2exportsspec.go new file mode 100644 index 0000000..3393985 --- /dev/null +++ b/pkg/generated/applyconfiguration/provisioning/v1alpha1/helmreleasev2exportsspec.go @@ -0,0 +1,48 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1alpha1 + +// HelmReleaseV2ExportsSpecApplyConfiguration represents an declarative configuration of the HelmReleaseV2ExportsSpec type for use +// with apply. +type HelmReleaseV2ExportsSpecApplyConfiguration struct { + Domain *string `json:"domain,omitempty"` + ReleaseName *ValueExportApplyConfiguration `json:"releaseName,omitempty"` +} + +// HelmReleaseV2ExportsSpecApplyConfiguration constructs an declarative configuration of the HelmReleaseV2ExportsSpec type for use with +// apply. +func HelmReleaseV2ExportsSpec() *HelmReleaseV2ExportsSpecApplyConfiguration { + return &HelmReleaseV2ExportsSpecApplyConfiguration{} +} + +// WithDomain sets the Domain field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Domain field is set to the value of the last call. +func (b *HelmReleaseV2ExportsSpecApplyConfiguration) WithDomain(value string) *HelmReleaseV2ExportsSpecApplyConfiguration { + b.Domain = &value + return b +} + +// WithReleaseName sets the ReleaseName field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the ReleaseName field is set to the value of the last call. +func (b *HelmReleaseV2ExportsSpecApplyConfiguration) WithReleaseName(value *ValueExportApplyConfiguration) *HelmReleaseV2ExportsSpecApplyConfiguration { + b.ReleaseName = value + return b +} diff --git a/pkg/generated/applyconfiguration/provisioning/v1alpha1/helmreleasev2spec.go b/pkg/generated/applyconfiguration/provisioning/v1alpha1/helmreleasev2spec.go new file mode 100644 index 0000000..09da55a --- /dev/null +++ b/pkg/generated/applyconfiguration/provisioning/v1alpha1/helmreleasev2spec.go @@ -0,0 +1,110 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1alpha1 + +import ( + v2 "github.com/fluxcd/helm-controller/api/v2" + v1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1" +) + +// HelmReleaseV2SpecApplyConfiguration represents an declarative configuration of the HelmReleaseV2Spec type for use +// with apply. +type HelmReleaseV2SpecApplyConfiguration struct { + Release *v2.HelmReleaseSpec `json:"release,omitempty"` + Exports []HelmReleaseV2ExportsSpecApplyConfiguration `json:"exports,omitempty"` + ProvisioningMetaApplyConfiguration `json:",inline"` +} + +// HelmReleaseV2SpecApplyConfiguration constructs an declarative configuration of the HelmReleaseV2Spec type for use with +// apply. +func HelmReleaseV2Spec() *HelmReleaseV2SpecApplyConfiguration { + return &HelmReleaseV2SpecApplyConfiguration{} +} + +// WithRelease sets the Release field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Release field is set to the value of the last call. +func (b *HelmReleaseV2SpecApplyConfiguration) WithRelease(value v2.HelmReleaseSpec) *HelmReleaseV2SpecApplyConfiguration { + b.Release = &value + return b +} + +// WithExports adds the given value to the Exports field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, values provided by each call will be appended to the Exports field. +func (b *HelmReleaseV2SpecApplyConfiguration) WithExports(values ...*HelmReleaseV2ExportsSpecApplyConfiguration) *HelmReleaseV2SpecApplyConfiguration { + for i := range values { + if values[i] == nil { + panic("nil value passed to WithExports") + } + b.Exports = append(b.Exports, *values[i]) + } + return b +} + +// WithPlatformRef sets the PlatformRef field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the PlatformRef field is set to the value of the last call. +func (b *HelmReleaseV2SpecApplyConfiguration) WithPlatformRef(value string) *HelmReleaseV2SpecApplyConfiguration { + b.PlatformRef = &value + return b +} + +// WithDomainRef sets the DomainRef field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the DomainRef field is set to the value of the last call. +func (b *HelmReleaseV2SpecApplyConfiguration) WithDomainRef(value string) *HelmReleaseV2SpecApplyConfiguration { + b.DomainRef = &value + return b +} + +// WithTenantOverrides puts the entries into the TenantOverrides field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, the entries provided by each call will be put on the TenantOverrides field, +// overwriting an existing map entries in TenantOverrides field with the same key. +func (b *HelmReleaseV2SpecApplyConfiguration) WithTenantOverrides(entries map[string]*v1.JSON) *HelmReleaseV2SpecApplyConfiguration { + if b.TenantOverrides == nil && len(entries) > 0 { + b.TenantOverrides = make(map[string]*v1.JSON, len(entries)) + } + for k, v := range entries { + b.TenantOverrides[k] = v + } + return b +} + +// WithTarget sets the Target field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Target field is set to the value of the last call. +func (b *HelmReleaseV2SpecApplyConfiguration) WithTarget(value *ProvisioningTargetApplyConfiguration) *HelmReleaseV2SpecApplyConfiguration { + b.Target = value + return b +} + +// WithDependsOn adds the given value to the DependsOn field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, values provided by each call will be appended to the DependsOn field. +func (b *HelmReleaseV2SpecApplyConfiguration) WithDependsOn(values ...*ProvisioningResourceIdendtifierApplyConfiguration) *HelmReleaseV2SpecApplyConfiguration { + for i := range values { + if values[i] == nil { + panic("nil value passed to WithDependsOn") + } + b.DependsOn = append(b.DependsOn, *values[i]) + } + return b +} diff --git a/pkg/generated/applyconfiguration/utils.go b/pkg/generated/applyconfiguration/utils.go index c1a2fbf..44b62ee 100644 --- a/pkg/generated/applyconfiguration/utils.go +++ b/pkg/generated/applyconfiguration/utils.go @@ -125,6 +125,12 @@ func ForKind(kind schema.GroupVersionKind) interface{} { return &applyconfigurationprovisioningv1alpha1.HelmReleaseExportsSpecApplyConfiguration{} case provisioningv1alpha1.SchemeGroupVersion.WithKind("HelmReleaseSpec"): return &applyconfigurationprovisioningv1alpha1.HelmReleaseSpecApplyConfiguration{} + case provisioningv1alpha1.SchemeGroupVersion.WithKind("HelmReleaseV2"): + return &applyconfigurationprovisioningv1alpha1.HelmReleaseV2ApplyConfiguration{} + case provisioningv1alpha1.SchemeGroupVersion.WithKind("HelmReleaseV2ExportsSpec"): + return &applyconfigurationprovisioningv1alpha1.HelmReleaseV2ExportsSpecApplyConfiguration{} + case provisioningv1alpha1.SchemeGroupVersion.WithKind("HelmReleaseV2Spec"): + return &applyconfigurationprovisioningv1alpha1.HelmReleaseV2SpecApplyConfiguration{} case provisioningv1alpha1.SchemeGroupVersion.WithKind("InitScriptArgs"): return &applyconfigurationprovisioningv1alpha1.InitScriptArgsApplyConfiguration{} case provisioningv1alpha1.SchemeGroupVersion.WithKind("KubeSecretTemplate"): diff --git a/pkg/generated/clientset/versioned/typed/provisioning/v1alpha1/fake/fake_helmreleasev2.go b/pkg/generated/clientset/versioned/typed/provisioning/v1alpha1/fake/fake_helmreleasev2.go new file mode 100644 index 0000000..bf780bd --- /dev/null +++ b/pkg/generated/clientset/versioned/typed/provisioning/v1alpha1/fake/fake_helmreleasev2.go @@ -0,0 +1,154 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by client-gen. DO NOT EDIT. + +package fake + +import ( + "context" + json "encoding/json" + "fmt" + + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + labels "k8s.io/apimachinery/pkg/labels" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + testing "k8s.io/client-go/testing" + v1alpha1 "totalsoft.ro/platform-controllers/pkg/apis/provisioning/v1alpha1" + provisioningv1alpha1 "totalsoft.ro/platform-controllers/pkg/generated/applyconfiguration/provisioning/v1alpha1" +) + +// FakeHelmReleaseV2s implements HelmReleaseV2Interface +type FakeHelmReleaseV2s struct { + Fake *FakeProvisioningV1alpha1 + ns string +} + +var helmreleasev2sResource = v1alpha1.SchemeGroupVersion.WithResource("helmreleasev2s") + +var helmreleasev2sKind = v1alpha1.SchemeGroupVersion.WithKind("HelmReleaseV2") + +// Get takes name of the helmReleaseV2, and returns the corresponding helmReleaseV2 object, and an error if there is any. +func (c *FakeHelmReleaseV2s) Get(ctx context.Context, name string, options v1.GetOptions) (result *v1alpha1.HelmReleaseV2, err error) { + obj, err := c.Fake. + Invokes(testing.NewGetAction(helmreleasev2sResource, c.ns, name), &v1alpha1.HelmReleaseV2{}) + + if obj == nil { + return nil, err + } + return obj.(*v1alpha1.HelmReleaseV2), err +} + +// List takes label and field selectors, and returns the list of HelmReleaseV2s that match those selectors. +func (c *FakeHelmReleaseV2s) List(ctx context.Context, opts v1.ListOptions) (result *v1alpha1.HelmReleaseV2List, err error) { + obj, err := c.Fake. + Invokes(testing.NewListAction(helmreleasev2sResource, helmreleasev2sKind, c.ns, opts), &v1alpha1.HelmReleaseV2List{}) + + if obj == nil { + return nil, err + } + + label, _, _ := testing.ExtractFromListOptions(opts) + if label == nil { + label = labels.Everything() + } + list := &v1alpha1.HelmReleaseV2List{ListMeta: obj.(*v1alpha1.HelmReleaseV2List).ListMeta} + for _, item := range obj.(*v1alpha1.HelmReleaseV2List).Items { + if label.Matches(labels.Set(item.Labels)) { + list.Items = append(list.Items, item) + } + } + return list, err +} + +// Watch returns a watch.Interface that watches the requested helmReleaseV2s. +func (c *FakeHelmReleaseV2s) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) { + return c.Fake. + InvokesWatch(testing.NewWatchAction(helmreleasev2sResource, c.ns, opts)) + +} + +// Create takes the representation of a helmReleaseV2 and creates it. Returns the server's representation of the helmReleaseV2, and an error, if there is any. +func (c *FakeHelmReleaseV2s) Create(ctx context.Context, helmReleaseV2 *v1alpha1.HelmReleaseV2, opts v1.CreateOptions) (result *v1alpha1.HelmReleaseV2, err error) { + obj, err := c.Fake. + Invokes(testing.NewCreateAction(helmreleasev2sResource, c.ns, helmReleaseV2), &v1alpha1.HelmReleaseV2{}) + + if obj == nil { + return nil, err + } + return obj.(*v1alpha1.HelmReleaseV2), err +} + +// Update takes the representation of a helmReleaseV2 and updates it. Returns the server's representation of the helmReleaseV2, and an error, if there is any. +func (c *FakeHelmReleaseV2s) Update(ctx context.Context, helmReleaseV2 *v1alpha1.HelmReleaseV2, opts v1.UpdateOptions) (result *v1alpha1.HelmReleaseV2, err error) { + obj, err := c.Fake. + Invokes(testing.NewUpdateAction(helmreleasev2sResource, c.ns, helmReleaseV2), &v1alpha1.HelmReleaseV2{}) + + if obj == nil { + return nil, err + } + return obj.(*v1alpha1.HelmReleaseV2), err +} + +// Delete takes name of the helmReleaseV2 and deletes it. Returns an error if one occurs. +func (c *FakeHelmReleaseV2s) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error { + _, err := c.Fake. + Invokes(testing.NewDeleteActionWithOptions(helmreleasev2sResource, c.ns, name, opts), &v1alpha1.HelmReleaseV2{}) + + return err +} + +// DeleteCollection deletes a collection of objects. +func (c *FakeHelmReleaseV2s) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error { + action := testing.NewDeleteCollectionAction(helmreleasev2sResource, c.ns, listOpts) + + _, err := c.Fake.Invokes(action, &v1alpha1.HelmReleaseV2List{}) + return err +} + +// Patch applies the patch and returns the patched helmReleaseV2. +func (c *FakeHelmReleaseV2s) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1alpha1.HelmReleaseV2, err error) { + obj, err := c.Fake. + Invokes(testing.NewPatchSubresourceAction(helmreleasev2sResource, c.ns, name, pt, data, subresources...), &v1alpha1.HelmReleaseV2{}) + + if obj == nil { + return nil, err + } + return obj.(*v1alpha1.HelmReleaseV2), err +} + +// Apply takes the given apply declarative configuration, applies it and returns the applied helmReleaseV2. +func (c *FakeHelmReleaseV2s) Apply(ctx context.Context, helmReleaseV2 *provisioningv1alpha1.HelmReleaseV2ApplyConfiguration, opts v1.ApplyOptions) (result *v1alpha1.HelmReleaseV2, err error) { + if helmReleaseV2 == nil { + return nil, fmt.Errorf("helmReleaseV2 provided to Apply must not be nil") + } + data, err := json.Marshal(helmReleaseV2) + if err != nil { + return nil, err + } + name := helmReleaseV2.Name + if name == nil { + return nil, fmt.Errorf("helmReleaseV2.Name must be provided to Apply") + } + obj, err := c.Fake. + Invokes(testing.NewPatchSubresourceAction(helmreleasev2sResource, c.ns, *name, types.ApplyPatchType, data), &v1alpha1.HelmReleaseV2{}) + + if obj == nil { + return nil, err + } + return obj.(*v1alpha1.HelmReleaseV2), err +} diff --git a/pkg/generated/clientset/versioned/typed/provisioning/v1alpha1/fake/fake_provisioning_client.go b/pkg/generated/clientset/versioned/typed/provisioning/v1alpha1/fake/fake_provisioning_client.go index 0431695..7e0fe5d 100644 --- a/pkg/generated/clientset/versioned/typed/provisioning/v1alpha1/fake/fake_provisioning_client.go +++ b/pkg/generated/clientset/versioned/typed/provisioning/v1alpha1/fake/fake_provisioning_client.go @@ -56,6 +56,10 @@ func (c *FakeProvisioningV1alpha1) HelmReleases(namespace string) v1alpha1.HelmR return &FakeHelmReleases{c, namespace} } +func (c *FakeProvisioningV1alpha1) HelmReleaseV2s(namespace string) v1alpha1.HelmReleaseV2Interface { + return &FakeHelmReleaseV2s{c, namespace} +} + func (c *FakeProvisioningV1alpha1) LocalScripts(namespace string) v1alpha1.LocalScriptInterface { return &FakeLocalScripts{c, namespace} } diff --git a/pkg/generated/clientset/versioned/typed/provisioning/v1alpha1/generated_expansion.go b/pkg/generated/clientset/versioned/typed/provisioning/v1alpha1/generated_expansion.go index 546dfe2..bfa641d 100644 --- a/pkg/generated/clientset/versioned/typed/provisioning/v1alpha1/generated_expansion.go +++ b/pkg/generated/clientset/versioned/typed/provisioning/v1alpha1/generated_expansion.go @@ -32,6 +32,8 @@ type EntraUserExpansion interface{} type HelmReleaseExpansion interface{} +type HelmReleaseV2Expansion interface{} + type LocalScriptExpansion interface{} type MinioBucketExpansion interface{} diff --git a/pkg/generated/clientset/versioned/typed/provisioning/v1alpha1/helmreleasev2.go b/pkg/generated/clientset/versioned/typed/provisioning/v1alpha1/helmreleasev2.go new file mode 100644 index 0000000..065d4c4 --- /dev/null +++ b/pkg/generated/clientset/versioned/typed/provisioning/v1alpha1/helmreleasev2.go @@ -0,0 +1,208 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by client-gen. DO NOT EDIT. + +package v1alpha1 + +import ( + "context" + json "encoding/json" + "fmt" + "time" + + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + rest "k8s.io/client-go/rest" + v1alpha1 "totalsoft.ro/platform-controllers/pkg/apis/provisioning/v1alpha1" + provisioningv1alpha1 "totalsoft.ro/platform-controllers/pkg/generated/applyconfiguration/provisioning/v1alpha1" + scheme "totalsoft.ro/platform-controllers/pkg/generated/clientset/versioned/scheme" +) + +// HelmReleaseV2sGetter has a method to return a HelmReleaseV2Interface. +// A group's client should implement this interface. +type HelmReleaseV2sGetter interface { + HelmReleaseV2s(namespace string) HelmReleaseV2Interface +} + +// HelmReleaseV2Interface has methods to work with HelmReleaseV2 resources. +type HelmReleaseV2Interface interface { + Create(ctx context.Context, helmReleaseV2 *v1alpha1.HelmReleaseV2, opts v1.CreateOptions) (*v1alpha1.HelmReleaseV2, error) + Update(ctx context.Context, helmReleaseV2 *v1alpha1.HelmReleaseV2, opts v1.UpdateOptions) (*v1alpha1.HelmReleaseV2, error) + Delete(ctx context.Context, name string, opts v1.DeleteOptions) error + DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error + Get(ctx context.Context, name string, opts v1.GetOptions) (*v1alpha1.HelmReleaseV2, error) + List(ctx context.Context, opts v1.ListOptions) (*v1alpha1.HelmReleaseV2List, error) + Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) + Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1alpha1.HelmReleaseV2, err error) + Apply(ctx context.Context, helmReleaseV2 *provisioningv1alpha1.HelmReleaseV2ApplyConfiguration, opts v1.ApplyOptions) (result *v1alpha1.HelmReleaseV2, err error) + HelmReleaseV2Expansion +} + +// helmReleaseV2s implements HelmReleaseV2Interface +type helmReleaseV2s struct { + client rest.Interface + ns string +} + +// newHelmReleaseV2s returns a HelmReleaseV2s +func newHelmReleaseV2s(c *ProvisioningV1alpha1Client, namespace string) *helmReleaseV2s { + return &helmReleaseV2s{ + client: c.RESTClient(), + ns: namespace, + } +} + +// Get takes name of the helmReleaseV2, and returns the corresponding helmReleaseV2 object, and an error if there is any. +func (c *helmReleaseV2s) Get(ctx context.Context, name string, options v1.GetOptions) (result *v1alpha1.HelmReleaseV2, err error) { + result = &v1alpha1.HelmReleaseV2{} + err = c.client.Get(). + Namespace(c.ns). + Resource("helmreleasev2s"). + Name(name). + VersionedParams(&options, scheme.ParameterCodec). + Do(ctx). + Into(result) + return +} + +// List takes label and field selectors, and returns the list of HelmReleaseV2s that match those selectors. +func (c *helmReleaseV2s) List(ctx context.Context, opts v1.ListOptions) (result *v1alpha1.HelmReleaseV2List, err error) { + var timeout time.Duration + if opts.TimeoutSeconds != nil { + timeout = time.Duration(*opts.TimeoutSeconds) * time.Second + } + result = &v1alpha1.HelmReleaseV2List{} + err = c.client.Get(). + Namespace(c.ns). + Resource("helmreleasev2s"). + VersionedParams(&opts, scheme.ParameterCodec). + Timeout(timeout). + Do(ctx). + Into(result) + return +} + +// Watch returns a watch.Interface that watches the requested helmReleaseV2s. +func (c *helmReleaseV2s) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) { + var timeout time.Duration + if opts.TimeoutSeconds != nil { + timeout = time.Duration(*opts.TimeoutSeconds) * time.Second + } + opts.Watch = true + return c.client.Get(). + Namespace(c.ns). + Resource("helmreleasev2s"). + VersionedParams(&opts, scheme.ParameterCodec). + Timeout(timeout). + Watch(ctx) +} + +// Create takes the representation of a helmReleaseV2 and creates it. Returns the server's representation of the helmReleaseV2, and an error, if there is any. +func (c *helmReleaseV2s) Create(ctx context.Context, helmReleaseV2 *v1alpha1.HelmReleaseV2, opts v1.CreateOptions) (result *v1alpha1.HelmReleaseV2, err error) { + result = &v1alpha1.HelmReleaseV2{} + err = c.client.Post(). + Namespace(c.ns). + Resource("helmreleasev2s"). + VersionedParams(&opts, scheme.ParameterCodec). + Body(helmReleaseV2). + Do(ctx). + Into(result) + return +} + +// Update takes the representation of a helmReleaseV2 and updates it. Returns the server's representation of the helmReleaseV2, and an error, if there is any. +func (c *helmReleaseV2s) Update(ctx context.Context, helmReleaseV2 *v1alpha1.HelmReleaseV2, opts v1.UpdateOptions) (result *v1alpha1.HelmReleaseV2, err error) { + result = &v1alpha1.HelmReleaseV2{} + err = c.client.Put(). + Namespace(c.ns). + Resource("helmreleasev2s"). + Name(helmReleaseV2.Name). + VersionedParams(&opts, scheme.ParameterCodec). + Body(helmReleaseV2). + Do(ctx). + Into(result) + return +} + +// Delete takes name of the helmReleaseV2 and deletes it. Returns an error if one occurs. +func (c *helmReleaseV2s) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error { + return c.client.Delete(). + Namespace(c.ns). + Resource("helmreleasev2s"). + Name(name). + Body(&opts). + Do(ctx). + Error() +} + +// DeleteCollection deletes a collection of objects. +func (c *helmReleaseV2s) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error { + var timeout time.Duration + if listOpts.TimeoutSeconds != nil { + timeout = time.Duration(*listOpts.TimeoutSeconds) * time.Second + } + return c.client.Delete(). + Namespace(c.ns). + Resource("helmreleasev2s"). + VersionedParams(&listOpts, scheme.ParameterCodec). + Timeout(timeout). + Body(&opts). + Do(ctx). + Error() +} + +// Patch applies the patch and returns the patched helmReleaseV2. +func (c *helmReleaseV2s) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1alpha1.HelmReleaseV2, err error) { + result = &v1alpha1.HelmReleaseV2{} + err = c.client.Patch(pt). + Namespace(c.ns). + Resource("helmreleasev2s"). + Name(name). + SubResource(subresources...). + VersionedParams(&opts, scheme.ParameterCodec). + Body(data). + Do(ctx). + Into(result) + return +} + +// Apply takes the given apply declarative configuration, applies it and returns the applied helmReleaseV2. +func (c *helmReleaseV2s) Apply(ctx context.Context, helmReleaseV2 *provisioningv1alpha1.HelmReleaseV2ApplyConfiguration, opts v1.ApplyOptions) (result *v1alpha1.HelmReleaseV2, err error) { + if helmReleaseV2 == nil { + return nil, fmt.Errorf("helmReleaseV2 provided to Apply must not be nil") + } + patchOpts := opts.ToPatchOptions() + data, err := json.Marshal(helmReleaseV2) + if err != nil { + return nil, err + } + name := helmReleaseV2.Name + if name == nil { + return nil, fmt.Errorf("helmReleaseV2.Name must be provided to Apply") + } + result = &v1alpha1.HelmReleaseV2{} + err = c.client.Patch(types.ApplyPatchType). + Namespace(c.ns). + Resource("helmreleasev2s"). + Name(*name). + VersionedParams(&patchOpts, scheme.ParameterCodec). + Body(data). + Do(ctx). + Into(result) + return +} diff --git a/pkg/generated/clientset/versioned/typed/provisioning/v1alpha1/provisioning_client.go b/pkg/generated/clientset/versioned/typed/provisioning/v1alpha1/provisioning_client.go index 8c673bd..b9c62ba 100644 --- a/pkg/generated/clientset/versioned/typed/provisioning/v1alpha1/provisioning_client.go +++ b/pkg/generated/clientset/versioned/typed/provisioning/v1alpha1/provisioning_client.go @@ -35,6 +35,7 @@ type ProvisioningV1alpha1Interface interface { AzureVirtualMachinesGetter EntraUsersGetter HelmReleasesGetter + HelmReleaseV2sGetter LocalScriptsGetter MinioBucketsGetter MsSqlDatabasesGetter @@ -73,6 +74,10 @@ func (c *ProvisioningV1alpha1Client) HelmReleases(namespace string) HelmReleaseI return newHelmReleases(c, namespace) } +func (c *ProvisioningV1alpha1Client) HelmReleaseV2s(namespace string) HelmReleaseV2Interface { + return newHelmReleaseV2s(c, namespace) +} + func (c *ProvisioningV1alpha1Client) LocalScripts(namespace string) LocalScriptInterface { return newLocalScripts(c, namespace) } diff --git a/pkg/generated/informers/externalversions/generic.go b/pkg/generated/informers/externalversions/generic.go index 81985be..36cab0a 100644 --- a/pkg/generated/informers/externalversions/generic.go +++ b/pkg/generated/informers/externalversions/generic.go @@ -83,6 +83,8 @@ func (f *sharedInformerFactory) ForResource(resource schema.GroupVersionResource return &genericInformer{resource: resource.GroupResource(), informer: f.Provisioning().V1alpha1().EntraUsers().Informer()}, nil case provisioningv1alpha1.SchemeGroupVersion.WithResource("helmreleases"): return &genericInformer{resource: resource.GroupResource(), informer: f.Provisioning().V1alpha1().HelmReleases().Informer()}, nil + case provisioningv1alpha1.SchemeGroupVersion.WithResource("helmreleasev2s"): + return &genericInformer{resource: resource.GroupResource(), informer: f.Provisioning().V1alpha1().HelmReleaseV2s().Informer()}, nil case provisioningv1alpha1.SchemeGroupVersion.WithResource("localscripts"): return &genericInformer{resource: resource.GroupResource(), informer: f.Provisioning().V1alpha1().LocalScripts().Informer()}, nil case provisioningv1alpha1.SchemeGroupVersion.WithResource("miniobuckets"): diff --git a/pkg/generated/informers/externalversions/provisioning/v1alpha1/helmreleasev2.go b/pkg/generated/informers/externalversions/provisioning/v1alpha1/helmreleasev2.go new file mode 100644 index 0000000..73f5ca0 --- /dev/null +++ b/pkg/generated/informers/externalversions/provisioning/v1alpha1/helmreleasev2.go @@ -0,0 +1,90 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by informer-gen. DO NOT EDIT. + +package v1alpha1 + +import ( + "context" + time "time" + + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + runtime "k8s.io/apimachinery/pkg/runtime" + watch "k8s.io/apimachinery/pkg/watch" + cache "k8s.io/client-go/tools/cache" + provisioningv1alpha1 "totalsoft.ro/platform-controllers/pkg/apis/provisioning/v1alpha1" + versioned "totalsoft.ro/platform-controllers/pkg/generated/clientset/versioned" + internalinterfaces "totalsoft.ro/platform-controllers/pkg/generated/informers/externalversions/internalinterfaces" + v1alpha1 "totalsoft.ro/platform-controllers/pkg/generated/listers/provisioning/v1alpha1" +) + +// HelmReleaseV2Informer provides access to a shared informer and lister for +// HelmReleaseV2s. +type HelmReleaseV2Informer interface { + Informer() cache.SharedIndexInformer + Lister() v1alpha1.HelmReleaseV2Lister +} + +type helmReleaseV2Informer struct { + factory internalinterfaces.SharedInformerFactory + tweakListOptions internalinterfaces.TweakListOptionsFunc + namespace string +} + +// NewHelmReleaseV2Informer constructs a new informer for HelmReleaseV2 type. +// Always prefer using an informer factory to get a shared informer instead of getting an independent +// one. This reduces memory footprint and number of connections to the server. +func NewHelmReleaseV2Informer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer { + return NewFilteredHelmReleaseV2Informer(client, namespace, resyncPeriod, indexers, nil) +} + +// NewFilteredHelmReleaseV2Informer constructs a new informer for HelmReleaseV2 type. +// Always prefer using an informer factory to get a shared informer instead of getting an independent +// one. This reduces memory footprint and number of connections to the server. +func NewFilteredHelmReleaseV2Informer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer { + return cache.NewSharedIndexInformer( + &cache.ListWatch{ + ListFunc: func(options v1.ListOptions) (runtime.Object, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.ProvisioningV1alpha1().HelmReleaseV2s(namespace).List(context.TODO(), options) + }, + WatchFunc: func(options v1.ListOptions) (watch.Interface, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.ProvisioningV1alpha1().HelmReleaseV2s(namespace).Watch(context.TODO(), options) + }, + }, + &provisioningv1alpha1.HelmReleaseV2{}, + resyncPeriod, + indexers, + ) +} + +func (f *helmReleaseV2Informer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer { + return NewFilteredHelmReleaseV2Informer(client, f.namespace, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions) +} + +func (f *helmReleaseV2Informer) Informer() cache.SharedIndexInformer { + return f.factory.InformerFor(&provisioningv1alpha1.HelmReleaseV2{}, f.defaultInformer) +} + +func (f *helmReleaseV2Informer) Lister() v1alpha1.HelmReleaseV2Lister { + return v1alpha1.NewHelmReleaseV2Lister(f.Informer().GetIndexer()) +} diff --git a/pkg/generated/informers/externalversions/provisioning/v1alpha1/interface.go b/pkg/generated/informers/externalversions/provisioning/v1alpha1/interface.go index 252cec8..d1c1a44 100644 --- a/pkg/generated/informers/externalversions/provisioning/v1alpha1/interface.go +++ b/pkg/generated/informers/externalversions/provisioning/v1alpha1/interface.go @@ -38,6 +38,8 @@ type Interface interface { EntraUsers() EntraUserInformer // HelmReleases returns a HelmReleaseInformer. HelmReleases() HelmReleaseInformer + // HelmReleaseV2s returns a HelmReleaseV2Informer. + HelmReleaseV2s() HelmReleaseV2Informer // LocalScripts returns a LocalScriptInformer. LocalScripts() LocalScriptInformer // MinioBuckets returns a MinioBucketInformer. @@ -92,6 +94,11 @@ func (v *version) HelmReleases() HelmReleaseInformer { return &helmReleaseInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions} } +// HelmReleaseV2s returns a HelmReleaseV2Informer. +func (v *version) HelmReleaseV2s() HelmReleaseV2Informer { + return &helmReleaseV2Informer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions} +} + // LocalScripts returns a LocalScriptInformer. func (v *version) LocalScripts() LocalScriptInformer { return &localScriptInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions} diff --git a/pkg/generated/listers/provisioning/v1alpha1/expansion_generated.go b/pkg/generated/listers/provisioning/v1alpha1/expansion_generated.go index 68136c4..8982d3c 100644 --- a/pkg/generated/listers/provisioning/v1alpha1/expansion_generated.go +++ b/pkg/generated/listers/provisioning/v1alpha1/expansion_generated.go @@ -74,6 +74,14 @@ type HelmReleaseListerExpansion interface{} // HelmReleaseNamespaceLister. type HelmReleaseNamespaceListerExpansion interface{} +// HelmReleaseV2ListerExpansion allows custom methods to be added to +// HelmReleaseV2Lister. +type HelmReleaseV2ListerExpansion interface{} + +// HelmReleaseV2NamespaceListerExpansion allows custom methods to be added to +// HelmReleaseV2NamespaceLister. +type HelmReleaseV2NamespaceListerExpansion interface{} + // LocalScriptListerExpansion allows custom methods to be added to // LocalScriptLister. type LocalScriptListerExpansion interface{} diff --git a/pkg/generated/listers/provisioning/v1alpha1/helmreleasev2.go b/pkg/generated/listers/provisioning/v1alpha1/helmreleasev2.go new file mode 100644 index 0000000..54a6431 --- /dev/null +++ b/pkg/generated/listers/provisioning/v1alpha1/helmreleasev2.go @@ -0,0 +1,99 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by lister-gen. DO NOT EDIT. + +package v1alpha1 + +import ( + "k8s.io/apimachinery/pkg/api/errors" + "k8s.io/apimachinery/pkg/labels" + "k8s.io/client-go/tools/cache" + v1alpha1 "totalsoft.ro/platform-controllers/pkg/apis/provisioning/v1alpha1" +) + +// HelmReleaseV2Lister helps list HelmReleaseV2s. +// All objects returned here must be treated as read-only. +type HelmReleaseV2Lister interface { + // List lists all HelmReleaseV2s in the indexer. + // Objects returned here must be treated as read-only. + List(selector labels.Selector) (ret []*v1alpha1.HelmReleaseV2, err error) + // HelmReleaseV2s returns an object that can list and get HelmReleaseV2s. + HelmReleaseV2s(namespace string) HelmReleaseV2NamespaceLister + HelmReleaseV2ListerExpansion +} + +// helmReleaseV2Lister implements the HelmReleaseV2Lister interface. +type helmReleaseV2Lister struct { + indexer cache.Indexer +} + +// NewHelmReleaseV2Lister returns a new HelmReleaseV2Lister. +func NewHelmReleaseV2Lister(indexer cache.Indexer) HelmReleaseV2Lister { + return &helmReleaseV2Lister{indexer: indexer} +} + +// List lists all HelmReleaseV2s in the indexer. +func (s *helmReleaseV2Lister) List(selector labels.Selector) (ret []*v1alpha1.HelmReleaseV2, err error) { + err = cache.ListAll(s.indexer, selector, func(m interface{}) { + ret = append(ret, m.(*v1alpha1.HelmReleaseV2)) + }) + return ret, err +} + +// HelmReleaseV2s returns an object that can list and get HelmReleaseV2s. +func (s *helmReleaseV2Lister) HelmReleaseV2s(namespace string) HelmReleaseV2NamespaceLister { + return helmReleaseV2NamespaceLister{indexer: s.indexer, namespace: namespace} +} + +// HelmReleaseV2NamespaceLister helps list and get HelmReleaseV2s. +// All objects returned here must be treated as read-only. +type HelmReleaseV2NamespaceLister interface { + // List lists all HelmReleaseV2s in the indexer for a given namespace. + // Objects returned here must be treated as read-only. + List(selector labels.Selector) (ret []*v1alpha1.HelmReleaseV2, err error) + // Get retrieves the HelmReleaseV2 from the indexer for a given namespace and name. + // Objects returned here must be treated as read-only. + Get(name string) (*v1alpha1.HelmReleaseV2, error) + HelmReleaseV2NamespaceListerExpansion +} + +// helmReleaseV2NamespaceLister implements the HelmReleaseV2NamespaceLister +// interface. +type helmReleaseV2NamespaceLister struct { + indexer cache.Indexer + namespace string +} + +// List lists all HelmReleaseV2s in the indexer for a given namespace. +func (s helmReleaseV2NamespaceLister) List(selector labels.Selector) (ret []*v1alpha1.HelmReleaseV2, err error) { + err = cache.ListAllByNamespace(s.indexer, s.namespace, selector, func(m interface{}) { + ret = append(ret, m.(*v1alpha1.HelmReleaseV2)) + }) + return ret, err +} + +// Get retrieves the HelmReleaseV2 from the indexer for a given namespace and name. +func (s helmReleaseV2NamespaceLister) Get(name string) (*v1alpha1.HelmReleaseV2, error) { + obj, exists, err := s.indexer.GetByKey(s.namespace + "/" + name) + if err != nil { + return nil, err + } + if !exists { + return nil, errors.NewNotFound(v1alpha1.Resource("helmreleasev2"), name) + } + return obj.(*v1alpha1.HelmReleaseV2), nil +}