flux_crds/lib.rs
1// Generated by:
2// target/debug/k8s-crds-codegen
3
4pub mod helm_toolkit_fluxcd_io {
5 pub mod v2beta1 {
6 pub mod helm_release {
7 /// HelmRelease is the Schema for the helmreleases API
8 #[derive(serde::Deserialize, Debug, PartialEq)]
9 pub struct HelmRelease {
10 pub metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta,
11 pub spec: Spec,
12 pub status: Status,
13 }
14
15 impl k8s_openapi::Resource for HelmRelease {
16 type Scope = k8s_openapi::ClusterResourceScope;
17
18 const API_VERSION: &'static str = "helm.toolkit.fluxcd.io/v2beta1";
19 const GROUP: &'static str = "helm.toolkit.fluxcd.io";
20 const KIND: &'static str = "HelmRelease";
21 const VERSION: &'static str = "v2beta1";
22 const URL_PATH_SEGMENT: &'static str = "TODO";
23 }
24
25 impl k8s_openapi::Metadata for HelmRelease {
26 type Ty = k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta;
27
28 fn metadata(&self) -> &<Self as k8s_openapi::Metadata>::Ty {
29 &self.metadata
30 }
31
32 fn metadata_mut(&mut self) -> &mut <Self as k8s_openapi::Metadata>::Ty {
33 &mut self.metadata
34 }
35 }
36
37 impl serde::Serialize for HelmRelease {
38 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
39 where
40 S: serde::Serializer,
41 {
42 use serde::ser::SerializeStruct;
43 let mut state = serializer.serialize_struct("HelmRelease", 5)?;
44 state.serialize_field(
45 "apiVersion",
46 <Self as k8s_openapi::Resource>::API_VERSION,
47 )?;
48 state.serialize_field("kind", <Self as k8s_openapi::Resource>::KIND)?;
49 state.serialize_field("metadata", &self.metadata)?;
50 state.serialize_field("spec", &self.spec)?;
51 state.serialize_field("status", &self.status)?;
52 state.end()
53 }
54 }
55
56 /// Chart defines the template of the v1beta2.HelmChart that should be created for this HelmRelease.
57 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
58 #[serde(rename_all = "camelCase")]
59 pub struct Chart {
60 /// Spec holds the template for the v1beta2.HelmChartSpec for this HelmRelease.
61 pub spec: ChartSpec,
62 }
63
64 /// Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: "Available", "Progressing", and "Degraded" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type" protobuf:"bytes,1,rep,name=conditions"`
65 /// // other fields }
66 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
67 #[serde(rename_all = "camelCase")]
68 pub struct ConditionsItem {
69 /// 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.
70 pub last_transition_time: String,
71 /// message is a human readable message indicating details about the transition. This may be an empty string.
72 pub message: String,
73 /// 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.
74 pub observed_generation: i64,
75 /// 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.
76 pub reason: String,
77 /// status of the condition, one of True, False, Unknown.
78 pub status: String,
79 /// type of condition in CamelCase or in foo.example.com/CamelCase. --- Many .condition.type values are consistent across resources like Available, but because arbitrary conditions can be useful (see .node.status.conditions), the ability to deconflict is important. The regex it matches is (dns1123SubdomainFmt/)?(qualifiedNameFmt)
80 pub r#type: String,
81 }
82
83 /// NamespacedObjectReference contains enough information to locate the referenced Kubernetes resource object in any namespace.
84 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
85 #[serde(rename_all = "camelCase")]
86 pub struct DependsOnItem {
87 /// Name of the referent.
88 pub name: String,
89 /// Namespace of the referent, when not specified it acts as LocalObjectReference.
90 pub namespace: String,
91 }
92
93 /// Image contains an image name, a new name, a new tag or digest, which will replace the original name and tag.
94 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
95 #[serde(rename_all = "camelCase")]
96 pub struct ImagesItem {
97 /// Digest is the value used to replace the original image tag. If digest is present NewTag value is ignored.
98 pub digest: String,
99 /// Name is a tag-less image name.
100 pub name: String,
101 /// NewName is the value used to replace the original name.
102 pub new_name: String,
103 /// NewTag is the value used to replace the original tag.
104 pub new_tag: String,
105 }
106
107 /// Install holds the configuration for Helm install actions for this HelmRelease.
108 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
109 #[serde(rename_all = "camelCase")]
110 pub struct Install {
111 /// 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.
112 /// Skip: do neither install nor replace (update) any CRDs.
113 /// Create: new CRDs are created, existing CRDs are neither updated nor deleted.
114 /// CreateReplace: new CRDs are created, existing CRDs are updated (replaced) but not deleted.
115 /// 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.
116 pub crds: String,
117 /// 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.
118 pub create_namespace: bool,
119 /// DisableHooks prevents hooks from running during the Helm install action.
120 pub disable_hooks: bool,
121 /// DisableOpenAPIValidation prevents the Helm install action from validating rendered templates against the Kubernetes OpenAPI Schema.
122 pub disable_open_a_p_i_validation: bool,
123 /// DisableWait disables the waiting for resources to be ready after a Helm install has been performed.
124 pub disable_wait: bool,
125 /// DisableWaitForJobs disables waiting for jobs to complete after a Helm install has been performed.
126 pub disable_wait_for_jobs: bool,
127 /// Remediation holds the remediation configuration for when the Helm install action for the HelmRelease fails. The default is to not perform any action.
128 pub remediation: InstallRemediation,
129 /// 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.
130 pub replace: bool,
131 /// SkipCRDs tells the Helm install action to not install any CRDs. By default, CRDs are installed if not already present.
132 /// Deprecated use CRD policy (`crds`) attribute with value `Skip` instead.
133 pub skip_c_r_ds: bool,
134 /// 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'.
135 pub timeout: String,
136 }
137
138 /// 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.
139 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
140 #[serde(rename_all = "camelCase")]
141 pub struct KubeConfig {
142 /// SecretRef holds the name to a secret that contains a key with the kubeconfig file as the value. If no key is specified the key will default to 'value'. The secret must be in the same namespace as the HelmRelease. 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 the HelmRelease.
143 pub secret_ref: SecretRef,
144 }
145
146 /// Kustomization to apply as PostRenderer.
147 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
148 #[serde(rename_all = "camelCase")]
149 pub struct Kustomize {
150 /// 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.
151 pub images: Vec<ImagesItem>,
152 /// Strategic merge and JSON patches, defined as inline YAML objects, capable of targeting objects based on kind, label and annotation selectors.
153 pub patches: Vec<PatchesItem>,
154 /// JSON 6902 patches, defined as inline YAML objects.
155 pub patches_json6902: Vec<PatchesJson6902Item>,
156 /// Strategic merge patches, defined as inline YAML objects.
157 pub patches_strategic_merge: Vec<serde_json::Map<String, serde_json::Value>>,
158 }
159
160 /// JSON6902 is a JSON6902 operation object. https://datatracker.ietf.org/doc/html/rfc6902#section-4
161 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
162 #[serde(rename_all = "camelCase")]
163 pub struct PatchItem {
164 /// From contains a JSON-pointer value that references a location within the target document where the operation is performed. The meaning of the value depends on the value of Op, and is NOT taken into account by all operations.
165 pub from: String,
166 /// Op indicates the operation to perform. Its value MUST be one of "add", "remove", "replace", "move", "copy", or "test". https://datatracker.ietf.org/doc/html/rfc6902#section-4
167 pub op: String,
168 /// Path contains the JSON-pointer value that references a location within the target document where the operation is performed. The meaning of the value depends on the value of Op.
169 pub path: String,
170 /// Value contains a valid JSON structure. The meaning of the value depends on the value of Op, and is NOT taken into account by all operations.
171 pub value: serde_json::Map<String, serde_json::Value>,
172 }
173
174 /// Patch contains an inline StrategicMerge or JSON6902 patch, and the target the patch should be applied to.
175 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
176 #[serde(rename_all = "camelCase")]
177 pub struct PatchesItem {
178 /// Patch contains an inline StrategicMerge patch or an inline JSON6902 patch with an array of operation objects.
179 pub patch: String,
180 /// Target points to the resources that the patch document should be applied to.
181 pub target: PatchesItemTarget,
182 }
183
184 /// JSON6902Patch contains a JSON6902 patch and the target the patch should be applied to.
185 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
186 #[serde(rename_all = "camelCase")]
187 pub struct PatchesJson6902Item {
188 /// Patch contains the JSON6902 patch document with an array of operation objects.
189 pub patch: Vec<PatchItem>,
190 /// Target points to the resources that the patch document should be applied to.
191 pub target: PatchesJson6902ItemTarget,
192 }
193
194 /// PostRenderer contains a Helm PostRenderer specification.
195 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
196 #[serde(rename_all = "camelCase")]
197 pub struct PostRenderersItem {
198 /// Kustomization to apply as PostRenderer.
199 pub kustomize: Kustomize,
200 }
201
202 /// Remediation holds the remediation configuration for when the Helm install action for the HelmRelease fails. The default is to not perform any action.
203 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
204 #[serde(rename_all = "camelCase")]
205 pub struct InstallRemediation {
206 /// IgnoreTestFailures tells the controller to skip remediation when the Helm tests are run after an install action but fail. Defaults to 'Test.IgnoreFailures'.
207 pub ignore_test_failures: bool,
208 /// RemediateLastFailure tells the controller to remediate the last failure, when no retries remain. Defaults to 'false'.
209 pub remediate_last_failure: bool,
210 /// 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.
211 pub retries: i64,
212 }
213
214 /// Remediation holds the remediation configuration for when the Helm upgrade action for the HelmRelease fails. The default is to not perform any action.
215 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
216 #[serde(rename_all = "camelCase")]
217 pub struct UpgradeRemediation {
218 /// IgnoreTestFailures tells the controller to skip remediation when the Helm tests are run after an upgrade action but fail. Defaults to 'Test.IgnoreFailures'.
219 pub ignore_test_failures: bool,
220 /// RemediateLastFailure tells the controller to remediate the last failure, when no retries remain. Defaults to 'false' unless 'Retries' is greater than 0.
221 pub remediate_last_failure: bool,
222 /// 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.
223 pub retries: i64,
224 /// Strategy to use for failure remediation. Defaults to 'rollback'.
225 pub strategy: String,
226 }
227
228 /// Rollback holds the configuration for Helm rollback actions for this HelmRelease.
229 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
230 #[serde(rename_all = "camelCase")]
231 pub struct Rollback {
232 /// CleanupOnFail allows deletion of new resources created during the Helm rollback action when it fails.
233 pub cleanup_on_fail: bool,
234 /// DisableHooks prevents hooks from running during the Helm rollback action.
235 pub disable_hooks: bool,
236 /// DisableWait disables the waiting for resources to be ready after a Helm rollback has been performed.
237 pub disable_wait: bool,
238 /// DisableWaitForJobs disables waiting for jobs to complete after a Helm rollback has been performed.
239 pub disable_wait_for_jobs: bool,
240 /// Force forces resource updates through a replacement strategy.
241 pub force: bool,
242 /// Recreate performs pod restarts for the resource if applicable.
243 pub recreate: bool,
244 /// 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'.
245 pub timeout: String,
246 }
247
248 /// SecretRef holds the name to a secret that contains a key with the kubeconfig file as the value. If no key is specified the key will default to 'value'. The secret must be in the same namespace as the HelmRelease. 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 the HelmRelease.
249 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
250 #[serde(rename_all = "camelCase")]
251 pub struct SecretRef {
252 /// Key in the Secret, when not specified an implementation-specific default key is used.
253 pub key: String,
254 /// Name of the Secret.
255 pub name: String,
256 }
257
258 /// The name and namespace of the v1beta2.Source the chart is available at.
259 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
260 #[serde(rename_all = "camelCase")]
261 pub struct SourceRef {
262 /// APIVersion of the referent.
263 pub api_version: String,
264 /// Kind of the referent.
265 pub kind: String,
266 /// Name of the referent.
267 pub name: String,
268 /// Namespace of the referent.
269 pub namespace: String,
270 }
271
272 /// HelmReleaseSpec defines the desired state of a Helm release.
273 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
274 #[serde(rename_all = "camelCase")]
275 pub struct Spec {
276 /// Chart defines the template of the v1beta2.HelmChart that should be created for this HelmRelease.
277 pub chart: Chart,
278 /// DependsOn may contain a meta.NamespacedObjectReference slice with references to HelmRelease resources that must be ready before this HelmRelease can be reconciled.
279 pub depends_on: Vec<DependsOnItem>,
280 /// Install holds the configuration for Helm install actions for this HelmRelease.
281 pub install: Install,
282 /// Interval at which to reconcile the Helm release.
283 pub interval: String,
284 /// 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.
285 pub kube_config: KubeConfig,
286 /// MaxHistory is the number of revisions saved by Helm for this HelmRelease. Use '0' for an unlimited number of revisions; defaults to '10'.
287 pub max_history: i64,
288 /// PostRenderers holds an array of Helm PostRenderers, which will be applied in order of their definition.
289 pub post_renderers: Vec<PostRenderersItem>,
290 /// ReleaseName used for the Helm release. Defaults to a composition of '[TargetNamespace-]Name'.
291 pub release_name: String,
292 /// Rollback holds the configuration for Helm rollback actions for this HelmRelease.
293 pub rollback: Rollback,
294 /// The name of the Kubernetes service account to impersonate when reconciling this HelmRelease.
295 pub service_account_name: String,
296 /// StorageNamespace used for the Helm storage. Defaults to the namespace of the HelmRelease.
297 pub storage_namespace: String,
298 /// Suspend tells the controller to suspend reconciliation for this HelmRelease, it does not apply to already started reconciliations. Defaults to false.
299 pub suspend: bool,
300 /// TargetNamespace to target when performing operations for the HelmRelease. Defaults to the namespace of the HelmRelease.
301 pub target_namespace: String,
302 /// Test holds the configuration for Helm test actions for this HelmRelease.
303 pub test: Test,
304 /// 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'.
305 pub timeout: String,
306 /// Uninstall holds the configuration for Helm uninstall actions for this HelmRelease.
307 pub uninstall: Uninstall,
308 /// Upgrade holds the configuration for Helm upgrade actions for this HelmRelease.
309 pub upgrade: Upgrade,
310 /// Values holds the values for this Helm release.
311 pub values: serde_json::Map<String, serde_json::Value>,
312 /// ValuesFrom holds references to resources containing Helm values for this HelmRelease, and information about how they should be merged.
313 pub values_from: Vec<ValuesFromItem>,
314 }
315
316 /// Spec holds the template for the v1beta2.HelmChartSpec for this HelmRelease.
317 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
318 #[serde(rename_all = "camelCase")]
319 pub struct ChartSpec {
320 /// The name or path the Helm chart is available at in the SourceRef.
321 pub chart: String,
322 /// Interval at which to check the v1beta2.Source for updates. Defaults to 'HelmReleaseSpec.Interval'.
323 pub interval: String,
324 /// 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.
325 pub reconcile_strategy: String,
326 /// The name and namespace of the v1beta2.Source the chart is available at.
327 pub source_ref: SourceRef,
328 /// Alternative values file to use as the default chart values, expected to be a relative path in the SourceRef. Deprecated in favor of ValuesFiles, for backwards compatibility the file defined here is merged before the ValuesFiles items. Ignored when omitted.
329 pub values_file: String,
330 /// 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.
331 pub values_files: Vec<String>,
332 /// Version semver expression, ignored for charts from v1beta2.GitRepository and v1beta2.Bucket sources. Defaults to latest when omitted.
333 pub version: String,
334 }
335
336 /// HelmReleaseStatus defines the observed state of a HelmRelease.
337 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
338 #[serde(rename_all = "camelCase")]
339 pub struct Status {
340 /// Conditions holds the conditions for the HelmRelease.
341 pub conditions: Vec<ConditionsItem>,
342 /// Failures is the reconciliation failure count against the latest desired state. It is reset after a successful reconciliation.
343 pub failures: i64,
344 /// HelmChart is the namespaced name of the HelmChart resource created by the controller for the HelmRelease.
345 pub helm_chart: String,
346 /// InstallFailures is the install failure count against the latest desired state. It is reset after a successful reconciliation.
347 pub install_failures: i64,
348 /// LastAppliedRevision is the revision of the last successfully applied source.
349 pub last_applied_revision: String,
350 /// LastAttemptedRevision is the revision of the last reconciliation attempt.
351 pub last_attempted_revision: String,
352 /// LastAttemptedValuesChecksum is the SHA1 checksum of the values of the last reconciliation attempt.
353 pub last_attempted_values_checksum: String,
354 /// LastHandledReconcileAt holds the value of the most recent reconcile request value, so a change of the annotation value can be detected.
355 pub last_handled_reconcile_at: String,
356 /// LastReleaseRevision is the revision of the last successful Helm release.
357 pub last_release_revision: i64,
358 /// ObservedGeneration is the last observed generation.
359 pub observed_generation: i64,
360 /// UpgradeFailures is the upgrade failure count against the latest desired state. It is reset after a successful reconciliation.
361 pub upgrade_failures: i64,
362 }
363
364 /// Target points to the resources that the patch document should be applied to.
365 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
366 #[serde(rename_all = "camelCase")]
367 pub struct PatchesItemTarget {
368 /// 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.
369 pub annotation_selector: String,
370 /// 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
371 pub group: String,
372 /// 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
373 pub kind: String,
374 /// 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.
375 pub label_selector: String,
376 /// Name to match resources with.
377 pub name: String,
378 /// Namespace to select resources from.
379 pub namespace: String,
380 /// 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
381 pub version: String,
382 }
383
384 /// Target points to the resources that the patch document should be applied to.
385 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
386 #[serde(rename_all = "camelCase")]
387 pub struct PatchesJson6902ItemTarget {
388 /// 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.
389 pub annotation_selector: String,
390 /// 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
391 pub group: String,
392 /// 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
393 pub kind: String,
394 /// 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.
395 pub label_selector: String,
396 /// Name to match resources with.
397 pub name: String,
398 /// Namespace to select resources from.
399 pub namespace: String,
400 /// 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
401 pub version: String,
402 }
403
404 /// Test holds the configuration for Helm test actions for this HelmRelease.
405 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
406 #[serde(rename_all = "camelCase")]
407 pub struct Test {
408 /// Enable enables Helm test actions for this HelmRelease after an Helm install or upgrade action has been performed.
409 pub enable: bool,
410 /// 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'.
411 pub ignore_failures: bool,
412 /// Timeout is the time to wait for any individual Kubernetes operation during the performance of a Helm test action. Defaults to 'HelmReleaseSpec.Timeout'.
413 pub timeout: String,
414 }
415
416 /// Uninstall holds the configuration for Helm uninstall actions for this HelmRelease.
417 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
418 #[serde(rename_all = "camelCase")]
419 pub struct Uninstall {
420 /// DisableHooks prevents hooks from running during the Helm rollback action.
421 pub disable_hooks: bool,
422 /// DisableWait disables waiting for all the resources to be deleted after a Helm uninstall is performed.
423 pub disable_wait: bool,
424 /// KeepHistory tells Helm to remove all associated resources and mark the release as deleted, but retain the release history.
425 pub keep_history: bool,
426 /// 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'.
427 pub timeout: String,
428 }
429
430 /// Upgrade holds the configuration for Helm upgrade actions for this HelmRelease.
431 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
432 #[serde(rename_all = "camelCase")]
433 pub struct Upgrade {
434 /// CleanupOnFail allows deletion of new resources created during the Helm upgrade action when it fails.
435 pub cleanup_on_fail: bool,
436 /// 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.
437 /// Skip: do neither install nor replace (update) any CRDs.
438 /// Create: new CRDs are created, existing CRDs are neither updated nor deleted.
439 /// CreateReplace: new CRDs are created, existing CRDs are updated (replaced) but not deleted.
440 /// 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.
441 pub crds: String,
442 /// DisableHooks prevents hooks from running during the Helm upgrade action.
443 pub disable_hooks: bool,
444 /// DisableOpenAPIValidation prevents the Helm upgrade action from validating rendered templates against the Kubernetes OpenAPI Schema.
445 pub disable_open_a_p_i_validation: bool,
446 /// DisableWait disables the waiting for resources to be ready after a Helm upgrade has been performed.
447 pub disable_wait: bool,
448 /// DisableWaitForJobs disables waiting for jobs to complete after a Helm upgrade has been performed.
449 pub disable_wait_for_jobs: bool,
450 /// Force forces resource updates through a replacement strategy.
451 pub force: bool,
452 /// PreserveValues will make Helm reuse the last release's values and merge in overrides from 'Values'. Setting this flag makes the HelmRelease non-declarative.
453 pub preserve_values: bool,
454 /// Remediation holds the remediation configuration for when the Helm upgrade action for the HelmRelease fails. The default is to not perform any action.
455 pub remediation: UpgradeRemediation,
456 /// 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'.
457 pub timeout: String,
458 }
459
460 /// ValuesReference contains a reference to a resource containing Helm values, and optionally the key they can be found at.
461 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
462 #[serde(rename_all = "camelCase")]
463 pub struct ValuesFromItem {
464 /// Kind of the values referent, valid values are ('Secret', 'ConfigMap').
465 pub kind: String,
466 /// Name of the values referent. Should reside in the same namespace as the referring resource.
467 pub name: String,
468 /// 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.
469 pub optional: bool,
470 /// 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.
471 pub target_path: String,
472 /// ValuesKey is the data key where the values.yaml or a specific value can be found at. Defaults to 'values.yaml'.
473 pub values_key: String,
474 }
475 }
476 }
477}
478pub mod image_toolkit_fluxcd_io {
479 pub mod v1alpha1 {
480 pub mod image_policy {
481 /// ImagePolicy is the Schema for the imagepolicies API
482 #[derive(serde::Deserialize, Debug, PartialEq)]
483 pub struct ImagePolicy {
484 pub metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta,
485 pub spec: Spec,
486 pub status: Status,
487 }
488
489 impl k8s_openapi::Resource for ImagePolicy {
490 type Scope = k8s_openapi::ClusterResourceScope;
491
492 const API_VERSION: &'static str = "image.toolkit.fluxcd.io/v1alpha1";
493 const GROUP: &'static str = "image.toolkit.fluxcd.io";
494 const KIND: &'static str = "ImagePolicy";
495 const VERSION: &'static str = "v1alpha1";
496 const URL_PATH_SEGMENT: &'static str = "TODO";
497 }
498
499 impl k8s_openapi::Metadata for ImagePolicy {
500 type Ty = k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta;
501
502 fn metadata(&self) -> &<Self as k8s_openapi::Metadata>::Ty {
503 &self.metadata
504 }
505
506 fn metadata_mut(&mut self) -> &mut <Self as k8s_openapi::Metadata>::Ty {
507 &mut self.metadata
508 }
509 }
510
511 impl serde::Serialize for ImagePolicy {
512 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
513 where
514 S: serde::Serializer,
515 {
516 use serde::ser::SerializeStruct;
517 let mut state = serializer.serialize_struct("ImagePolicy", 5)?;
518 state.serialize_field(
519 "apiVersion",
520 <Self as k8s_openapi::Resource>::API_VERSION,
521 )?;
522 state.serialize_field("kind", <Self as k8s_openapi::Resource>::KIND)?;
523 state.serialize_field("metadata", &self.metadata)?;
524 state.serialize_field("spec", &self.spec)?;
525 state.serialize_field("status", &self.status)?;
526 state.end()
527 }
528 }
529
530 /// Alphabetical set of rules to use for alphabetical ordering of the tags.
531 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
532 #[serde(rename_all = "camelCase")]
533 pub struct Alphabetical {
534 /// Order specifies the sorting order of the tags. Given the letters of the alphabet as tags, ascending order would select Z, and descending order would select A.
535 pub order: String,
536 }
537
538 /// Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: "Available", "Progressing", and "Degraded" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type" protobuf:"bytes,1,rep,name=conditions"`
539 /// // other fields }
540 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
541 #[serde(rename_all = "camelCase")]
542 pub struct ConditionsItem {
543 /// 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.
544 pub last_transition_time: String,
545 /// message is a human readable message indicating details about the transition. This may be an empty string.
546 pub message: String,
547 /// 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.
548 pub observed_generation: i64,
549 /// 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.
550 pub reason: String,
551 /// status of the condition, one of True, False, Unknown.
552 pub status: String,
553 /// type of condition in CamelCase or in foo.example.com/CamelCase. --- Many .condition.type values are consistent across resources like Available, but because arbitrary conditions can be useful (see .node.status.conditions), the ability to deconflict is important. The regex it matches is (dns1123SubdomainFmt/)?(qualifiedNameFmt)
554 pub r#type: String,
555 }
556
557 /// FilterTags enables filtering for only a subset of tags based on a set of rules. If no rules are provided, all the tags from the repository will be ordered and compared.
558 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
559 #[serde(rename_all = "camelCase")]
560 pub struct FilterTags {
561 /// Extract allows a capture group to be extracted from the specified regular expression pattern, useful before tag evaluation.
562 pub extract: String,
563 /// Pattern specifies a regular expression pattern used to filter for image tags.
564 pub pattern: String,
565 }
566
567 /// ImageRepositoryRef points at the object specifying the image being scanned
568 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
569 #[serde(rename_all = "camelCase")]
570 pub struct ImageRepositoryRef {
571 /// Name of the referent.
572 pub name: String,
573 }
574
575 /// Numerical set of rules to use for numerical ordering of the tags.
576 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
577 #[serde(rename_all = "camelCase")]
578 pub struct Numerical {
579 /// Order specifies the sorting order of the tags. Given the integer values from 0 to 9 as tags, ascending order would select 9, and descending order would select 0.
580 pub order: String,
581 }
582
583 /// Policy gives the particulars of the policy to be followed in selecting the most recent image
584 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
585 #[serde(rename_all = "camelCase")]
586 pub struct Policy {
587 /// Alphabetical set of rules to use for alphabetical ordering of the tags.
588 pub alphabetical: Alphabetical,
589 /// Numerical set of rules to use for numerical ordering of the tags.
590 pub numerical: Numerical,
591 /// SemVer gives a semantic version range to check against the tags available.
592 pub semver: Semver,
593 }
594
595 /// SemVer gives a semantic version range to check against the tags available.
596 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
597 #[serde(rename_all = "camelCase")]
598 pub struct Semver {
599 /// Range gives a semver range for the image tag; the highest version within the range that's a tag yields the latest image.
600 pub range: String,
601 }
602
603 /// ImagePolicySpec defines the parameters for calculating the ImagePolicy
604 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
605 #[serde(rename_all = "camelCase")]
606 pub struct Spec {
607 /// FilterTags enables filtering for only a subset of tags based on a set of rules. If no rules are provided, all the tags from the repository will be ordered and compared.
608 pub filter_tags: FilterTags,
609 /// ImageRepositoryRef points at the object specifying the image being scanned
610 pub image_repository_ref: ImageRepositoryRef,
611 /// Policy gives the particulars of the policy to be followed in selecting the most recent image
612 pub policy: Policy,
613 }
614
615 /// ImagePolicyStatus defines the observed state of ImagePolicy
616 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
617 #[serde(rename_all = "camelCase")]
618 pub struct Status {
619 pub conditions: Vec<ConditionsItem>,
620 /// LatestImage gives the first in the list of images scanned by the image repository, when filtered and ordered according to the policy.
621 pub latest_image: String,
622 pub observed_generation: i64,
623 }
624 }
625 pub mod image_repository {
626 /// ImageRepository is the Schema for the imagerepositories API
627 #[derive(serde::Deserialize, Debug, PartialEq)]
628 pub struct ImageRepository {
629 pub metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta,
630 pub spec: Spec,
631 pub status: Status,
632 }
633
634 impl k8s_openapi::Resource for ImageRepository {
635 type Scope = k8s_openapi::ClusterResourceScope;
636
637 const API_VERSION: &'static str = "image.toolkit.fluxcd.io/v1alpha1";
638 const GROUP: &'static str = "image.toolkit.fluxcd.io";
639 const KIND: &'static str = "ImageRepository";
640 const VERSION: &'static str = "v1alpha1";
641 const URL_PATH_SEGMENT: &'static str = "TODO";
642 }
643
644 impl k8s_openapi::Metadata for ImageRepository {
645 type Ty = k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta;
646
647 fn metadata(&self) -> &<Self as k8s_openapi::Metadata>::Ty {
648 &self.metadata
649 }
650
651 fn metadata_mut(&mut self) -> &mut <Self as k8s_openapi::Metadata>::Ty {
652 &mut self.metadata
653 }
654 }
655
656 impl serde::Serialize for ImageRepository {
657 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
658 where
659 S: serde::Serializer,
660 {
661 use serde::ser::SerializeStruct;
662 let mut state = serializer.serialize_struct("ImageRepository", 5)?;
663 state.serialize_field(
664 "apiVersion",
665 <Self as k8s_openapi::Resource>::API_VERSION,
666 )?;
667 state.serialize_field("kind", <Self as k8s_openapi::Resource>::KIND)?;
668 state.serialize_field("metadata", &self.metadata)?;
669 state.serialize_field("spec", &self.spec)?;
670 state.serialize_field("status", &self.status)?;
671 state.end()
672 }
673 }
674
675 /// CertSecretRef can be given the name of a secret containing either or both of
676 /// - a PEM-encoded client certificate (`certFile`) and private key (`keyFile`); - a PEM-encoded CA certificate (`caFile`)
677 /// and whichever are supplied, will be used for connecting to the registry. The client cert and key are useful if you are authenticating with a certificate; the CA cert is useful if you are using a self-signed server certificate.
678 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
679 #[serde(rename_all = "camelCase")]
680 pub struct CertSecretRef {
681 /// Name of the referent.
682 pub name: String,
683 }
684
685 /// Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: "Available", "Progressing", and "Degraded" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type" protobuf:"bytes,1,rep,name=conditions"`
686 /// // other fields }
687 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
688 #[serde(rename_all = "camelCase")]
689 pub struct ConditionsItem {
690 /// 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.
691 pub last_transition_time: String,
692 /// message is a human readable message indicating details about the transition. This may be an empty string.
693 pub message: String,
694 /// 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.
695 pub observed_generation: i64,
696 /// 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.
697 pub reason: String,
698 /// status of the condition, one of True, False, Unknown.
699 pub status: String,
700 /// type of condition in CamelCase or in foo.example.com/CamelCase. --- Many .condition.type values are consistent across resources like Available, but because arbitrary conditions can be useful (see .node.status.conditions), the ability to deconflict is important. The regex it matches is (dns1123SubdomainFmt/)?(qualifiedNameFmt)
701 pub r#type: String,
702 }
703
704 /// LastScanResult contains the number of fetched tags.
705 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
706 #[serde(rename_all = "camelCase")]
707 pub struct LastScanResult {
708 pub scan_time: String,
709 pub tag_count: i64,
710 }
711
712 /// SecretRef can be given the name of a secret containing credentials to use for the image registry. The secret should be created with `kubectl create secret docker-registry`, or the equivalent.
713 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
714 #[serde(rename_all = "camelCase")]
715 pub struct SecretRef {
716 /// Name of the referent.
717 pub name: String,
718 }
719
720 /// ImageRepositorySpec defines the parameters for scanning an image repository, e.g., `fluxcd/flux`.
721 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
722 #[serde(rename_all = "camelCase")]
723 pub struct Spec {
724 /// CertSecretRef can be given the name of a secret containing either or both of
725 /// - a PEM-encoded client certificate (`certFile`) and private key (`keyFile`); - a PEM-encoded CA certificate (`caFile`)
726 /// and whichever are supplied, will be used for connecting to the registry. The client cert and key are useful if you are authenticating with a certificate; the CA cert is useful if you are using a self-signed server certificate.
727 pub cert_secret_ref: CertSecretRef,
728 /// Image is the name of the image repository
729 pub image: String,
730 /// Interval is the length of time to wait between scans of the image repository.
731 pub interval: String,
732 /// SecretRef can be given the name of a secret containing credentials to use for the image registry. The secret should be created with `kubectl create secret docker-registry`, or the equivalent.
733 pub secret_ref: SecretRef,
734 /// This flag tells the controller to suspend subsequent image scans. It does not apply to already started scans. Defaults to false.
735 pub suspend: bool,
736 /// Timeout for image scanning. Defaults to 'Interval' duration.
737 pub timeout: String,
738 }
739
740 /// ImageRepositoryStatus defines the observed state of ImageRepository
741 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
742 #[serde(rename_all = "camelCase")]
743 pub struct Status {
744 /// CanonicalName is the name of the image repository with all the implied bits made explicit; e.g., `docker.io/library/alpine` rather than `alpine`.
745 pub canonical_image_name: String,
746 pub conditions: Vec<ConditionsItem>,
747 /// LastHandledReconcileAt holds the value of the most recent reconcile request value, so a change of the annotation value can be detected.
748 pub last_handled_reconcile_at: String,
749 /// LastScanResult contains the number of fetched tags.
750 pub last_scan_result: LastScanResult,
751 /// ObservedGeneration is the last reconciled generation.
752 pub observed_generation: i64,
753 }
754 }
755 pub mod image_update_automation {
756 /// ImageUpdateAutomation is the Schema for the imageupdateautomations API
757 #[derive(serde::Deserialize, Debug, PartialEq)]
758 pub struct ImageUpdateAutomation {
759 pub metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta,
760 pub spec: Spec,
761 pub status: Status,
762 }
763
764 impl k8s_openapi::Resource for ImageUpdateAutomation {
765 type Scope = k8s_openapi::ClusterResourceScope;
766
767 const API_VERSION: &'static str = "image.toolkit.fluxcd.io/v1alpha1";
768 const GROUP: &'static str = "image.toolkit.fluxcd.io";
769 const KIND: &'static str = "ImageUpdateAutomation";
770 const VERSION: &'static str = "v1alpha1";
771 const URL_PATH_SEGMENT: &'static str = "TODO";
772 }
773
774 impl k8s_openapi::Metadata for ImageUpdateAutomation {
775 type Ty = k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta;
776
777 fn metadata(&self) -> &<Self as k8s_openapi::Metadata>::Ty {
778 &self.metadata
779 }
780
781 fn metadata_mut(&mut self) -> &mut <Self as k8s_openapi::Metadata>::Ty {
782 &mut self.metadata
783 }
784 }
785
786 impl serde::Serialize for ImageUpdateAutomation {
787 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
788 where
789 S: serde::Serializer,
790 {
791 use serde::ser::SerializeStruct;
792 let mut state = serializer.serialize_struct("ImageUpdateAutomation", 5)?;
793 state.serialize_field(
794 "apiVersion",
795 <Self as k8s_openapi::Resource>::API_VERSION,
796 )?;
797 state.serialize_field("kind", <Self as k8s_openapi::Resource>::KIND)?;
798 state.serialize_field("metadata", &self.metadata)?;
799 state.serialize_field("spec", &self.spec)?;
800 state.serialize_field("status", &self.status)?;
801 state.end()
802 }
803 }
804
805 /// Checkout gives the parameters for cloning the git repository, ready to make changes.
806 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
807 #[serde(rename_all = "camelCase")]
808 pub struct Checkout {
809 /// Branch gives the branch to clone from the git repository. If `.spec.push` is not supplied, commits will also be pushed to this branch.
810 pub branch: String,
811 /// GitRepositoryRef refers to the resource giving access details to a git repository to update files in.
812 pub git_repository_ref: GitRepositoryRef,
813 }
814
815 /// Commit specifies how to commit to the git repository.
816 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
817 #[serde(rename_all = "camelCase")]
818 pub struct Commit {
819 /// AuthorEmail gives the email to provide when making a commit
820 pub author_email: String,
821 /// AuthorName gives the name to provide when making a commit
822 pub author_name: String,
823 /// MessageTemplate provides a template for the commit message, into which will be interpolated the details of the change made.
824 pub message_template: String,
825 /// SigningKey provides the option to sign commits with a GPG key
826 pub signing_key: SigningKey,
827 }
828
829 /// Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: "Available", "Progressing", and "Degraded" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type" protobuf:"bytes,1,rep,name=conditions"`
830 /// // other fields }
831 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
832 #[serde(rename_all = "camelCase")]
833 pub struct ConditionsItem {
834 /// 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.
835 pub last_transition_time: String,
836 /// message is a human readable message indicating details about the transition. This may be an empty string.
837 pub message: String,
838 /// 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.
839 pub observed_generation: i64,
840 /// 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.
841 pub reason: String,
842 /// status of the condition, one of True, False, Unknown.
843 pub status: String,
844 /// type of condition in CamelCase or in foo.example.com/CamelCase. --- Many .condition.type values are consistent across resources like Available, but because arbitrary conditions can be useful (see .node.status.conditions), the ability to deconflict is important. The regex it matches is (dns1123SubdomainFmt/)?(qualifiedNameFmt)
845 pub r#type: String,
846 }
847
848 /// GitRepositoryRef refers to the resource giving access details to a git repository to update files in.
849 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
850 #[serde(rename_all = "camelCase")]
851 pub struct GitRepositoryRef {
852 /// Name of the referent.
853 pub name: String,
854 }
855
856 /// Push specifies how and where to push commits made by the automation. If missing, commits are pushed (back) to `.spec.checkout.branch`.
857 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
858 #[serde(rename_all = "camelCase")]
859 pub struct Push {
860 /// Branch specifies that commits should be pushed to the branch named. The branch is created using `.spec.checkout.branch` as the starting point, if it doesn't already exist.
861 pub branch: String,
862 }
863
864 /// SecretRef holds the name to a secret that contains a 'git.asc' key corresponding to the ASCII Armored file containing the GPG signing keypair as the value. It must be in the same namespace as the ImageUpdateAutomation.
865 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
866 #[serde(rename_all = "camelCase")]
867 pub struct SecretRef {
868 /// Name of the referent.
869 pub name: String,
870 }
871
872 /// SigningKey provides the option to sign commits with a GPG key
873 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
874 #[serde(rename_all = "camelCase")]
875 pub struct SigningKey {
876 /// SecretRef holds the name to a secret that contains a 'git.asc' key corresponding to the ASCII Armored file containing the GPG signing keypair as the value. It must be in the same namespace as the ImageUpdateAutomation.
877 pub secret_ref: SecretRef,
878 }
879
880 /// ImageUpdateAutomationSpec defines the desired state of ImageUpdateAutomation
881 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
882 #[serde(rename_all = "camelCase")]
883 pub struct Spec {
884 /// Checkout gives the parameters for cloning the git repository, ready to make changes.
885 pub checkout: Checkout,
886 /// Commit specifies how to commit to the git repository.
887 pub commit: Commit,
888 /// Interval gives an lower bound for how often the automation run should be attempted.
889 pub interval: String,
890 /// Push specifies how and where to push commits made by the automation. If missing, commits are pushed (back) to `.spec.checkout.branch`.
891 pub push: Push,
892 /// Suspend tells the controller to not run this automation, until it is unset (or set to false). Defaults to false.
893 pub suspend: bool,
894 /// Update gives the specification for how to update the files in the repository. This can be left empty, to use the default value.
895 pub update: Update,
896 }
897
898 /// ImageUpdateAutomationStatus defines the observed state of ImageUpdateAutomation
899 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
900 #[serde(rename_all = "camelCase")]
901 pub struct Status {
902 pub conditions: Vec<ConditionsItem>,
903 /// LastAutomationRunTime records the last time the controller ran this automation through to completion (even if no updates were made).
904 pub last_automation_run_time: String,
905 /// LastHandledReconcileAt holds the value of the most recent reconcile request value, so a change of the annotation value can be detected.
906 pub last_handled_reconcile_at: String,
907 /// LastPushCommit records the SHA1 of the last commit made by the controller, for this automation object
908 pub last_push_commit: String,
909 /// LastPushTime records the time of the last pushed change.
910 pub last_push_time: String,
911 pub observed_generation: i64,
912 }
913
914 /// Update gives the specification for how to update the files in the repository. This can be left empty, to use the default value.
915 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
916 #[serde(rename_all = "camelCase")]
917 pub struct Update {
918 /// Path to the directory containing the manifests to be updated. Defaults to 'None', which translates to the root path of the GitRepositoryRef.
919 pub path: String,
920 /// Strategy names the strategy to be used.
921 pub strategy: String,
922 }
923 }
924 }
925 pub mod v1alpha2 {
926 pub mod image_policy {
927 /// ImagePolicy is the Schema for the imagepolicies API
928 #[derive(serde::Deserialize, Debug, PartialEq)]
929 pub struct ImagePolicy {
930 pub metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta,
931 pub spec: Spec,
932 pub status: Status,
933 }
934
935 impl k8s_openapi::Resource for ImagePolicy {
936 type Scope = k8s_openapi::ClusterResourceScope;
937
938 const API_VERSION: &'static str = "image.toolkit.fluxcd.io/v1alpha2";
939 const GROUP: &'static str = "image.toolkit.fluxcd.io";
940 const KIND: &'static str = "ImagePolicy";
941 const VERSION: &'static str = "v1alpha2";
942 const URL_PATH_SEGMENT: &'static str = "TODO";
943 }
944
945 impl k8s_openapi::Metadata for ImagePolicy {
946 type Ty = k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta;
947
948 fn metadata(&self) -> &<Self as k8s_openapi::Metadata>::Ty {
949 &self.metadata
950 }
951
952 fn metadata_mut(&mut self) -> &mut <Self as k8s_openapi::Metadata>::Ty {
953 &mut self.metadata
954 }
955 }
956
957 impl serde::Serialize for ImagePolicy {
958 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
959 where
960 S: serde::Serializer,
961 {
962 use serde::ser::SerializeStruct;
963 let mut state = serializer.serialize_struct("ImagePolicy", 5)?;
964 state.serialize_field(
965 "apiVersion",
966 <Self as k8s_openapi::Resource>::API_VERSION,
967 )?;
968 state.serialize_field("kind", <Self as k8s_openapi::Resource>::KIND)?;
969 state.serialize_field("metadata", &self.metadata)?;
970 state.serialize_field("spec", &self.spec)?;
971 state.serialize_field("status", &self.status)?;
972 state.end()
973 }
974 }
975
976 /// Alphabetical set of rules to use for alphabetical ordering of the tags.
977 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
978 #[serde(rename_all = "camelCase")]
979 pub struct Alphabetical {
980 /// Order specifies the sorting order of the tags. Given the letters of the alphabet as tags, ascending order would select Z, and descending order would select A.
981 pub order: String,
982 }
983
984 /// Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: "Available", "Progressing", and "Degraded" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type" protobuf:"bytes,1,rep,name=conditions"`
985 /// // other fields }
986 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
987 #[serde(rename_all = "camelCase")]
988 pub struct ConditionsItem {
989 /// 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.
990 pub last_transition_time: String,
991 /// message is a human readable message indicating details about the transition. This may be an empty string.
992 pub message: String,
993 /// 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.
994 pub observed_generation: i64,
995 /// 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.
996 pub reason: String,
997 /// status of the condition, one of True, False, Unknown.
998 pub status: String,
999 /// type of condition in CamelCase or in foo.example.com/CamelCase. --- Many .condition.type values are consistent across resources like Available, but because arbitrary conditions can be useful (see .node.status.conditions), the ability to deconflict is important. The regex it matches is (dns1123SubdomainFmt/)?(qualifiedNameFmt)
1000 pub r#type: String,
1001 }
1002
1003 /// FilterTags enables filtering for only a subset of tags based on a set of rules. If no rules are provided, all the tags from the repository will be ordered and compared.
1004 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1005 #[serde(rename_all = "camelCase")]
1006 pub struct FilterTags {
1007 /// Extract allows a capture group to be extracted from the specified regular expression pattern, useful before tag evaluation.
1008 pub extract: String,
1009 /// Pattern specifies a regular expression pattern used to filter for image tags.
1010 pub pattern: String,
1011 }
1012
1013 /// ImageRepositoryRef points at the object specifying the image being scanned
1014 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1015 #[serde(rename_all = "camelCase")]
1016 pub struct ImageRepositoryRef {
1017 /// Name of the referent.
1018 pub name: String,
1019 }
1020
1021 /// Numerical set of rules to use for numerical ordering of the tags.
1022 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1023 #[serde(rename_all = "camelCase")]
1024 pub struct Numerical {
1025 /// Order specifies the sorting order of the tags. Given the integer values from 0 to 9 as tags, ascending order would select 9, and descending order would select 0.
1026 pub order: String,
1027 }
1028
1029 /// Policy gives the particulars of the policy to be followed in selecting the most recent image
1030 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1031 #[serde(rename_all = "camelCase")]
1032 pub struct Policy {
1033 /// Alphabetical set of rules to use for alphabetical ordering of the tags.
1034 pub alphabetical: Alphabetical,
1035 /// Numerical set of rules to use for numerical ordering of the tags.
1036 pub numerical: Numerical,
1037 /// SemVer gives a semantic version range to check against the tags available.
1038 pub semver: Semver,
1039 }
1040
1041 /// SemVer gives a semantic version range to check against the tags available.
1042 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1043 #[serde(rename_all = "camelCase")]
1044 pub struct Semver {
1045 /// Range gives a semver range for the image tag; the highest version within the range that's a tag yields the latest image.
1046 pub range: String,
1047 }
1048
1049 /// ImagePolicySpec defines the parameters for calculating the ImagePolicy
1050 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1051 #[serde(rename_all = "camelCase")]
1052 pub struct Spec {
1053 /// FilterTags enables filtering for only a subset of tags based on a set of rules. If no rules are provided, all the tags from the repository will be ordered and compared.
1054 pub filter_tags: FilterTags,
1055 /// ImageRepositoryRef points at the object specifying the image being scanned
1056 pub image_repository_ref: ImageRepositoryRef,
1057 /// Policy gives the particulars of the policy to be followed in selecting the most recent image
1058 pub policy: Policy,
1059 }
1060
1061 /// ImagePolicyStatus defines the observed state of ImagePolicy
1062 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1063 #[serde(rename_all = "camelCase")]
1064 pub struct Status {
1065 pub conditions: Vec<ConditionsItem>,
1066 /// LatestImage gives the first in the list of images scanned by the image repository, when filtered and ordered according to the policy.
1067 pub latest_image: String,
1068 pub observed_generation: i64,
1069 }
1070 }
1071 pub mod image_repository {
1072 /// ImageRepository is the Schema for the imagerepositories API
1073 #[derive(serde::Deserialize, Debug, PartialEq)]
1074 pub struct ImageRepository {
1075 pub metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta,
1076 pub spec: Spec,
1077 pub status: Status,
1078 }
1079
1080 impl k8s_openapi::Resource for ImageRepository {
1081 type Scope = k8s_openapi::ClusterResourceScope;
1082
1083 const API_VERSION: &'static str = "image.toolkit.fluxcd.io/v1alpha2";
1084 const GROUP: &'static str = "image.toolkit.fluxcd.io";
1085 const KIND: &'static str = "ImageRepository";
1086 const VERSION: &'static str = "v1alpha2";
1087 const URL_PATH_SEGMENT: &'static str = "TODO";
1088 }
1089
1090 impl k8s_openapi::Metadata for ImageRepository {
1091 type Ty = k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta;
1092
1093 fn metadata(&self) -> &<Self as k8s_openapi::Metadata>::Ty {
1094 &self.metadata
1095 }
1096
1097 fn metadata_mut(&mut self) -> &mut <Self as k8s_openapi::Metadata>::Ty {
1098 &mut self.metadata
1099 }
1100 }
1101
1102 impl serde::Serialize for ImageRepository {
1103 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1104 where
1105 S: serde::Serializer,
1106 {
1107 use serde::ser::SerializeStruct;
1108 let mut state = serializer.serialize_struct("ImageRepository", 5)?;
1109 state.serialize_field(
1110 "apiVersion",
1111 <Self as k8s_openapi::Resource>::API_VERSION,
1112 )?;
1113 state.serialize_field("kind", <Self as k8s_openapi::Resource>::KIND)?;
1114 state.serialize_field("metadata", &self.metadata)?;
1115 state.serialize_field("spec", &self.spec)?;
1116 state.serialize_field("status", &self.status)?;
1117 state.end()
1118 }
1119 }
1120
1121 /// CertSecretRef can be given the name of a secret containing either or both of
1122 /// - a PEM-encoded client certificate (`certFile`) and private key (`keyFile`); - a PEM-encoded CA certificate (`caFile`)
1123 /// and whichever are supplied, will be used for connecting to the registry. The client cert and key are useful if you are authenticating with a certificate; the CA cert is useful if you are using a self-signed server certificate.
1124 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1125 #[serde(rename_all = "camelCase")]
1126 pub struct CertSecretRef {
1127 /// Name of the referent.
1128 pub name: String,
1129 }
1130
1131 /// Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: "Available", "Progressing", and "Degraded" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type" protobuf:"bytes,1,rep,name=conditions"`
1132 /// // other fields }
1133 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1134 #[serde(rename_all = "camelCase")]
1135 pub struct ConditionsItem {
1136 /// 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.
1137 pub last_transition_time: String,
1138 /// message is a human readable message indicating details about the transition. This may be an empty string.
1139 pub message: String,
1140 /// 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.
1141 pub observed_generation: i64,
1142 /// 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.
1143 pub reason: String,
1144 /// status of the condition, one of True, False, Unknown.
1145 pub status: String,
1146 /// type of condition in CamelCase or in foo.example.com/CamelCase. --- Many .condition.type values are consistent across resources like Available, but because arbitrary conditions can be useful (see .node.status.conditions), the ability to deconflict is important. The regex it matches is (dns1123SubdomainFmt/)?(qualifiedNameFmt)
1147 pub r#type: String,
1148 }
1149
1150 /// LastScanResult contains the number of fetched tags.
1151 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1152 #[serde(rename_all = "camelCase")]
1153 pub struct LastScanResult {
1154 pub scan_time: String,
1155 pub tag_count: i64,
1156 }
1157
1158 /// SecretRef can be given the name of a secret containing credentials to use for the image registry. The secret should be created with `kubectl create secret docker-registry`, or the equivalent.
1159 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1160 #[serde(rename_all = "camelCase")]
1161 pub struct SecretRef {
1162 /// Name of the referent.
1163 pub name: String,
1164 }
1165
1166 /// ImageRepositorySpec defines the parameters for scanning an image repository, e.g., `fluxcd/flux`.
1167 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1168 #[serde(rename_all = "camelCase")]
1169 pub struct Spec {
1170 /// CertSecretRef can be given the name of a secret containing either or both of
1171 /// - a PEM-encoded client certificate (`certFile`) and private key (`keyFile`); - a PEM-encoded CA certificate (`caFile`)
1172 /// and whichever are supplied, will be used for connecting to the registry. The client cert and key are useful if you are authenticating with a certificate; the CA cert is useful if you are using a self-signed server certificate.
1173 pub cert_secret_ref: CertSecretRef,
1174 /// Image is the name of the image repository
1175 pub image: String,
1176 /// Interval is the length of time to wait between scans of the image repository.
1177 pub interval: String,
1178 /// SecretRef can be given the name of a secret containing credentials to use for the image registry. The secret should be created with `kubectl create secret docker-registry`, or the equivalent.
1179 pub secret_ref: SecretRef,
1180 /// This flag tells the controller to suspend subsequent image scans. It does not apply to already started scans. Defaults to false.
1181 pub suspend: bool,
1182 /// Timeout for image scanning. Defaults to 'Interval' duration.
1183 pub timeout: String,
1184 }
1185
1186 /// ImageRepositoryStatus defines the observed state of ImageRepository
1187 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1188 #[serde(rename_all = "camelCase")]
1189 pub struct Status {
1190 /// CanonicalName is the name of the image repository with all the implied bits made explicit; e.g., `docker.io/library/alpine` rather than `alpine`.
1191 pub canonical_image_name: String,
1192 pub conditions: Vec<ConditionsItem>,
1193 /// LastHandledReconcileAt holds the value of the most recent reconcile request value, so a change of the annotation value can be detected.
1194 pub last_handled_reconcile_at: String,
1195 /// LastScanResult contains the number of fetched tags.
1196 pub last_scan_result: LastScanResult,
1197 /// ObservedGeneration is the last reconciled generation.
1198 pub observed_generation: i64,
1199 }
1200 }
1201 pub mod image_update_automation {
1202 /// ImageUpdateAutomation is the Schema for the imageupdateautomations API
1203 #[derive(serde::Deserialize, Debug, PartialEq)]
1204 pub struct ImageUpdateAutomation {
1205 pub metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta,
1206 pub spec: Spec,
1207 pub status: Status,
1208 }
1209
1210 impl k8s_openapi::Resource for ImageUpdateAutomation {
1211 type Scope = k8s_openapi::ClusterResourceScope;
1212
1213 const API_VERSION: &'static str = "image.toolkit.fluxcd.io/v1alpha2";
1214 const GROUP: &'static str = "image.toolkit.fluxcd.io";
1215 const KIND: &'static str = "ImageUpdateAutomation";
1216 const VERSION: &'static str = "v1alpha2";
1217 const URL_PATH_SEGMENT: &'static str = "TODO";
1218 }
1219
1220 impl k8s_openapi::Metadata for ImageUpdateAutomation {
1221 type Ty = k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta;
1222
1223 fn metadata(&self) -> &<Self as k8s_openapi::Metadata>::Ty {
1224 &self.metadata
1225 }
1226
1227 fn metadata_mut(&mut self) -> &mut <Self as k8s_openapi::Metadata>::Ty {
1228 &mut self.metadata
1229 }
1230 }
1231
1232 impl serde::Serialize for ImageUpdateAutomation {
1233 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1234 where
1235 S: serde::Serializer,
1236 {
1237 use serde::ser::SerializeStruct;
1238 let mut state = serializer.serialize_struct("ImageUpdateAutomation", 5)?;
1239 state.serialize_field(
1240 "apiVersion",
1241 <Self as k8s_openapi::Resource>::API_VERSION,
1242 )?;
1243 state.serialize_field("kind", <Self as k8s_openapi::Resource>::KIND)?;
1244 state.serialize_field("metadata", &self.metadata)?;
1245 state.serialize_field("spec", &self.spec)?;
1246 state.serialize_field("status", &self.status)?;
1247 state.end()
1248 }
1249 }
1250
1251 /// Author gives the email and optionally the name to use as the author of commits.
1252 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1253 #[serde(rename_all = "camelCase")]
1254 pub struct Author {
1255 /// Email gives the email to provide when making a commit.
1256 pub email: String,
1257 /// Name gives the name to provide when making a commit.
1258 pub name: String,
1259 }
1260
1261 /// Checkout gives the parameters for cloning the git repository, ready to make changes. If not present, the `spec.ref` field from the referenced `GitRepository` or its default will be used.
1262 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1263 #[serde(rename_all = "camelCase")]
1264 pub struct Checkout {
1265 /// Reference gives a branch, tag or commit to clone from the Git repository.
1266 pub r#ref: Ref,
1267 }
1268
1269 /// Commit specifies how to commit to the git repository.
1270 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1271 #[serde(rename_all = "camelCase")]
1272 pub struct Commit {
1273 /// Author gives the email and optionally the name to use as the author of commits.
1274 pub author: Author,
1275 /// MessageTemplate provides a template for the commit message, into which will be interpolated the details of the change made.
1276 pub message_template: String,
1277 /// SigningKey provides the option to sign commits with a GPG key
1278 pub signing_key: SigningKey,
1279 }
1280
1281 /// Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: "Available", "Progressing", and "Degraded" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type" protobuf:"bytes,1,rep,name=conditions"`
1282 /// // other fields }
1283 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1284 #[serde(rename_all = "camelCase")]
1285 pub struct ConditionsItem {
1286 /// 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.
1287 pub last_transition_time: String,
1288 /// message is a human readable message indicating details about the transition. This may be an empty string.
1289 pub message: String,
1290 /// 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.
1291 pub observed_generation: i64,
1292 /// 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.
1293 pub reason: String,
1294 /// status of the condition, one of True, False, Unknown.
1295 pub status: String,
1296 /// type of condition in CamelCase or in foo.example.com/CamelCase. --- Many .condition.type values are consistent across resources like Available, but because arbitrary conditions can be useful (see .node.status.conditions), the ability to deconflict is important. The regex it matches is (dns1123SubdomainFmt/)?(qualifiedNameFmt)
1297 pub r#type: String,
1298 }
1299
1300 /// GitSpec contains all the git-specific definitions. This is technically optional, but in practice mandatory until there are other kinds of source allowed.
1301 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1302 #[serde(rename_all = "camelCase")]
1303 pub struct Git {
1304 /// Checkout gives the parameters for cloning the git repository, ready to make changes. If not present, the `spec.ref` field from the referenced `GitRepository` or its default will be used.
1305 pub checkout: Checkout,
1306 /// Commit specifies how to commit to the git repository.
1307 pub commit: Commit,
1308 /// Push specifies how and where to push commits made by the automation. If missing, commits are pushed (back) to `.spec.checkout.branch` or its default.
1309 pub push: Push,
1310 }
1311
1312 /// Push specifies how and where to push commits made by the automation. If missing, commits are pushed (back) to `.spec.checkout.branch` or its default.
1313 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1314 #[serde(rename_all = "camelCase")]
1315 pub struct Push {
1316 /// Branch specifies that commits should be pushed to the branch named. The branch is created using `.spec.checkout.branch` as the starting point, if it doesn't already exist.
1317 pub branch: String,
1318 }
1319
1320 /// Reference gives a branch, tag or commit to clone from the Git repository.
1321 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1322 #[serde(rename_all = "camelCase")]
1323 pub struct Ref {
1324 /// The Git branch to checkout, defaults to master.
1325 pub branch: String,
1326 /// The Git commit SHA to checkout, if specified Tag filters will be ignored.
1327 pub commit: String,
1328 /// The Git tag semver expression, takes precedence over Tag.
1329 pub semver: String,
1330 /// The Git tag to checkout, takes precedence over Branch.
1331 pub tag: String,
1332 }
1333
1334 /// SecretRef holds the name to a secret that contains a 'git.asc' key corresponding to the ASCII Armored file containing the GPG signing keypair as the value. It must be in the same namespace as the ImageUpdateAutomation.
1335 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1336 #[serde(rename_all = "camelCase")]
1337 pub struct SecretRef {
1338 /// Name of the referent.
1339 pub name: String,
1340 }
1341
1342 /// SigningKey provides the option to sign commits with a GPG key
1343 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1344 #[serde(rename_all = "camelCase")]
1345 pub struct SigningKey {
1346 /// SecretRef holds the name to a secret that contains a 'git.asc' key corresponding to the ASCII Armored file containing the GPG signing keypair as the value. It must be in the same namespace as the ImageUpdateAutomation.
1347 pub secret_ref: SecretRef,
1348 }
1349
1350 /// SourceRef refers to the resource giving access details to a git repository.
1351 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1352 #[serde(rename_all = "camelCase")]
1353 pub struct SourceRef {
1354 /// API version of the referent
1355 pub api_version: String,
1356 /// Kind of the referent
1357 pub kind: String,
1358 /// Name of the referent
1359 pub name: String,
1360 }
1361
1362 /// ImageUpdateAutomationSpec defines the desired state of ImageUpdateAutomation
1363 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1364 #[serde(rename_all = "camelCase")]
1365 pub struct Spec {
1366 /// GitSpec contains all the git-specific definitions. This is technically optional, but in practice mandatory until there are other kinds of source allowed.
1367 pub git: Git,
1368 /// Interval gives an lower bound for how often the automation run should be attempted.
1369 pub interval: String,
1370 /// SourceRef refers to the resource giving access details to a git repository.
1371 pub source_ref: SourceRef,
1372 /// Suspend tells the controller to not run this automation, until it is unset (or set to false). Defaults to false.
1373 pub suspend: bool,
1374 /// Update gives the specification for how to update the files in the repository. This can be left empty, to use the default value.
1375 pub update: Update,
1376 }
1377
1378 /// ImageUpdateAutomationStatus defines the observed state of ImageUpdateAutomation
1379 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1380 #[serde(rename_all = "camelCase")]
1381 pub struct Status {
1382 pub conditions: Vec<ConditionsItem>,
1383 /// LastAutomationRunTime records the last time the controller ran this automation through to completion (even if no updates were made).
1384 pub last_automation_run_time: String,
1385 /// LastHandledReconcileAt holds the value of the most recent reconcile request value, so a change of the annotation value can be detected.
1386 pub last_handled_reconcile_at: String,
1387 /// LastPushCommit records the SHA1 of the last commit made by the controller, for this automation object
1388 pub last_push_commit: String,
1389 /// LastPushTime records the time of the last pushed change.
1390 pub last_push_time: String,
1391 pub observed_generation: i64,
1392 }
1393
1394 /// Update gives the specification for how to update the files in the repository. This can be left empty, to use the default value.
1395 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1396 #[serde(rename_all = "camelCase")]
1397 pub struct Update {
1398 /// Path to the directory containing the manifests to be updated. Defaults to 'None', which translates to the root path of the GitRepositoryRef.
1399 pub path: String,
1400 /// Strategy names the strategy to be used.
1401 pub strategy: String,
1402 }
1403 }
1404 }
1405 pub mod v1beta1 {
1406 pub mod image_policy {
1407 /// ImagePolicy is the Schema for the imagepolicies API
1408 #[derive(serde::Deserialize, Debug, PartialEq)]
1409 pub struct ImagePolicy {
1410 pub metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta,
1411 pub spec: Spec,
1412 pub status: Status,
1413 }
1414
1415 impl k8s_openapi::Resource for ImagePolicy {
1416 type Scope = k8s_openapi::ClusterResourceScope;
1417
1418 const API_VERSION: &'static str = "image.toolkit.fluxcd.io/v1beta1";
1419 const GROUP: &'static str = "image.toolkit.fluxcd.io";
1420 const KIND: &'static str = "ImagePolicy";
1421 const VERSION: &'static str = "v1beta1";
1422 const URL_PATH_SEGMENT: &'static str = "TODO";
1423 }
1424
1425 impl k8s_openapi::Metadata for ImagePolicy {
1426 type Ty = k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta;
1427
1428 fn metadata(&self) -> &<Self as k8s_openapi::Metadata>::Ty {
1429 &self.metadata
1430 }
1431
1432 fn metadata_mut(&mut self) -> &mut <Self as k8s_openapi::Metadata>::Ty {
1433 &mut self.metadata
1434 }
1435 }
1436
1437 impl serde::Serialize for ImagePolicy {
1438 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1439 where
1440 S: serde::Serializer,
1441 {
1442 use serde::ser::SerializeStruct;
1443 let mut state = serializer.serialize_struct("ImagePolicy", 5)?;
1444 state.serialize_field(
1445 "apiVersion",
1446 <Self as k8s_openapi::Resource>::API_VERSION,
1447 )?;
1448 state.serialize_field("kind", <Self as k8s_openapi::Resource>::KIND)?;
1449 state.serialize_field("metadata", &self.metadata)?;
1450 state.serialize_field("spec", &self.spec)?;
1451 state.serialize_field("status", &self.status)?;
1452 state.end()
1453 }
1454 }
1455
1456 /// Alphabetical set of rules to use for alphabetical ordering of the tags.
1457 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1458 #[serde(rename_all = "camelCase")]
1459 pub struct Alphabetical {
1460 /// Order specifies the sorting order of the tags. Given the letters of the alphabet as tags, ascending order would select Z, and descending order would select A.
1461 pub order: String,
1462 }
1463
1464 /// Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: "Available", "Progressing", and "Degraded" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type" protobuf:"bytes,1,rep,name=conditions"`
1465 /// // other fields }
1466 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1467 #[serde(rename_all = "camelCase")]
1468 pub struct ConditionsItem {
1469 /// 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.
1470 pub last_transition_time: String,
1471 /// message is a human readable message indicating details about the transition. This may be an empty string.
1472 pub message: String,
1473 /// 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.
1474 pub observed_generation: i64,
1475 /// 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.
1476 pub reason: String,
1477 /// status of the condition, one of True, False, Unknown.
1478 pub status: String,
1479 /// type of condition in CamelCase or in foo.example.com/CamelCase. --- Many .condition.type values are consistent across resources like Available, but because arbitrary conditions can be useful (see .node.status.conditions), the ability to deconflict is important. The regex it matches is (dns1123SubdomainFmt/)?(qualifiedNameFmt)
1480 pub r#type: String,
1481 }
1482
1483 /// FilterTags enables filtering for only a subset of tags based on a set of rules. If no rules are provided, all the tags from the repository will be ordered and compared.
1484 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1485 #[serde(rename_all = "camelCase")]
1486 pub struct FilterTags {
1487 /// Extract allows a capture group to be extracted from the specified regular expression pattern, useful before tag evaluation.
1488 pub extract: String,
1489 /// Pattern specifies a regular expression pattern used to filter for image tags.
1490 pub pattern: String,
1491 }
1492
1493 /// ImageRepositoryRef points at the object specifying the image being scanned
1494 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1495 #[serde(rename_all = "camelCase")]
1496 pub struct ImageRepositoryRef {
1497 /// Name of the referent.
1498 pub name: String,
1499 /// Namespace of the referent, when not specified it acts as LocalObjectReference.
1500 pub namespace: String,
1501 }
1502
1503 /// Numerical set of rules to use for numerical ordering of the tags.
1504 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1505 #[serde(rename_all = "camelCase")]
1506 pub struct Numerical {
1507 /// Order specifies the sorting order of the tags. Given the integer values from 0 to 9 as tags, ascending order would select 9, and descending order would select 0.
1508 pub order: String,
1509 }
1510
1511 /// Policy gives the particulars of the policy to be followed in selecting the most recent image
1512 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1513 #[serde(rename_all = "camelCase")]
1514 pub struct Policy {
1515 /// Alphabetical set of rules to use for alphabetical ordering of the tags.
1516 pub alphabetical: Alphabetical,
1517 /// Numerical set of rules to use for numerical ordering of the tags.
1518 pub numerical: Numerical,
1519 /// SemVer gives a semantic version range to check against the tags available.
1520 pub semver: Semver,
1521 }
1522
1523 /// SemVer gives a semantic version range to check against the tags available.
1524 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1525 #[serde(rename_all = "camelCase")]
1526 pub struct Semver {
1527 /// Range gives a semver range for the image tag; the highest version within the range that's a tag yields the latest image.
1528 pub range: String,
1529 }
1530
1531 /// ImagePolicySpec defines the parameters for calculating the ImagePolicy
1532 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1533 #[serde(rename_all = "camelCase")]
1534 pub struct Spec {
1535 /// FilterTags enables filtering for only a subset of tags based on a set of rules. If no rules are provided, all the tags from the repository will be ordered and compared.
1536 pub filter_tags: FilterTags,
1537 /// ImageRepositoryRef points at the object specifying the image being scanned
1538 pub image_repository_ref: ImageRepositoryRef,
1539 /// Policy gives the particulars of the policy to be followed in selecting the most recent image
1540 pub policy: Policy,
1541 }
1542
1543 /// ImagePolicyStatus defines the observed state of ImagePolicy
1544 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1545 #[serde(rename_all = "camelCase")]
1546 pub struct Status {
1547 pub conditions: Vec<ConditionsItem>,
1548 /// LatestImage gives the first in the list of images scanned by the image repository, when filtered and ordered according to the policy.
1549 pub latest_image: String,
1550 pub observed_generation: i64,
1551 }
1552 }
1553 pub mod image_repository {
1554 /// ImageRepository is the Schema for the imagerepositories API
1555 #[derive(serde::Deserialize, Debug, PartialEq)]
1556 pub struct ImageRepository {
1557 pub metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta,
1558 pub spec: Spec,
1559 pub status: Status,
1560 }
1561
1562 impl k8s_openapi::Resource for ImageRepository {
1563 type Scope = k8s_openapi::ClusterResourceScope;
1564
1565 const API_VERSION: &'static str = "image.toolkit.fluxcd.io/v1beta1";
1566 const GROUP: &'static str = "image.toolkit.fluxcd.io";
1567 const KIND: &'static str = "ImageRepository";
1568 const VERSION: &'static str = "v1beta1";
1569 const URL_PATH_SEGMENT: &'static str = "TODO";
1570 }
1571
1572 impl k8s_openapi::Metadata for ImageRepository {
1573 type Ty = k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta;
1574
1575 fn metadata(&self) -> &<Self as k8s_openapi::Metadata>::Ty {
1576 &self.metadata
1577 }
1578
1579 fn metadata_mut(&mut self) -> &mut <Self as k8s_openapi::Metadata>::Ty {
1580 &mut self.metadata
1581 }
1582 }
1583
1584 impl serde::Serialize for ImageRepository {
1585 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1586 where
1587 S: serde::Serializer,
1588 {
1589 use serde::ser::SerializeStruct;
1590 let mut state = serializer.serialize_struct("ImageRepository", 5)?;
1591 state.serialize_field(
1592 "apiVersion",
1593 <Self as k8s_openapi::Resource>::API_VERSION,
1594 )?;
1595 state.serialize_field("kind", <Self as k8s_openapi::Resource>::KIND)?;
1596 state.serialize_field("metadata", &self.metadata)?;
1597 state.serialize_field("spec", &self.spec)?;
1598 state.serialize_field("status", &self.status)?;
1599 state.end()
1600 }
1601 }
1602
1603 /// AccessFrom defines an ACL for allowing cross-namespace references to the ImageRepository object based on the caller's namespace labels.
1604 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1605 #[serde(rename_all = "camelCase")]
1606 pub struct AccessFrom {
1607 /// NamespaceSelectors is the list of namespace selectors to which this ACL applies. Items in this list are evaluated using a logical OR operation.
1608 pub namespace_selectors: Vec<NamespaceSelectorsItem>,
1609 }
1610
1611 /// CertSecretRef can be given the name of a secret containing either or both of
1612 /// - a PEM-encoded client certificate (`certFile`) and private key (`keyFile`); - a PEM-encoded CA certificate (`caFile`)
1613 /// and whichever are supplied, will be used for connecting to the registry. The client cert and key are useful if you are authenticating with a certificate; the CA cert is useful if you are using a self-signed server certificate.
1614 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1615 #[serde(rename_all = "camelCase")]
1616 pub struct CertSecretRef {
1617 /// Name of the referent.
1618 pub name: String,
1619 }
1620
1621 /// Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: "Available", "Progressing", and "Degraded" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type" protobuf:"bytes,1,rep,name=conditions"`
1622 /// // other fields }
1623 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1624 #[serde(rename_all = "camelCase")]
1625 pub struct ConditionsItem {
1626 /// 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.
1627 pub last_transition_time: String,
1628 /// message is a human readable message indicating details about the transition. This may be an empty string.
1629 pub message: String,
1630 /// 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.
1631 pub observed_generation: i64,
1632 /// 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.
1633 pub reason: String,
1634 /// status of the condition, one of True, False, Unknown.
1635 pub status: String,
1636 /// type of condition in CamelCase or in foo.example.com/CamelCase. --- Many .condition.type values are consistent across resources like Available, but because arbitrary conditions can be useful (see .node.status.conditions), the ability to deconflict is important. The regex it matches is (dns1123SubdomainFmt/)?(qualifiedNameFmt)
1637 pub r#type: String,
1638 }
1639
1640 /// LastScanResult contains the number of fetched tags.
1641 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1642 #[serde(rename_all = "camelCase")]
1643 pub struct LastScanResult {
1644 pub scan_time: String,
1645 pub tag_count: i64,
1646 }
1647
1648 /// MatchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
1649 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1650 #[serde(rename_all = "camelCase")]
1651 pub struct MatchLabels {
1652 /// MatchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
1653 pub properties: std::collections::HashMap<String, String>,
1654 }
1655
1656 /// NamespaceSelector selects the namespaces to which this ACL applies. An empty map of MatchLabels matches all namespaces in a cluster.
1657 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1658 #[serde(rename_all = "camelCase")]
1659 pub struct NamespaceSelectorsItem {
1660 /// MatchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
1661 pub match_labels: MatchLabels,
1662 }
1663
1664 /// SecretRef can be given the name of a secret containing credentials to use for the image registry. The secret should be created with `kubectl create secret docker-registry`, or the equivalent.
1665 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1666 #[serde(rename_all = "camelCase")]
1667 pub struct SecretRef {
1668 /// Name of the referent.
1669 pub name: String,
1670 }
1671
1672 /// ImageRepositorySpec defines the parameters for scanning an image repository, e.g., `fluxcd/flux`.
1673 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1674 #[serde(rename_all = "camelCase")]
1675 pub struct Spec {
1676 /// AccessFrom defines an ACL for allowing cross-namespace references to the ImageRepository object based on the caller's namespace labels.
1677 pub access_from: AccessFrom,
1678 /// CertSecretRef can be given the name of a secret containing either or both of
1679 /// - a PEM-encoded client certificate (`certFile`) and private key (`keyFile`); - a PEM-encoded CA certificate (`caFile`)
1680 /// and whichever are supplied, will be used for connecting to the registry. The client cert and key are useful if you are authenticating with a certificate; the CA cert is useful if you are using a self-signed server certificate.
1681 pub cert_secret_ref: CertSecretRef,
1682 /// ExclusionList is a list of regex strings used to exclude certain tags from being stored in the database.
1683 pub exclusion_list: Vec<String>,
1684 /// Image is the name of the image repository
1685 pub image: String,
1686 /// Interval is the length of time to wait between scans of the image repository.
1687 pub interval: String,
1688 /// SecretRef can be given the name of a secret containing credentials to use for the image registry. The secret should be created with `kubectl create secret docker-registry`, or the equivalent.
1689 pub secret_ref: SecretRef,
1690 /// ServiceAccountName is the name of the Kubernetes ServiceAccount used to authenticate the image pull if the service account has attached pull secrets.
1691 pub service_account_name: String,
1692 /// This flag tells the controller to suspend subsequent image scans. It does not apply to already started scans. Defaults to false.
1693 pub suspend: bool,
1694 /// Timeout for image scanning. Defaults to 'Interval' duration.
1695 pub timeout: String,
1696 }
1697
1698 /// ImageRepositoryStatus defines the observed state of ImageRepository
1699 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1700 #[serde(rename_all = "camelCase")]
1701 pub struct Status {
1702 /// CanonicalName is the name of the image repository with all the implied bits made explicit; e.g., `docker.io/library/alpine` rather than `alpine`.
1703 pub canonical_image_name: String,
1704 pub conditions: Vec<ConditionsItem>,
1705 /// LastHandledReconcileAt holds the value of the most recent reconcile request value, so a change of the annotation value can be detected.
1706 pub last_handled_reconcile_at: String,
1707 /// LastScanResult contains the number of fetched tags.
1708 pub last_scan_result: LastScanResult,
1709 /// ObservedGeneration is the last reconciled generation.
1710 pub observed_generation: i64,
1711 }
1712 }
1713 pub mod image_update_automation {
1714 /// ImageUpdateAutomation is the Schema for the imageupdateautomations API
1715 #[derive(serde::Deserialize, Debug, PartialEq)]
1716 pub struct ImageUpdateAutomation {
1717 pub metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta,
1718 pub spec: Spec,
1719 pub status: Status,
1720 }
1721
1722 impl k8s_openapi::Resource for ImageUpdateAutomation {
1723 type Scope = k8s_openapi::ClusterResourceScope;
1724
1725 const API_VERSION: &'static str = "image.toolkit.fluxcd.io/v1beta1";
1726 const GROUP: &'static str = "image.toolkit.fluxcd.io";
1727 const KIND: &'static str = "ImageUpdateAutomation";
1728 const VERSION: &'static str = "v1beta1";
1729 const URL_PATH_SEGMENT: &'static str = "TODO";
1730 }
1731
1732 impl k8s_openapi::Metadata for ImageUpdateAutomation {
1733 type Ty = k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta;
1734
1735 fn metadata(&self) -> &<Self as k8s_openapi::Metadata>::Ty {
1736 &self.metadata
1737 }
1738
1739 fn metadata_mut(&mut self) -> &mut <Self as k8s_openapi::Metadata>::Ty {
1740 &mut self.metadata
1741 }
1742 }
1743
1744 impl serde::Serialize for ImageUpdateAutomation {
1745 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1746 where
1747 S: serde::Serializer,
1748 {
1749 use serde::ser::SerializeStruct;
1750 let mut state = serializer.serialize_struct("ImageUpdateAutomation", 5)?;
1751 state.serialize_field(
1752 "apiVersion",
1753 <Self as k8s_openapi::Resource>::API_VERSION,
1754 )?;
1755 state.serialize_field("kind", <Self as k8s_openapi::Resource>::KIND)?;
1756 state.serialize_field("metadata", &self.metadata)?;
1757 state.serialize_field("spec", &self.spec)?;
1758 state.serialize_field("status", &self.status)?;
1759 state.end()
1760 }
1761 }
1762
1763 /// Author gives the email and optionally the name to use as the author of commits.
1764 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1765 #[serde(rename_all = "camelCase")]
1766 pub struct Author {
1767 /// Email gives the email to provide when making a commit.
1768 pub email: String,
1769 /// Name gives the name to provide when making a commit.
1770 pub name: String,
1771 }
1772
1773 /// Checkout gives the parameters for cloning the git repository, ready to make changes. If not present, the `spec.ref` field from the referenced `GitRepository` or its default will be used.
1774 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1775 #[serde(rename_all = "camelCase")]
1776 pub struct Checkout {
1777 /// Reference gives a branch, tag or commit to clone from the Git repository.
1778 pub r#ref: Ref,
1779 }
1780
1781 /// Commit specifies how to commit to the git repository.
1782 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1783 #[serde(rename_all = "camelCase")]
1784 pub struct Commit {
1785 /// Author gives the email and optionally the name to use as the author of commits.
1786 pub author: Author,
1787 /// MessageTemplate provides a template for the commit message, into which will be interpolated the details of the change made.
1788 pub message_template: String,
1789 /// SigningKey provides the option to sign commits with a GPG key
1790 pub signing_key: SigningKey,
1791 }
1792
1793 /// Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: "Available", "Progressing", and "Degraded" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type" protobuf:"bytes,1,rep,name=conditions"`
1794 /// // other fields }
1795 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1796 #[serde(rename_all = "camelCase")]
1797 pub struct ConditionsItem {
1798 /// 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.
1799 pub last_transition_time: String,
1800 /// message is a human readable message indicating details about the transition. This may be an empty string.
1801 pub message: String,
1802 /// 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.
1803 pub observed_generation: i64,
1804 /// 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.
1805 pub reason: String,
1806 /// status of the condition, one of True, False, Unknown.
1807 pub status: String,
1808 /// type of condition in CamelCase or in foo.example.com/CamelCase. --- Many .condition.type values are consistent across resources like Available, but because arbitrary conditions can be useful (see .node.status.conditions), the ability to deconflict is important. The regex it matches is (dns1123SubdomainFmt/)?(qualifiedNameFmt)
1809 pub r#type: String,
1810 }
1811
1812 /// GitSpec contains all the git-specific definitions. This is technically optional, but in practice mandatory until there are other kinds of source allowed.
1813 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1814 #[serde(rename_all = "camelCase")]
1815 pub struct Git {
1816 /// Checkout gives the parameters for cloning the git repository, ready to make changes. If not present, the `spec.ref` field from the referenced `GitRepository` or its default will be used.
1817 pub checkout: Checkout,
1818 /// Commit specifies how to commit to the git repository.
1819 pub commit: Commit,
1820 /// Push specifies how and where to push commits made by the automation. If missing, commits are pushed (back) to `.spec.checkout.branch` or its default.
1821 pub push: Push,
1822 }
1823
1824 /// Push specifies how and where to push commits made by the automation. If missing, commits are pushed (back) to `.spec.checkout.branch` or its default.
1825 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1826 #[serde(rename_all = "camelCase")]
1827 pub struct Push {
1828 /// Branch specifies that commits should be pushed to the branch named. The branch is created using `.spec.checkout.branch` as the starting point, if it doesn't already exist.
1829 pub branch: String,
1830 }
1831
1832 /// Reference gives a branch, tag or commit to clone from the Git repository.
1833 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1834 #[serde(rename_all = "camelCase")]
1835 pub struct Ref {
1836 /// Branch to check out, defaults to 'master' if no other field is defined.
1837 /// When GitRepositorySpec.GitImplementation is set to 'go-git', a shallow clone of the specified branch is performed.
1838 pub branch: String,
1839 /// Commit SHA to check out, takes precedence over all reference fields.
1840 /// When GitRepositorySpec.GitImplementation is set to 'go-git', this can be combined with Branch to shallow clone the branch, in which the commit is expected to exist.
1841 pub commit: String,
1842 /// SemVer tag expression to check out, takes precedence over Tag.
1843 pub semver: String,
1844 /// Tag to check out, takes precedence over Branch.
1845 pub tag: String,
1846 }
1847
1848 /// SecretRef holds the name to a secret that contains a 'git.asc' key corresponding to the ASCII Armored file containing the GPG signing keypair as the value. It must be in the same namespace as the ImageUpdateAutomation.
1849 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1850 #[serde(rename_all = "camelCase")]
1851 pub struct SecretRef {
1852 /// Name of the referent.
1853 pub name: String,
1854 }
1855
1856 /// SigningKey provides the option to sign commits with a GPG key
1857 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1858 #[serde(rename_all = "camelCase")]
1859 pub struct SigningKey {
1860 /// SecretRef holds the name to a secret that contains a 'git.asc' key corresponding to the ASCII Armored file containing the GPG signing keypair as the value. It must be in the same namespace as the ImageUpdateAutomation.
1861 pub secret_ref: SecretRef,
1862 }
1863
1864 /// SourceRef refers to the resource giving access details to a git repository.
1865 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1866 #[serde(rename_all = "camelCase")]
1867 pub struct SourceRef {
1868 /// API version of the referent.
1869 pub api_version: String,
1870 /// Kind of the referent.
1871 pub kind: String,
1872 /// Name of the referent.
1873 pub name: String,
1874 /// Namespace of the referent, defaults to the namespace of the Kubernetes resource object that contains the reference.
1875 pub namespace: String,
1876 }
1877
1878 /// ImageUpdateAutomationSpec defines the desired state of ImageUpdateAutomation
1879 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1880 #[serde(rename_all = "camelCase")]
1881 pub struct Spec {
1882 /// GitSpec contains all the git-specific definitions. This is technically optional, but in practice mandatory until there are other kinds of source allowed.
1883 pub git: Git,
1884 /// Interval gives an lower bound for how often the automation run should be attempted.
1885 pub interval: String,
1886 /// SourceRef refers to the resource giving access details to a git repository.
1887 pub source_ref: SourceRef,
1888 /// Suspend tells the controller to not run this automation, until it is unset (or set to false). Defaults to false.
1889 pub suspend: bool,
1890 /// Update gives the specification for how to update the files in the repository. This can be left empty, to use the default value.
1891 pub update: Update,
1892 }
1893
1894 /// ImageUpdateAutomationStatus defines the observed state of ImageUpdateAutomation
1895 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1896 #[serde(rename_all = "camelCase")]
1897 pub struct Status {
1898 pub conditions: Vec<ConditionsItem>,
1899 /// LastAutomationRunTime records the last time the controller ran this automation through to completion (even if no updates were made).
1900 pub last_automation_run_time: String,
1901 /// LastHandledReconcileAt holds the value of the most recent reconcile request value, so a change of the annotation value can be detected.
1902 pub last_handled_reconcile_at: String,
1903 /// LastPushCommit records the SHA1 of the last commit made by the controller, for this automation object
1904 pub last_push_commit: String,
1905 /// LastPushTime records the time of the last pushed change.
1906 pub last_push_time: String,
1907 pub observed_generation: i64,
1908 }
1909
1910 /// Update gives the specification for how to update the files in the repository. This can be left empty, to use the default value.
1911 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1912 #[serde(rename_all = "camelCase")]
1913 pub struct Update {
1914 /// Path to the directory containing the manifests to be updated. Defaults to 'None', which translates to the root path of the GitRepositoryRef.
1915 pub path: String,
1916 /// Strategy names the strategy to be used.
1917 pub strategy: String,
1918 }
1919 }
1920 }
1921}
1922pub mod kustomize_toolkit_fluxcd_io {
1923 pub mod v1beta1 {
1924 pub mod kustomization {
1925 /// Kustomization is the Schema for the kustomizations API.
1926 #[derive(serde::Deserialize, Debug, PartialEq)]
1927 pub struct Kustomization {
1928 pub metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta,
1929 pub spec: Spec,
1930 pub status: Status,
1931 }
1932
1933 impl k8s_openapi::Resource for Kustomization {
1934 type Scope = k8s_openapi::ClusterResourceScope;
1935
1936 const API_VERSION: &'static str = "kustomize.toolkit.fluxcd.io/v1beta1";
1937 const GROUP: &'static str = "kustomize.toolkit.fluxcd.io";
1938 const KIND: &'static str = "Kustomization";
1939 const VERSION: &'static str = "v1beta1";
1940 const URL_PATH_SEGMENT: &'static str = "TODO";
1941 }
1942
1943 impl k8s_openapi::Metadata for Kustomization {
1944 type Ty = k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta;
1945
1946 fn metadata(&self) -> &<Self as k8s_openapi::Metadata>::Ty {
1947 &self.metadata
1948 }
1949
1950 fn metadata_mut(&mut self) -> &mut <Self as k8s_openapi::Metadata>::Ty {
1951 &mut self.metadata
1952 }
1953 }
1954
1955 impl serde::Serialize for Kustomization {
1956 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1957 where
1958 S: serde::Serializer,
1959 {
1960 use serde::ser::SerializeStruct;
1961 let mut state = serializer.serialize_struct("Kustomization", 5)?;
1962 state.serialize_field(
1963 "apiVersion",
1964 <Self as k8s_openapi::Resource>::API_VERSION,
1965 )?;
1966 state.serialize_field("kind", <Self as k8s_openapi::Resource>::KIND)?;
1967 state.serialize_field("metadata", &self.metadata)?;
1968 state.serialize_field("spec", &self.spec)?;
1969 state.serialize_field("status", &self.status)?;
1970 state.end()
1971 }
1972 }
1973
1974 /// Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: "Available", "Progressing", and "Degraded" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type" protobuf:"bytes,1,rep,name=conditions"`
1975 /// // other fields }
1976 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1977 #[serde(rename_all = "camelCase")]
1978 pub struct ConditionsItem {
1979 /// 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.
1980 pub last_transition_time: String,
1981 /// message is a human readable message indicating details about the transition. This may be an empty string.
1982 pub message: String,
1983 /// 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.
1984 pub observed_generation: i64,
1985 /// 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.
1986 pub reason: String,
1987 /// status of the condition, one of True, False, Unknown.
1988 pub status: String,
1989 /// type of condition in CamelCase or in foo.example.com/CamelCase. --- Many .condition.type values are consistent across resources like Available, but because arbitrary conditions can be useful (see .node.status.conditions), the ability to deconflict is important. The regex it matches is (dns1123SubdomainFmt/)?(qualifiedNameFmt)
1990 pub r#type: String,
1991 }
1992
1993 /// Decrypt Kubernetes secrets before applying them on the cluster.
1994 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1995 #[serde(rename_all = "camelCase")]
1996 pub struct Decryption {
1997 /// Provider is the name of the decryption engine.
1998 pub provider: String,
1999 /// The secret name containing the private OpenPGP keys used for decryption.
2000 pub secret_ref: DecryptionSecretRef,
2001 }
2002
2003 /// NamespacedObjectReference contains enough information to locate the referenced Kubernetes resource object in any namespace.
2004 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2005 #[serde(rename_all = "camelCase")]
2006 pub struct DependsOnItem {
2007 /// Name of the referent.
2008 pub name: String,
2009 /// Namespace of the referent, when not specified it acts as LocalObjectReference.
2010 pub namespace: String,
2011 }
2012
2013 /// Snapshot holds the metadata of namespaced Kubernetes objects
2014 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2015 #[serde(rename_all = "camelCase")]
2016 pub struct EntriesItem {
2017 /// The list of Kubernetes kinds.
2018 pub kinds: Kinds,
2019 /// The namespace of this entry.
2020 pub namespace: String,
2021 }
2022
2023 /// NamespacedObjectKindReference contains enough information to locate the typed referenced Kubernetes resource object in any namespace.
2024 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2025 #[serde(rename_all = "camelCase")]
2026 pub struct HealthChecksItem {
2027 /// API version of the referent, if not specified the Kubernetes preferred version will be used.
2028 pub api_version: String,
2029 /// Kind of the referent.
2030 pub kind: String,
2031 /// Name of the referent.
2032 pub name: String,
2033 /// Namespace of the referent, when not specified it acts as LocalObjectReference.
2034 pub namespace: String,
2035 }
2036
2037 /// Image contains an image name, a new name, a new tag or digest, which will replace the original name and tag.
2038 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2039 #[serde(rename_all = "camelCase")]
2040 pub struct ImagesItem {
2041 /// Digest is the value used to replace the original image tag. If digest is present NewTag value is ignored.
2042 pub digest: String,
2043 /// Name is a tag-less image name.
2044 pub name: String,
2045 /// NewName is the value used to replace the original name.
2046 pub new_name: String,
2047 /// NewTag is the value used to replace the original tag.
2048 pub new_tag: String,
2049 }
2050
2051 /// The list of Kubernetes kinds.
2052 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2053 #[serde(rename_all = "camelCase")]
2054 pub struct Kinds {
2055 /// The list of Kubernetes kinds.
2056 pub properties: std::collections::HashMap<String, String>,
2057 }
2058
2059 /// The KubeConfig for reconciling the Kustomization on a remote cluster. When specified, KubeConfig takes precedence over ServiceAccountName.
2060 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2061 #[serde(rename_all = "camelCase")]
2062 pub struct KubeConfig {
2063 /// SecretRef holds the name to a secret that contains a 'value' key with the kubeconfig file as the value. It must be in the same namespace as the Kustomization. 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 the Kustomization.
2064 pub secret_ref: KubeConfigSecretRef,
2065 }
2066
2067 /// JSON6902 is a JSON6902 operation object. https://datatracker.ietf.org/doc/html/rfc6902#section-4
2068 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2069 #[serde(rename_all = "camelCase")]
2070 pub struct PatchItem {
2071 /// From contains a JSON-pointer value that references a location within the target document where the operation is performed. The meaning of the value depends on the value of Op, and is NOT taken into account by all operations.
2072 pub from: String,
2073 /// Op indicates the operation to perform. Its value MUST be one of "add", "remove", "replace", "move", "copy", or "test". https://datatracker.ietf.org/doc/html/rfc6902#section-4
2074 pub op: String,
2075 /// Path contains the JSON-pointer value that references a location within the target document where the operation is performed. The meaning of the value depends on the value of Op.
2076 pub path: String,
2077 /// Value contains a valid JSON structure. The meaning of the value depends on the value of Op, and is NOT taken into account by all operations.
2078 pub value: serde_json::Map<String, serde_json::Value>,
2079 }
2080
2081 /// Patch contains an inline StrategicMerge or JSON6902 patch, and the target the patch should be applied to.
2082 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2083 #[serde(rename_all = "camelCase")]
2084 pub struct PatchesItem {
2085 /// Patch contains an inline StrategicMerge patch or an inline JSON6902 patch with an array of operation objects.
2086 pub patch: String,
2087 /// Target points to the resources that the patch document should be applied to.
2088 pub target: PatchesItemTarget,
2089 }
2090
2091 /// JSON6902Patch contains a JSON6902 patch and the target the patch should be applied to.
2092 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2093 #[serde(rename_all = "camelCase")]
2094 pub struct PatchesJson6902Item {
2095 /// Patch contains the JSON6902 patch document with an array of operation objects.
2096 pub patch: Vec<PatchItem>,
2097 /// Target points to the resources that the patch document should be applied to.
2098 pub target: PatchesJson6902ItemTarget,
2099 }
2100
2101 /// PostBuild describes which actions to perform on the YAML manifest generated by building the kustomize overlay.
2102 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2103 #[serde(rename_all = "camelCase")]
2104 pub struct PostBuild {
2105 /// Substitute holds a map of key/value pairs. The variables defined in your YAML manifests that match any of the keys defined in the map will be substituted with the set value. Includes support for bash string replacement functions e.g. ${var:=default}, ${var:position} and ${var/substring/replacement}.
2106 pub substitute: Substitute,
2107 /// SubstituteFrom holds references to ConfigMaps and Secrets containing the variables and their values to be substituted in the YAML manifests. The ConfigMap and the Secret data keys represent the var names and they must match the vars declared in the manifests for the substitution to happen.
2108 pub substitute_from: Vec<SubstituteFromItem>,
2109 }
2110
2111 /// The secret name containing the private OpenPGP keys used for decryption.
2112 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2113 #[serde(rename_all = "camelCase")]
2114 pub struct DecryptionSecretRef {
2115 /// Name of the referent.
2116 pub name: String,
2117 }
2118
2119 /// SecretRef holds the name to a secret that contains a 'value' key with the kubeconfig file as the value. It must be in the same namespace as the Kustomization. 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 the Kustomization.
2120 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2121 #[serde(rename_all = "camelCase")]
2122 pub struct KubeConfigSecretRef {
2123 /// Name of the referent.
2124 pub name: String,
2125 }
2126
2127 /// The last successfully applied revision metadata.
2128 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2129 #[serde(rename_all = "camelCase")]
2130 pub struct Snapshot {
2131 /// The manifests sha1 checksum.
2132 pub checksum: String,
2133 /// A list of Kubernetes kinds grouped by namespace.
2134 pub entries: Vec<EntriesItem>,
2135 }
2136
2137 /// Reference of the source where the kustomization file is.
2138 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2139 #[serde(rename_all = "camelCase")]
2140 pub struct SourceRef {
2141 /// API version of the referent
2142 pub api_version: String,
2143 /// Kind of the referent
2144 pub kind: String,
2145 /// Name of the referent
2146 pub name: String,
2147 /// Namespace of the referent, defaults to the Kustomization namespace
2148 pub namespace: String,
2149 }
2150
2151 /// KustomizationSpec defines the desired state of a kustomization.
2152 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2153 #[serde(rename_all = "camelCase")]
2154 pub struct Spec {
2155 /// Decrypt Kubernetes secrets before applying them on the cluster.
2156 pub decryption: Decryption,
2157 /// DependsOn may contain a meta.NamespacedObjectReference slice with references to Kustomization resources that must be ready before this Kustomization can be reconciled.
2158 pub depends_on: Vec<DependsOnItem>,
2159 /// Force instructs the controller to recreate resources when patching fails due to an immutable field change.
2160 pub force: bool,
2161 /// A list of resources to be included in the health assessment.
2162 pub health_checks: Vec<HealthChecksItem>,
2163 /// 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.
2164 pub images: Vec<ImagesItem>,
2165 /// The interval at which to reconcile the Kustomization.
2166 pub interval: String,
2167 /// The KubeConfig for reconciling the Kustomization on a remote cluster. When specified, KubeConfig takes precedence over ServiceAccountName.
2168 pub kube_config: KubeConfig,
2169 /// Strategic merge and JSON patches, defined as inline YAML objects, capable of targeting objects based on kind, label and annotation selectors.
2170 pub patches: Vec<PatchesItem>,
2171 /// JSON 6902 patches, defined as inline YAML objects.
2172 pub patches_json6902: Vec<PatchesJson6902Item>,
2173 /// Strategic merge patches, defined as inline YAML objects.
2174 pub patches_strategic_merge: Vec<serde_json::Map<String, serde_json::Value>>,
2175 /// Path to the directory containing the kustomization.yaml file, or the set of plain YAMLs a kustomization.yaml should be generated for. Defaults to 'None', which translates to the root path of the SourceRef.
2176 pub path: String,
2177 /// PostBuild describes which actions to perform on the YAML manifest generated by building the kustomize overlay.
2178 pub post_build: PostBuild,
2179 /// Prune enables garbage collection.
2180 pub prune: bool,
2181 /// The interval at which to retry a previously failed reconciliation. When not specified, the controller uses the KustomizationSpec.Interval value to retry failures.
2182 pub retry_interval: String,
2183 /// The name of the Kubernetes service account to impersonate when reconciling this Kustomization.
2184 pub service_account_name: String,
2185 /// Reference of the source where the kustomization file is.
2186 pub source_ref: SourceRef,
2187 /// This flag tells the controller to suspend subsequent kustomize executions, it does not apply to already started executions. Defaults to false.
2188 pub suspend: bool,
2189 /// TargetNamespace sets or overrides the namespace in the kustomization.yaml file.
2190 pub target_namespace: String,
2191 /// Timeout for validation, apply and health checking operations. Defaults to 'Interval' duration.
2192 pub timeout: String,
2193 /// Validate the Kubernetes objects before applying them on the cluster. The validation strategy can be 'client' (local dry-run), 'server' (APIServer dry-run) or 'none'. When 'Force' is 'true', validation will fallback to 'client' if set to 'server' because server-side validation is not supported in this scenario.
2194 pub validation: String,
2195 }
2196
2197 /// KustomizationStatus defines the observed state of a kustomization.
2198 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2199 #[serde(rename_all = "camelCase")]
2200 pub struct Status {
2201 pub conditions: Vec<ConditionsItem>,
2202 /// The last successfully applied revision. The revision format for Git sources is <branch|tag>/<commit-sha>.
2203 pub last_applied_revision: String,
2204 /// LastAttemptedRevision is the revision of the last reconciliation attempt.
2205 pub last_attempted_revision: String,
2206 /// LastHandledReconcileAt holds the value of the most recent reconcile request value, so a change of the annotation value can be detected.
2207 pub last_handled_reconcile_at: String,
2208 /// ObservedGeneration is the last reconciled generation.
2209 pub observed_generation: i64,
2210 /// The last successfully applied revision metadata.
2211 pub snapshot: Snapshot,
2212 }
2213
2214 /// Substitute holds a map of key/value pairs. The variables defined in your YAML manifests that match any of the keys defined in the map will be substituted with the set value. Includes support for bash string replacement functions e.g. ${var:=default}, ${var:position} and ${var/substring/replacement}.
2215 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2216 #[serde(rename_all = "camelCase")]
2217 pub struct Substitute {
2218 /// Substitute holds a map of key/value pairs. The variables defined in your YAML manifests that match any of the keys defined in the map will be substituted with the set value. Includes support for bash string replacement functions e.g. ${var:=default}, ${var:position} and ${var/substring/replacement}.
2219 pub properties: std::collections::HashMap<String, String>,
2220 }
2221
2222 /// SubstituteReference contains a reference to a resource containing the variables name and value.
2223 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2224 #[serde(rename_all = "camelCase")]
2225 pub struct SubstituteFromItem {
2226 /// Kind of the values referent, valid values are ('Secret', 'ConfigMap').
2227 pub kind: String,
2228 /// Name of the values referent. Should reside in the same namespace as the referring resource.
2229 pub name: String,
2230 }
2231
2232 /// Target points to the resources that the patch document should be applied to.
2233 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2234 #[serde(rename_all = "camelCase")]
2235 pub struct PatchesItemTarget {
2236 /// 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.
2237 pub annotation_selector: String,
2238 /// 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
2239 pub group: String,
2240 /// 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
2241 pub kind: String,
2242 /// 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.
2243 pub label_selector: String,
2244 /// Name to match resources with.
2245 pub name: String,
2246 /// Namespace to select resources from.
2247 pub namespace: String,
2248 /// 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
2249 pub version: String,
2250 }
2251
2252 /// Target points to the resources that the patch document should be applied to.
2253 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2254 #[serde(rename_all = "camelCase")]
2255 pub struct PatchesJson6902ItemTarget {
2256 /// 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.
2257 pub annotation_selector: String,
2258 /// 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
2259 pub group: String,
2260 /// 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
2261 pub kind: String,
2262 /// 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.
2263 pub label_selector: String,
2264 /// Name to match resources with.
2265 pub name: String,
2266 /// Namespace to select resources from.
2267 pub namespace: String,
2268 /// 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
2269 pub version: String,
2270 }
2271 }
2272 }
2273 pub mod v1beta2 {
2274 pub mod kustomization {
2275 /// Kustomization is the Schema for the kustomizations API.
2276 #[derive(serde::Deserialize, Debug, PartialEq)]
2277 pub struct Kustomization {
2278 pub metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta,
2279 pub spec: Spec,
2280 pub status: Status,
2281 }
2282
2283 impl k8s_openapi::Resource for Kustomization {
2284 type Scope = k8s_openapi::ClusterResourceScope;
2285
2286 const API_VERSION: &'static str = "kustomize.toolkit.fluxcd.io/v1beta2";
2287 const GROUP: &'static str = "kustomize.toolkit.fluxcd.io";
2288 const KIND: &'static str = "Kustomization";
2289 const VERSION: &'static str = "v1beta2";
2290 const URL_PATH_SEGMENT: &'static str = "TODO";
2291 }
2292
2293 impl k8s_openapi::Metadata for Kustomization {
2294 type Ty = k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta;
2295
2296 fn metadata(&self) -> &<Self as k8s_openapi::Metadata>::Ty {
2297 &self.metadata
2298 }
2299
2300 fn metadata_mut(&mut self) -> &mut <Self as k8s_openapi::Metadata>::Ty {
2301 &mut self.metadata
2302 }
2303 }
2304
2305 impl serde::Serialize for Kustomization {
2306 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2307 where
2308 S: serde::Serializer,
2309 {
2310 use serde::ser::SerializeStruct;
2311 let mut state = serializer.serialize_struct("Kustomization", 5)?;
2312 state.serialize_field(
2313 "apiVersion",
2314 <Self as k8s_openapi::Resource>::API_VERSION,
2315 )?;
2316 state.serialize_field("kind", <Self as k8s_openapi::Resource>::KIND)?;
2317 state.serialize_field("metadata", &self.metadata)?;
2318 state.serialize_field("spec", &self.spec)?;
2319 state.serialize_field("status", &self.status)?;
2320 state.end()
2321 }
2322 }
2323
2324 /// Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: "Available", "Progressing", and "Degraded" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type" protobuf:"bytes,1,rep,name=conditions"`
2325 /// // other fields }
2326 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2327 #[serde(rename_all = "camelCase")]
2328 pub struct ConditionsItem {
2329 /// 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.
2330 pub last_transition_time: String,
2331 /// message is a human readable message indicating details about the transition. This may be an empty string.
2332 pub message: String,
2333 /// 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.
2334 pub observed_generation: i64,
2335 /// 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.
2336 pub reason: String,
2337 /// status of the condition, one of True, False, Unknown.
2338 pub status: String,
2339 /// type of condition in CamelCase or in foo.example.com/CamelCase. --- Many .condition.type values are consistent across resources like Available, but because arbitrary conditions can be useful (see .node.status.conditions), the ability to deconflict is important. The regex it matches is (dns1123SubdomainFmt/)?(qualifiedNameFmt)
2340 pub r#type: String,
2341 }
2342
2343 /// Decrypt Kubernetes secrets before applying them on the cluster.
2344 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2345 #[serde(rename_all = "camelCase")]
2346 pub struct Decryption {
2347 /// Provider is the name of the decryption engine.
2348 pub provider: String,
2349 /// The secret name containing the private OpenPGP keys used for decryption.
2350 pub secret_ref: DecryptionSecretRef,
2351 }
2352
2353 /// NamespacedObjectReference contains enough information to locate the referenced Kubernetes resource object in any namespace.
2354 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2355 #[serde(rename_all = "camelCase")]
2356 pub struct DependsOnItem {
2357 /// Name of the referent.
2358 pub name: String,
2359 /// Namespace of the referent, when not specified it acts as LocalObjectReference.
2360 pub namespace: String,
2361 }
2362
2363 /// ResourceRef contains the information necessary to locate a resource within a cluster.
2364 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2365 #[serde(rename_all = "camelCase")]
2366 pub struct EntriesItem {
2367 /// ID is the string representation of the Kubernetes resource object's metadata, in the format '<namespace>_<name>_<group>_<kind>'.
2368 pub id: String,
2369 /// Version is the API version of the Kubernetes resource object's kind.
2370 pub v: String,
2371 }
2372
2373 /// NamespacedObjectKindReference contains enough information to locate the typed referenced Kubernetes resource object in any namespace.
2374 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2375 #[serde(rename_all = "camelCase")]
2376 pub struct HealthChecksItem {
2377 /// API version of the referent, if not specified the Kubernetes preferred version will be used.
2378 pub api_version: String,
2379 /// Kind of the referent.
2380 pub kind: String,
2381 /// Name of the referent.
2382 pub name: String,
2383 /// Namespace of the referent, when not specified it acts as LocalObjectReference.
2384 pub namespace: String,
2385 }
2386
2387 /// Image contains an image name, a new name, a new tag or digest, which will replace the original name and tag.
2388 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2389 #[serde(rename_all = "camelCase")]
2390 pub struct ImagesItem {
2391 /// Digest is the value used to replace the original image tag. If digest is present NewTag value is ignored.
2392 pub digest: String,
2393 /// Name is a tag-less image name.
2394 pub name: String,
2395 /// NewName is the value used to replace the original name.
2396 pub new_name: String,
2397 /// NewTag is the value used to replace the original tag.
2398 pub new_tag: String,
2399 }
2400
2401 /// Inventory contains the list of Kubernetes resource object references that have been successfully applied.
2402 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2403 #[serde(rename_all = "camelCase")]
2404 pub struct Inventory {
2405 /// Entries of Kubernetes resource object references.
2406 pub entries: Vec<EntriesItem>,
2407 }
2408
2409 /// The KubeConfig for reconciling the Kustomization on a remote cluster. When used in combination with KustomizationSpec.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 KustomizationSpec.ServiceAccountName is empty.
2410 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2411 #[serde(rename_all = "camelCase")]
2412 pub struct KubeConfig {
2413 /// SecretRef holds the 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'. The secret must be in the same namespace as the Kustomization. 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 the Kustomization.
2414 pub secret_ref: KubeConfigSecretRef,
2415 }
2416
2417 /// JSON6902 is a JSON6902 operation object. https://datatracker.ietf.org/doc/html/rfc6902#section-4
2418 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2419 #[serde(rename_all = "camelCase")]
2420 pub struct PatchItem {
2421 /// From contains a JSON-pointer value that references a location within the target document where the operation is performed. The meaning of the value depends on the value of Op, and is NOT taken into account by all operations.
2422 pub from: String,
2423 /// Op indicates the operation to perform. Its value MUST be one of "add", "remove", "replace", "move", "copy", or "test". https://datatracker.ietf.org/doc/html/rfc6902#section-4
2424 pub op: String,
2425 /// Path contains the JSON-pointer value that references a location within the target document where the operation is performed. The meaning of the value depends on the value of Op.
2426 pub path: String,
2427 /// Value contains a valid JSON structure. The meaning of the value depends on the value of Op, and is NOT taken into account by all operations.
2428 pub value: serde_json::Map<String, serde_json::Value>,
2429 }
2430
2431 /// Patch contains an inline StrategicMerge or JSON6902 patch, and the target the patch should be applied to.
2432 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2433 #[serde(rename_all = "camelCase")]
2434 pub struct PatchesItem {
2435 /// Patch contains an inline StrategicMerge patch or an inline JSON6902 patch with an array of operation objects.
2436 pub patch: String,
2437 /// Target points to the resources that the patch document should be applied to.
2438 pub target: PatchesItemTarget,
2439 }
2440
2441 /// JSON6902Patch contains a JSON6902 patch and the target the patch should be applied to.
2442 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2443 #[serde(rename_all = "camelCase")]
2444 pub struct PatchesJson6902Item {
2445 /// Patch contains the JSON6902 patch document with an array of operation objects.
2446 pub patch: Vec<PatchItem>,
2447 /// Target points to the resources that the patch document should be applied to.
2448 pub target: PatchesJson6902ItemTarget,
2449 }
2450
2451 /// PostBuild describes which actions to perform on the YAML manifest generated by building the kustomize overlay.
2452 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2453 #[serde(rename_all = "camelCase")]
2454 pub struct PostBuild {
2455 /// Substitute holds a map of key/value pairs. The variables defined in your YAML manifests that match any of the keys defined in the map will be substituted with the set value. Includes support for bash string replacement functions e.g. ${var:=default}, ${var:position} and ${var/substring/replacement}.
2456 pub substitute: Substitute,
2457 /// SubstituteFrom holds references to ConfigMaps and Secrets containing the variables and their values to be substituted in the YAML manifests. The ConfigMap and the Secret data keys represent the var names and they must match the vars declared in the manifests for the substitution to happen.
2458 pub substitute_from: Vec<SubstituteFromItem>,
2459 }
2460
2461 /// The secret name containing the private OpenPGP keys used for decryption.
2462 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2463 #[serde(rename_all = "camelCase")]
2464 pub struct DecryptionSecretRef {
2465 /// Name of the referent.
2466 pub name: String,
2467 }
2468
2469 /// SecretRef holds the 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'. The secret must be in the same namespace as the Kustomization. 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 the Kustomization.
2470 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2471 #[serde(rename_all = "camelCase")]
2472 pub struct KubeConfigSecretRef {
2473 /// Key in the Secret, when not specified an implementation-specific default key is used.
2474 pub key: String,
2475 /// Name of the Secret.
2476 pub name: String,
2477 }
2478
2479 /// Reference of the source where the kustomization file is.
2480 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2481 #[serde(rename_all = "camelCase")]
2482 pub struct SourceRef {
2483 /// API version of the referent.
2484 pub api_version: String,
2485 /// Kind of the referent.
2486 pub kind: String,
2487 /// Name of the referent.
2488 pub name: String,
2489 /// Namespace of the referent, defaults to the namespace of the Kubernetes resource object that contains the reference.
2490 pub namespace: String,
2491 }
2492
2493 /// KustomizationSpec defines the configuration to calculate the desired state from a Source using Kustomize.
2494 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2495 #[serde(rename_all = "camelCase")]
2496 pub struct Spec {
2497 /// Decrypt Kubernetes secrets before applying them on the cluster.
2498 pub decryption: Decryption,
2499 /// DependsOn may contain a meta.NamespacedObjectReference slice with references to Kustomization resources that must be ready before this Kustomization can be reconciled.
2500 pub depends_on: Vec<DependsOnItem>,
2501 /// Force instructs the controller to recreate resources when patching fails due to an immutable field change.
2502 pub force: bool,
2503 /// A list of resources to be included in the health assessment.
2504 pub health_checks: Vec<HealthChecksItem>,
2505 /// 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.
2506 pub images: Vec<ImagesItem>,
2507 /// The interval at which to reconcile the Kustomization.
2508 pub interval: String,
2509 /// The KubeConfig for reconciling the Kustomization on a remote cluster. When used in combination with KustomizationSpec.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 KustomizationSpec.ServiceAccountName is empty.
2510 pub kube_config: KubeConfig,
2511 /// Strategic merge and JSON patches, defined as inline YAML objects, capable of targeting objects based on kind, label and annotation selectors.
2512 pub patches: Vec<PatchesItem>,
2513 /// JSON 6902 patches, defined as inline YAML objects. Deprecated: Use Patches instead.
2514 pub patches_json6902: Vec<PatchesJson6902Item>,
2515 /// Strategic merge patches, defined as inline YAML objects. Deprecated: Use Patches instead.
2516 pub patches_strategic_merge: Vec<serde_json::Map<String, serde_json::Value>>,
2517 /// Path to the directory containing the kustomization.yaml file, or the set of plain YAMLs a kustomization.yaml should be generated for. Defaults to 'None', which translates to the root path of the SourceRef.
2518 pub path: String,
2519 /// PostBuild describes which actions to perform on the YAML manifest generated by building the kustomize overlay.
2520 pub post_build: PostBuild,
2521 /// Prune enables garbage collection.
2522 pub prune: bool,
2523 /// The interval at which to retry a previously failed reconciliation. When not specified, the controller uses the KustomizationSpec.Interval value to retry failures.
2524 pub retry_interval: String,
2525 /// The name of the Kubernetes service account to impersonate when reconciling this Kustomization.
2526 pub service_account_name: String,
2527 /// Reference of the source where the kustomization file is.
2528 pub source_ref: SourceRef,
2529 /// This flag tells the controller to suspend subsequent kustomize executions, it does not apply to already started executions. Defaults to false.
2530 pub suspend: bool,
2531 /// TargetNamespace sets or overrides the namespace in the kustomization.yaml file.
2532 pub target_namespace: String,
2533 /// Timeout for validation, apply and health checking operations. Defaults to 'Interval' duration.
2534 pub timeout: String,
2535 /// Deprecated: Not used in v1beta2.
2536 pub validation: String,
2537 /// Wait instructs the controller to check the health of all the reconciled resources. When enabled, the HealthChecks are ignored. Defaults to false.
2538 pub wait: bool,
2539 }
2540
2541 /// KustomizationStatus defines the observed state of a kustomization.
2542 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2543 #[serde(rename_all = "camelCase")]
2544 pub struct Status {
2545 pub conditions: Vec<ConditionsItem>,
2546 /// Inventory contains the list of Kubernetes resource object references that have been successfully applied.
2547 pub inventory: Inventory,
2548 /// The last successfully applied revision. The revision format for Git sources is <branch|tag>/<commit-sha>.
2549 pub last_applied_revision: String,
2550 /// LastAttemptedRevision is the revision of the last reconciliation attempt.
2551 pub last_attempted_revision: String,
2552 /// LastHandledReconcileAt holds the value of the most recent reconcile request value, so a change of the annotation value can be detected.
2553 pub last_handled_reconcile_at: String,
2554 /// ObservedGeneration is the last reconciled generation.
2555 pub observed_generation: i64,
2556 }
2557
2558 /// Substitute holds a map of key/value pairs. The variables defined in your YAML manifests that match any of the keys defined in the map will be substituted with the set value. Includes support for bash string replacement functions e.g. ${var:=default}, ${var:position} and ${var/substring/replacement}.
2559 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2560 #[serde(rename_all = "camelCase")]
2561 pub struct Substitute {
2562 /// Substitute holds a map of key/value pairs. The variables defined in your YAML manifests that match any of the keys defined in the map will be substituted with the set value. Includes support for bash string replacement functions e.g. ${var:=default}, ${var:position} and ${var/substring/replacement}.
2563 pub properties: std::collections::HashMap<String, String>,
2564 }
2565
2566 /// SubstituteReference contains a reference to a resource containing the variables name and value.
2567 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2568 #[serde(rename_all = "camelCase")]
2569 pub struct SubstituteFromItem {
2570 /// Kind of the values referent, valid values are ('Secret', 'ConfigMap').
2571 pub kind: String,
2572 /// Name of the values referent. Should reside in the same namespace as the referring resource.
2573 pub name: String,
2574 /// Optional indicates whether the referenced resource must exist, or whether to tolerate its absence. If true and the referenced resource is absent, proceed as if the resource was present but empty, without any variables defined.
2575 pub optional: bool,
2576 }
2577
2578 /// Target points to the resources that the patch document should be applied to.
2579 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2580 #[serde(rename_all = "camelCase")]
2581 pub struct PatchesItemTarget {
2582 /// 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.
2583 pub annotation_selector: String,
2584 /// 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
2585 pub group: String,
2586 /// 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
2587 pub kind: String,
2588 /// 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.
2589 pub label_selector: String,
2590 /// Name to match resources with.
2591 pub name: String,
2592 /// Namespace to select resources from.
2593 pub namespace: String,
2594 /// 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
2595 pub version: String,
2596 }
2597
2598 /// Target points to the resources that the patch document should be applied to.
2599 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2600 #[serde(rename_all = "camelCase")]
2601 pub struct PatchesJson6902ItemTarget {
2602 /// 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.
2603 pub annotation_selector: String,
2604 /// 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
2605 pub group: String,
2606 /// 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
2607 pub kind: String,
2608 /// 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.
2609 pub label_selector: String,
2610 /// Name to match resources with.
2611 pub name: String,
2612 /// Namespace to select resources from.
2613 pub namespace: String,
2614 /// 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
2615 pub version: String,
2616 }
2617 }
2618 }
2619}
2620pub mod notification_toolkit_fluxcd_io {
2621 pub mod v1beta1 {
2622 pub mod alert {
2623 /// Alert is the Schema for the alerts API
2624 #[derive(serde::Deserialize, Debug, PartialEq)]
2625 pub struct Alert {
2626 pub metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta,
2627 pub spec: Spec,
2628 pub status: Status,
2629 }
2630
2631 impl k8s_openapi::Resource for Alert {
2632 type Scope = k8s_openapi::ClusterResourceScope;
2633
2634 const API_VERSION: &'static str = "notification.toolkit.fluxcd.io/v1beta1";
2635 const GROUP: &'static str = "notification.toolkit.fluxcd.io";
2636 const KIND: &'static str = "Alert";
2637 const VERSION: &'static str = "v1beta1";
2638 const URL_PATH_SEGMENT: &'static str = "TODO";
2639 }
2640
2641 impl k8s_openapi::Metadata for Alert {
2642 type Ty = k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta;
2643
2644 fn metadata(&self) -> &<Self as k8s_openapi::Metadata>::Ty {
2645 &self.metadata
2646 }
2647
2648 fn metadata_mut(&mut self) -> &mut <Self as k8s_openapi::Metadata>::Ty {
2649 &mut self.metadata
2650 }
2651 }
2652
2653 impl serde::Serialize for Alert {
2654 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2655 where
2656 S: serde::Serializer,
2657 {
2658 use serde::ser::SerializeStruct;
2659 let mut state = serializer.serialize_struct("Alert", 5)?;
2660 state.serialize_field(
2661 "apiVersion",
2662 <Self as k8s_openapi::Resource>::API_VERSION,
2663 )?;
2664 state.serialize_field("kind", <Self as k8s_openapi::Resource>::KIND)?;
2665 state.serialize_field("metadata", &self.metadata)?;
2666 state.serialize_field("spec", &self.spec)?;
2667 state.serialize_field("status", &self.status)?;
2668 state.end()
2669 }
2670 }
2671
2672 /// Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: "Available", "Progressing", and "Degraded" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type" protobuf:"bytes,1,rep,name=conditions"`
2673 /// // other fields }
2674 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2675 #[serde(rename_all = "camelCase")]
2676 pub struct ConditionsItem {
2677 /// 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.
2678 pub last_transition_time: String,
2679 /// message is a human readable message indicating details about the transition. This may be an empty string.
2680 pub message: String,
2681 /// 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.
2682 pub observed_generation: i64,
2683 /// 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.
2684 pub reason: String,
2685 /// status of the condition, one of True, False, Unknown.
2686 pub status: String,
2687 /// type of condition in CamelCase or in foo.example.com/CamelCase. --- Many .condition.type values are consistent across resources like Available, but because arbitrary conditions can be useful (see .node.status.conditions), the ability to deconflict is important. The regex it matches is (dns1123SubdomainFmt/)?(qualifiedNameFmt)
2688 pub r#type: String,
2689 }
2690
2691 /// CrossNamespaceObjectReference contains enough information to let you locate the typed referenced object at cluster level
2692 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2693 #[serde(rename_all = "camelCase")]
2694 pub struct EventSourcesItem {
2695 /// API version of the referent
2696 pub api_version: String,
2697 /// Kind of the referent
2698 pub kind: String,
2699 /// MatchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
2700 pub match_labels: MatchLabels,
2701 /// Name of the referent
2702 pub name: String,
2703 /// Namespace of the referent
2704 pub namespace: String,
2705 }
2706
2707 /// MatchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
2708 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2709 #[serde(rename_all = "camelCase")]
2710 pub struct MatchLabels {
2711 /// MatchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
2712 pub properties: std::collections::HashMap<String, String>,
2713 }
2714
2715 /// Send events using this provider.
2716 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2717 #[serde(rename_all = "camelCase")]
2718 pub struct ProviderRef {
2719 /// Name of the referent.
2720 pub name: String,
2721 }
2722
2723 /// AlertSpec defines an alerting rule for events involving a list of objects
2724 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2725 #[serde(rename_all = "camelCase")]
2726 pub struct Spec {
2727 /// Filter events based on severity, defaults to ('info'). If set to 'info' no events will be filtered.
2728 pub event_severity: String,
2729 /// Filter events based on the involved objects.
2730 pub event_sources: Vec<EventSourcesItem>,
2731 /// A list of Golang regular expressions to be used for excluding messages.
2732 pub exclusion_list: Vec<String>,
2733 /// Send events using this provider.
2734 pub provider_ref: ProviderRef,
2735 /// Short description of the impact and affected cluster.
2736 pub summary: String,
2737 /// This flag tells the controller to suspend subsequent events dispatching. Defaults to false.
2738 pub suspend: bool,
2739 }
2740
2741 /// AlertStatus defines the observed state of Alert
2742 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2743 #[serde(rename_all = "camelCase")]
2744 pub struct Status {
2745 pub conditions: Vec<ConditionsItem>,
2746 /// ObservedGeneration is the last observed generation.
2747 pub observed_generation: i64,
2748 }
2749 }
2750 pub mod provider {
2751 /// Provider is the Schema for the providers API
2752 #[derive(serde::Deserialize, Debug, PartialEq)]
2753 pub struct Provider {
2754 pub metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta,
2755 pub spec: Spec,
2756 pub status: Status,
2757 }
2758
2759 impl k8s_openapi::Resource for Provider {
2760 type Scope = k8s_openapi::ClusterResourceScope;
2761
2762 const API_VERSION: &'static str = "notification.toolkit.fluxcd.io/v1beta1";
2763 const GROUP: &'static str = "notification.toolkit.fluxcd.io";
2764 const KIND: &'static str = "Provider";
2765 const VERSION: &'static str = "v1beta1";
2766 const URL_PATH_SEGMENT: &'static str = "TODO";
2767 }
2768
2769 impl k8s_openapi::Metadata for Provider {
2770 type Ty = k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta;
2771
2772 fn metadata(&self) -> &<Self as k8s_openapi::Metadata>::Ty {
2773 &self.metadata
2774 }
2775
2776 fn metadata_mut(&mut self) -> &mut <Self as k8s_openapi::Metadata>::Ty {
2777 &mut self.metadata
2778 }
2779 }
2780
2781 impl serde::Serialize for Provider {
2782 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2783 where
2784 S: serde::Serializer,
2785 {
2786 use serde::ser::SerializeStruct;
2787 let mut state = serializer.serialize_struct("Provider", 5)?;
2788 state.serialize_field(
2789 "apiVersion",
2790 <Self as k8s_openapi::Resource>::API_VERSION,
2791 )?;
2792 state.serialize_field("kind", <Self as k8s_openapi::Resource>::KIND)?;
2793 state.serialize_field("metadata", &self.metadata)?;
2794 state.serialize_field("spec", &self.spec)?;
2795 state.serialize_field("status", &self.status)?;
2796 state.end()
2797 }
2798 }
2799
2800 /// CertSecretRef can be given the name of a secret containing a PEM-encoded CA certificate (`caFile`)
2801 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2802 #[serde(rename_all = "camelCase")]
2803 pub struct CertSecretRef {
2804 /// Name of the referent.
2805 pub name: String,
2806 }
2807
2808 /// Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: "Available", "Progressing", and "Degraded" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type" protobuf:"bytes,1,rep,name=conditions"`
2809 /// // other fields }
2810 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2811 #[serde(rename_all = "camelCase")]
2812 pub struct ConditionsItem {
2813 /// 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.
2814 pub last_transition_time: String,
2815 /// message is a human readable message indicating details about the transition. This may be an empty string.
2816 pub message: String,
2817 /// 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.
2818 pub observed_generation: i64,
2819 /// 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.
2820 pub reason: String,
2821 /// status of the condition, one of True, False, Unknown.
2822 pub status: String,
2823 /// type of condition in CamelCase or in foo.example.com/CamelCase. --- Many .condition.type values are consistent across resources like Available, but because arbitrary conditions can be useful (see .node.status.conditions), the ability to deconflict is important. The regex it matches is (dns1123SubdomainFmt/)?(qualifiedNameFmt)
2824 pub r#type: String,
2825 }
2826
2827 /// Secret reference containing the provider webhook URL using "address" as data key
2828 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2829 #[serde(rename_all = "camelCase")]
2830 pub struct SecretRef {
2831 /// Name of the referent.
2832 pub name: String,
2833 }
2834
2835 /// ProviderSpec defines the desired state of Provider
2836 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2837 #[serde(rename_all = "camelCase")]
2838 pub struct Spec {
2839 /// HTTP/S webhook address of this provider
2840 pub address: String,
2841 /// CertSecretRef can be given the name of a secret containing a PEM-encoded CA certificate (`caFile`)
2842 pub cert_secret_ref: CertSecretRef,
2843 /// Alert channel for this provider
2844 pub channel: String,
2845 /// HTTP/S address of the proxy
2846 pub proxy: String,
2847 /// Secret reference containing the provider webhook URL using "address" as data key
2848 pub secret_ref: SecretRef,
2849 /// This flag tells the controller to suspend subsequent events handling. Defaults to false.
2850 pub suspend: bool,
2851 /// Type of provider
2852 pub r#type: String,
2853 /// Bot username for this provider
2854 pub username: String,
2855 }
2856
2857 /// ProviderStatus defines the observed state of Provider
2858 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2859 #[serde(rename_all = "camelCase")]
2860 pub struct Status {
2861 pub conditions: Vec<ConditionsItem>,
2862 /// ObservedGeneration is the last reconciled generation.
2863 pub observed_generation: i64,
2864 }
2865 }
2866 pub mod receiver {
2867 /// Receiver is the Schema for the receivers API
2868 #[derive(serde::Deserialize, Debug, PartialEq)]
2869 pub struct Receiver {
2870 pub metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta,
2871 pub spec: Spec,
2872 pub status: Status,
2873 }
2874
2875 impl k8s_openapi::Resource for Receiver {
2876 type Scope = k8s_openapi::ClusterResourceScope;
2877
2878 const API_VERSION: &'static str = "notification.toolkit.fluxcd.io/v1beta1";
2879 const GROUP: &'static str = "notification.toolkit.fluxcd.io";
2880 const KIND: &'static str = "Receiver";
2881 const VERSION: &'static str = "v1beta1";
2882 const URL_PATH_SEGMENT: &'static str = "TODO";
2883 }
2884
2885 impl k8s_openapi::Metadata for Receiver {
2886 type Ty = k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta;
2887
2888 fn metadata(&self) -> &<Self as k8s_openapi::Metadata>::Ty {
2889 &self.metadata
2890 }
2891
2892 fn metadata_mut(&mut self) -> &mut <Self as k8s_openapi::Metadata>::Ty {
2893 &mut self.metadata
2894 }
2895 }
2896
2897 impl serde::Serialize for Receiver {
2898 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2899 where
2900 S: serde::Serializer,
2901 {
2902 use serde::ser::SerializeStruct;
2903 let mut state = serializer.serialize_struct("Receiver", 5)?;
2904 state.serialize_field(
2905 "apiVersion",
2906 <Self as k8s_openapi::Resource>::API_VERSION,
2907 )?;
2908 state.serialize_field("kind", <Self as k8s_openapi::Resource>::KIND)?;
2909 state.serialize_field("metadata", &self.metadata)?;
2910 state.serialize_field("spec", &self.spec)?;
2911 state.serialize_field("status", &self.status)?;
2912 state.end()
2913 }
2914 }
2915
2916 /// Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: "Available", "Progressing", and "Degraded" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type" protobuf:"bytes,1,rep,name=conditions"`
2917 /// // other fields }
2918 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2919 #[serde(rename_all = "camelCase")]
2920 pub struct ConditionsItem {
2921 /// 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.
2922 pub last_transition_time: String,
2923 /// message is a human readable message indicating details about the transition. This may be an empty string.
2924 pub message: String,
2925 /// 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.
2926 pub observed_generation: i64,
2927 /// 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.
2928 pub reason: String,
2929 /// status of the condition, one of True, False, Unknown.
2930 pub status: String,
2931 /// type of condition in CamelCase or in foo.example.com/CamelCase. --- Many .condition.type values are consistent across resources like Available, but because arbitrary conditions can be useful (see .node.status.conditions), the ability to deconflict is important. The regex it matches is (dns1123SubdomainFmt/)?(qualifiedNameFmt)
2932 pub r#type: String,
2933 }
2934
2935 /// MatchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
2936 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2937 #[serde(rename_all = "camelCase")]
2938 pub struct MatchLabels {
2939 /// MatchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
2940 pub properties: std::collections::HashMap<String, String>,
2941 }
2942
2943 /// CrossNamespaceObjectReference contains enough information to let you locate the typed referenced object at cluster level
2944 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2945 #[serde(rename_all = "camelCase")]
2946 pub struct ResourcesItem {
2947 /// API version of the referent
2948 pub api_version: String,
2949 /// Kind of the referent
2950 pub kind: String,
2951 /// MatchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
2952 pub match_labels: MatchLabels,
2953 /// Name of the referent
2954 pub name: String,
2955 /// Namespace of the referent
2956 pub namespace: String,
2957 }
2958
2959 /// Secret reference containing the token used to validate the payload authenticity
2960 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2961 #[serde(rename_all = "camelCase")]
2962 pub struct SecretRef {
2963 /// Name of the referent.
2964 pub name: String,
2965 }
2966
2967 /// ReceiverSpec defines the desired state of Receiver
2968 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2969 #[serde(rename_all = "camelCase")]
2970 pub struct Spec {
2971 /// A list of events to handle, e.g. 'push' for GitHub or 'Push Hook' for GitLab.
2972 pub events: Vec<String>,
2973 /// A list of resources to be notified about changes.
2974 pub resources: Vec<ResourcesItem>,
2975 /// Secret reference containing the token used to validate the payload authenticity
2976 pub secret_ref: SecretRef,
2977 /// This flag tells the controller to suspend subsequent events handling. Defaults to false.
2978 pub suspend: bool,
2979 /// Type of webhook sender, used to determine the validation procedure and payload deserialization.
2980 pub r#type: String,
2981 }
2982
2983 /// ReceiverStatus defines the observed state of Receiver
2984 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2985 #[serde(rename_all = "camelCase")]
2986 pub struct Status {
2987 pub conditions: Vec<ConditionsItem>,
2988 /// ObservedGeneration is the last observed generation.
2989 pub observed_generation: i64,
2990 /// Generated webhook URL in the format of '/hook/sha256sum(token+name+namespace)'.
2991 pub url: String,
2992 }
2993 }
2994 }
2995}
2996pub mod source_toolkit_fluxcd_io {
2997 pub mod v1beta1 {
2998 pub mod bucket {
2999 /// Bucket is the Schema for the buckets API
3000 #[derive(serde::Deserialize, Debug, PartialEq)]
3001 pub struct Bucket {
3002 pub metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta,
3003 pub spec: Spec,
3004 pub status: Status,
3005 }
3006
3007 impl k8s_openapi::Resource for Bucket {
3008 type Scope = k8s_openapi::ClusterResourceScope;
3009
3010 const API_VERSION: &'static str = "source.toolkit.fluxcd.io/v1beta1";
3011 const GROUP: &'static str = "source.toolkit.fluxcd.io";
3012 const KIND: &'static str = "Bucket";
3013 const VERSION: &'static str = "v1beta1";
3014 const URL_PATH_SEGMENT: &'static str = "TODO";
3015 }
3016
3017 impl k8s_openapi::Metadata for Bucket {
3018 type Ty = k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta;
3019
3020 fn metadata(&self) -> &<Self as k8s_openapi::Metadata>::Ty {
3021 &self.metadata
3022 }
3023
3024 fn metadata_mut(&mut self) -> &mut <Self as k8s_openapi::Metadata>::Ty {
3025 &mut self.metadata
3026 }
3027 }
3028
3029 impl serde::Serialize for Bucket {
3030 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3031 where
3032 S: serde::Serializer,
3033 {
3034 use serde::ser::SerializeStruct;
3035 let mut state = serializer.serialize_struct("Bucket", 5)?;
3036 state.serialize_field(
3037 "apiVersion",
3038 <Self as k8s_openapi::Resource>::API_VERSION,
3039 )?;
3040 state.serialize_field("kind", <Self as k8s_openapi::Resource>::KIND)?;
3041 state.serialize_field("metadata", &self.metadata)?;
3042 state.serialize_field("spec", &self.spec)?;
3043 state.serialize_field("status", &self.status)?;
3044 state.end()
3045 }
3046 }
3047
3048 /// AccessFrom defines an Access Control List for allowing cross-namespace references to this object.
3049 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3050 #[serde(rename_all = "camelCase")]
3051 pub struct AccessFrom {
3052 /// NamespaceSelectors is the list of namespace selectors to which this ACL applies. Items in this list are evaluated using a logical OR operation.
3053 pub namespace_selectors: Vec<NamespaceSelectorsItem>,
3054 }
3055
3056 /// Artifact represents the output of the last successful Bucket sync.
3057 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3058 #[serde(rename_all = "camelCase")]
3059 pub struct Artifact {
3060 /// Checksum is the SHA256 checksum of the artifact.
3061 pub checksum: String,
3062 /// LastUpdateTime is the timestamp corresponding to the last update of this artifact.
3063 pub last_update_time: String,
3064 /// Path is the relative file path of this artifact.
3065 pub path: String,
3066 /// Revision is a human readable identifier traceable in the origin source system. It can be a Git commit SHA, Git tag, a Helm index timestamp, a Helm chart version, etc.
3067 pub revision: String,
3068 /// URL is the HTTP address of this artifact.
3069 pub url: String,
3070 }
3071
3072 /// Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: "Available", "Progressing", and "Degraded" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type" protobuf:"bytes,1,rep,name=conditions"`
3073 /// // other fields }
3074 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3075 #[serde(rename_all = "camelCase")]
3076 pub struct ConditionsItem {
3077 /// 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.
3078 pub last_transition_time: String,
3079 /// message is a human readable message indicating details about the transition. This may be an empty string.
3080 pub message: String,
3081 /// 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.
3082 pub observed_generation: i64,
3083 /// 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.
3084 pub reason: String,
3085 /// status of the condition, one of True, False, Unknown.
3086 pub status: String,
3087 /// type of condition in CamelCase or in foo.example.com/CamelCase. --- Many .condition.type values are consistent across resources like Available, but because arbitrary conditions can be useful (see .node.status.conditions), the ability to deconflict is important. The regex it matches is (dns1123SubdomainFmt/)?(qualifiedNameFmt)
3088 pub r#type: String,
3089 }
3090
3091 /// MatchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
3092 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3093 #[serde(rename_all = "camelCase")]
3094 pub struct MatchLabels {
3095 /// MatchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
3096 pub properties: std::collections::HashMap<String, String>,
3097 }
3098
3099 /// NamespaceSelector selects the namespaces to which this ACL applies. An empty map of MatchLabels matches all namespaces in a cluster.
3100 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3101 #[serde(rename_all = "camelCase")]
3102 pub struct NamespaceSelectorsItem {
3103 /// MatchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
3104 pub match_labels: MatchLabels,
3105 }
3106
3107 /// The name of the secret containing authentication credentials for the Bucket.
3108 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3109 #[serde(rename_all = "camelCase")]
3110 pub struct SecretRef {
3111 /// Name of the referent.
3112 pub name: String,
3113 }
3114
3115 /// BucketSpec defines the desired state of an S3 compatible bucket
3116 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3117 #[serde(rename_all = "camelCase")]
3118 pub struct Spec {
3119 /// AccessFrom defines an Access Control List for allowing cross-namespace references to this object.
3120 pub access_from: AccessFrom,
3121 /// The bucket name.
3122 pub bucket_name: String,
3123 /// The bucket endpoint address.
3124 pub endpoint: String,
3125 /// Ignore overrides the set of excluded patterns in the .sourceignore format (which is the same as .gitignore). If not provided, a default will be used, consult the documentation for your version to find out what those are.
3126 pub ignore: String,
3127 /// Insecure allows connecting to a non-TLS S3 HTTP endpoint.
3128 pub insecure: bool,
3129 /// The interval at which to check for bucket updates.
3130 pub interval: String,
3131 /// The S3 compatible storage provider name, default ('generic').
3132 pub provider: String,
3133 /// The bucket region.
3134 pub region: String,
3135 /// The name of the secret containing authentication credentials for the Bucket.
3136 pub secret_ref: SecretRef,
3137 /// This flag tells the controller to suspend the reconciliation of this source.
3138 pub suspend: bool,
3139 /// The timeout for download operations, defaults to 60s.
3140 pub timeout: String,
3141 }
3142
3143 /// BucketStatus defines the observed state of a bucket
3144 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3145 #[serde(rename_all = "camelCase")]
3146 pub struct Status {
3147 /// Artifact represents the output of the last successful Bucket sync.
3148 pub artifact: Artifact,
3149 /// Conditions holds the conditions for the Bucket.
3150 pub conditions: Vec<ConditionsItem>,
3151 /// LastHandledReconcileAt holds the value of the most recent reconcile request value, so a change of the annotation value can be detected.
3152 pub last_handled_reconcile_at: String,
3153 /// ObservedGeneration is the last observed generation.
3154 pub observed_generation: i64,
3155 /// URL is the download link for the artifact output of the last Bucket sync.
3156 pub url: String,
3157 }
3158 }
3159 pub mod git_repository {
3160 /// GitRepository is the Schema for the gitrepositories API
3161 #[derive(serde::Deserialize, Debug, PartialEq)]
3162 pub struct GitRepository {
3163 pub metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta,
3164 pub spec: Spec,
3165 pub status: Status,
3166 }
3167
3168 impl k8s_openapi::Resource for GitRepository {
3169 type Scope = k8s_openapi::ClusterResourceScope;
3170
3171 const API_VERSION: &'static str = "source.toolkit.fluxcd.io/v1beta1";
3172 const GROUP: &'static str = "source.toolkit.fluxcd.io";
3173 const KIND: &'static str = "GitRepository";
3174 const VERSION: &'static str = "v1beta1";
3175 const URL_PATH_SEGMENT: &'static str = "TODO";
3176 }
3177
3178 impl k8s_openapi::Metadata for GitRepository {
3179 type Ty = k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta;
3180
3181 fn metadata(&self) -> &<Self as k8s_openapi::Metadata>::Ty {
3182 &self.metadata
3183 }
3184
3185 fn metadata_mut(&mut self) -> &mut <Self as k8s_openapi::Metadata>::Ty {
3186 &mut self.metadata
3187 }
3188 }
3189
3190 impl serde::Serialize for GitRepository {
3191 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3192 where
3193 S: serde::Serializer,
3194 {
3195 use serde::ser::SerializeStruct;
3196 let mut state = serializer.serialize_struct("GitRepository", 5)?;
3197 state.serialize_field(
3198 "apiVersion",
3199 <Self as k8s_openapi::Resource>::API_VERSION,
3200 )?;
3201 state.serialize_field("kind", <Self as k8s_openapi::Resource>::KIND)?;
3202 state.serialize_field("metadata", &self.metadata)?;
3203 state.serialize_field("spec", &self.spec)?;
3204 state.serialize_field("status", &self.status)?;
3205 state.end()
3206 }
3207 }
3208
3209 /// AccessFrom defines an Access Control List for allowing cross-namespace references to this object.
3210 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3211 #[serde(rename_all = "camelCase")]
3212 pub struct AccessFrom {
3213 /// NamespaceSelectors is the list of namespace selectors to which this ACL applies. Items in this list are evaluated using a logical OR operation.
3214 pub namespace_selectors: Vec<NamespaceSelectorsItem>,
3215 }
3216
3217 /// Artifact represents the output of the last successful repository sync.
3218 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3219 #[serde(rename_all = "camelCase")]
3220 pub struct Artifact {
3221 /// Checksum is the SHA256 checksum of the artifact.
3222 pub checksum: String,
3223 /// LastUpdateTime is the timestamp corresponding to the last update of this artifact.
3224 pub last_update_time: String,
3225 /// Path is the relative file path of this artifact.
3226 pub path: String,
3227 /// Revision is a human readable identifier traceable in the origin source system. It can be a Git commit SHA, Git tag, a Helm index timestamp, a Helm chart version, etc.
3228 pub revision: String,
3229 /// URL is the HTTP address of this artifact.
3230 pub url: String,
3231 }
3232
3233 /// Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: "Available", "Progressing", and "Degraded" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type" protobuf:"bytes,1,rep,name=conditions"`
3234 /// // other fields }
3235 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3236 #[serde(rename_all = "camelCase")]
3237 pub struct ConditionsItem {
3238 /// 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.
3239 pub last_transition_time: String,
3240 /// message is a human readable message indicating details about the transition. This may be an empty string.
3241 pub message: String,
3242 /// 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.
3243 pub observed_generation: i64,
3244 /// 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.
3245 pub reason: String,
3246 /// status of the condition, one of True, False, Unknown.
3247 pub status: String,
3248 /// type of condition in CamelCase or in foo.example.com/CamelCase. --- Many .condition.type values are consistent across resources like Available, but because arbitrary conditions can be useful (see .node.status.conditions), the ability to deconflict is important. The regex it matches is (dns1123SubdomainFmt/)?(qualifiedNameFmt)
3249 pub r#type: String,
3250 }
3251
3252 /// GitRepositoryInclude defines a source with a from and to path.
3253 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3254 #[serde(rename_all = "camelCase")]
3255 pub struct IncludeItem {
3256 /// The path to copy contents from, defaults to the root directory.
3257 pub from_path: String,
3258 /// Reference to a GitRepository to include.
3259 pub repository: Repository,
3260 /// The path to copy contents to, defaults to the name of the source ref.
3261 pub to_path: String,
3262 }
3263
3264 /// Artifact represents the output of a source synchronisation.
3265 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3266 #[serde(rename_all = "camelCase")]
3267 pub struct IncludedArtifactsItem {
3268 /// Checksum is the SHA256 checksum of the artifact.
3269 pub checksum: String,
3270 /// LastUpdateTime is the timestamp corresponding to the last update of this artifact.
3271 pub last_update_time: String,
3272 /// Path is the relative file path of this artifact.
3273 pub path: String,
3274 /// Revision is a human readable identifier traceable in the origin source system. It can be a Git commit SHA, Git tag, a Helm index timestamp, a Helm chart version, etc.
3275 pub revision: String,
3276 /// URL is the HTTP address of this artifact.
3277 pub url: String,
3278 }
3279
3280 /// MatchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
3281 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3282 #[serde(rename_all = "camelCase")]
3283 pub struct MatchLabels {
3284 /// MatchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
3285 pub properties: std::collections::HashMap<String, String>,
3286 }
3287
3288 /// NamespaceSelector selects the namespaces to which this ACL applies. An empty map of MatchLabels matches all namespaces in a cluster.
3289 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3290 #[serde(rename_all = "camelCase")]
3291 pub struct NamespaceSelectorsItem {
3292 /// MatchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
3293 pub match_labels: MatchLabels,
3294 }
3295
3296 /// The Git reference to checkout and monitor for changes, defaults to master branch.
3297 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3298 #[serde(rename_all = "camelCase")]
3299 pub struct Ref {
3300 /// The Git branch to checkout, defaults to master.
3301 pub branch: String,
3302 /// The Git commit SHA to checkout, if specified Tag filters will be ignored.
3303 pub commit: String,
3304 /// The Git tag semver expression, takes precedence over Tag.
3305 pub semver: String,
3306 /// The Git tag to checkout, takes precedence over Branch.
3307 pub tag: String,
3308 }
3309
3310 /// Reference to a GitRepository to include.
3311 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3312 #[serde(rename_all = "camelCase")]
3313 pub struct Repository {
3314 /// Name of the referent.
3315 pub name: String,
3316 }
3317
3318 /// The secret name containing the Git credentials. For HTTPS repositories the secret must contain username and password fields. For SSH repositories the secret must contain identity and known_hosts fields.
3319 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3320 #[serde(rename_all = "camelCase")]
3321 pub struct SpecSecretRef {
3322 /// Name of the referent.
3323 pub name: String,
3324 }
3325
3326 /// The secret name containing the public keys of all trusted Git authors.
3327 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3328 #[serde(rename_all = "camelCase")]
3329 pub struct VerifySecretRef {
3330 /// Name of the referent.
3331 pub name: String,
3332 }
3333
3334 /// GitRepositorySpec defines the desired state of a Git repository.
3335 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3336 #[serde(rename_all = "camelCase")]
3337 pub struct Spec {
3338 /// AccessFrom defines an Access Control List for allowing cross-namespace references to this object.
3339 pub access_from: AccessFrom,
3340 /// Determines which git client library to use. Defaults to go-git, valid values are ('go-git', 'libgit2').
3341 pub git_implementation: String,
3342 /// Ignore overrides the set of excluded patterns in the .sourceignore format (which is the same as .gitignore). If not provided, a default will be used, consult the documentation for your version to find out what those are.
3343 pub ignore: String,
3344 /// Extra git repositories to map into the repository
3345 pub include: Vec<IncludeItem>,
3346 /// The interval at which to check for repository updates.
3347 pub interval: String,
3348 /// When enabled, after the clone is created, initializes all submodules within, using their default settings. This option is available only when using the 'go-git' GitImplementation.
3349 pub recurse_submodules: bool,
3350 /// The Git reference to checkout and monitor for changes, defaults to master branch.
3351 pub r#ref: Ref,
3352 /// The secret name containing the Git credentials. For HTTPS repositories the secret must contain username and password fields. For SSH repositories the secret must contain identity and known_hosts fields.
3353 pub secret_ref: SpecSecretRef,
3354 /// This flag tells the controller to suspend the reconciliation of this source.
3355 pub suspend: bool,
3356 /// The timeout for remote Git operations like cloning, defaults to 60s.
3357 pub timeout: String,
3358 /// The repository URL, can be a HTTP/S or SSH address.
3359 pub url: String,
3360 /// Verify OpenPGP signature for the Git commit HEAD points to.
3361 pub verify: Verify,
3362 }
3363
3364 /// GitRepositoryStatus defines the observed state of a Git repository.
3365 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3366 #[serde(rename_all = "camelCase")]
3367 pub struct Status {
3368 /// Artifact represents the output of the last successful repository sync.
3369 pub artifact: Artifact,
3370 /// Conditions holds the conditions for the GitRepository.
3371 pub conditions: Vec<ConditionsItem>,
3372 /// IncludedArtifacts represents the included artifacts from the last successful repository sync.
3373 pub included_artifacts: Vec<IncludedArtifactsItem>,
3374 /// LastHandledReconcileAt holds the value of the most recent reconcile request value, so a change of the annotation value can be detected.
3375 pub last_handled_reconcile_at: String,
3376 /// ObservedGeneration is the last observed generation.
3377 pub observed_generation: i64,
3378 /// URL is the download link for the artifact output of the last repository sync.
3379 pub url: String,
3380 }
3381
3382 /// Verify OpenPGP signature for the Git commit HEAD points to.
3383 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3384 #[serde(rename_all = "camelCase")]
3385 pub struct Verify {
3386 /// Mode describes what git object should be verified, currently ('head').
3387 pub mode: String,
3388 /// The secret name containing the public keys of all trusted Git authors.
3389 pub secret_ref: VerifySecretRef,
3390 }
3391 }
3392 pub mod helm_chart {
3393 /// HelmChart is the Schema for the helmcharts API
3394 #[derive(serde::Deserialize, Debug, PartialEq)]
3395 pub struct HelmChart {
3396 pub metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta,
3397 pub spec: Spec,
3398 pub status: Status,
3399 }
3400
3401 impl k8s_openapi::Resource for HelmChart {
3402 type Scope = k8s_openapi::ClusterResourceScope;
3403
3404 const API_VERSION: &'static str = "source.toolkit.fluxcd.io/v1beta1";
3405 const GROUP: &'static str = "source.toolkit.fluxcd.io";
3406 const KIND: &'static str = "HelmChart";
3407 const VERSION: &'static str = "v1beta1";
3408 const URL_PATH_SEGMENT: &'static str = "TODO";
3409 }
3410
3411 impl k8s_openapi::Metadata for HelmChart {
3412 type Ty = k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta;
3413
3414 fn metadata(&self) -> &<Self as k8s_openapi::Metadata>::Ty {
3415 &self.metadata
3416 }
3417
3418 fn metadata_mut(&mut self) -> &mut <Self as k8s_openapi::Metadata>::Ty {
3419 &mut self.metadata
3420 }
3421 }
3422
3423 impl serde::Serialize for HelmChart {
3424 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3425 where
3426 S: serde::Serializer,
3427 {
3428 use serde::ser::SerializeStruct;
3429 let mut state = serializer.serialize_struct("HelmChart", 5)?;
3430 state.serialize_field(
3431 "apiVersion",
3432 <Self as k8s_openapi::Resource>::API_VERSION,
3433 )?;
3434 state.serialize_field("kind", <Self as k8s_openapi::Resource>::KIND)?;
3435 state.serialize_field("metadata", &self.metadata)?;
3436 state.serialize_field("spec", &self.spec)?;
3437 state.serialize_field("status", &self.status)?;
3438 state.end()
3439 }
3440 }
3441
3442 /// AccessFrom defines an Access Control List for allowing cross-namespace references to this object.
3443 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3444 #[serde(rename_all = "camelCase")]
3445 pub struct AccessFrom {
3446 /// NamespaceSelectors is the list of namespace selectors to which this ACL applies. Items in this list are evaluated using a logical OR operation.
3447 pub namespace_selectors: Vec<NamespaceSelectorsItem>,
3448 }
3449
3450 /// Artifact represents the output of the last successful chart sync.
3451 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3452 #[serde(rename_all = "camelCase")]
3453 pub struct Artifact {
3454 /// Checksum is the SHA256 checksum of the artifact.
3455 pub checksum: String,
3456 /// LastUpdateTime is the timestamp corresponding to the last update of this artifact.
3457 pub last_update_time: String,
3458 /// Path is the relative file path of this artifact.
3459 pub path: String,
3460 /// Revision is a human readable identifier traceable in the origin source system. It can be a Git commit SHA, Git tag, a Helm index timestamp, a Helm chart version, etc.
3461 pub revision: String,
3462 /// URL is the HTTP address of this artifact.
3463 pub url: String,
3464 }
3465
3466 /// Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: "Available", "Progressing", and "Degraded" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type" protobuf:"bytes,1,rep,name=conditions"`
3467 /// // other fields }
3468 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3469 #[serde(rename_all = "camelCase")]
3470 pub struct ConditionsItem {
3471 /// 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.
3472 pub last_transition_time: String,
3473 /// message is a human readable message indicating details about the transition. This may be an empty string.
3474 pub message: String,
3475 /// 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.
3476 pub observed_generation: i64,
3477 /// 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.
3478 pub reason: String,
3479 /// status of the condition, one of True, False, Unknown.
3480 pub status: String,
3481 /// type of condition in CamelCase or in foo.example.com/CamelCase. --- Many .condition.type values are consistent across resources like Available, but because arbitrary conditions can be useful (see .node.status.conditions), the ability to deconflict is important. The regex it matches is (dns1123SubdomainFmt/)?(qualifiedNameFmt)
3482 pub r#type: String,
3483 }
3484
3485 /// MatchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
3486 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3487 #[serde(rename_all = "camelCase")]
3488 pub struct MatchLabels {
3489 /// MatchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
3490 pub properties: std::collections::HashMap<String, String>,
3491 }
3492
3493 /// NamespaceSelector selects the namespaces to which this ACL applies. An empty map of MatchLabels matches all namespaces in a cluster.
3494 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3495 #[serde(rename_all = "camelCase")]
3496 pub struct NamespaceSelectorsItem {
3497 /// MatchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
3498 pub match_labels: MatchLabels,
3499 }
3500
3501 /// The reference to the Source the chart is available at.
3502 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3503 #[serde(rename_all = "camelCase")]
3504 pub struct SourceRef {
3505 /// APIVersion of the referent.
3506 pub api_version: String,
3507 /// Kind of the referent, valid values are ('HelmRepository', 'GitRepository', 'Bucket').
3508 pub kind: String,
3509 /// Name of the referent.
3510 pub name: String,
3511 }
3512
3513 /// HelmChartSpec defines the desired state of a Helm chart.
3514 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3515 #[serde(rename_all = "camelCase")]
3516 pub struct Spec {
3517 /// AccessFrom defines an Access Control List for allowing cross-namespace references to this object.
3518 pub access_from: AccessFrom,
3519 /// The name or path the Helm chart is available at in the SourceRef.
3520 pub chart: String,
3521 /// The interval at which to check the Source for updates.
3522 pub interval: String,
3523 /// 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.
3524 pub reconcile_strategy: String,
3525 /// The reference to the Source the chart is available at.
3526 pub source_ref: SourceRef,
3527 /// This flag tells the controller to suspend the reconciliation of this source.
3528 pub suspend: bool,
3529 /// Alternative values file to use as the default chart values, expected to be a relative path in the SourceRef. Deprecated in favor of ValuesFiles, for backwards compatibility the file defined here is merged before the ValuesFiles items. Ignored when omitted.
3530 pub values_file: String,
3531 /// 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.
3532 pub values_files: Vec<String>,
3533 /// The chart version semver expression, ignored for charts from GitRepository and Bucket sources. Defaults to latest when omitted.
3534 pub version: String,
3535 }
3536
3537 /// HelmChartStatus defines the observed state of the HelmChart.
3538 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3539 #[serde(rename_all = "camelCase")]
3540 pub struct Status {
3541 /// Artifact represents the output of the last successful chart sync.
3542 pub artifact: Artifact,
3543 /// Conditions holds the conditions for the HelmChart.
3544 pub conditions: Vec<ConditionsItem>,
3545 /// LastHandledReconcileAt holds the value of the most recent reconcile request value, so a change of the annotation value can be detected.
3546 pub last_handled_reconcile_at: String,
3547 /// ObservedGeneration is the last observed generation.
3548 pub observed_generation: i64,
3549 /// URL is the download link for the last chart pulled.
3550 pub url: String,
3551 }
3552 }
3553 pub mod helm_repository {
3554 /// HelmRepository is the Schema for the helmrepositories API
3555 #[derive(serde::Deserialize, Debug, PartialEq)]
3556 pub struct HelmRepository {
3557 pub metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta,
3558 pub spec: Spec,
3559 pub status: Status,
3560 }
3561
3562 impl k8s_openapi::Resource for HelmRepository {
3563 type Scope = k8s_openapi::ClusterResourceScope;
3564
3565 const API_VERSION: &'static str = "source.toolkit.fluxcd.io/v1beta1";
3566 const GROUP: &'static str = "source.toolkit.fluxcd.io";
3567 const KIND: &'static str = "HelmRepository";
3568 const VERSION: &'static str = "v1beta1";
3569 const URL_PATH_SEGMENT: &'static str = "TODO";
3570 }
3571
3572 impl k8s_openapi::Metadata for HelmRepository {
3573 type Ty = k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta;
3574
3575 fn metadata(&self) -> &<Self as k8s_openapi::Metadata>::Ty {
3576 &self.metadata
3577 }
3578
3579 fn metadata_mut(&mut self) -> &mut <Self as k8s_openapi::Metadata>::Ty {
3580 &mut self.metadata
3581 }
3582 }
3583
3584 impl serde::Serialize for HelmRepository {
3585 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3586 where
3587 S: serde::Serializer,
3588 {
3589 use serde::ser::SerializeStruct;
3590 let mut state = serializer.serialize_struct("HelmRepository", 5)?;
3591 state.serialize_field(
3592 "apiVersion",
3593 <Self as k8s_openapi::Resource>::API_VERSION,
3594 )?;
3595 state.serialize_field("kind", <Self as k8s_openapi::Resource>::KIND)?;
3596 state.serialize_field("metadata", &self.metadata)?;
3597 state.serialize_field("spec", &self.spec)?;
3598 state.serialize_field("status", &self.status)?;
3599 state.end()
3600 }
3601 }
3602
3603 /// AccessFrom defines an Access Control List for allowing cross-namespace references to this object.
3604 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3605 #[serde(rename_all = "camelCase")]
3606 pub struct AccessFrom {
3607 /// NamespaceSelectors is the list of namespace selectors to which this ACL applies. Items in this list are evaluated using a logical OR operation.
3608 pub namespace_selectors: Vec<NamespaceSelectorsItem>,
3609 }
3610
3611 /// Artifact represents the output of the last successful repository sync.
3612 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3613 #[serde(rename_all = "camelCase")]
3614 pub struct Artifact {
3615 /// Checksum is the SHA256 checksum of the artifact.
3616 pub checksum: String,
3617 /// LastUpdateTime is the timestamp corresponding to the last update of this artifact.
3618 pub last_update_time: String,
3619 /// Path is the relative file path of this artifact.
3620 pub path: String,
3621 /// Revision is a human readable identifier traceable in the origin source system. It can be a Git commit SHA, Git tag, a Helm index timestamp, a Helm chart version, etc.
3622 pub revision: String,
3623 /// URL is the HTTP address of this artifact.
3624 pub url: String,
3625 }
3626
3627 /// Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: "Available", "Progressing", and "Degraded" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type" protobuf:"bytes,1,rep,name=conditions"`
3628 /// // other fields }
3629 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3630 #[serde(rename_all = "camelCase")]
3631 pub struct ConditionsItem {
3632 /// 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.
3633 pub last_transition_time: String,
3634 /// message is a human readable message indicating details about the transition. This may be an empty string.
3635 pub message: String,
3636 /// 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.
3637 pub observed_generation: i64,
3638 /// 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.
3639 pub reason: String,
3640 /// status of the condition, one of True, False, Unknown.
3641 pub status: String,
3642 /// type of condition in CamelCase or in foo.example.com/CamelCase. --- Many .condition.type values are consistent across resources like Available, but because arbitrary conditions can be useful (see .node.status.conditions), the ability to deconflict is important. The regex it matches is (dns1123SubdomainFmt/)?(qualifiedNameFmt)
3643 pub r#type: String,
3644 }
3645
3646 /// MatchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
3647 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3648 #[serde(rename_all = "camelCase")]
3649 pub struct MatchLabels {
3650 /// MatchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
3651 pub properties: std::collections::HashMap<String, String>,
3652 }
3653
3654 /// NamespaceSelector selects the namespaces to which this ACL applies. An empty map of MatchLabels matches all namespaces in a cluster.
3655 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3656 #[serde(rename_all = "camelCase")]
3657 pub struct NamespaceSelectorsItem {
3658 /// MatchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
3659 pub match_labels: MatchLabels,
3660 }
3661
3662 /// The name of the secret containing authentication credentials for the Helm repository. For HTTP/S basic auth the secret must contain username and password fields. For TLS the secret must contain a certFile and keyFile, and/or caCert fields.
3663 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3664 #[serde(rename_all = "camelCase")]
3665 pub struct SecretRef {
3666 /// Name of the referent.
3667 pub name: String,
3668 }
3669
3670 /// HelmRepositorySpec defines the reference to a Helm repository.
3671 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3672 #[serde(rename_all = "camelCase")]
3673 pub struct Spec {
3674 /// AccessFrom defines an Access Control List for allowing cross-namespace references to this object.
3675 pub access_from: AccessFrom,
3676 /// The interval at which to check the upstream for updates.
3677 pub interval: String,
3678 /// PassCredentials allows the credentials from the SecretRef to be passed on to a host that does not match the host as defined in URL. This may be required if the host of the advertised chart URLs in the index differ from the defined URL. Enabling this should be done with caution, as it can potentially result in credentials getting stolen in a MITM-attack.
3679 pub pass_credentials: bool,
3680 /// The name of the secret containing authentication credentials for the Helm repository. For HTTP/S basic auth the secret must contain username and password fields. For TLS the secret must contain a certFile and keyFile, and/or caCert fields.
3681 pub secret_ref: SecretRef,
3682 /// This flag tells the controller to suspend the reconciliation of this source.
3683 pub suspend: bool,
3684 /// The timeout of index downloading, defaults to 60s.
3685 pub timeout: String,
3686 /// The Helm repository URL, a valid URL contains at least a protocol and host.
3687 pub url: String,
3688 }
3689
3690 /// HelmRepositoryStatus defines the observed state of the HelmRepository.
3691 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3692 #[serde(rename_all = "camelCase")]
3693 pub struct Status {
3694 /// Artifact represents the output of the last successful repository sync.
3695 pub artifact: Artifact,
3696 /// Conditions holds the conditions for the HelmRepository.
3697 pub conditions: Vec<ConditionsItem>,
3698 /// LastHandledReconcileAt holds the value of the most recent reconcile request value, so a change of the annotation value can be detected.
3699 pub last_handled_reconcile_at: String,
3700 /// ObservedGeneration is the last observed generation.
3701 pub observed_generation: i64,
3702 /// URL is the download link for the last index fetched.
3703 pub url: String,
3704 }
3705 }
3706 }
3707 pub mod v1beta2 {
3708 pub mod bucket {
3709 /// Bucket is the Schema for the buckets API.
3710 #[derive(serde::Deserialize, Debug, PartialEq)]
3711 pub struct Bucket {
3712 pub metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta,
3713 pub spec: Spec,
3714 pub status: Status,
3715 }
3716
3717 impl k8s_openapi::Resource for Bucket {
3718 type Scope = k8s_openapi::ClusterResourceScope;
3719
3720 const API_VERSION: &'static str = "source.toolkit.fluxcd.io/v1beta2";
3721 const GROUP: &'static str = "source.toolkit.fluxcd.io";
3722 const KIND: &'static str = "Bucket";
3723 const VERSION: &'static str = "v1beta2";
3724 const URL_PATH_SEGMENT: &'static str = "TODO";
3725 }
3726
3727 impl k8s_openapi::Metadata for Bucket {
3728 type Ty = k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta;
3729
3730 fn metadata(&self) -> &<Self as k8s_openapi::Metadata>::Ty {
3731 &self.metadata
3732 }
3733
3734 fn metadata_mut(&mut self) -> &mut <Self as k8s_openapi::Metadata>::Ty {
3735 &mut self.metadata
3736 }
3737 }
3738
3739 impl serde::Serialize for Bucket {
3740 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3741 where
3742 S: serde::Serializer,
3743 {
3744 use serde::ser::SerializeStruct;
3745 let mut state = serializer.serialize_struct("Bucket", 5)?;
3746 state.serialize_field(
3747 "apiVersion",
3748 <Self as k8s_openapi::Resource>::API_VERSION,
3749 )?;
3750 state.serialize_field("kind", <Self as k8s_openapi::Resource>::KIND)?;
3751 state.serialize_field("metadata", &self.metadata)?;
3752 state.serialize_field("spec", &self.spec)?;
3753 state.serialize_field("status", &self.status)?;
3754 state.end()
3755 }
3756 }
3757
3758 /// AccessFrom specifies an Access Control List for allowing cross-namespace references to this object. NOTE: Not implemented, provisional as of https://github.com/fluxcd/flux2/pull/2092
3759 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3760 #[serde(rename_all = "camelCase")]
3761 pub struct AccessFrom {
3762 /// NamespaceSelectors is the list of namespace selectors to which this ACL applies. Items in this list are evaluated using a logical OR operation.
3763 pub namespace_selectors: Vec<NamespaceSelectorsItem>,
3764 }
3765
3766 /// Artifact represents the last successful Bucket reconciliation.
3767 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3768 #[serde(rename_all = "camelCase")]
3769 pub struct Artifact {
3770 /// Checksum is the SHA256 checksum of the Artifact file.
3771 pub checksum: String,
3772 /// LastUpdateTime is the timestamp corresponding to the last update of the Artifact.
3773 pub last_update_time: String,
3774 /// Path is the relative file path of the Artifact. It can be used to locate the file in the root of the Artifact storage on the local file system of the controller managing the Source.
3775 pub path: String,
3776 /// Revision is a human-readable identifier traceable in the origin source system. It can be a Git commit SHA, Git tag, a Helm chart version, etc.
3777 pub revision: String,
3778 /// Size is the number of bytes in the file.
3779 pub size: i64,
3780 /// URL is the HTTP address of the Artifact as exposed by the controller managing the Source. It can be used to retrieve the Artifact for consumption, e.g. by another controller applying the Artifact contents.
3781 pub url: String,
3782 }
3783
3784 /// Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: "Available", "Progressing", and "Degraded" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type" protobuf:"bytes,1,rep,name=conditions"`
3785 /// // other fields }
3786 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3787 #[serde(rename_all = "camelCase")]
3788 pub struct ConditionsItem {
3789 /// 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.
3790 pub last_transition_time: String,
3791 /// message is a human readable message indicating details about the transition. This may be an empty string.
3792 pub message: String,
3793 /// 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.
3794 pub observed_generation: i64,
3795 /// 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.
3796 pub reason: String,
3797 /// status of the condition, one of True, False, Unknown.
3798 pub status: String,
3799 /// type of condition in CamelCase or in foo.example.com/CamelCase. --- Many .condition.type values are consistent across resources like Available, but because arbitrary conditions can be useful (see .node.status.conditions), the ability to deconflict is important. The regex it matches is (dns1123SubdomainFmt/)?(qualifiedNameFmt)
3800 pub r#type: String,
3801 }
3802
3803 /// MatchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
3804 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3805 #[serde(rename_all = "camelCase")]
3806 pub struct MatchLabels {
3807 /// MatchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
3808 pub properties: std::collections::HashMap<String, String>,
3809 }
3810
3811 /// NamespaceSelector selects the namespaces to which this ACL applies. An empty map of MatchLabels matches all namespaces in a cluster.
3812 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3813 #[serde(rename_all = "camelCase")]
3814 pub struct NamespaceSelectorsItem {
3815 /// MatchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
3816 pub match_labels: MatchLabels,
3817 }
3818
3819 /// SecretRef specifies the Secret containing authentication credentials for the Bucket.
3820 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3821 #[serde(rename_all = "camelCase")]
3822 pub struct SecretRef {
3823 /// Name of the referent.
3824 pub name: String,
3825 }
3826
3827 /// BucketSpec specifies the required configuration to produce an Artifact for an object storage bucket.
3828 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3829 #[serde(rename_all = "camelCase")]
3830 pub struct Spec {
3831 /// AccessFrom specifies an Access Control List for allowing cross-namespace references to this object. NOTE: Not implemented, provisional as of https://github.com/fluxcd/flux2/pull/2092
3832 pub access_from: AccessFrom,
3833 /// BucketName is the name of the object storage bucket.
3834 pub bucket_name: String,
3835 /// Endpoint is the object storage address the BucketName is located at.
3836 pub endpoint: String,
3837 /// Ignore overrides the set of excluded patterns in the .sourceignore format (which is the same as .gitignore). If not provided, a default will be used, consult the documentation for your version to find out what those are.
3838 pub ignore: String,
3839 /// Insecure allows connecting to a non-TLS HTTP Endpoint.
3840 pub insecure: bool,
3841 /// Interval at which to check the Endpoint for updates.
3842 pub interval: String,
3843 /// Provider of the object storage bucket. Defaults to 'generic', which expects an S3 (API) compatible object storage.
3844 pub provider: String,
3845 /// Region of the Endpoint where the BucketName is located in.
3846 pub region: String,
3847 /// SecretRef specifies the Secret containing authentication credentials for the Bucket.
3848 pub secret_ref: SecretRef,
3849 /// Suspend tells the controller to suspend the reconciliation of this Bucket.
3850 pub suspend: bool,
3851 /// Timeout for fetch operations, defaults to 60s.
3852 pub timeout: String,
3853 }
3854
3855 /// BucketStatus records the observed state of a Bucket.
3856 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3857 #[serde(rename_all = "camelCase")]
3858 pub struct Status {
3859 /// Artifact represents the last successful Bucket reconciliation.
3860 pub artifact: Artifact,
3861 /// Conditions holds the conditions for the Bucket.
3862 pub conditions: Vec<ConditionsItem>,
3863 /// LastHandledReconcileAt holds the value of the most recent reconcile request value, so a change of the annotation value can be detected.
3864 pub last_handled_reconcile_at: String,
3865 /// ObservedGeneration is the last observed generation of the Bucket object.
3866 pub observed_generation: i64,
3867 /// URL is the dynamic fetch link for the latest Artifact. It is provided on a "best effort" basis, and using the precise BucketStatus.Artifact data is recommended.
3868 pub url: String,
3869 }
3870 }
3871 pub mod git_repository {
3872 /// GitRepository is the Schema for the gitrepositories API.
3873 #[derive(serde::Deserialize, Debug, PartialEq)]
3874 pub struct GitRepository {
3875 pub metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta,
3876 pub spec: Spec,
3877 pub status: Status,
3878 }
3879
3880 impl k8s_openapi::Resource for GitRepository {
3881 type Scope = k8s_openapi::ClusterResourceScope;
3882
3883 const API_VERSION: &'static str = "source.toolkit.fluxcd.io/v1beta2";
3884 const GROUP: &'static str = "source.toolkit.fluxcd.io";
3885 const KIND: &'static str = "GitRepository";
3886 const VERSION: &'static str = "v1beta2";
3887 const URL_PATH_SEGMENT: &'static str = "TODO";
3888 }
3889
3890 impl k8s_openapi::Metadata for GitRepository {
3891 type Ty = k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta;
3892
3893 fn metadata(&self) -> &<Self as k8s_openapi::Metadata>::Ty {
3894 &self.metadata
3895 }
3896
3897 fn metadata_mut(&mut self) -> &mut <Self as k8s_openapi::Metadata>::Ty {
3898 &mut self.metadata
3899 }
3900 }
3901
3902 impl serde::Serialize for GitRepository {
3903 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3904 where
3905 S: serde::Serializer,
3906 {
3907 use serde::ser::SerializeStruct;
3908 let mut state = serializer.serialize_struct("GitRepository", 5)?;
3909 state.serialize_field(
3910 "apiVersion",
3911 <Self as k8s_openapi::Resource>::API_VERSION,
3912 )?;
3913 state.serialize_field("kind", <Self as k8s_openapi::Resource>::KIND)?;
3914 state.serialize_field("metadata", &self.metadata)?;
3915 state.serialize_field("spec", &self.spec)?;
3916 state.serialize_field("status", &self.status)?;
3917 state.end()
3918 }
3919 }
3920
3921 /// AccessFrom specifies an Access Control List for allowing cross-namespace references to this object. NOTE: Not implemented, provisional as of https://github.com/fluxcd/flux2/pull/2092
3922 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3923 #[serde(rename_all = "camelCase")]
3924 pub struct AccessFrom {
3925 /// NamespaceSelectors is the list of namespace selectors to which this ACL applies. Items in this list are evaluated using a logical OR operation.
3926 pub namespace_selectors: Vec<NamespaceSelectorsItem>,
3927 }
3928
3929 /// Artifact represents the last successful GitRepository reconciliation.
3930 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3931 #[serde(rename_all = "camelCase")]
3932 pub struct Artifact {
3933 /// Checksum is the SHA256 checksum of the Artifact file.
3934 pub checksum: String,
3935 /// LastUpdateTime is the timestamp corresponding to the last update of the Artifact.
3936 pub last_update_time: String,
3937 /// Path is the relative file path of the Artifact. It can be used to locate the file in the root of the Artifact storage on the local file system of the controller managing the Source.
3938 pub path: String,
3939 /// Revision is a human-readable identifier traceable in the origin source system. It can be a Git commit SHA, Git tag, a Helm chart version, etc.
3940 pub revision: String,
3941 /// Size is the number of bytes in the file.
3942 pub size: i64,
3943 /// URL is the HTTP address of the Artifact as exposed by the controller managing the Source. It can be used to retrieve the Artifact for consumption, e.g. by another controller applying the Artifact contents.
3944 pub url: String,
3945 }
3946
3947 /// Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: "Available", "Progressing", and "Degraded" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type" protobuf:"bytes,1,rep,name=conditions"`
3948 /// // other fields }
3949 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3950 #[serde(rename_all = "camelCase")]
3951 pub struct ConditionsItem {
3952 /// 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.
3953 pub last_transition_time: String,
3954 /// message is a human readable message indicating details about the transition. This may be an empty string.
3955 pub message: String,
3956 /// 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.
3957 pub observed_generation: i64,
3958 /// 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.
3959 pub reason: String,
3960 /// status of the condition, one of True, False, Unknown.
3961 pub status: String,
3962 /// type of condition in CamelCase or in foo.example.com/CamelCase. --- Many .condition.type values are consistent across resources like Available, but because arbitrary conditions can be useful (see .node.status.conditions), the ability to deconflict is important. The regex it matches is (dns1123SubdomainFmt/)?(qualifiedNameFmt)
3963 pub r#type: String,
3964 }
3965
3966 /// GitRepositoryInclude specifies a local reference to a GitRepository which Artifact (sub-)contents must be included, and where they should be placed.
3967 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3968 #[serde(rename_all = "camelCase")]
3969 pub struct IncludeItem {
3970 /// FromPath specifies the path to copy contents from, defaults to the root of the Artifact.
3971 pub from_path: String,
3972 /// GitRepositoryRef specifies the GitRepository which Artifact contents must be included.
3973 pub repository: Repository,
3974 /// ToPath specifies the path to copy contents to, defaults to the name of the GitRepositoryRef.
3975 pub to_path: String,
3976 }
3977
3978 /// Artifact represents the output of a Source reconciliation.
3979 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3980 #[serde(rename_all = "camelCase")]
3981 pub struct IncludedArtifactsItem {
3982 /// Checksum is the SHA256 checksum of the Artifact file.
3983 pub checksum: String,
3984 /// LastUpdateTime is the timestamp corresponding to the last update of the Artifact.
3985 pub last_update_time: String,
3986 /// Path is the relative file path of the Artifact. It can be used to locate the file in the root of the Artifact storage on the local file system of the controller managing the Source.
3987 pub path: String,
3988 /// Revision is a human-readable identifier traceable in the origin source system. It can be a Git commit SHA, Git tag, a Helm chart version, etc.
3989 pub revision: String,
3990 /// Size is the number of bytes in the file.
3991 pub size: i64,
3992 /// URL is the HTTP address of the Artifact as exposed by the controller managing the Source. It can be used to retrieve the Artifact for consumption, e.g. by another controller applying the Artifact contents.
3993 pub url: String,
3994 }
3995
3996 /// MatchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
3997 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3998 #[serde(rename_all = "camelCase")]
3999 pub struct MatchLabels {
4000 /// MatchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
4001 pub properties: std::collections::HashMap<String, String>,
4002 }
4003
4004 /// NamespaceSelector selects the namespaces to which this ACL applies. An empty map of MatchLabels matches all namespaces in a cluster.
4005 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4006 #[serde(rename_all = "camelCase")]
4007 pub struct NamespaceSelectorsItem {
4008 /// MatchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
4009 pub match_labels: MatchLabels,
4010 }
4011
4012 /// Reference specifies the Git reference to resolve and monitor for changes, defaults to the 'master' branch.
4013 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4014 #[serde(rename_all = "camelCase")]
4015 pub struct Ref {
4016 /// Branch to check out, defaults to 'master' if no other field is defined.
4017 /// When GitRepositorySpec.GitImplementation is set to 'go-git', a shallow clone of the specified branch is performed.
4018 pub branch: String,
4019 /// Commit SHA to check out, takes precedence over all reference fields.
4020 /// When GitRepositorySpec.GitImplementation is set to 'go-git', this can be combined with Branch to shallow clone the branch, in which the commit is expected to exist.
4021 pub commit: String,
4022 /// SemVer tag expression to check out, takes precedence over Tag.
4023 pub semver: String,
4024 /// Tag to check out, takes precedence over Branch.
4025 pub tag: String,
4026 }
4027
4028 /// GitRepositoryRef specifies the GitRepository which Artifact contents must be included.
4029 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4030 #[serde(rename_all = "camelCase")]
4031 pub struct Repository {
4032 /// Name of the referent.
4033 pub name: String,
4034 }
4035
4036 /// SecretRef specifies the Secret containing authentication credentials for the GitRepository. For HTTPS repositories the Secret must contain 'username' and 'password' fields. For SSH repositories the Secret must contain 'identity' and 'known_hosts' fields.
4037 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4038 #[serde(rename_all = "camelCase")]
4039 pub struct SpecSecretRef {
4040 /// Name of the referent.
4041 pub name: String,
4042 }
4043
4044 /// SecretRef specifies the Secret containing the public keys of trusted Git authors.
4045 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4046 #[serde(rename_all = "camelCase")]
4047 pub struct VerifySecretRef {
4048 /// Name of the referent.
4049 pub name: String,
4050 }
4051
4052 /// GitRepositorySpec specifies the required configuration to produce an Artifact for a Git repository.
4053 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4054 #[serde(rename_all = "camelCase")]
4055 pub struct Spec {
4056 /// AccessFrom specifies an Access Control List for allowing cross-namespace references to this object. NOTE: Not implemented, provisional as of https://github.com/fluxcd/flux2/pull/2092
4057 pub access_from: AccessFrom,
4058 /// GitImplementation specifies which Git client library implementation to use. Defaults to 'go-git', valid values are ('go-git', 'libgit2').
4059 pub git_implementation: String,
4060 /// Ignore overrides the set of excluded patterns in the .sourceignore format (which is the same as .gitignore). If not provided, a default will be used, consult the documentation for your version to find out what those are.
4061 pub ignore: String,
4062 /// Include specifies a list of GitRepository resources which Artifacts should be included in the Artifact produced for this GitRepository.
4063 pub include: Vec<IncludeItem>,
4064 /// Interval at which to check the GitRepository for updates.
4065 pub interval: String,
4066 /// RecurseSubmodules enables the initialization of all submodules within the GitRepository as cloned from the URL, using their default settings. This option is available only when using the 'go-git' GitImplementation.
4067 pub recurse_submodules: bool,
4068 /// Reference specifies the Git reference to resolve and monitor for changes, defaults to the 'master' branch.
4069 pub r#ref: Ref,
4070 /// SecretRef specifies the Secret containing authentication credentials for the GitRepository. For HTTPS repositories the Secret must contain 'username' and 'password' fields. For SSH repositories the Secret must contain 'identity' and 'known_hosts' fields.
4071 pub secret_ref: SpecSecretRef,
4072 /// Suspend tells the controller to suspend the reconciliation of this GitRepository.
4073 pub suspend: bool,
4074 /// Timeout for Git operations like cloning, defaults to 60s.
4075 pub timeout: String,
4076 /// URL specifies the Git repository URL, it can be an HTTP/S or SSH address.
4077 pub url: String,
4078 /// Verification specifies the configuration to verify the Git commit signature(s).
4079 pub verify: Verify,
4080 }
4081
4082 /// GitRepositoryStatus records the observed state of a Git repository.
4083 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4084 #[serde(rename_all = "camelCase")]
4085 pub struct Status {
4086 /// Artifact represents the last successful GitRepository reconciliation.
4087 pub artifact: Artifact,
4088 /// Conditions holds the conditions for the GitRepository.
4089 pub conditions: Vec<ConditionsItem>,
4090 /// ContentConfigChecksum is a checksum of all the configurations related to the content of the source artifact: - .spec.ignore - .spec.recurseSubmodules - .spec.included and the checksum of the included artifacts observed in .status.observedGeneration version of the object. This can be used to determine if the content of the included repository has changed. It has the format of `<algo>:<checksum>`, for example: `sha256:<checksum>`.
4091 pub content_config_checksum: String,
4092 /// IncludedArtifacts contains a list of the last successfully included Artifacts as instructed by GitRepositorySpec.Include.
4093 pub included_artifacts: Vec<IncludedArtifactsItem>,
4094 /// LastHandledReconcileAt holds the value of the most recent reconcile request value, so a change of the annotation value can be detected.
4095 pub last_handled_reconcile_at: String,
4096 /// ObservedGeneration is the last observed generation of the GitRepository object.
4097 pub observed_generation: i64,
4098 /// URL is the dynamic fetch link for the latest Artifact. It is provided on a "best effort" basis, and using the precise GitRepositoryStatus.Artifact data is recommended.
4099 pub url: String,
4100 }
4101
4102 /// Verification specifies the configuration to verify the Git commit signature(s).
4103 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4104 #[serde(rename_all = "camelCase")]
4105 pub struct Verify {
4106 /// Mode specifies what Git object should be verified, currently ('head').
4107 pub mode: String,
4108 /// SecretRef specifies the Secret containing the public keys of trusted Git authors.
4109 pub secret_ref: VerifySecretRef,
4110 }
4111 }
4112 pub mod helm_chart {
4113 /// HelmChart is the Schema for the helmcharts API.
4114 #[derive(serde::Deserialize, Debug, PartialEq)]
4115 pub struct HelmChart {
4116 pub metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta,
4117 pub spec: Spec,
4118 pub status: Status,
4119 }
4120
4121 impl k8s_openapi::Resource for HelmChart {
4122 type Scope = k8s_openapi::ClusterResourceScope;
4123
4124 const API_VERSION: &'static str = "source.toolkit.fluxcd.io/v1beta2";
4125 const GROUP: &'static str = "source.toolkit.fluxcd.io";
4126 const KIND: &'static str = "HelmChart";
4127 const VERSION: &'static str = "v1beta2";
4128 const URL_PATH_SEGMENT: &'static str = "TODO";
4129 }
4130
4131 impl k8s_openapi::Metadata for HelmChart {
4132 type Ty = k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta;
4133
4134 fn metadata(&self) -> &<Self as k8s_openapi::Metadata>::Ty {
4135 &self.metadata
4136 }
4137
4138 fn metadata_mut(&mut self) -> &mut <Self as k8s_openapi::Metadata>::Ty {
4139 &mut self.metadata
4140 }
4141 }
4142
4143 impl serde::Serialize for HelmChart {
4144 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4145 where
4146 S: serde::Serializer,
4147 {
4148 use serde::ser::SerializeStruct;
4149 let mut state = serializer.serialize_struct("HelmChart", 5)?;
4150 state.serialize_field(
4151 "apiVersion",
4152 <Self as k8s_openapi::Resource>::API_VERSION,
4153 )?;
4154 state.serialize_field("kind", <Self as k8s_openapi::Resource>::KIND)?;
4155 state.serialize_field("metadata", &self.metadata)?;
4156 state.serialize_field("spec", &self.spec)?;
4157 state.serialize_field("status", &self.status)?;
4158 state.end()
4159 }
4160 }
4161
4162 /// AccessFrom specifies an Access Control List for allowing cross-namespace references to this object. NOTE: Not implemented, provisional as of https://github.com/fluxcd/flux2/pull/2092
4163 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4164 #[serde(rename_all = "camelCase")]
4165 pub struct AccessFrom {
4166 /// NamespaceSelectors is the list of namespace selectors to which this ACL applies. Items in this list are evaluated using a logical OR operation.
4167 pub namespace_selectors: Vec<NamespaceSelectorsItem>,
4168 }
4169
4170 /// Artifact represents the output of the last successful reconciliation.
4171 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4172 #[serde(rename_all = "camelCase")]
4173 pub struct Artifact {
4174 /// Checksum is the SHA256 checksum of the Artifact file.
4175 pub checksum: String,
4176 /// LastUpdateTime is the timestamp corresponding to the last update of the Artifact.
4177 pub last_update_time: String,
4178 /// Path is the relative file path of the Artifact. It can be used to locate the file in the root of the Artifact storage on the local file system of the controller managing the Source.
4179 pub path: String,
4180 /// Revision is a human-readable identifier traceable in the origin source system. It can be a Git commit SHA, Git tag, a Helm chart version, etc.
4181 pub revision: String,
4182 /// Size is the number of bytes in the file.
4183 pub size: i64,
4184 /// URL is the HTTP address of the Artifact as exposed by the controller managing the Source. It can be used to retrieve the Artifact for consumption, e.g. by another controller applying the Artifact contents.
4185 pub url: String,
4186 }
4187
4188 /// Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: "Available", "Progressing", and "Degraded" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type" protobuf:"bytes,1,rep,name=conditions"`
4189 /// // other fields }
4190 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4191 #[serde(rename_all = "camelCase")]
4192 pub struct ConditionsItem {
4193 /// 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.
4194 pub last_transition_time: String,
4195 /// message is a human readable message indicating details about the transition. This may be an empty string.
4196 pub message: String,
4197 /// 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.
4198 pub observed_generation: i64,
4199 /// 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.
4200 pub reason: String,
4201 /// status of the condition, one of True, False, Unknown.
4202 pub status: String,
4203 /// type of condition in CamelCase or in foo.example.com/CamelCase. --- Many .condition.type values are consistent across resources like Available, but because arbitrary conditions can be useful (see .node.status.conditions), the ability to deconflict is important. The regex it matches is (dns1123SubdomainFmt/)?(qualifiedNameFmt)
4204 pub r#type: String,
4205 }
4206
4207 /// MatchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
4208 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4209 #[serde(rename_all = "camelCase")]
4210 pub struct MatchLabels {
4211 /// MatchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
4212 pub properties: std::collections::HashMap<String, String>,
4213 }
4214
4215 /// NamespaceSelector selects the namespaces to which this ACL applies. An empty map of MatchLabels matches all namespaces in a cluster.
4216 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4217 #[serde(rename_all = "camelCase")]
4218 pub struct NamespaceSelectorsItem {
4219 /// MatchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
4220 pub match_labels: MatchLabels,
4221 }
4222
4223 /// SourceRef is the reference to the Source the chart is available at.
4224 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4225 #[serde(rename_all = "camelCase")]
4226 pub struct SourceRef {
4227 /// APIVersion of the referent.
4228 pub api_version: String,
4229 /// Kind of the referent, valid values are ('HelmRepository', 'GitRepository', 'Bucket').
4230 pub kind: String,
4231 /// Name of the referent.
4232 pub name: String,
4233 }
4234
4235 /// HelmChartSpec specifies the desired state of a Helm chart.
4236 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4237 #[serde(rename_all = "camelCase")]
4238 pub struct Spec {
4239 /// AccessFrom specifies an Access Control List for allowing cross-namespace references to this object. NOTE: Not implemented, provisional as of https://github.com/fluxcd/flux2/pull/2092
4240 pub access_from: AccessFrom,
4241 /// Chart is the name or path the Helm chart is available at in the SourceRef.
4242 pub chart: String,
4243 /// Interval is the interval at which to check the Source for updates.
4244 pub interval: String,
4245 /// ReconcileStrategy 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.
4246 pub reconcile_strategy: String,
4247 /// SourceRef is the reference to the Source the chart is available at.
4248 pub source_ref: SourceRef,
4249 /// Suspend tells the controller to suspend the reconciliation of this source.
4250 pub suspend: bool,
4251 /// ValuesFile is an alternative values file to use as the default chart values, expected to be a relative path in the SourceRef. Deprecated in favor of ValuesFiles, for backwards compatibility the file specified here is merged before the ValuesFiles items. Ignored when omitted.
4252 pub values_file: String,
4253 /// ValuesFiles is an 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.
4254 pub values_files: Vec<String>,
4255 /// Version is the chart version semver expression, ignored for charts from GitRepository and Bucket sources. Defaults to latest when omitted.
4256 pub version: String,
4257 }
4258
4259 /// HelmChartStatus records the observed state of the HelmChart.
4260 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4261 #[serde(rename_all = "camelCase")]
4262 pub struct Status {
4263 /// Artifact represents the output of the last successful reconciliation.
4264 pub artifact: Artifact,
4265 /// Conditions holds the conditions for the HelmChart.
4266 pub conditions: Vec<ConditionsItem>,
4267 /// LastHandledReconcileAt holds the value of the most recent reconcile request value, so a change of the annotation value can be detected.
4268 pub last_handled_reconcile_at: String,
4269 /// ObservedChartName is the last observed chart name as specified by the resolved chart reference.
4270 pub observed_chart_name: String,
4271 /// ObservedGeneration is the last observed generation of the HelmChart object.
4272 pub observed_generation: i64,
4273 /// ObservedSourceArtifactRevision is the last observed Artifact.Revision of the HelmChartSpec.SourceRef.
4274 pub observed_source_artifact_revision: String,
4275 /// URL is the dynamic fetch link for the latest Artifact. It is provided on a "best effort" basis, and using the precise BucketStatus.Artifact data is recommended.
4276 pub url: String,
4277 }
4278 }
4279 pub mod helm_repository {
4280 /// HelmRepository is the Schema for the helmrepositories API.
4281 #[derive(serde::Deserialize, Debug, PartialEq)]
4282 pub struct HelmRepository {
4283 pub metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta,
4284 pub spec: Spec,
4285 pub status: Status,
4286 }
4287
4288 impl k8s_openapi::Resource for HelmRepository {
4289 type Scope = k8s_openapi::ClusterResourceScope;
4290
4291 const API_VERSION: &'static str = "source.toolkit.fluxcd.io/v1beta2";
4292 const GROUP: &'static str = "source.toolkit.fluxcd.io";
4293 const KIND: &'static str = "HelmRepository";
4294 const VERSION: &'static str = "v1beta2";
4295 const URL_PATH_SEGMENT: &'static str = "TODO";
4296 }
4297
4298 impl k8s_openapi::Metadata for HelmRepository {
4299 type Ty = k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta;
4300
4301 fn metadata(&self) -> &<Self as k8s_openapi::Metadata>::Ty {
4302 &self.metadata
4303 }
4304
4305 fn metadata_mut(&mut self) -> &mut <Self as k8s_openapi::Metadata>::Ty {
4306 &mut self.metadata
4307 }
4308 }
4309
4310 impl serde::Serialize for HelmRepository {
4311 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4312 where
4313 S: serde::Serializer,
4314 {
4315 use serde::ser::SerializeStruct;
4316 let mut state = serializer.serialize_struct("HelmRepository", 5)?;
4317 state.serialize_field(
4318 "apiVersion",
4319 <Self as k8s_openapi::Resource>::API_VERSION,
4320 )?;
4321 state.serialize_field("kind", <Self as k8s_openapi::Resource>::KIND)?;
4322 state.serialize_field("metadata", &self.metadata)?;
4323 state.serialize_field("spec", &self.spec)?;
4324 state.serialize_field("status", &self.status)?;
4325 state.end()
4326 }
4327 }
4328
4329 /// AccessFrom specifies an Access Control List for allowing cross-namespace references to this object. NOTE: Not implemented, provisional as of https://github.com/fluxcd/flux2/pull/2092
4330 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4331 #[serde(rename_all = "camelCase")]
4332 pub struct AccessFrom {
4333 /// NamespaceSelectors is the list of namespace selectors to which this ACL applies. Items in this list are evaluated using a logical OR operation.
4334 pub namespace_selectors: Vec<NamespaceSelectorsItem>,
4335 }
4336
4337 /// Artifact represents the last successful HelmRepository reconciliation.
4338 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4339 #[serde(rename_all = "camelCase")]
4340 pub struct Artifact {
4341 /// Checksum is the SHA256 checksum of the Artifact file.
4342 pub checksum: String,
4343 /// LastUpdateTime is the timestamp corresponding to the last update of the Artifact.
4344 pub last_update_time: String,
4345 /// Path is the relative file path of the Artifact. It can be used to locate the file in the root of the Artifact storage on the local file system of the controller managing the Source.
4346 pub path: String,
4347 /// Revision is a human-readable identifier traceable in the origin source system. It can be a Git commit SHA, Git tag, a Helm chart version, etc.
4348 pub revision: String,
4349 /// Size is the number of bytes in the file.
4350 pub size: i64,
4351 /// URL is the HTTP address of the Artifact as exposed by the controller managing the Source. It can be used to retrieve the Artifact for consumption, e.g. by another controller applying the Artifact contents.
4352 pub url: String,
4353 }
4354
4355 /// Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions. For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: "Available", "Progressing", and "Degraded" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type" protobuf:"bytes,1,rep,name=conditions"`
4356 /// // other fields }
4357 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4358 #[serde(rename_all = "camelCase")]
4359 pub struct ConditionsItem {
4360 /// 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.
4361 pub last_transition_time: String,
4362 /// message is a human readable message indicating details about the transition. This may be an empty string.
4363 pub message: String,
4364 /// 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.
4365 pub observed_generation: i64,
4366 /// 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.
4367 pub reason: String,
4368 /// status of the condition, one of True, False, Unknown.
4369 pub status: String,
4370 /// type of condition in CamelCase or in foo.example.com/CamelCase. --- Many .condition.type values are consistent across resources like Available, but because arbitrary conditions can be useful (see .node.status.conditions), the ability to deconflict is important. The regex it matches is (dns1123SubdomainFmt/)?(qualifiedNameFmt)
4371 pub r#type: String,
4372 }
4373
4374 /// MatchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
4375 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4376 #[serde(rename_all = "camelCase")]
4377 pub struct MatchLabels {
4378 /// MatchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
4379 pub properties: std::collections::HashMap<String, String>,
4380 }
4381
4382 /// NamespaceSelector selects the namespaces to which this ACL applies. An empty map of MatchLabels matches all namespaces in a cluster.
4383 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4384 #[serde(rename_all = "camelCase")]
4385 pub struct NamespaceSelectorsItem {
4386 /// MatchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
4387 pub match_labels: MatchLabels,
4388 }
4389
4390 /// SecretRef specifies the Secret containing authentication credentials for the HelmRepository. For HTTP/S basic auth the secret must contain 'username' and 'password' fields. For TLS the secret must contain a 'certFile' and 'keyFile', and/or 'caCert' fields.
4391 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4392 #[serde(rename_all = "camelCase")]
4393 pub struct SecretRef {
4394 /// Name of the referent.
4395 pub name: String,
4396 }
4397
4398 /// HelmRepositorySpec specifies the required configuration to produce an Artifact for a Helm repository index YAML.
4399 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4400 #[serde(rename_all = "camelCase")]
4401 pub struct Spec {
4402 /// AccessFrom specifies an Access Control List for allowing cross-namespace references to this object. NOTE: Not implemented, provisional as of https://github.com/fluxcd/flux2/pull/2092
4403 pub access_from: AccessFrom,
4404 /// Interval at which to check the URL for updates.
4405 pub interval: String,
4406 /// PassCredentials allows the credentials from the SecretRef to be passed on to a host that does not match the host as defined in URL. This may be required if the host of the advertised chart URLs in the index differ from the defined URL. Enabling this should be done with caution, as it can potentially result in credentials getting stolen in a MITM-attack.
4407 pub pass_credentials: bool,
4408 /// SecretRef specifies the Secret containing authentication credentials for the HelmRepository. For HTTP/S basic auth the secret must contain 'username' and 'password' fields. For TLS the secret must contain a 'certFile' and 'keyFile', and/or 'caCert' fields.
4409 pub secret_ref: SecretRef,
4410 /// Suspend tells the controller to suspend the reconciliation of this HelmRepository.
4411 pub suspend: bool,
4412 /// Timeout of the index fetch operation, defaults to 60s.
4413 pub timeout: String,
4414 /// Type of the HelmRepository. When this field is set to "oci", the URL field value must be prefixed with "oci://".
4415 pub r#type: String,
4416 /// URL of the Helm repository, a valid URL contains at least a protocol and host.
4417 pub url: String,
4418 }
4419
4420 /// HelmRepositoryStatus records the observed state of the HelmRepository.
4421 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4422 #[serde(rename_all = "camelCase")]
4423 pub struct Status {
4424 /// Artifact represents the last successful HelmRepository reconciliation.
4425 pub artifact: Artifact,
4426 /// Conditions holds the conditions for the HelmRepository.
4427 pub conditions: Vec<ConditionsItem>,
4428 /// LastHandledReconcileAt holds the value of the most recent reconcile request value, so a change of the annotation value can be detected.
4429 pub last_handled_reconcile_at: String,
4430 /// ObservedGeneration is the last observed generation of the HelmRepository object.
4431 pub observed_generation: i64,
4432 /// URL is the dynamic fetch link for the latest Artifact. It is provided on a "best effort" basis, and using the precise HelmRepositoryStatus.Artifact data is recommended.
4433 pub url: String,
4434 }
4435 }
4436 }
4437}