argo_cd_crds/

lib.rs

// Generated by:
// target/debug/k8s-crds-codegen

pub mod argoproj_io {
    pub mod v1alpha1 {
        pub mod app_project {
            /// AppProject provides a logical grouping of applications, providing controls for: * where the apps may deploy to (cluster whitelist) * what may be deployed (repository whitelist, resource whitelist/blacklist) * who can access these applications (roles, OIDC group claims bindings) * and what they can do (RBAC policies) * automation access to these roles (JWT tokens)
            #[derive(serde::Deserialize, Debug, PartialEq)]
            pub struct AppProject {
                pub metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta,
                pub spec: Spec,
                pub status: Status,
            }

            impl k8s_openapi::Resource for AppProject {
                type Scope = k8s_openapi::ClusterResourceScope;

                const API_VERSION: &'static str = "argoproj.io/v1alpha1";
                const GROUP: &'static str = "argoproj.io";
                const KIND: &'static str = "AppProject";
                const VERSION: &'static str = "v1alpha1";
                const URL_PATH_SEGMENT: &'static str = "TODO";
            }

            impl k8s_openapi::Metadata for AppProject {
                type Ty = k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta;

                fn metadata(&self) -> &<Self as k8s_openapi::Metadata>::Ty {
                    &self.metadata
                }

                fn metadata_mut(&mut self) -> &mut <Self as k8s_openapi::Metadata>::Ty {
                    &mut self.metadata
                }
            }

            impl serde::Serialize for AppProject {
                fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where
                    S: serde::Serializer,
                {
                    use serde::ser::SerializeStruct;
                    let mut state = serializer.serialize_struct("AppProject", 5)?;
                    state.serialize_field(
                        "apiVersion",
                        <Self as k8s_openapi::Resource>::API_VERSION,
                    )?;
                    state.serialize_field("kind", <Self as k8s_openapi::Resource>::KIND)?;
                    state.serialize_field("metadata", &self.metadata)?;
                    state.serialize_field("spec", &self.spec)?;
                    state.serialize_field("status", &self.status)?;
                    state.end()
                }
            }

            /// GroupKind specifies a Group and a Kind, but does not force a version.  This is useful for identifying concepts during lookup stages without having partially valid types
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct ClusterResourceBlacklistItem {
                pub group: String,
                pub kind: String,
            }

            /// GroupKind specifies a Group and a Kind, but does not force a version.  This is useful for identifying concepts during lookup stages without having partially valid types
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct ClusterResourceWhitelistItem {
                pub group: String,
                pub kind: String,
            }

            /// ApplicationDestination holds information about the application's destination
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct DestinationsItem {
                /// Name is an alternate way of specifying the target cluster by its symbolic name
                pub name: String,
                /// Namespace specifies the target namespace for the application's resources. The namespace will only be set for namespace-scoped resources that have not set a value for .metadata.namespace
                pub namespace: String,
                /// Server specifies the URL of the target cluster and must be set to the Kubernetes control plane API
                pub server: String,
            }

            /// OrphanedResourceKey is a reference to a resource to be ignored from
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct IgnoreItem {
                pub group: String,
                pub kind: String,
                pub name: String,
            }

            /// JWTToken holds the issuedAt and expiresAt values of a token
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct ItemsItem {
                pub exp: i64,
                pub iat: i64,
                pub id: String,
            }

            /// JWTTokensByRole contains a list of JWT tokens issued for a given role
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct JwtTokensByRole {
                /// JWTTokensByRole contains a list of JWT tokens issued for a given role
                pub properties: std::collections::HashMap<String, Value>,
            }

            /// JWTToken holds the issuedAt and expiresAt values of a token
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct JwtTokensItem {
                pub exp: i64,
                pub iat: i64,
                pub id: String,
            }

            /// GroupKind specifies a Group and a Kind, but does not force a version.  This is useful for identifying concepts during lookup stages without having partially valid types
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct NamespaceResourceBlacklistItem {
                pub group: String,
                pub kind: String,
            }

            /// GroupKind specifies a Group and a Kind, but does not force a version.  This is useful for identifying concepts during lookup stages without having partially valid types
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct NamespaceResourceWhitelistItem {
                pub group: String,
                pub kind: String,
            }

            /// OrphanedResources specifies if controller should monitor orphaned resources of apps in this project
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct OrphanedResources {
                /// Ignore contains a list of resources that are to be excluded from orphaned resources monitoring
                pub ignore: Vec<IgnoreItem>,
                /// Warn indicates if warning condition should be created for apps which have orphaned resources
                pub warn: bool,
            }

            /// ProjectRole represents a role that has access to a project
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct RolesItem {
                /// Description is a description of the role
                pub description: String,
                /// Groups are a list of OIDC group claims bound to this role
                pub groups: Vec<String>,
                /// JWTTokens are a list of generated JWT tokens bound to this role
                pub jwt_tokens: Vec<JwtTokensItem>,
                /// Name is a name for this role
                pub name: String,
                /// Policies Stores a list of casbin formatted strings that define access policies for the role in the project
                pub policies: Vec<String>,
            }

            /// SignatureKey is the specification of a key required to verify commit signatures with
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SignatureKeysItem {
                /// The ID of the key in hexadecimal notation
                pub key_i_d: String,
            }

            /// AppProjectSpec is the specification of an AppProject
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct Spec {
                /// ClusterResourceBlacklist contains list of blacklisted cluster level resources
                pub cluster_resource_blacklist: Vec<ClusterResourceBlacklistItem>,
                /// ClusterResourceWhitelist contains list of whitelisted cluster level resources
                pub cluster_resource_whitelist: Vec<ClusterResourceWhitelistItem>,
                /// Description contains optional project description
                pub description: String,
                /// Destinations contains list of destinations available for deployment
                pub destinations: Vec<DestinationsItem>,
                /// NamespaceResourceBlacklist contains list of blacklisted namespace level resources
                pub namespace_resource_blacklist: Vec<NamespaceResourceBlacklistItem>,
                /// NamespaceResourceWhitelist contains list of whitelisted namespace level resources
                pub namespace_resource_whitelist: Vec<NamespaceResourceWhitelistItem>,
                /// OrphanedResources specifies if controller should monitor orphaned resources of apps in this project
                pub orphaned_resources: OrphanedResources,
                /// Roles are user defined RBAC roles associated with this project
                pub roles: Vec<RolesItem>,
                /// SignatureKeys contains a list of PGP key IDs that commits in Git must be signed with in order to be allowed for sync
                pub signature_keys: Vec<SignatureKeysItem>,
                /// SourceRepos contains list of repository URLs which can be used for deployment
                pub source_repos: Vec<String>,
                /// SyncWindows controls when syncs can be run for apps in this project
                pub sync_windows: Vec<SyncWindowsItem>,
            }

            /// AppProjectStatus contains status information for AppProject CRs
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct Status {
                /// JWTTokensByRole contains a list of JWT tokens issued for a given role
                pub jwt_tokens_by_role: JwtTokensByRole,
            }

            /// SyncWindow contains the kind, time, duration and attributes that are used to assign the syncWindows to apps
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SyncWindowsItem {
                /// Applications contains a list of applications that the window will apply to
                pub applications: Vec<String>,
                /// Clusters contains a list of clusters that the window will apply to
                pub clusters: Vec<String>,
                /// Duration is the amount of time the sync window will be open
                pub duration: String,
                /// Kind defines if the window allows or blocks syncs
                pub kind: String,
                /// ManualSync enables manual syncs when they would otherwise be blocked
                pub manual_sync: bool,
                /// Namespaces contains a list of namespaces that the window will apply to
                pub namespaces: Vec<String>,
                /// Schedule is the time the window will begin, specified in cron format
                pub schedule: String,
                /// TimeZone of the sync that will be applied to the schedule
                pub time_zone: String,
            }

            /// JWTTokens represents a list of JWT tokens
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct Value {
                pub items: Vec<ItemsItem>,
            }
        }
        pub mod application {
            /// Application is a definition of Application resource.
            #[derive(serde::Deserialize, Debug, PartialEq)]
            pub struct Application {
                pub metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta,
                pub operation: Operation,
                pub spec: Spec,
                pub status: Status,
            }

            impl k8s_openapi::Resource for Application {
                type Scope = k8s_openapi::ClusterResourceScope;

                const API_VERSION: &'static str = "argoproj.io/v1alpha1";
                const GROUP: &'static str = "argoproj.io";
                const KIND: &'static str = "Application";
                const VERSION: &'static str = "v1alpha1";
                const URL_PATH_SEGMENT: &'static str = "TODO";
            }

            impl k8s_openapi::Metadata for Application {
                type Ty = k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta;

                fn metadata(&self) -> &<Self as k8s_openapi::Metadata>::Ty {
                    &self.metadata
                }

                fn metadata_mut(&mut self) -> &mut <Self as k8s_openapi::Metadata>::Ty {
                    &mut self.metadata
                }
            }

            impl serde::Serialize for Application {
                fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where
                    S: serde::Serializer,
                {
                    use serde::ser::SerializeStruct;
                    let mut state = serializer.serialize_struct("Application", 6)?;
                    state.serialize_field(
                        "apiVersion",
                        <Self as k8s_openapi::Resource>::API_VERSION,
                    )?;
                    state.serialize_field("kind", <Self as k8s_openapi::Resource>::KIND)?;
                    state.serialize_field("metadata", &self.metadata)?;
                    state.serialize_field("operation", &self.operation)?;
                    state.serialize_field("spec", &self.spec)?;
                    state.serialize_field("status", &self.status)?;
                    state.end()
                }
            }

            /// Apply will perform a `kubectl apply` to perform the sync.
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct OperationSyncSyncStrategyApply {
                /// Force indicates whether or not to supply the --force flag to `kubectl apply`. The --force flag deletes and re-create the resource, when PATCH encounters conflict and has retried for 5 times.
                pub force: bool,
            }

            /// Apply will perform a `kubectl apply` to perform the sync.
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct OperationStateOperationSyncSyncStrategyApply {
                /// Force indicates whether or not to supply the --force flag to `kubectl apply`. The --force flag deletes and re-create the resource, when PATCH encounters conflict and has retried for 5 times.
                pub force: bool,
            }

            /// Automated will keep an application synced to the target revision
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct Automated {
                /// AllowEmpty allows apps have zero live resources (default: false)
                pub allow_empty: bool,
                /// Prune specifies whether to delete resources from the cluster that are not found in the sources anymore as part of automated sync (default: false)
                pub prune: bool,
                /// SelfHeal specifes whether to revert resources back to their desired state upon modification in the cluster (default: false)
                pub self_heal: bool,
            }

            /// Backoff controls how to backoff on subsequent retries of failed syncs
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct OperationRetryBackoff {
                /// Duration is the amount to back off. Default unit is seconds, but could also be a duration (e.g. "2m", "1h")
                pub duration: String,
                /// Factor is a factor to multiply the base duration after each failed retry
                pub factor: i64,
                /// MaxDuration is the maximum amount of time allowed for the backoff strategy
                pub max_duration: String,
            }

            /// Backoff controls how to backoff on subsequent retries of failed syncs
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SyncPolicyRetryBackoff {
                /// Duration is the amount to back off. Default unit is seconds, but could also be a duration (e.g. "2m", "1h")
                pub duration: String,
                /// Factor is a factor to multiply the base duration after each failed retry
                pub factor: i64,
                /// MaxDuration is the maximum amount of time allowed for the backoff strategy
                pub max_duration: String,
            }

            /// Backoff controls how to backoff on subsequent retries of failed syncs
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct OperationStateOperationRetryBackoff {
                /// Duration is the amount to back off. Default unit is seconds, but could also be a duration (e.g. "2m", "1h")
                pub duration: String,
                /// Factor is a factor to multiply the base duration after each failed retry
                pub factor: i64,
                /// MaxDuration is the maximum amount of time allowed for the backoff strategy
                pub max_duration: String,
            }

            /// CommonAnnotations is a list of additional annotations to add to rendered manifests
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct OperationSyncSourceKustomizeCommonAnnotations {
                /// CommonAnnotations is a list of additional annotations to add to rendered manifests
                pub properties: std::collections::HashMap<String, String>,
            }

            /// CommonAnnotations is a list of additional annotations to add to rendered manifests
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecSourceKustomizeCommonAnnotations {
                /// CommonAnnotations is a list of additional annotations to add to rendered manifests
                pub properties: std::collections::HashMap<String, String>,
            }

            /// CommonAnnotations is a list of additional annotations to add to rendered manifests
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct HistoryItemSourceKustomizeCommonAnnotations {
                /// CommonAnnotations is a list of additional annotations to add to rendered manifests
                pub properties: std::collections::HashMap<String, String>,
            }

            /// CommonAnnotations is a list of additional annotations to add to rendered manifests
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct OperationStateOperationSyncSourceKustomizeCommonAnnotations {
                /// CommonAnnotations is a list of additional annotations to add to rendered manifests
                pub properties: std::collections::HashMap<String, String>,
            }

            /// CommonAnnotations is a list of additional annotations to add to rendered manifests
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SyncResultSourceKustomizeCommonAnnotations {
                /// CommonAnnotations is a list of additional annotations to add to rendered manifests
                pub properties: std::collections::HashMap<String, String>,
            }

            /// CommonAnnotations is a list of additional annotations to add to rendered manifests
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct ComparedToSourceKustomizeCommonAnnotations {
                /// CommonAnnotations is a list of additional annotations to add to rendered manifests
                pub properties: std::collections::HashMap<String, String>,
            }

            /// CommonLabels is a list of additional labels to add to rendered manifests
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct OperationSyncSourceKustomizeCommonLabels {
                /// CommonLabels is a list of additional labels to add to rendered manifests
                pub properties: std::collections::HashMap<String, String>,
            }

            /// CommonLabels is a list of additional labels to add to rendered manifests
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecSourceKustomizeCommonLabels {
                /// CommonLabels is a list of additional labels to add to rendered manifests
                pub properties: std::collections::HashMap<String, String>,
            }

            /// CommonLabels is a list of additional labels to add to rendered manifests
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct HistoryItemSourceKustomizeCommonLabels {
                /// CommonLabels is a list of additional labels to add to rendered manifests
                pub properties: std::collections::HashMap<String, String>,
            }

            /// CommonLabels is a list of additional labels to add to rendered manifests
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct OperationStateOperationSyncSourceKustomizeCommonLabels {
                /// CommonLabels is a list of additional labels to add to rendered manifests
                pub properties: std::collections::HashMap<String, String>,
            }

            /// CommonLabels is a list of additional labels to add to rendered manifests
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SyncResultSourceKustomizeCommonLabels {
                /// CommonLabels is a list of additional labels to add to rendered manifests
                pub properties: std::collections::HashMap<String, String>,
            }

            /// CommonLabels is a list of additional labels to add to rendered manifests
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct ComparedToSourceKustomizeCommonLabels {
                /// CommonLabels is a list of additional labels to add to rendered manifests
                pub properties: std::collections::HashMap<String, String>,
            }

            /// ComparedTo contains information about what has been compared
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct ComparedTo {
                /// Destination is a reference to the application's destination used for comparison
                pub destination: ComparedToDestination,
                /// Source is a reference to the application's source used for comparison
                pub source: ComparedToSource,
            }

            /// ApplicationCondition contains details about an application condition, which is usally an error or warning
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct ConditionsItem {
                /// LastTransitionTime is the time the condition was last observed
                pub last_transition_time: String,
                /// Message contains human-readable message indicating details about condition
                pub message: String,
                /// Type is an application condition type
                pub r#type: String,
            }

            /// Destination is a reference to the target Kubernetes server and namespace
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecDestination {
                /// Name is an alternate way of specifying the target cluster by its symbolic name
                pub name: String,
                /// Namespace specifies the target namespace for the application's resources. The namespace will only be set for namespace-scoped resources that have not set a value for .metadata.namespace
                pub namespace: String,
                /// Server specifies the URL of the target cluster and must be set to the Kubernetes control plane API
                pub server: String,
            }

            /// Destination is a reference to the application's destination used for comparison
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct ComparedToDestination {
                /// Name is an alternate way of specifying the target cluster by its symbolic name
                pub name: String,
                /// Namespace specifies the target namespace for the application's resources. The namespace will only be set for namespace-scoped resources that have not set a value for .metadata.namespace
                pub namespace: String,
                /// Server specifies the URL of the target cluster and must be set to the Kubernetes control plane API
                pub server: String,
            }

            /// Directory holds path/directory specific options
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct OperationSyncSourceDirectory {
                /// Exclude contains a glob pattern to match paths against that should be explicitly excluded from being used during manifest generation
                pub exclude: String,
                /// Include contains a glob pattern to match paths against that should be explicitly included during manifest generation
                pub include: String,
                /// Jsonnet holds options specific to Jsonnet
                pub jsonnet: OperationSyncSourceDirectoryJsonnet,
                /// Recurse specifies whether to scan a directory recursively for manifests
                pub recurse: bool,
            }

            /// Directory holds path/directory specific options
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecSourceDirectory {
                /// Exclude contains a glob pattern to match paths against that should be explicitly excluded from being used during manifest generation
                pub exclude: String,
                /// Include contains a glob pattern to match paths against that should be explicitly included during manifest generation
                pub include: String,
                /// Jsonnet holds options specific to Jsonnet
                pub jsonnet: SpecSourceDirectoryJsonnet,
                /// Recurse specifies whether to scan a directory recursively for manifests
                pub recurse: bool,
            }

            /// Directory holds path/directory specific options
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct HistoryItemSourceDirectory {
                /// Exclude contains a glob pattern to match paths against that should be explicitly excluded from being used during manifest generation
                pub exclude: String,
                /// Include contains a glob pattern to match paths against that should be explicitly included during manifest generation
                pub include: String,
                /// Jsonnet holds options specific to Jsonnet
                pub jsonnet: HistoryItemSourceDirectoryJsonnet,
                /// Recurse specifies whether to scan a directory recursively for manifests
                pub recurse: bool,
            }

            /// Directory holds path/directory specific options
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct OperationStateOperationSyncSourceDirectory {
                /// Exclude contains a glob pattern to match paths against that should be explicitly excluded from being used during manifest generation
                pub exclude: String,
                /// Include contains a glob pattern to match paths against that should be explicitly included during manifest generation
                pub include: String,
                /// Jsonnet holds options specific to Jsonnet
                pub jsonnet: OperationStateOperationSyncSourceDirectoryJsonnet,
                /// Recurse specifies whether to scan a directory recursively for manifests
                pub recurse: bool,
            }

            /// Directory holds path/directory specific options
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SyncResultSourceDirectory {
                /// Exclude contains a glob pattern to match paths against that should be explicitly excluded from being used during manifest generation
                pub exclude: String,
                /// Include contains a glob pattern to match paths against that should be explicitly included during manifest generation
                pub include: String,
                /// Jsonnet holds options specific to Jsonnet
                pub jsonnet: SyncResultSourceDirectoryJsonnet,
                /// Recurse specifies whether to scan a directory recursively for manifests
                pub recurse: bool,
            }

            /// Directory holds path/directory specific options
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct ComparedToSourceDirectory {
                /// Exclude contains a glob pattern to match paths against that should be explicitly excluded from being used during manifest generation
                pub exclude: String,
                /// Include contains a glob pattern to match paths against that should be explicitly included during manifest generation
                pub include: String,
                /// Jsonnet holds options specific to Jsonnet
                pub jsonnet: ComparedToSourceDirectoryJsonnet,
                /// Recurse specifies whether to scan a directory recursively for manifests
                pub recurse: bool,
            }

            /// EnvEntry represents an entry in the application's environment
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct OperationSyncSourcePluginEnvItem {
                /// Name is the name of the variable, usually expressed in uppercase
                pub name: String,
                /// Value is the value of the variable
                pub value: String,
            }

            /// EnvEntry represents an entry in the application's environment
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecSourcePluginEnvItem {
                /// Name is the name of the variable, usually expressed in uppercase
                pub name: String,
                /// Value is the value of the variable
                pub value: String,
            }

            /// EnvEntry represents an entry in the application's environment
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct HistoryItemSourcePluginEnvItem {
                /// Name is the name of the variable, usually expressed in uppercase
                pub name: String,
                /// Value is the value of the variable
                pub value: String,
            }

            /// EnvEntry represents an entry in the application's environment
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct OperationStateOperationSyncSourcePluginEnvItem {
                /// Name is the name of the variable, usually expressed in uppercase
                pub name: String,
                /// Value is the value of the variable
                pub value: String,
            }

            /// EnvEntry represents an entry in the application's environment
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SyncResultSourcePluginEnvItem {
                /// Name is the name of the variable, usually expressed in uppercase
                pub name: String,
                /// Value is the value of the variable
                pub value: String,
            }

            /// EnvEntry represents an entry in the application's environment
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct ComparedToSourcePluginEnvItem {
                /// Name is the name of the variable, usually expressed in uppercase
                pub name: String,
                /// Value is the value of the variable
                pub value: String,
            }

            /// JsonnetVar represents a variable to be passed to jsonnet during manifest generation
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct OperationSyncSourceDirectoryJsonnetExtVarsItem {
                pub code: bool,
                pub name: String,
                pub value: String,
            }

            /// JsonnetVar represents a variable to be passed to jsonnet during manifest generation
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecSourceDirectoryJsonnetExtVarsItem {
                pub code: bool,
                pub name: String,
                pub value: String,
            }

            /// JsonnetVar represents a variable to be passed to jsonnet during manifest generation
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct HistoryItemSourceDirectoryJsonnetExtVarsItem {
                pub code: bool,
                pub name: String,
                pub value: String,
            }

            /// JsonnetVar represents a variable to be passed to jsonnet during manifest generation
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct OperationStateOperationSyncSourceDirectoryJsonnetExtVarsItem {
                pub code: bool,
                pub name: String,
                pub value: String,
            }

            /// JsonnetVar represents a variable to be passed to jsonnet during manifest generation
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SyncResultSourceDirectoryJsonnetExtVarsItem {
                pub code: bool,
                pub name: String,
                pub value: String,
            }

            /// JsonnetVar represents a variable to be passed to jsonnet during manifest generation
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct ComparedToSourceDirectoryJsonnetExtVarsItem {
                pub code: bool,
                pub name: String,
                pub value: String,
            }

            /// HelmFileParameter is a file parameter that's passed to helm template during manifest generation
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct OperationSyncSourceHelmFileParametersItem {
                /// Name is the name of the Helm parameter
                pub name: String,
                /// Path is the path to the file containing the values for the Helm parameter
                pub path: String,
            }

            /// HelmFileParameter is a file parameter that's passed to helm template during manifest generation
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecSourceHelmFileParametersItem {
                /// Name is the name of the Helm parameter
                pub name: String,
                /// Path is the path to the file containing the values for the Helm parameter
                pub path: String,
            }

            /// HelmFileParameter is a file parameter that's passed to helm template during manifest generation
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct HistoryItemSourceHelmFileParametersItem {
                /// Name is the name of the Helm parameter
                pub name: String,
                /// Path is the path to the file containing the values for the Helm parameter
                pub path: String,
            }

            /// HelmFileParameter is a file parameter that's passed to helm template during manifest generation
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct OperationStateOperationSyncSourceHelmFileParametersItem {
                /// Name is the name of the Helm parameter
                pub name: String,
                /// Path is the path to the file containing the values for the Helm parameter
                pub path: String,
            }

            /// HelmFileParameter is a file parameter that's passed to helm template during manifest generation
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SyncResultSourceHelmFileParametersItem {
                /// Name is the name of the Helm parameter
                pub name: String,
                /// Path is the path to the file containing the values for the Helm parameter
                pub path: String,
            }

            /// HelmFileParameter is a file parameter that's passed to helm template during manifest generation
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct ComparedToSourceHelmFileParametersItem {
                /// Name is the name of the Helm parameter
                pub name: String,
                /// Path is the path to the file containing the values for the Helm parameter
                pub path: String,
            }

            /// Health contains information about the application's current health status
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct StatusHealth {
                /// Message is a human-readable informational message describing the health status
                pub message: String,
                /// Status holds the status code of the application or resource
                pub status: String,
            }

            /// HealthStatus contains information about the currently observed health state of an application or resource
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct ResourcesItemHealth {
                /// Message is a human-readable informational message describing the health status
                pub message: String,
                /// Status holds the status code of the application or resource
                pub status: String,
            }

            /// Helm holds helm specific options
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct OperationSyncSourceHelm {
                /// FileParameters are file parameters to the helm template
                pub file_parameters: Vec<OperationSyncSourceHelmFileParametersItem>,
                /// IgnoreMissingValueFiles prevents helm template from failing when valueFiles do not exist locally by not appending them to helm template --values
                pub ignore_missing_value_files: bool,
                /// Parameters is a list of Helm parameters which are passed to the helm template command upon manifest generation
                pub parameters: Vec<OperationSyncSourceHelmParametersItem>,
                /// PassCredentials pass credentials to all domains (Helm's --pass-credentials)
                pub pass_credentials: bool,
                /// ReleaseName is the Helm release name to use. If omitted it will use the application name
                pub release_name: String,
                /// SkipCrds skips custom resource definition installation step (Helm's --skip-crds)
                pub skip_crds: bool,
                /// ValuesFiles is a list of Helm value files to use when generating a template
                pub value_files: Vec<String>,
                /// Values specifies Helm values to be passed to helm template, typically defined as a block
                pub values: String,
                /// Version is the Helm version to use for templating ("3")
                pub version: String,
            }

            /// Helm holds helm specific options
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecSourceHelm {
                /// FileParameters are file parameters to the helm template
                pub file_parameters: Vec<SpecSourceHelmFileParametersItem>,
                /// IgnoreMissingValueFiles prevents helm template from failing when valueFiles do not exist locally by not appending them to helm template --values
                pub ignore_missing_value_files: bool,
                /// Parameters is a list of Helm parameters which are passed to the helm template command upon manifest generation
                pub parameters: Vec<SpecSourceHelmParametersItem>,
                /// PassCredentials pass credentials to all domains (Helm's --pass-credentials)
                pub pass_credentials: bool,
                /// ReleaseName is the Helm release name to use. If omitted it will use the application name
                pub release_name: String,
                /// SkipCrds skips custom resource definition installation step (Helm's --skip-crds)
                pub skip_crds: bool,
                /// ValuesFiles is a list of Helm value files to use when generating a template
                pub value_files: Vec<String>,
                /// Values specifies Helm values to be passed to helm template, typically defined as a block
                pub values: String,
                /// Version is the Helm version to use for templating ("3")
                pub version: String,
            }

            /// Helm holds helm specific options
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct HistoryItemSourceHelm {
                /// FileParameters are file parameters to the helm template
                pub file_parameters: Vec<HistoryItemSourceHelmFileParametersItem>,
                /// IgnoreMissingValueFiles prevents helm template from failing when valueFiles do not exist locally by not appending them to helm template --values
                pub ignore_missing_value_files: bool,
                /// Parameters is a list of Helm parameters which are passed to the helm template command upon manifest generation
                pub parameters: Vec<HistoryItemSourceHelmParametersItem>,
                /// PassCredentials pass credentials to all domains (Helm's --pass-credentials)
                pub pass_credentials: bool,
                /// ReleaseName is the Helm release name to use. If omitted it will use the application name
                pub release_name: String,
                /// SkipCrds skips custom resource definition installation step (Helm's --skip-crds)
                pub skip_crds: bool,
                /// ValuesFiles is a list of Helm value files to use when generating a template
                pub value_files: Vec<String>,
                /// Values specifies Helm values to be passed to helm template, typically defined as a block
                pub values: String,
                /// Version is the Helm version to use for templating ("3")
                pub version: String,
            }

            /// Helm holds helm specific options
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct OperationStateOperationSyncSourceHelm {
                /// FileParameters are file parameters to the helm template
                pub file_parameters: Vec<OperationStateOperationSyncSourceHelmFileParametersItem>,
                /// IgnoreMissingValueFiles prevents helm template from failing when valueFiles do not exist locally by not appending them to helm template --values
                pub ignore_missing_value_files: bool,
                /// Parameters is a list of Helm parameters which are passed to the helm template command upon manifest generation
                pub parameters: Vec<OperationStateOperationSyncSourceHelmParametersItem>,
                /// PassCredentials pass credentials to all domains (Helm's --pass-credentials)
                pub pass_credentials: bool,
                /// ReleaseName is the Helm release name to use. If omitted it will use the application name
                pub release_name: String,
                /// SkipCrds skips custom resource definition installation step (Helm's --skip-crds)
                pub skip_crds: bool,
                /// ValuesFiles is a list of Helm value files to use when generating a template
                pub value_files: Vec<String>,
                /// Values specifies Helm values to be passed to helm template, typically defined as a block
                pub values: String,
                /// Version is the Helm version to use for templating ("3")
                pub version: String,
            }

            /// Helm holds helm specific options
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SyncResultSourceHelm {
                /// FileParameters are file parameters to the helm template
                pub file_parameters: Vec<SyncResultSourceHelmFileParametersItem>,
                /// IgnoreMissingValueFiles prevents helm template from failing when valueFiles do not exist locally by not appending them to helm template --values
                pub ignore_missing_value_files: bool,
                /// Parameters is a list of Helm parameters which are passed to the helm template command upon manifest generation
                pub parameters: Vec<SyncResultSourceHelmParametersItem>,
                /// PassCredentials pass credentials to all domains (Helm's --pass-credentials)
                pub pass_credentials: bool,
                /// ReleaseName is the Helm release name to use. If omitted it will use the application name
                pub release_name: String,
                /// SkipCrds skips custom resource definition installation step (Helm's --skip-crds)
                pub skip_crds: bool,
                /// ValuesFiles is a list of Helm value files to use when generating a template
                pub value_files: Vec<String>,
                /// Values specifies Helm values to be passed to helm template, typically defined as a block
                pub values: String,
                /// Version is the Helm version to use for templating ("3")
                pub version: String,
            }

            /// Helm holds helm specific options
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct ComparedToSourceHelm {
                /// FileParameters are file parameters to the helm template
                pub file_parameters: Vec<ComparedToSourceHelmFileParametersItem>,
                /// IgnoreMissingValueFiles prevents helm template from failing when valueFiles do not exist locally by not appending them to helm template --values
                pub ignore_missing_value_files: bool,
                /// Parameters is a list of Helm parameters which are passed to the helm template command upon manifest generation
                pub parameters: Vec<ComparedToSourceHelmParametersItem>,
                /// PassCredentials pass credentials to all domains (Helm's --pass-credentials)
                pub pass_credentials: bool,
                /// ReleaseName is the Helm release name to use. If omitted it will use the application name
                pub release_name: String,
                /// SkipCrds skips custom resource definition installation step (Helm's --skip-crds)
                pub skip_crds: bool,
                /// ValuesFiles is a list of Helm value files to use when generating a template
                pub value_files: Vec<String>,
                /// Values specifies Helm values to be passed to helm template, typically defined as a block
                pub values: String,
                /// Version is the Helm version to use for templating ("3")
                pub version: String,
            }

            /// RevisionHistory contains history information about a previous sync
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct HistoryItem {
                /// DeployStartedAt holds the time the sync operation started
                pub deploy_started_at: String,
                /// DeployedAt holds the time the sync operation completed
                pub deployed_at: String,
                /// ID is an auto incrementing identifier of the RevisionHistory
                pub id: i64,
                /// Revision holds the revision the sync was performed against
                pub revision: String,
                /// Source is a reference to the application source used for the sync operation
                pub source: HistoryItemSource,
            }

            /// Hook will submit any referenced resources to perform the sync. This is the default strategy
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct OperationSyncSyncStrategyHook {
                /// Force indicates whether or not to supply the --force flag to `kubectl apply`. The --force flag deletes and re-create the resource, when PATCH encounters conflict and has retried for 5 times.
                pub force: bool,
            }

            /// Hook will submit any referenced resources to perform the sync. This is the default strategy
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct OperationStateOperationSyncSyncStrategyHook {
                /// Force indicates whether or not to supply the --force flag to `kubectl apply`. The --force flag deletes and re-create the resource, when PATCH encounters conflict and has retried for 5 times.
                pub force: bool,
            }

            /// ResourceIgnoreDifferences contains resource filter and list of json paths which should be ignored during comparison with live state.
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct IgnoreDifferencesItem {
                pub group: String,
                pub jq_path_expressions: Vec<String>,
                pub json_pointers: Vec<String>,
                pub kind: String,
                /// ManagedFieldsManagers is a list of trusted managers. Fields mutated by those managers will take precedence over the desired state defined in the SCM and won't be displayed in diffs
                pub managed_fields_managers: Vec<String>,
                pub name: String,
                pub namespace: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct OperationInfoItem {
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecInfoItem {
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct OperationStateOperationInfoItem {
                pub name: String,
                pub value: String,
            }

            /// InitiatedBy contains information about who initiated the operations
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct OperationInitiatedBy {
                /// Automated is set to true if operation was initiated automatically by the application controller.
                pub automated: bool,
                /// Username contains the name of a user who started operation
                pub username: String,
            }

            /// InitiatedBy contains information about who initiated the operations
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct OperationStateOperationInitiatedBy {
                /// Automated is set to true if operation was initiated automatically by the application controller.
                pub automated: bool,
                /// Username contains the name of a user who started operation
                pub username: String,
            }

            /// Jsonnet holds options specific to Jsonnet
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct OperationSyncSourceDirectoryJsonnet {
                /// ExtVars is a list of Jsonnet External Variables
                pub ext_vars: Vec<OperationSyncSourceDirectoryJsonnetExtVarsItem>,
                /// Additional library search dirs
                pub libs: Vec<String>,
                /// TLAS is a list of Jsonnet Top-level Arguments
                pub tlas: Vec<OperationSyncSourceDirectoryJsonnetTlasItem>,
            }

            /// Jsonnet holds options specific to Jsonnet
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecSourceDirectoryJsonnet {
                /// ExtVars is a list of Jsonnet External Variables
                pub ext_vars: Vec<SpecSourceDirectoryJsonnetExtVarsItem>,
                /// Additional library search dirs
                pub libs: Vec<String>,
                /// TLAS is a list of Jsonnet Top-level Arguments
                pub tlas: Vec<SpecSourceDirectoryJsonnetTlasItem>,
            }

            /// Jsonnet holds options specific to Jsonnet
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct HistoryItemSourceDirectoryJsonnet {
                /// ExtVars is a list of Jsonnet External Variables
                pub ext_vars: Vec<HistoryItemSourceDirectoryJsonnetExtVarsItem>,
                /// Additional library search dirs
                pub libs: Vec<String>,
                /// TLAS is a list of Jsonnet Top-level Arguments
                pub tlas: Vec<HistoryItemSourceDirectoryJsonnetTlasItem>,
            }

            /// Jsonnet holds options specific to Jsonnet
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct OperationStateOperationSyncSourceDirectoryJsonnet {
                /// ExtVars is a list of Jsonnet External Variables
                pub ext_vars: Vec<OperationStateOperationSyncSourceDirectoryJsonnetExtVarsItem>,
                /// Additional library search dirs
                pub libs: Vec<String>,
                /// TLAS is a list of Jsonnet Top-level Arguments
                pub tlas: Vec<OperationStateOperationSyncSourceDirectoryJsonnetTlasItem>,
            }

            /// Jsonnet holds options specific to Jsonnet
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SyncResultSourceDirectoryJsonnet {
                /// ExtVars is a list of Jsonnet External Variables
                pub ext_vars: Vec<SyncResultSourceDirectoryJsonnetExtVarsItem>,
                /// Additional library search dirs
                pub libs: Vec<String>,
                /// TLAS is a list of Jsonnet Top-level Arguments
                pub tlas: Vec<SyncResultSourceDirectoryJsonnetTlasItem>,
            }

            /// Jsonnet holds options specific to Jsonnet
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct ComparedToSourceDirectoryJsonnet {
                /// ExtVars is a list of Jsonnet External Variables
                pub ext_vars: Vec<ComparedToSourceDirectoryJsonnetExtVarsItem>,
                /// Additional library search dirs
                pub libs: Vec<String>,
                /// TLAS is a list of Jsonnet Top-level Arguments
                pub tlas: Vec<ComparedToSourceDirectoryJsonnetTlasItem>,
            }

            /// Kustomize holds kustomize specific options
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct OperationSyncSourceKustomize {
                /// CommonAnnotations is a list of additional annotations to add to rendered manifests
                pub common_annotations: OperationSyncSourceKustomizeCommonAnnotations,
                /// CommonLabels is a list of additional labels to add to rendered manifests
                pub common_labels: OperationSyncSourceKustomizeCommonLabels,
                /// ForceCommonAnnotations specifies whether to force applying common annotations to resources for Kustomize apps
                pub force_common_annotations: bool,
                /// ForceCommonLabels specifies whether to force applying common labels to resources for Kustomize apps
                pub force_common_labels: bool,
                /// Images is a list of Kustomize image override specifications
                pub images: Vec<String>,
                /// NamePrefix is a prefix appended to resources for Kustomize apps
                pub name_prefix: String,
                /// NameSuffix is a suffix appended to resources for Kustomize apps
                pub name_suffix: String,
                /// Version controls which version of Kustomize to use for rendering manifests
                pub version: String,
            }

            /// Kustomize holds kustomize specific options
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecSourceKustomize {
                /// CommonAnnotations is a list of additional annotations to add to rendered manifests
                pub common_annotations: SpecSourceKustomizeCommonAnnotations,
                /// CommonLabels is a list of additional labels to add to rendered manifests
                pub common_labels: SpecSourceKustomizeCommonLabels,
                /// ForceCommonAnnotations specifies whether to force applying common annotations to resources for Kustomize apps
                pub force_common_annotations: bool,
                /// ForceCommonLabels specifies whether to force applying common labels to resources for Kustomize apps
                pub force_common_labels: bool,
                /// Images is a list of Kustomize image override specifications
                pub images: Vec<String>,
                /// NamePrefix is a prefix appended to resources for Kustomize apps
                pub name_prefix: String,
                /// NameSuffix is a suffix appended to resources for Kustomize apps
                pub name_suffix: String,
                /// Version controls which version of Kustomize to use for rendering manifests
                pub version: String,
            }

            /// Kustomize holds kustomize specific options
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct HistoryItemSourceKustomize {
                /// CommonAnnotations is a list of additional annotations to add to rendered manifests
                pub common_annotations: HistoryItemSourceKustomizeCommonAnnotations,
                /// CommonLabels is a list of additional labels to add to rendered manifests
                pub common_labels: HistoryItemSourceKustomizeCommonLabels,
                /// ForceCommonAnnotations specifies whether to force applying common annotations to resources for Kustomize apps
                pub force_common_annotations: bool,
                /// ForceCommonLabels specifies whether to force applying common labels to resources for Kustomize apps
                pub force_common_labels: bool,
                /// Images is a list of Kustomize image override specifications
                pub images: Vec<String>,
                /// NamePrefix is a prefix appended to resources for Kustomize apps
                pub name_prefix: String,
                /// NameSuffix is a suffix appended to resources for Kustomize apps
                pub name_suffix: String,
                /// Version controls which version of Kustomize to use for rendering manifests
                pub version: String,
            }

            /// Kustomize holds kustomize specific options
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct OperationStateOperationSyncSourceKustomize {
                /// CommonAnnotations is a list of additional annotations to add to rendered manifests
                pub common_annotations: OperationStateOperationSyncSourceKustomizeCommonAnnotations,
                /// CommonLabels is a list of additional labels to add to rendered manifests
                pub common_labels: OperationStateOperationSyncSourceKustomizeCommonLabels,
                /// ForceCommonAnnotations specifies whether to force applying common annotations to resources for Kustomize apps
                pub force_common_annotations: bool,
                /// ForceCommonLabels specifies whether to force applying common labels to resources for Kustomize apps
                pub force_common_labels: bool,
                /// Images is a list of Kustomize image override specifications
                pub images: Vec<String>,
                /// NamePrefix is a prefix appended to resources for Kustomize apps
                pub name_prefix: String,
                /// NameSuffix is a suffix appended to resources for Kustomize apps
                pub name_suffix: String,
                /// Version controls which version of Kustomize to use for rendering manifests
                pub version: String,
            }

            /// Kustomize holds kustomize specific options
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SyncResultSourceKustomize {
                /// CommonAnnotations is a list of additional annotations to add to rendered manifests
                pub common_annotations: SyncResultSourceKustomizeCommonAnnotations,
                /// CommonLabels is a list of additional labels to add to rendered manifests
                pub common_labels: SyncResultSourceKustomizeCommonLabels,
                /// ForceCommonAnnotations specifies whether to force applying common annotations to resources for Kustomize apps
                pub force_common_annotations: bool,
                /// ForceCommonLabels specifies whether to force applying common labels to resources for Kustomize apps
                pub force_common_labels: bool,
                /// Images is a list of Kustomize image override specifications
                pub images: Vec<String>,
                /// NamePrefix is a prefix appended to resources for Kustomize apps
                pub name_prefix: String,
                /// NameSuffix is a suffix appended to resources for Kustomize apps
                pub name_suffix: String,
                /// Version controls which version of Kustomize to use for rendering manifests
                pub version: String,
            }

            /// Kustomize holds kustomize specific options
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct ComparedToSourceKustomize {
                /// CommonAnnotations is a list of additional annotations to add to rendered manifests
                pub common_annotations: ComparedToSourceKustomizeCommonAnnotations,
                /// CommonLabels is a list of additional labels to add to rendered manifests
                pub common_labels: ComparedToSourceKustomizeCommonLabels,
                /// ForceCommonAnnotations specifies whether to force applying common annotations to resources for Kustomize apps
                pub force_common_annotations: bool,
                /// ForceCommonLabels specifies whether to force applying common labels to resources for Kustomize apps
                pub force_common_labels: bool,
                /// Images is a list of Kustomize image override specifications
                pub images: Vec<String>,
                /// NamePrefix is a prefix appended to resources for Kustomize apps
                pub name_prefix: String,
                /// NameSuffix is a suffix appended to resources for Kustomize apps
                pub name_suffix: String,
                /// Version controls which version of Kustomize to use for rendering manifests
                pub version: String,
            }

            /// Operation contains information about a requested or running operation
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct Operation {
                /// Info is a list of informational items for this operation
                pub info: Vec<OperationInfoItem>,
                /// InitiatedBy contains information about who initiated the operations
                pub initiated_by: OperationInitiatedBy,
                /// Retry controls the strategy to apply if a sync fails
                pub retry: OperationRetry,
                /// Sync contains parameters for the operation
                pub sync: OperationSync,
            }

            /// Operation is the original requested operation
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct OperationStateOperation {
                /// Info is a list of informational items for this operation
                pub info: Vec<OperationStateOperationInfoItem>,
                /// InitiatedBy contains information about who initiated the operations
                pub initiated_by: OperationStateOperationInitiatedBy,
                /// Retry controls the strategy to apply if a sync fails
                pub retry: OperationStateOperationRetry,
                /// Sync contains parameters for the operation
                pub sync: OperationStateOperationSync,
            }

            /// OperationState contains information about any ongoing operations, such as a sync
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct OperationState {
                /// FinishedAt contains time of operation completion
                pub finished_at: String,
                /// Message holds any pertinent messages when attempting to perform operation (typically errors).
                pub message: String,
                /// Operation is the original requested operation
                pub operation: OperationStateOperation,
                /// Phase is the current phase of the operation
                pub phase: String,
                /// RetryCount contains time of operation retries
                pub retry_count: i64,
                /// StartedAt contains time of operation start
                pub started_at: String,
                /// SyncResult is the result of a Sync operation
                pub sync_result: SyncResult,
            }

            /// HelmParameter is a parameter that's passed to helm template during manifest generation
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct OperationSyncSourceHelmParametersItem {
                /// ForceString determines whether to tell Helm to interpret booleans and numbers as strings
                pub force_string: bool,
                /// Name is the name of the Helm parameter
                pub name: String,
                /// Value is the value for the Helm parameter
                pub value: String,
            }

            /// HelmParameter is a parameter that's passed to helm template during manifest generation
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecSourceHelmParametersItem {
                /// ForceString determines whether to tell Helm to interpret booleans and numbers as strings
                pub force_string: bool,
                /// Name is the name of the Helm parameter
                pub name: String,
                /// Value is the value for the Helm parameter
                pub value: String,
            }

            /// HelmParameter is a parameter that's passed to helm template during manifest generation
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct HistoryItemSourceHelmParametersItem {
                /// ForceString determines whether to tell Helm to interpret booleans and numbers as strings
                pub force_string: bool,
                /// Name is the name of the Helm parameter
                pub name: String,
                /// Value is the value for the Helm parameter
                pub value: String,
            }

            /// HelmParameter is a parameter that's passed to helm template during manifest generation
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct OperationStateOperationSyncSourceHelmParametersItem {
                /// ForceString determines whether to tell Helm to interpret booleans and numbers as strings
                pub force_string: bool,
                /// Name is the name of the Helm parameter
                pub name: String,
                /// Value is the value for the Helm parameter
                pub value: String,
            }

            /// HelmParameter is a parameter that's passed to helm template during manifest generation
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SyncResultSourceHelmParametersItem {
                /// ForceString determines whether to tell Helm to interpret booleans and numbers as strings
                pub force_string: bool,
                /// Name is the name of the Helm parameter
                pub name: String,
                /// Value is the value for the Helm parameter
                pub value: String,
            }

            /// HelmParameter is a parameter that's passed to helm template during manifest generation
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct ComparedToSourceHelmParametersItem {
                /// ForceString determines whether to tell Helm to interpret booleans and numbers as strings
                pub force_string: bool,
                /// Name is the name of the Helm parameter
                pub name: String,
                /// Value is the value for the Helm parameter
                pub value: String,
            }

            /// ConfigManagementPlugin holds config management plugin specific options
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct OperationSyncSourcePlugin {
                /// Env is a list of environment variable entries
                pub env: Vec<OperationSyncSourcePluginEnvItem>,
                pub name: String,
            }

            /// ConfigManagementPlugin holds config management plugin specific options
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecSourcePlugin {
                /// Env is a list of environment variable entries
                pub env: Vec<SpecSourcePluginEnvItem>,
                pub name: String,
            }

            /// ConfigManagementPlugin holds config management plugin specific options
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct HistoryItemSourcePlugin {
                /// Env is a list of environment variable entries
                pub env: Vec<HistoryItemSourcePluginEnvItem>,
                pub name: String,
            }

            /// ConfigManagementPlugin holds config management plugin specific options
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct OperationStateOperationSyncSourcePlugin {
                /// Env is a list of environment variable entries
                pub env: Vec<OperationStateOperationSyncSourcePluginEnvItem>,
                pub name: String,
            }

            /// ConfigManagementPlugin holds config management plugin specific options
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SyncResultSourcePlugin {
                /// Env is a list of environment variable entries
                pub env: Vec<SyncResultSourcePluginEnvItem>,
                pub name: String,
            }

            /// ConfigManagementPlugin holds config management plugin specific options
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct ComparedToSourcePlugin {
                /// Env is a list of environment variable entries
                pub env: Vec<ComparedToSourcePluginEnvItem>,
                pub name: String,
            }

            /// SyncOperationResource contains resources to sync.
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct OperationSyncResourcesItem {
                pub group: String,
                pub kind: String,
                pub name: String,
                pub namespace: String,
            }

            /// ResourceStatus holds the current sync and health status of a resource TODO: describe members of this type
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct StatusResourcesItem {
                pub group: String,
                /// HealthStatus contains information about the currently observed health state of an application or resource
                pub health: ResourcesItemHealth,
                pub hook: bool,
                pub kind: String,
                pub name: String,
                pub namespace: String,
                pub requires_pruning: bool,
                /// SyncStatusCode is a type which represents possible comparison results
                pub status: String,
                pub version: String,
            }

            /// SyncOperationResource contains resources to sync.
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct OperationStateOperationSyncResourcesItem {
                pub group: String,
                pub kind: String,
                pub name: String,
                pub namespace: String,
            }

            /// ResourceResult holds the operation result details of a specific resource
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SyncResultResourcesItem {
                /// Group specifies the API group of the resource
                pub group: String,
                /// HookPhase contains the state of any operation associated with this resource OR hook This can also contain values for non-hook resources.
                pub hook_phase: String,
                /// HookType specifies the type of the hook. Empty for non-hook resources
                pub hook_type: String,
                /// Kind specifies the API kind of the resource
                pub kind: String,
                /// Message contains an informational or error message for the last sync OR operation
                pub message: String,
                /// Name specifies the name of the resource
                pub name: String,
                /// Namespace specifies the target namespace of the resource
                pub namespace: String,
                /// Status holds the final result of the sync. Will be empty if the resources is yet to be applied/pruned and is always zero-value for hooks
                pub status: String,
                /// SyncPhase indicates the particular phase of the sync that this result was acquired in
                pub sync_phase: String,
                /// Version specifies the API version of the resource
                pub version: String,
            }

            /// Retry controls the strategy to apply if a sync fails
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct OperationRetry {
                /// Backoff controls how to backoff on subsequent retries of failed syncs
                pub backoff: OperationRetryBackoff,
                /// Limit is the maximum number of attempts for retrying a failed sync. If set to 0, no retries will be performed.
                pub limit: i64,
            }

            /// Retry controls failed sync retry behavior
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SyncPolicyRetry {
                /// Backoff controls how to backoff on subsequent retries of failed syncs
                pub backoff: SyncPolicyRetryBackoff,
                /// Limit is the maximum number of attempts for retrying a failed sync. If set to 0, no retries will be performed.
                pub limit: i64,
            }

            /// Retry controls the strategy to apply if a sync fails
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct OperationStateOperationRetry {
                /// Backoff controls how to backoff on subsequent retries of failed syncs
                pub backoff: OperationStateOperationRetryBackoff,
                /// Limit is the maximum number of attempts for retrying a failed sync. If set to 0, no retries will be performed.
                pub limit: i64,
            }

            /// Source overrides the source definition set in the application. This is typically set in a Rollback operation and is nil during a Sync operation
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct OperationSyncSource {
                /// Chart is a Helm chart name, and must be specified for applications sourced from a Helm repo.
                pub chart: String,
                /// Directory holds path/directory specific options
                pub directory: OperationSyncSourceDirectory,
                /// Helm holds helm specific options
                pub helm: OperationSyncSourceHelm,
                /// Kustomize holds kustomize specific options
                pub kustomize: OperationSyncSourceKustomize,
                /// Path is a directory path within the Git repository, and is only valid for applications sourced from Git.
                pub path: String,
                /// ConfigManagementPlugin holds config management plugin specific options
                pub plugin: OperationSyncSourcePlugin,
                /// RepoURL is the URL to the repository (Git or Helm) that contains the application manifests
                pub repo_u_r_l: String,
                /// TargetRevision defines the revision of the source to sync the application to. In case of Git, this can be commit, tag, or branch. If omitted, will equal to HEAD. In case of Helm, this is a semver tag for the Chart's version.
                pub target_revision: String,
            }

            /// Source is a reference to the location of the application's manifests or chart
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecSource {
                /// Chart is a Helm chart name, and must be specified for applications sourced from a Helm repo.
                pub chart: String,
                /// Directory holds path/directory specific options
                pub directory: SpecSourceDirectory,
                /// Helm holds helm specific options
                pub helm: SpecSourceHelm,
                /// Kustomize holds kustomize specific options
                pub kustomize: SpecSourceKustomize,
                /// Path is a directory path within the Git repository, and is only valid for applications sourced from Git.
                pub path: String,
                /// ConfigManagementPlugin holds config management plugin specific options
                pub plugin: SpecSourcePlugin,
                /// RepoURL is the URL to the repository (Git or Helm) that contains the application manifests
                pub repo_u_r_l: String,
                /// TargetRevision defines the revision of the source to sync the application to. In case of Git, this can be commit, tag, or branch. If omitted, will equal to HEAD. In case of Helm, this is a semver tag for the Chart's version.
                pub target_revision: String,
            }

            /// Source is a reference to the application source used for the sync operation
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct HistoryItemSource {
                /// Chart is a Helm chart name, and must be specified for applications sourced from a Helm repo.
                pub chart: String,
                /// Directory holds path/directory specific options
                pub directory: HistoryItemSourceDirectory,
                /// Helm holds helm specific options
                pub helm: HistoryItemSourceHelm,
                /// Kustomize holds kustomize specific options
                pub kustomize: HistoryItemSourceKustomize,
                /// Path is a directory path within the Git repository, and is only valid for applications sourced from Git.
                pub path: String,
                /// ConfigManagementPlugin holds config management plugin specific options
                pub plugin: HistoryItemSourcePlugin,
                /// RepoURL is the URL to the repository (Git or Helm) that contains the application manifests
                pub repo_u_r_l: String,
                /// TargetRevision defines the revision of the source to sync the application to. In case of Git, this can be commit, tag, or branch. If omitted, will equal to HEAD. In case of Helm, this is a semver tag for the Chart's version.
                pub target_revision: String,
            }

            /// Source overrides the source definition set in the application. This is typically set in a Rollback operation and is nil during a Sync operation
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct OperationStateOperationSyncSource {
                /// Chart is a Helm chart name, and must be specified for applications sourced from a Helm repo.
                pub chart: String,
                /// Directory holds path/directory specific options
                pub directory: OperationStateOperationSyncSourceDirectory,
                /// Helm holds helm specific options
                pub helm: OperationStateOperationSyncSourceHelm,
                /// Kustomize holds kustomize specific options
                pub kustomize: OperationStateOperationSyncSourceKustomize,
                /// Path is a directory path within the Git repository, and is only valid for applications sourced from Git.
                pub path: String,
                /// ConfigManagementPlugin holds config management plugin specific options
                pub plugin: OperationStateOperationSyncSourcePlugin,
                /// RepoURL is the URL to the repository (Git or Helm) that contains the application manifests
                pub repo_u_r_l: String,
                /// TargetRevision defines the revision of the source to sync the application to. In case of Git, this can be commit, tag, or branch. If omitted, will equal to HEAD. In case of Helm, this is a semver tag for the Chart's version.
                pub target_revision: String,
            }

            /// Source records the application source information of the sync, used for comparing auto-sync
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SyncResultSource {
                /// Chart is a Helm chart name, and must be specified for applications sourced from a Helm repo.
                pub chart: String,
                /// Directory holds path/directory specific options
                pub directory: SyncResultSourceDirectory,
                /// Helm holds helm specific options
                pub helm: SyncResultSourceHelm,
                /// Kustomize holds kustomize specific options
                pub kustomize: SyncResultSourceKustomize,
                /// Path is a directory path within the Git repository, and is only valid for applications sourced from Git.
                pub path: String,
                /// ConfigManagementPlugin holds config management plugin specific options
                pub plugin: SyncResultSourcePlugin,
                /// RepoURL is the URL to the repository (Git or Helm) that contains the application manifests
                pub repo_u_r_l: String,
                /// TargetRevision defines the revision of the source to sync the application to. In case of Git, this can be commit, tag, or branch. If omitted, will equal to HEAD. In case of Helm, this is a semver tag for the Chart's version.
                pub target_revision: String,
            }

            /// Source is a reference to the application's source used for comparison
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct ComparedToSource {
                /// Chart is a Helm chart name, and must be specified for applications sourced from a Helm repo.
                pub chart: String,
                /// Directory holds path/directory specific options
                pub directory: ComparedToSourceDirectory,
                /// Helm holds helm specific options
                pub helm: ComparedToSourceHelm,
                /// Kustomize holds kustomize specific options
                pub kustomize: ComparedToSourceKustomize,
                /// Path is a directory path within the Git repository, and is only valid for applications sourced from Git.
                pub path: String,
                /// ConfigManagementPlugin holds config management plugin specific options
                pub plugin: ComparedToSourcePlugin,
                /// RepoURL is the URL to the repository (Git or Helm) that contains the application manifests
                pub repo_u_r_l: String,
                /// TargetRevision defines the revision of the source to sync the application to. In case of Git, this can be commit, tag, or branch. If omitted, will equal to HEAD. In case of Helm, this is a semver tag for the Chart's version.
                pub target_revision: String,
            }

            /// ApplicationSpec represents desired application state. Contains link to repository with application definition and additional parameters link definition revision.
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct Spec {
                /// Destination is a reference to the target Kubernetes server and namespace
                pub destination: SpecDestination,
                /// IgnoreDifferences is a list of resources and their fields which should be ignored during comparison
                pub ignore_differences: Vec<IgnoreDifferencesItem>,
                /// Info contains a list of information (URLs, email addresses, and plain text) that relates to the application
                pub info: Vec<SpecInfoItem>,
                /// Project is a reference to the project this application belongs to. The empty string means that application belongs to the 'default' project.
                pub project: String,
                /// RevisionHistoryLimit limits the number of items kept in the application's revision history, which is used for informational purposes as well as for rollbacks to previous versions. This should only be changed in exceptional circumstances. Setting to zero will store no history. This will reduce storage used. Increasing will increase the space used to store the history, so we do not recommend increasing it. Default is 10.
                pub revision_history_limit: i64,
                /// Source is a reference to the location of the application's manifests or chart
                pub source: SpecSource,
                /// SyncPolicy controls when and how a sync will be performed
                pub sync_policy: SyncPolicy,
            }

            /// ApplicationStatus contains status information for the application
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct Status {
                /// Conditions is a list of currently observed application conditions
                pub conditions: Vec<ConditionsItem>,
                /// Health contains information about the application's current health status
                pub health: StatusHealth,
                /// History contains information about the application's sync history
                pub history: Vec<HistoryItem>,
                /// ObservedAt indicates when the application state was updated without querying latest git state Deprecated: controller no longer updates ObservedAt field
                pub observed_at: String,
                /// OperationState contains information about any ongoing operations, such as a sync
                pub operation_state: OperationState,
                /// ReconciledAt indicates when the application state was reconciled using the latest git version
                pub reconciled_at: String,
                /// Resources is a list of Kubernetes resources managed by this application
                pub resources: Vec<StatusResourcesItem>,
                /// SourceType specifies the type of this application
                pub source_type: String,
                /// Summary contains a list of URLs and container images used by this application
                pub summary: Summary,
                /// Sync contains information about the application's current sync status
                pub sync: StatusSync,
            }

            /// Summary contains a list of URLs and container images used by this application
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct Summary {
                /// ExternalURLs holds all external URLs of application child resources.
                pub external_u_r_ls: Vec<String>,
                /// Images holds all images of application child resources.
                pub images: Vec<String>,
            }

            /// Sync contains parameters for the operation
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct OperationSync {
                /// DryRun specifies to perform a `kubectl apply --dry-run` without actually performing the sync
                pub dry_run: bool,
                /// Manifests is an optional field that overrides sync source with a local directory for development
                pub manifests: Vec<String>,
                /// Prune specifies to delete resources from the cluster that are no longer tracked in git
                pub prune: bool,
                /// Resources describes which resources shall be part of the sync
                pub resources: Vec<OperationSyncResourcesItem>,
                /// Revision is the revision (Git) or chart version (Helm) which to sync the application to If omitted, will use the revision specified in app spec.
                pub revision: String,
                /// Source overrides the source definition set in the application. This is typically set in a Rollback operation and is nil during a Sync operation
                pub source: OperationSyncSource,
                /// SyncOptions provide per-sync sync-options, e.g. Validate=false
                pub sync_options: Vec<String>,
                /// SyncStrategy describes how to perform the sync
                pub sync_strategy: OperationSyncSyncStrategy,
            }

            /// Sync contains information about the application's current sync status
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct StatusSync {
                /// ComparedTo contains information about what has been compared
                pub compared_to: ComparedTo,
                /// Revision contains information about the revision the comparison has been performed to
                pub revision: String,
                /// Status is the sync state of the comparison
                pub status: String,
            }

            /// Sync contains parameters for the operation
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct OperationStateOperationSync {
                /// DryRun specifies to perform a `kubectl apply --dry-run` without actually performing the sync
                pub dry_run: bool,
                /// Manifests is an optional field that overrides sync source with a local directory for development
                pub manifests: Vec<String>,
                /// Prune specifies to delete resources from the cluster that are no longer tracked in git
                pub prune: bool,
                /// Resources describes which resources shall be part of the sync
                pub resources: Vec<OperationStateOperationSyncResourcesItem>,
                /// Revision is the revision (Git) or chart version (Helm) which to sync the application to If omitted, will use the revision specified in app spec.
                pub revision: String,
                /// Source overrides the source definition set in the application. This is typically set in a Rollback operation and is nil during a Sync operation
                pub source: OperationStateOperationSyncSource,
                /// SyncOptions provide per-sync sync-options, e.g. Validate=false
                pub sync_options: Vec<String>,
                /// SyncStrategy describes how to perform the sync
                pub sync_strategy: OperationStateOperationSyncSyncStrategy,
            }

            /// SyncPolicy controls when and how a sync will be performed
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SyncPolicy {
                /// Automated will keep an application synced to the target revision
                pub automated: Automated,
                /// Retry controls failed sync retry behavior
                pub retry: SyncPolicyRetry,
                /// Options allow you to specify whole app sync-options
                pub sync_options: Vec<String>,
            }

            /// SyncResult is the result of a Sync operation
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SyncResult {
                /// Resources contains a list of sync result items for each individual resource in a sync operation
                pub resources: Vec<SyncResultResourcesItem>,
                /// Revision holds the revision this sync operation was performed to
                pub revision: String,
                /// Source records the application source information of the sync, used for comparing auto-sync
                pub source: SyncResultSource,
            }

            /// SyncStrategy describes how to perform the sync
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct OperationSyncSyncStrategy {
                /// Apply will perform a `kubectl apply` to perform the sync.
                pub apply: OperationSyncSyncStrategyApply,
                /// Hook will submit any referenced resources to perform the sync. This is the default strategy
                pub hook: OperationSyncSyncStrategyHook,
            }

            /// SyncStrategy describes how to perform the sync
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct OperationStateOperationSyncSyncStrategy {
                /// Apply will perform a `kubectl apply` to perform the sync.
                pub apply: OperationStateOperationSyncSyncStrategyApply,
                /// Hook will submit any referenced resources to perform the sync. This is the default strategy
                pub hook: OperationStateOperationSyncSyncStrategyHook,
            }

            /// JsonnetVar represents a variable to be passed to jsonnet during manifest generation
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct OperationSyncSourceDirectoryJsonnetTlasItem {
                pub code: bool,
                pub name: String,
                pub value: String,
            }

            /// JsonnetVar represents a variable to be passed to jsonnet during manifest generation
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecSourceDirectoryJsonnetTlasItem {
                pub code: bool,
                pub name: String,
                pub value: String,
            }

            /// JsonnetVar represents a variable to be passed to jsonnet during manifest generation
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct HistoryItemSourceDirectoryJsonnetTlasItem {
                pub code: bool,
                pub name: String,
                pub value: String,
            }

            /// JsonnetVar represents a variable to be passed to jsonnet during manifest generation
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct OperationStateOperationSyncSourceDirectoryJsonnetTlasItem {
                pub code: bool,
                pub name: String,
                pub value: String,
            }

            /// JsonnetVar represents a variable to be passed to jsonnet during manifest generation
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SyncResultSourceDirectoryJsonnetTlasItem {
                pub code: bool,
                pub name: String,
                pub value: String,
            }

            /// JsonnetVar represents a variable to be passed to jsonnet during manifest generation
            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct ComparedToSourceDirectoryJsonnetTlasItem {
                pub code: bool,
                pub name: String,
                pub value: String,
            }
        }
        pub mod application_set {
            #[derive(serde::Deserialize, Debug, PartialEq)]
            pub struct ApplicationSet {
                pub metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta,
                pub spec: Spec,
                pub status: Status,
            }

            impl k8s_openapi::Resource for ApplicationSet {
                type Scope = k8s_openapi::ClusterResourceScope;

                const API_VERSION: &'static str = "argoproj.io/v1alpha1";
                const GROUP: &'static str = "argoproj.io";
                const KIND: &'static str = "ApplicationSet";
                const VERSION: &'static str = "v1alpha1";
                const URL_PATH_SEGMENT: &'static str = "TODO";
            }

            impl k8s_openapi::Metadata for ApplicationSet {
                type Ty = k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta;

                fn metadata(&self) -> &<Self as k8s_openapi::Metadata>::Ty {
                    &self.metadata
                }

                fn metadata_mut(&mut self) -> &mut <Self as k8s_openapi::Metadata>::Ty {
                    &mut self.metadata
                }
            }

            impl serde::Serialize for ApplicationSet {
                fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where
                    S: serde::Serializer,
                {
                    use serde::ser::SerializeStruct;
                    let mut state = serializer.serialize_struct("ApplicationSet", 5)?;
                    state.serialize_field(
                        "apiVersion",
                        <Self as k8s_openapi::Resource>::API_VERSION,
                    )?;
                    state.serialize_field("kind", <Self as k8s_openapi::Resource>::KIND)?;
                    state.serialize_field("metadata", &self.metadata)?;
                    state.serialize_field("spec", &self.spec)?;
                    state.serialize_field("status", &self.status)?;
                    state.end()
                }
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemScmProviderAzureDevOpsAccessTokenRef {
                pub key: String,
                pub secret_name: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemScmProviderAzureDevOpsAccessTokenRef {
                pub key: String,
                pub secret_name: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemScmProviderAzureDevOpsAccessTokenRef {
                pub key: String,
                pub secret_name: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClusterDecisionResourceTemplateMetadataAnnotations {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClustersTemplateMetadataAnnotations {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemGitTemplateMetadataAnnotations {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemListTemplateMetadataAnnotations {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClusterDecisionResourceTemplateMetadataAnnotations {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClustersTemplateMetadataAnnotations {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemGitTemplateMetadataAnnotations {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemListTemplateMetadataAnnotations {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemPullRequestTemplateMetadataAnnotations {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemScmProviderTemplateMetadataAnnotations {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixTemplateMetadataAnnotations {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClusterDecisionResourceTemplateMetadataAnnotations {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClustersTemplateMetadataAnnotations {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemGitTemplateMetadataAnnotations {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemListTemplateMetadataAnnotations {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemPullRequestTemplateMetadataAnnotations {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemScmProviderTemplateMetadataAnnotations {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeTemplateMetadataAnnotations {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemPullRequestTemplateMetadataAnnotations {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemScmProviderTemplateMetadataAnnotations {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecTemplateMetadataAnnotations {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemScmProviderBitbucketAppPasswordRef {
                pub key: String,
                pub secret_name: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemScmProviderBitbucketAppPasswordRef {
                pub key: String,
                pub secret_name: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemScmProviderBitbucketAppPasswordRef {
                pub key: String,
                pub secret_name: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClusterDecisionResourceTemplateSpecSyncPolicyAutomated {
                pub allow_empty: bool,
                pub prune: bool,
                pub self_heal: bool,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClustersTemplateSpecSyncPolicyAutomated {
                pub allow_empty: bool,
                pub prune: bool,
                pub self_heal: bool,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemGitTemplateSpecSyncPolicyAutomated {
                pub allow_empty: bool,
                pub prune: bool,
                pub self_heal: bool,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemListTemplateSpecSyncPolicyAutomated {
                pub allow_empty: bool,
                pub prune: bool,
                pub self_heal: bool,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClusterDecisionResourceTemplateSpecSyncPolicyAutomated {
                pub allow_empty: bool,
                pub prune: bool,
                pub self_heal: bool,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClustersTemplateSpecSyncPolicyAutomated {
                pub allow_empty: bool,
                pub prune: bool,
                pub self_heal: bool,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemGitTemplateSpecSyncPolicyAutomated {
                pub allow_empty: bool,
                pub prune: bool,
                pub self_heal: bool,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemListTemplateSpecSyncPolicyAutomated {
                pub allow_empty: bool,
                pub prune: bool,
                pub self_heal: bool,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemPullRequestTemplateSpecSyncPolicyAutomated {
                pub allow_empty: bool,
                pub prune: bool,
                pub self_heal: bool,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemScmProviderTemplateSpecSyncPolicyAutomated {
                pub allow_empty: bool,
                pub prune: bool,
                pub self_heal: bool,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixTemplateSpecSyncPolicyAutomated {
                pub allow_empty: bool,
                pub prune: bool,
                pub self_heal: bool,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClusterDecisionResourceTemplateSpecSyncPolicyAutomated {
                pub allow_empty: bool,
                pub prune: bool,
                pub self_heal: bool,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClustersTemplateSpecSyncPolicyAutomated {
                pub allow_empty: bool,
                pub prune: bool,
                pub self_heal: bool,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemGitTemplateSpecSyncPolicyAutomated {
                pub allow_empty: bool,
                pub prune: bool,
                pub self_heal: bool,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemListTemplateSpecSyncPolicyAutomated {
                pub allow_empty: bool,
                pub prune: bool,
                pub self_heal: bool,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemPullRequestTemplateSpecSyncPolicyAutomated {
                pub allow_empty: bool,
                pub prune: bool,
                pub self_heal: bool,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemScmProviderTemplateSpecSyncPolicyAutomated {
                pub allow_empty: bool,
                pub prune: bool,
                pub self_heal: bool,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeTemplateSpecSyncPolicyAutomated {
                pub allow_empty: bool,
                pub prune: bool,
                pub self_heal: bool,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemPullRequestTemplateSpecSyncPolicyAutomated {
                pub allow_empty: bool,
                pub prune: bool,
                pub self_heal: bool,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemScmProviderTemplateSpecSyncPolicyAutomated {
                pub allow_empty: bool,
                pub prune: bool,
                pub self_heal: bool,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecTemplateSpecSyncPolicyAutomated {
                pub allow_empty: bool,
                pub prune: bool,
                pub self_heal: bool,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemScmProviderAzureDevOps {
                pub access_token_ref: MatrixGeneratorsItemScmProviderAzureDevOpsAccessTokenRef,
                pub all_branches: bool,
                pub api: String,
                pub organization: String,
                pub team_project: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemScmProviderAzureDevOps {
                pub access_token_ref: MergeGeneratorsItemScmProviderAzureDevOpsAccessTokenRef,
                pub all_branches: bool,
                pub api: String,
                pub organization: String,
                pub team_project: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemScmProviderAzureDevOps {
                pub access_token_ref: SpecGeneratorsItemScmProviderAzureDevOpsAccessTokenRef,
                pub all_branches: bool,
                pub api: String,
                pub organization: String,
                pub team_project: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClusterDecisionResourceTemplateSpecSyncPolicyRetryBackoff {
                pub duration: String,
                pub factor: i64,
                pub max_duration: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClustersTemplateSpecSyncPolicyRetryBackoff {
                pub duration: String,
                pub factor: i64,
                pub max_duration: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemGitTemplateSpecSyncPolicyRetryBackoff {
                pub duration: String,
                pub factor: i64,
                pub max_duration: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemListTemplateSpecSyncPolicyRetryBackoff {
                pub duration: String,
                pub factor: i64,
                pub max_duration: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClusterDecisionResourceTemplateSpecSyncPolicyRetryBackoff {
                pub duration: String,
                pub factor: i64,
                pub max_duration: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClustersTemplateSpecSyncPolicyRetryBackoff {
                pub duration: String,
                pub factor: i64,
                pub max_duration: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemGitTemplateSpecSyncPolicyRetryBackoff {
                pub duration: String,
                pub factor: i64,
                pub max_duration: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemListTemplateSpecSyncPolicyRetryBackoff {
                pub duration: String,
                pub factor: i64,
                pub max_duration: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemPullRequestTemplateSpecSyncPolicyRetryBackoff {
                pub duration: String,
                pub factor: i64,
                pub max_duration: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemScmProviderTemplateSpecSyncPolicyRetryBackoff {
                pub duration: String,
                pub factor: i64,
                pub max_duration: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixTemplateSpecSyncPolicyRetryBackoff {
                pub duration: String,
                pub factor: i64,
                pub max_duration: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClusterDecisionResourceTemplateSpecSyncPolicyRetryBackoff {
                pub duration: String,
                pub factor: i64,
                pub max_duration: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClustersTemplateSpecSyncPolicyRetryBackoff {
                pub duration: String,
                pub factor: i64,
                pub max_duration: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemGitTemplateSpecSyncPolicyRetryBackoff {
                pub duration: String,
                pub factor: i64,
                pub max_duration: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemListTemplateSpecSyncPolicyRetryBackoff {
                pub duration: String,
                pub factor: i64,
                pub max_duration: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemPullRequestTemplateSpecSyncPolicyRetryBackoff {
                pub duration: String,
                pub factor: i64,
                pub max_duration: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemScmProviderTemplateSpecSyncPolicyRetryBackoff {
                pub duration: String,
                pub factor: i64,
                pub max_duration: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeTemplateSpecSyncPolicyRetryBackoff {
                pub duration: String,
                pub factor: i64,
                pub max_duration: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemPullRequestTemplateSpecSyncPolicyRetryBackoff {
                pub duration: String,
                pub factor: i64,
                pub max_duration: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemScmProviderTemplateSpecSyncPolicyRetryBackoff {
                pub duration: String,
                pub factor: i64,
                pub max_duration: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecTemplateSpecSyncPolicyRetryBackoff {
                pub duration: String,
                pub factor: i64,
                pub max_duration: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemPullRequestBitbucketServerBasicAuth {
                pub password_ref:
                    MatrixGeneratorsItemPullRequestBitbucketServerBasicAuthPasswordRef,
                pub username: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemScmProviderBitbucketServerBasicAuth {
                pub password_ref:
                    MatrixGeneratorsItemScmProviderBitbucketServerBasicAuthPasswordRef,
                pub username: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemPullRequestBitbucketServerBasicAuth {
                pub password_ref: MergeGeneratorsItemPullRequestBitbucketServerBasicAuthPasswordRef,
                pub username: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemScmProviderBitbucketServerBasicAuth {
                pub password_ref: MergeGeneratorsItemScmProviderBitbucketServerBasicAuthPasswordRef,
                pub username: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemPullRequestBitbucketServerBasicAuth {
                pub password_ref: SpecGeneratorsItemPullRequestBitbucketServerBasicAuthPasswordRef,
                pub username: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemScmProviderBitbucketServerBasicAuth {
                pub password_ref: SpecGeneratorsItemScmProviderBitbucketServerBasicAuthPasswordRef,
                pub username: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemScmProviderBitbucket {
                pub all_branches: bool,
                pub app_password_ref: MatrixGeneratorsItemScmProviderBitbucketAppPasswordRef,
                pub owner: String,
                pub user: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemScmProviderBitbucket {
                pub all_branches: bool,
                pub app_password_ref: MergeGeneratorsItemScmProviderBitbucketAppPasswordRef,
                pub owner: String,
                pub user: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemScmProviderBitbucket {
                pub all_branches: bool,
                pub app_password_ref: SpecGeneratorsItemScmProviderBitbucketAppPasswordRef,
                pub owner: String,
                pub user: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemPullRequestBitbucketServer {
                pub api: String,
                pub basic_auth: MatrixGeneratorsItemPullRequestBitbucketServerBasicAuth,
                pub project: String,
                pub repo: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemScmProviderBitbucketServer {
                pub all_branches: bool,
                pub api: String,
                pub basic_auth: MatrixGeneratorsItemScmProviderBitbucketServerBasicAuth,
                pub project: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemPullRequestBitbucketServer {
                pub api: String,
                pub basic_auth: MergeGeneratorsItemPullRequestBitbucketServerBasicAuth,
                pub project: String,
                pub repo: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemScmProviderBitbucketServer {
                pub all_branches: bool,
                pub api: String,
                pub basic_auth: MergeGeneratorsItemScmProviderBitbucketServerBasicAuth,
                pub project: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemPullRequestBitbucketServer {
                pub api: String,
                pub basic_auth: SpecGeneratorsItemPullRequestBitbucketServerBasicAuth,
                pub project: String,
                pub repo: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemScmProviderBitbucketServer {
                pub all_branches: bool,
                pub api: String,
                pub basic_auth: SpecGeneratorsItemScmProviderBitbucketServerBasicAuth,
                pub project: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClusterDecisionResource {
                pub config_map_ref: String,
                pub label_selector: SpecGeneratorsItemClusterDecisionResourceLabelSelector,
                pub name: String,
                pub requeue_after_seconds: i64,
                pub template: SpecGeneratorsItemClusterDecisionResourceTemplate,
                pub values: SpecGeneratorsItemClusterDecisionResourceValues,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClusterDecisionResource {
                pub config_map_ref: String,
                pub label_selector: MatrixGeneratorsItemClusterDecisionResourceLabelSelector,
                pub name: String,
                pub requeue_after_seconds: i64,
                pub template: MatrixGeneratorsItemClusterDecisionResourceTemplate,
                pub values: MatrixGeneratorsItemClusterDecisionResourceValues,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClusterDecisionResource {
                pub config_map_ref: String,
                pub label_selector: MergeGeneratorsItemClusterDecisionResourceLabelSelector,
                pub name: String,
                pub requeue_after_seconds: i64,
                pub template: MergeGeneratorsItemClusterDecisionResourceTemplate,
                pub values: MergeGeneratorsItemClusterDecisionResourceValues,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClusters {
                pub selector: SpecGeneratorsItemClustersSelector,
                pub template: SpecGeneratorsItemClustersTemplate,
                pub values: SpecGeneratorsItemClustersValues,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClusters {
                pub selector: MatrixGeneratorsItemClustersSelector,
                pub template: MatrixGeneratorsItemClustersTemplate,
                pub values: MatrixGeneratorsItemClustersValues,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClusters {
                pub selector: MergeGeneratorsItemClustersSelector,
                pub template: MergeGeneratorsItemClustersTemplate,
                pub values: MergeGeneratorsItemClustersValues,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClusterDecisionResourceTemplateSpecSourceKustomizeCommonAnnotations {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClustersTemplateSpecSourceKustomizeCommonAnnotations {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemGitTemplateSpecSourceKustomizeCommonAnnotations {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemListTemplateSpecSourceKustomizeCommonAnnotations {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClusterDecisionResourceTemplateSpecSourceKustomizeCommonAnnotations {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClustersTemplateSpecSourceKustomizeCommonAnnotations {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemGitTemplateSpecSourceKustomizeCommonAnnotations {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemListTemplateSpecSourceKustomizeCommonAnnotations {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemPullRequestTemplateSpecSourceKustomizeCommonAnnotations {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemScmProviderTemplateSpecSourceKustomizeCommonAnnotations {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixTemplateSpecSourceKustomizeCommonAnnotations {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClusterDecisionResourceTemplateSpecSourceKustomizeCommonAnnotations {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClustersTemplateSpecSourceKustomizeCommonAnnotations {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemGitTemplateSpecSourceKustomizeCommonAnnotations {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemListTemplateSpecSourceKustomizeCommonAnnotations {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemPullRequestTemplateSpecSourceKustomizeCommonAnnotations {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemScmProviderTemplateSpecSourceKustomizeCommonAnnotations {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeTemplateSpecSourceKustomizeCommonAnnotations {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemPullRequestTemplateSpecSourceKustomizeCommonAnnotations {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemScmProviderTemplateSpecSourceKustomizeCommonAnnotations {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecTemplateSpecSourceKustomizeCommonAnnotations {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClusterDecisionResourceTemplateSpecSourceKustomizeCommonLabels {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClustersTemplateSpecSourceKustomizeCommonLabels {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemGitTemplateSpecSourceKustomizeCommonLabels {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemListTemplateSpecSourceKustomizeCommonLabels {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClusterDecisionResourceTemplateSpecSourceKustomizeCommonLabels {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClustersTemplateSpecSourceKustomizeCommonLabels {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemGitTemplateSpecSourceKustomizeCommonLabels {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemListTemplateSpecSourceKustomizeCommonLabels {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemPullRequestTemplateSpecSourceKustomizeCommonLabels {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemScmProviderTemplateSpecSourceKustomizeCommonLabels {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixTemplateSpecSourceKustomizeCommonLabels {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClusterDecisionResourceTemplateSpecSourceKustomizeCommonLabels {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClustersTemplateSpecSourceKustomizeCommonLabels {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemGitTemplateSpecSourceKustomizeCommonLabels {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemListTemplateSpecSourceKustomizeCommonLabels {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemPullRequestTemplateSpecSourceKustomizeCommonLabels {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemScmProviderTemplateSpecSourceKustomizeCommonLabels {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeTemplateSpecSourceKustomizeCommonLabels {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemPullRequestTemplateSpecSourceKustomizeCommonLabels {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemScmProviderTemplateSpecSourceKustomizeCommonLabels {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecTemplateSpecSourceKustomizeCommonLabels {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct ConditionsItem {
                pub last_transition_time: String,
                pub message: String,
                pub reason: String,
                pub status: String,
                pub r#type: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClusterDecisionResourceTemplateSpecDestination {
                pub name: String,
                pub namespace: String,
                pub server: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClustersTemplateSpecDestination {
                pub name: String,
                pub namespace: String,
                pub server: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemGitTemplateSpecDestination {
                pub name: String,
                pub namespace: String,
                pub server: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemListTemplateSpecDestination {
                pub name: String,
                pub namespace: String,
                pub server: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClusterDecisionResourceTemplateSpecDestination {
                pub name: String,
                pub namespace: String,
                pub server: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClustersTemplateSpecDestination {
                pub name: String,
                pub namespace: String,
                pub server: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemGitTemplateSpecDestination {
                pub name: String,
                pub namespace: String,
                pub server: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemListTemplateSpecDestination {
                pub name: String,
                pub namespace: String,
                pub server: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemPullRequestTemplateSpecDestination {
                pub name: String,
                pub namespace: String,
                pub server: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemScmProviderTemplateSpecDestination {
                pub name: String,
                pub namespace: String,
                pub server: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixTemplateSpecDestination {
                pub name: String,
                pub namespace: String,
                pub server: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClusterDecisionResourceTemplateSpecDestination {
                pub name: String,
                pub namespace: String,
                pub server: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClustersTemplateSpecDestination {
                pub name: String,
                pub namespace: String,
                pub server: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemGitTemplateSpecDestination {
                pub name: String,
                pub namespace: String,
                pub server: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemListTemplateSpecDestination {
                pub name: String,
                pub namespace: String,
                pub server: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemPullRequestTemplateSpecDestination {
                pub name: String,
                pub namespace: String,
                pub server: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemScmProviderTemplateSpecDestination {
                pub name: String,
                pub namespace: String,
                pub server: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeTemplateSpecDestination {
                pub name: String,
                pub namespace: String,
                pub server: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemPullRequestTemplateSpecDestination {
                pub name: String,
                pub namespace: String,
                pub server: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemScmProviderTemplateSpecDestination {
                pub name: String,
                pub namespace: String,
                pub server: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecTemplateSpecDestination {
                pub name: String,
                pub namespace: String,
                pub server: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemGitDirectoriesItem {
                pub exclude: bool,
                pub path: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemGitDirectoriesItem {
                pub exclude: bool,
                pub path: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemGitDirectoriesItem {
                pub exclude: bool,
                pub path: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClusterDecisionResourceTemplateSpecSourceDirectory {
                pub exclude: String,
                pub include: String,
                pub jsonnet:
                    SpecGeneratorsItemClusterDecisionResourceTemplateSpecSourceDirectoryJsonnet,
                pub recurse: bool,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClustersTemplateSpecSourceDirectory {
                pub exclude: String,
                pub include: String,
                pub jsonnet: SpecGeneratorsItemClustersTemplateSpecSourceDirectoryJsonnet,
                pub recurse: bool,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemGitTemplateSpecSourceDirectory {
                pub exclude: String,
                pub include: String,
                pub jsonnet: SpecGeneratorsItemGitTemplateSpecSourceDirectoryJsonnet,
                pub recurse: bool,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemListTemplateSpecSourceDirectory {
                pub exclude: String,
                pub include: String,
                pub jsonnet: SpecGeneratorsItemListTemplateSpecSourceDirectoryJsonnet,
                pub recurse: bool,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClusterDecisionResourceTemplateSpecSourceDirectory {
                pub exclude: String,
                pub include: String,
                pub jsonnet:
                    MatrixGeneratorsItemClusterDecisionResourceTemplateSpecSourceDirectoryJsonnet,
                pub recurse: bool,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClustersTemplateSpecSourceDirectory {
                pub exclude: String,
                pub include: String,
                pub jsonnet: MatrixGeneratorsItemClustersTemplateSpecSourceDirectoryJsonnet,
                pub recurse: bool,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemGitTemplateSpecSourceDirectory {
                pub exclude: String,
                pub include: String,
                pub jsonnet: MatrixGeneratorsItemGitTemplateSpecSourceDirectoryJsonnet,
                pub recurse: bool,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemListTemplateSpecSourceDirectory {
                pub exclude: String,
                pub include: String,
                pub jsonnet: MatrixGeneratorsItemListTemplateSpecSourceDirectoryJsonnet,
                pub recurse: bool,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemPullRequestTemplateSpecSourceDirectory {
                pub exclude: String,
                pub include: String,
                pub jsonnet: MatrixGeneratorsItemPullRequestTemplateSpecSourceDirectoryJsonnet,
                pub recurse: bool,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemScmProviderTemplateSpecSourceDirectory {
                pub exclude: String,
                pub include: String,
                pub jsonnet: MatrixGeneratorsItemScmProviderTemplateSpecSourceDirectoryJsonnet,
                pub recurse: bool,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixTemplateSpecSourceDirectory {
                pub exclude: String,
                pub include: String,
                pub jsonnet: MatrixTemplateSpecSourceDirectoryJsonnet,
                pub recurse: bool,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClusterDecisionResourceTemplateSpecSourceDirectory {
                pub exclude: String,
                pub include: String,
                pub jsonnet:
                    MergeGeneratorsItemClusterDecisionResourceTemplateSpecSourceDirectoryJsonnet,
                pub recurse: bool,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClustersTemplateSpecSourceDirectory {
                pub exclude: String,
                pub include: String,
                pub jsonnet: MergeGeneratorsItemClustersTemplateSpecSourceDirectoryJsonnet,
                pub recurse: bool,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemGitTemplateSpecSourceDirectory {
                pub exclude: String,
                pub include: String,
                pub jsonnet: MergeGeneratorsItemGitTemplateSpecSourceDirectoryJsonnet,
                pub recurse: bool,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemListTemplateSpecSourceDirectory {
                pub exclude: String,
                pub include: String,
                pub jsonnet: MergeGeneratorsItemListTemplateSpecSourceDirectoryJsonnet,
                pub recurse: bool,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemPullRequestTemplateSpecSourceDirectory {
                pub exclude: String,
                pub include: String,
                pub jsonnet: MergeGeneratorsItemPullRequestTemplateSpecSourceDirectoryJsonnet,
                pub recurse: bool,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemScmProviderTemplateSpecSourceDirectory {
                pub exclude: String,
                pub include: String,
                pub jsonnet: MergeGeneratorsItemScmProviderTemplateSpecSourceDirectoryJsonnet,
                pub recurse: bool,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeTemplateSpecSourceDirectory {
                pub exclude: String,
                pub include: String,
                pub jsonnet: MergeTemplateSpecSourceDirectoryJsonnet,
                pub recurse: bool,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemPullRequestTemplateSpecSourceDirectory {
                pub exclude: String,
                pub include: String,
                pub jsonnet: SpecGeneratorsItemPullRequestTemplateSpecSourceDirectoryJsonnet,
                pub recurse: bool,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemScmProviderTemplateSpecSourceDirectory {
                pub exclude: String,
                pub include: String,
                pub jsonnet: SpecGeneratorsItemScmProviderTemplateSpecSourceDirectoryJsonnet,
                pub recurse: bool,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecTemplateSpecSourceDirectory {
                pub exclude: String,
                pub include: String,
                pub jsonnet: SpecTemplateSpecSourceDirectoryJsonnet,
                pub recurse: bool,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClusterDecisionResourceTemplateSpecSourcePluginEnvItem {
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClustersTemplateSpecSourcePluginEnvItem {
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemGitTemplateSpecSourcePluginEnvItem {
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemListTemplateSpecSourcePluginEnvItem {
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClusterDecisionResourceTemplateSpecSourcePluginEnvItem {
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClustersTemplateSpecSourcePluginEnvItem {
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemGitTemplateSpecSourcePluginEnvItem {
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemListTemplateSpecSourcePluginEnvItem {
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemPullRequestTemplateSpecSourcePluginEnvItem {
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemScmProviderTemplateSpecSourcePluginEnvItem {
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixTemplateSpecSourcePluginEnvItem {
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClusterDecisionResourceTemplateSpecSourcePluginEnvItem {
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClustersTemplateSpecSourcePluginEnvItem {
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemGitTemplateSpecSourcePluginEnvItem {
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemListTemplateSpecSourcePluginEnvItem {
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemPullRequestTemplateSpecSourcePluginEnvItem {
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemScmProviderTemplateSpecSourcePluginEnvItem {
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeTemplateSpecSourcePluginEnvItem {
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemPullRequestTemplateSpecSourcePluginEnvItem {
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemScmProviderTemplateSpecSourcePluginEnvItem {
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecTemplateSpecSourcePluginEnvItem {
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClusterDecisionResourceTemplateSpecSourceDirectoryJsonnetExtVarsItem {
                pub code: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClustersTemplateSpecSourceDirectoryJsonnetExtVarsItem {
                pub code: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemGitTemplateSpecSourceDirectoryJsonnetExtVarsItem {
                pub code: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemListTemplateSpecSourceDirectoryJsonnetExtVarsItem {
                pub code: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClusterDecisionResourceTemplateSpecSourceDirectoryJsonnetExtVarsItem
            {
                pub code: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClustersTemplateSpecSourceDirectoryJsonnetExtVarsItem {
                pub code: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemGitTemplateSpecSourceDirectoryJsonnetExtVarsItem {
                pub code: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemListTemplateSpecSourceDirectoryJsonnetExtVarsItem {
                pub code: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemPullRequestTemplateSpecSourceDirectoryJsonnetExtVarsItem {
                pub code: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemScmProviderTemplateSpecSourceDirectoryJsonnetExtVarsItem {
                pub code: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixTemplateSpecSourceDirectoryJsonnetExtVarsItem {
                pub code: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClusterDecisionResourceTemplateSpecSourceDirectoryJsonnetExtVarsItem {
                pub code: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClustersTemplateSpecSourceDirectoryJsonnetExtVarsItem {
                pub code: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemGitTemplateSpecSourceDirectoryJsonnetExtVarsItem {
                pub code: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemListTemplateSpecSourceDirectoryJsonnetExtVarsItem {
                pub code: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemPullRequestTemplateSpecSourceDirectoryJsonnetExtVarsItem {
                pub code: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemScmProviderTemplateSpecSourceDirectoryJsonnetExtVarsItem {
                pub code: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeTemplateSpecSourceDirectoryJsonnetExtVarsItem {
                pub code: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemPullRequestTemplateSpecSourceDirectoryJsonnetExtVarsItem {
                pub code: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemScmProviderTemplateSpecSourceDirectoryJsonnetExtVarsItem {
                pub code: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecTemplateSpecSourceDirectoryJsonnetExtVarsItem {
                pub code: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClusterDecisionResourceTemplateSpecSourceHelmFileParametersItem {
                pub name: String,
                pub path: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClustersTemplateSpecSourceHelmFileParametersItem {
                pub name: String,
                pub path: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemGitTemplateSpecSourceHelmFileParametersItem {
                pub name: String,
                pub path: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemListTemplateSpecSourceHelmFileParametersItem {
                pub name: String,
                pub path: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClusterDecisionResourceTemplateSpecSourceHelmFileParametersItem {
                pub name: String,
                pub path: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClustersTemplateSpecSourceHelmFileParametersItem {
                pub name: String,
                pub path: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemGitTemplateSpecSourceHelmFileParametersItem {
                pub name: String,
                pub path: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemListTemplateSpecSourceHelmFileParametersItem {
                pub name: String,
                pub path: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemPullRequestTemplateSpecSourceHelmFileParametersItem {
                pub name: String,
                pub path: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemScmProviderTemplateSpecSourceHelmFileParametersItem {
                pub name: String,
                pub path: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixTemplateSpecSourceHelmFileParametersItem {
                pub name: String,
                pub path: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClusterDecisionResourceTemplateSpecSourceHelmFileParametersItem {
                pub name: String,
                pub path: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClustersTemplateSpecSourceHelmFileParametersItem {
                pub name: String,
                pub path: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemGitTemplateSpecSourceHelmFileParametersItem {
                pub name: String,
                pub path: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemListTemplateSpecSourceHelmFileParametersItem {
                pub name: String,
                pub path: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemPullRequestTemplateSpecSourceHelmFileParametersItem {
                pub name: String,
                pub path: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemScmProviderTemplateSpecSourceHelmFileParametersItem {
                pub name: String,
                pub path: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeTemplateSpecSourceHelmFileParametersItem {
                pub name: String,
                pub path: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemPullRequestTemplateSpecSourceHelmFileParametersItem {
                pub name: String,
                pub path: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemScmProviderTemplateSpecSourceHelmFileParametersItem {
                pub name: String,
                pub path: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecTemplateSpecSourceHelmFileParametersItem {
                pub name: String,
                pub path: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemGitFilesItem {
                pub path: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemGitFilesItem {
                pub path: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemGitFilesItem {
                pub path: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemPullRequestFiltersItem {
                pub branch_match: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemScmProviderFiltersItem {
                pub branch_match: String,
                pub label_match: String,
                pub paths_do_not_exist: Vec<String>,
                pub paths_exist: Vec<String>,
                pub repository_match: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemPullRequestFiltersItem {
                pub branch_match: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemScmProviderFiltersItem {
                pub branch_match: String,
                pub label_match: String,
                pub paths_do_not_exist: Vec<String>,
                pub paths_exist: Vec<String>,
                pub repository_match: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemPullRequestFiltersItem {
                pub branch_match: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemScmProviderFiltersItem {
                pub branch_match: String,
                pub label_match: String,
                pub paths_do_not_exist: Vec<String>,
                pub paths_exist: Vec<String>,
                pub repository_match: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItem {
                pub cluster_decision_resource: SpecGeneratorsItemClusterDecisionResource,
                pub clusters: SpecGeneratorsItemClusters,
                pub git: SpecGeneratorsItemGit,
                pub list: SpecGeneratorsItemList,
                pub matrix: Matrix,
                pub merge: Merge,
                pub pull_request: SpecGeneratorsItemPullRequest,
                pub scm_provider: SpecGeneratorsItemScmProvider,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItem {
                pub cluster_decision_resource: MatrixGeneratorsItemClusterDecisionResource,
                pub clusters: MatrixGeneratorsItemClusters,
                pub git: MatrixGeneratorsItemGit,
                pub list: MatrixGeneratorsItemList,
                pub matrix: serde_json::Map<String, serde_json::Value>,
                pub merge: serde_json::Map<String, serde_json::Value>,
                pub pull_request: MatrixGeneratorsItemPullRequest,
                pub scm_provider: MatrixGeneratorsItemScmProvider,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItem {
                pub cluster_decision_resource: MergeGeneratorsItemClusterDecisionResource,
                pub clusters: MergeGeneratorsItemClusters,
                pub git: MergeGeneratorsItemGit,
                pub list: MergeGeneratorsItemList,
                pub matrix: serde_json::Map<String, serde_json::Value>,
                pub merge: serde_json::Map<String, serde_json::Value>,
                pub pull_request: MergeGeneratorsItemPullRequest,
                pub scm_provider: MergeGeneratorsItemScmProvider,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemGit {
                pub directories: Vec<SpecGeneratorsItemGitDirectoriesItem>,
                pub files: Vec<SpecGeneratorsItemGitFilesItem>,
                pub repo_u_r_l: String,
                pub requeue_after_seconds: i64,
                pub revision: String,
                pub template: SpecGeneratorsItemGitTemplate,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemGit {
                pub directories: Vec<MatrixGeneratorsItemGitDirectoriesItem>,
                pub files: Vec<MatrixGeneratorsItemGitFilesItem>,
                pub repo_u_r_l: String,
                pub requeue_after_seconds: i64,
                pub revision: String,
                pub template: MatrixGeneratorsItemGitTemplate,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemGit {
                pub directories: Vec<MergeGeneratorsItemGitDirectoriesItem>,
                pub files: Vec<MergeGeneratorsItemGitFilesItem>,
                pub repo_u_r_l: String,
                pub requeue_after_seconds: i64,
                pub revision: String,
                pub template: MergeGeneratorsItemGitTemplate,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemPullRequestGitea {
                pub api: String,
                pub insecure: bool,
                pub owner: String,
                pub repo: String,
                pub token_ref: MatrixGeneratorsItemPullRequestGiteaTokenRef,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemScmProviderGitea {
                pub all_branches: bool,
                pub api: String,
                pub insecure: bool,
                pub owner: String,
                pub token_ref: MatrixGeneratorsItemScmProviderGiteaTokenRef,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemPullRequestGitea {
                pub api: String,
                pub insecure: bool,
                pub owner: String,
                pub repo: String,
                pub token_ref: MergeGeneratorsItemPullRequestGiteaTokenRef,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemScmProviderGitea {
                pub all_branches: bool,
                pub api: String,
                pub insecure: bool,
                pub owner: String,
                pub token_ref: MergeGeneratorsItemScmProviderGiteaTokenRef,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemPullRequestGitea {
                pub api: String,
                pub insecure: bool,
                pub owner: String,
                pub repo: String,
                pub token_ref: SpecGeneratorsItemPullRequestGiteaTokenRef,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemScmProviderGitea {
                pub all_branches: bool,
                pub api: String,
                pub insecure: bool,
                pub owner: String,
                pub token_ref: SpecGeneratorsItemScmProviderGiteaTokenRef,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemPullRequestGithub {
                pub api: String,
                pub labels: Vec<String>,
                pub owner: String,
                pub repo: String,
                pub token_ref: MatrixGeneratorsItemPullRequestGithubTokenRef,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemScmProviderGithub {
                pub all_branches: bool,
                pub api: String,
                pub organization: String,
                pub token_ref: MatrixGeneratorsItemScmProviderGithubTokenRef,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemPullRequestGithub {
                pub api: String,
                pub labels: Vec<String>,
                pub owner: String,
                pub repo: String,
                pub token_ref: MergeGeneratorsItemPullRequestGithubTokenRef,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemScmProviderGithub {
                pub all_branches: bool,
                pub api: String,
                pub organization: String,
                pub token_ref: MergeGeneratorsItemScmProviderGithubTokenRef,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemPullRequestGithub {
                pub api: String,
                pub labels: Vec<String>,
                pub owner: String,
                pub repo: String,
                pub token_ref: SpecGeneratorsItemPullRequestGithubTokenRef,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemScmProviderGithub {
                pub all_branches: bool,
                pub api: String,
                pub organization: String,
                pub token_ref: SpecGeneratorsItemScmProviderGithubTokenRef,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemPullRequestGitlab {
                pub api: String,
                pub labels: Vec<String>,
                pub project: String,
                pub pull_request_state: String,
                pub token_ref: MatrixGeneratorsItemPullRequestGitlabTokenRef,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemScmProviderGitlab {
                pub all_branches: bool,
                pub api: String,
                pub group: String,
                pub include_subgroups: bool,
                pub token_ref: MatrixGeneratorsItemScmProviderGitlabTokenRef,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemPullRequestGitlab {
                pub api: String,
                pub labels: Vec<String>,
                pub project: String,
                pub pull_request_state: String,
                pub token_ref: MergeGeneratorsItemPullRequestGitlabTokenRef,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemScmProviderGitlab {
                pub all_branches: bool,
                pub api: String,
                pub group: String,
                pub include_subgroups: bool,
                pub token_ref: MergeGeneratorsItemScmProviderGitlabTokenRef,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemPullRequestGitlab {
                pub api: String,
                pub labels: Vec<String>,
                pub project: String,
                pub pull_request_state: String,
                pub token_ref: SpecGeneratorsItemPullRequestGitlabTokenRef,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemScmProviderGitlab {
                pub all_branches: bool,
                pub api: String,
                pub group: String,
                pub include_subgroups: bool,
                pub token_ref: SpecGeneratorsItemScmProviderGitlabTokenRef,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClusterDecisionResourceTemplateSpecSourceHelm {
            pub file_parameters: Vec<SpecGeneratorsItemClusterDecisionResourceTemplateSpecSourceHelmFileParametersItem>,
            pub ignore_missing_value_files: bool,
            pub parameters: Vec<SpecGeneratorsItemClusterDecisionResourceTemplateSpecSourceHelmParametersItem>,
            pub pass_credentials: bool,
            pub release_name: String,
            pub skip_crds: bool,
            pub value_files: Vec<String>,
            pub values: String,
            pub version: String,
        }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClustersTemplateSpecSourceHelm {
                pub file_parameters:
                    Vec<SpecGeneratorsItemClustersTemplateSpecSourceHelmFileParametersItem>,
                pub ignore_missing_value_files: bool,
                pub parameters: Vec<SpecGeneratorsItemClustersTemplateSpecSourceHelmParametersItem>,
                pub pass_credentials: bool,
                pub release_name: String,
                pub skip_crds: bool,
                pub value_files: Vec<String>,
                pub values: String,
                pub version: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemGitTemplateSpecSourceHelm {
                pub file_parameters:
                    Vec<SpecGeneratorsItemGitTemplateSpecSourceHelmFileParametersItem>,
                pub ignore_missing_value_files: bool,
                pub parameters: Vec<SpecGeneratorsItemGitTemplateSpecSourceHelmParametersItem>,
                pub pass_credentials: bool,
                pub release_name: String,
                pub skip_crds: bool,
                pub value_files: Vec<String>,
                pub values: String,
                pub version: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemListTemplateSpecSourceHelm {
                pub file_parameters:
                    Vec<SpecGeneratorsItemListTemplateSpecSourceHelmFileParametersItem>,
                pub ignore_missing_value_files: bool,
                pub parameters: Vec<SpecGeneratorsItemListTemplateSpecSourceHelmParametersItem>,
                pub pass_credentials: bool,
                pub release_name: String,
                pub skip_crds: bool,
                pub value_files: Vec<String>,
                pub values: String,
                pub version: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClusterDecisionResourceTemplateSpecSourceHelm {
            pub file_parameters: Vec<MatrixGeneratorsItemClusterDecisionResourceTemplateSpecSourceHelmFileParametersItem>,
            pub ignore_missing_value_files: bool,
            pub parameters: Vec<MatrixGeneratorsItemClusterDecisionResourceTemplateSpecSourceHelmParametersItem>,
            pub pass_credentials: bool,
            pub release_name: String,
            pub skip_crds: bool,
            pub value_files: Vec<String>,
            pub values: String,
            pub version: String,
        }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClustersTemplateSpecSourceHelm {
                pub file_parameters:
                    Vec<MatrixGeneratorsItemClustersTemplateSpecSourceHelmFileParametersItem>,
                pub ignore_missing_value_files: bool,
                pub parameters:
                    Vec<MatrixGeneratorsItemClustersTemplateSpecSourceHelmParametersItem>,
                pub pass_credentials: bool,
                pub release_name: String,
                pub skip_crds: bool,
                pub value_files: Vec<String>,
                pub values: String,
                pub version: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemGitTemplateSpecSourceHelm {
                pub file_parameters:
                    Vec<MatrixGeneratorsItemGitTemplateSpecSourceHelmFileParametersItem>,
                pub ignore_missing_value_files: bool,
                pub parameters: Vec<MatrixGeneratorsItemGitTemplateSpecSourceHelmParametersItem>,
                pub pass_credentials: bool,
                pub release_name: String,
                pub skip_crds: bool,
                pub value_files: Vec<String>,
                pub values: String,
                pub version: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemListTemplateSpecSourceHelm {
                pub file_parameters:
                    Vec<MatrixGeneratorsItemListTemplateSpecSourceHelmFileParametersItem>,
                pub ignore_missing_value_files: bool,
                pub parameters: Vec<MatrixGeneratorsItemListTemplateSpecSourceHelmParametersItem>,
                pub pass_credentials: bool,
                pub release_name: String,
                pub skip_crds: bool,
                pub value_files: Vec<String>,
                pub values: String,
                pub version: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemPullRequestTemplateSpecSourceHelm {
                pub file_parameters:
                    Vec<MatrixGeneratorsItemPullRequestTemplateSpecSourceHelmFileParametersItem>,
                pub ignore_missing_value_files: bool,
                pub parameters:
                    Vec<MatrixGeneratorsItemPullRequestTemplateSpecSourceHelmParametersItem>,
                pub pass_credentials: bool,
                pub release_name: String,
                pub skip_crds: bool,
                pub value_files: Vec<String>,
                pub values: String,
                pub version: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemScmProviderTemplateSpecSourceHelm {
                pub file_parameters:
                    Vec<MatrixGeneratorsItemScmProviderTemplateSpecSourceHelmFileParametersItem>,
                pub ignore_missing_value_files: bool,
                pub parameters:
                    Vec<MatrixGeneratorsItemScmProviderTemplateSpecSourceHelmParametersItem>,
                pub pass_credentials: bool,
                pub release_name: String,
                pub skip_crds: bool,
                pub value_files: Vec<String>,
                pub values: String,
                pub version: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixTemplateSpecSourceHelm {
                pub file_parameters: Vec<MatrixTemplateSpecSourceHelmFileParametersItem>,
                pub ignore_missing_value_files: bool,
                pub parameters: Vec<MatrixTemplateSpecSourceHelmParametersItem>,
                pub pass_credentials: bool,
                pub release_name: String,
                pub skip_crds: bool,
                pub value_files: Vec<String>,
                pub values: String,
                pub version: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClusterDecisionResourceTemplateSpecSourceHelm {
            pub file_parameters: Vec<MergeGeneratorsItemClusterDecisionResourceTemplateSpecSourceHelmFileParametersItem>,
            pub ignore_missing_value_files: bool,
            pub parameters: Vec<MergeGeneratorsItemClusterDecisionResourceTemplateSpecSourceHelmParametersItem>,
            pub pass_credentials: bool,
            pub release_name: String,
            pub skip_crds: bool,
            pub value_files: Vec<String>,
            pub values: String,
            pub version: String,
        }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClustersTemplateSpecSourceHelm {
                pub file_parameters:
                    Vec<MergeGeneratorsItemClustersTemplateSpecSourceHelmFileParametersItem>,
                pub ignore_missing_value_files: bool,
                pub parameters:
                    Vec<MergeGeneratorsItemClustersTemplateSpecSourceHelmParametersItem>,
                pub pass_credentials: bool,
                pub release_name: String,
                pub skip_crds: bool,
                pub value_files: Vec<String>,
                pub values: String,
                pub version: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemGitTemplateSpecSourceHelm {
                pub file_parameters:
                    Vec<MergeGeneratorsItemGitTemplateSpecSourceHelmFileParametersItem>,
                pub ignore_missing_value_files: bool,
                pub parameters: Vec<MergeGeneratorsItemGitTemplateSpecSourceHelmParametersItem>,
                pub pass_credentials: bool,
                pub release_name: String,
                pub skip_crds: bool,
                pub value_files: Vec<String>,
                pub values: String,
                pub version: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemListTemplateSpecSourceHelm {
                pub file_parameters:
                    Vec<MergeGeneratorsItemListTemplateSpecSourceHelmFileParametersItem>,
                pub ignore_missing_value_files: bool,
                pub parameters: Vec<MergeGeneratorsItemListTemplateSpecSourceHelmParametersItem>,
                pub pass_credentials: bool,
                pub release_name: String,
                pub skip_crds: bool,
                pub value_files: Vec<String>,
                pub values: String,
                pub version: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemPullRequestTemplateSpecSourceHelm {
                pub file_parameters:
                    Vec<MergeGeneratorsItemPullRequestTemplateSpecSourceHelmFileParametersItem>,
                pub ignore_missing_value_files: bool,
                pub parameters:
                    Vec<MergeGeneratorsItemPullRequestTemplateSpecSourceHelmParametersItem>,
                pub pass_credentials: bool,
                pub release_name: String,
                pub skip_crds: bool,
                pub value_files: Vec<String>,
                pub values: String,
                pub version: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemScmProviderTemplateSpecSourceHelm {
                pub file_parameters:
                    Vec<MergeGeneratorsItemScmProviderTemplateSpecSourceHelmFileParametersItem>,
                pub ignore_missing_value_files: bool,
                pub parameters:
                    Vec<MergeGeneratorsItemScmProviderTemplateSpecSourceHelmParametersItem>,
                pub pass_credentials: bool,
                pub release_name: String,
                pub skip_crds: bool,
                pub value_files: Vec<String>,
                pub values: String,
                pub version: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeTemplateSpecSourceHelm {
                pub file_parameters: Vec<MergeTemplateSpecSourceHelmFileParametersItem>,
                pub ignore_missing_value_files: bool,
                pub parameters: Vec<MergeTemplateSpecSourceHelmParametersItem>,
                pub pass_credentials: bool,
                pub release_name: String,
                pub skip_crds: bool,
                pub value_files: Vec<String>,
                pub values: String,
                pub version: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemPullRequestTemplateSpecSourceHelm {
                pub file_parameters:
                    Vec<SpecGeneratorsItemPullRequestTemplateSpecSourceHelmFileParametersItem>,
                pub ignore_missing_value_files: bool,
                pub parameters:
                    Vec<SpecGeneratorsItemPullRequestTemplateSpecSourceHelmParametersItem>,
                pub pass_credentials: bool,
                pub release_name: String,
                pub skip_crds: bool,
                pub value_files: Vec<String>,
                pub values: String,
                pub version: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemScmProviderTemplateSpecSourceHelm {
                pub file_parameters:
                    Vec<SpecGeneratorsItemScmProviderTemplateSpecSourceHelmFileParametersItem>,
                pub ignore_missing_value_files: bool,
                pub parameters:
                    Vec<SpecGeneratorsItemScmProviderTemplateSpecSourceHelmParametersItem>,
                pub pass_credentials: bool,
                pub release_name: String,
                pub skip_crds: bool,
                pub value_files: Vec<String>,
                pub values: String,
                pub version: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecTemplateSpecSourceHelm {
                pub file_parameters: Vec<SpecTemplateSpecSourceHelmFileParametersItem>,
                pub ignore_missing_value_files: bool,
                pub parameters: Vec<SpecTemplateSpecSourceHelmParametersItem>,
                pub pass_credentials: bool,
                pub release_name: String,
                pub skip_crds: bool,
                pub value_files: Vec<String>,
                pub values: String,
                pub version: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClusterDecisionResourceTemplateSpecIgnoreDifferencesItem {
                pub group: String,
                pub jq_path_expressions: Vec<String>,
                pub json_pointers: Vec<String>,
                pub kind: String,
                pub managed_fields_managers: Vec<String>,
                pub name: String,
                pub namespace: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClustersTemplateSpecIgnoreDifferencesItem {
                pub group: String,
                pub jq_path_expressions: Vec<String>,
                pub json_pointers: Vec<String>,
                pub kind: String,
                pub managed_fields_managers: Vec<String>,
                pub name: String,
                pub namespace: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemGitTemplateSpecIgnoreDifferencesItem {
                pub group: String,
                pub jq_path_expressions: Vec<String>,
                pub json_pointers: Vec<String>,
                pub kind: String,
                pub managed_fields_managers: Vec<String>,
                pub name: String,
                pub namespace: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemListTemplateSpecIgnoreDifferencesItem {
                pub group: String,
                pub jq_path_expressions: Vec<String>,
                pub json_pointers: Vec<String>,
                pub kind: String,
                pub managed_fields_managers: Vec<String>,
                pub name: String,
                pub namespace: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClusterDecisionResourceTemplateSpecIgnoreDifferencesItem {
                pub group: String,
                pub jq_path_expressions: Vec<String>,
                pub json_pointers: Vec<String>,
                pub kind: String,
                pub managed_fields_managers: Vec<String>,
                pub name: String,
                pub namespace: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClustersTemplateSpecIgnoreDifferencesItem {
                pub group: String,
                pub jq_path_expressions: Vec<String>,
                pub json_pointers: Vec<String>,
                pub kind: String,
                pub managed_fields_managers: Vec<String>,
                pub name: String,
                pub namespace: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemGitTemplateSpecIgnoreDifferencesItem {
                pub group: String,
                pub jq_path_expressions: Vec<String>,
                pub json_pointers: Vec<String>,
                pub kind: String,
                pub managed_fields_managers: Vec<String>,
                pub name: String,
                pub namespace: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemListTemplateSpecIgnoreDifferencesItem {
                pub group: String,
                pub jq_path_expressions: Vec<String>,
                pub json_pointers: Vec<String>,
                pub kind: String,
                pub managed_fields_managers: Vec<String>,
                pub name: String,
                pub namespace: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemPullRequestTemplateSpecIgnoreDifferencesItem {
                pub group: String,
                pub jq_path_expressions: Vec<String>,
                pub json_pointers: Vec<String>,
                pub kind: String,
                pub managed_fields_managers: Vec<String>,
                pub name: String,
                pub namespace: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemScmProviderTemplateSpecIgnoreDifferencesItem {
                pub group: String,
                pub jq_path_expressions: Vec<String>,
                pub json_pointers: Vec<String>,
                pub kind: String,
                pub managed_fields_managers: Vec<String>,
                pub name: String,
                pub namespace: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixTemplateSpecIgnoreDifferencesItem {
                pub group: String,
                pub jq_path_expressions: Vec<String>,
                pub json_pointers: Vec<String>,
                pub kind: String,
                pub managed_fields_managers: Vec<String>,
                pub name: String,
                pub namespace: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClusterDecisionResourceTemplateSpecIgnoreDifferencesItem {
                pub group: String,
                pub jq_path_expressions: Vec<String>,
                pub json_pointers: Vec<String>,
                pub kind: String,
                pub managed_fields_managers: Vec<String>,
                pub name: String,
                pub namespace: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClustersTemplateSpecIgnoreDifferencesItem {
                pub group: String,
                pub jq_path_expressions: Vec<String>,
                pub json_pointers: Vec<String>,
                pub kind: String,
                pub managed_fields_managers: Vec<String>,
                pub name: String,
                pub namespace: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemGitTemplateSpecIgnoreDifferencesItem {
                pub group: String,
                pub jq_path_expressions: Vec<String>,
                pub json_pointers: Vec<String>,
                pub kind: String,
                pub managed_fields_managers: Vec<String>,
                pub name: String,
                pub namespace: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemListTemplateSpecIgnoreDifferencesItem {
                pub group: String,
                pub jq_path_expressions: Vec<String>,
                pub json_pointers: Vec<String>,
                pub kind: String,
                pub managed_fields_managers: Vec<String>,
                pub name: String,
                pub namespace: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemPullRequestTemplateSpecIgnoreDifferencesItem {
                pub group: String,
                pub jq_path_expressions: Vec<String>,
                pub json_pointers: Vec<String>,
                pub kind: String,
                pub managed_fields_managers: Vec<String>,
                pub name: String,
                pub namespace: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemScmProviderTemplateSpecIgnoreDifferencesItem {
                pub group: String,
                pub jq_path_expressions: Vec<String>,
                pub json_pointers: Vec<String>,
                pub kind: String,
                pub managed_fields_managers: Vec<String>,
                pub name: String,
                pub namespace: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeTemplateSpecIgnoreDifferencesItem {
                pub group: String,
                pub jq_path_expressions: Vec<String>,
                pub json_pointers: Vec<String>,
                pub kind: String,
                pub managed_fields_managers: Vec<String>,
                pub name: String,
                pub namespace: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemPullRequestTemplateSpecIgnoreDifferencesItem {
                pub group: String,
                pub jq_path_expressions: Vec<String>,
                pub json_pointers: Vec<String>,
                pub kind: String,
                pub managed_fields_managers: Vec<String>,
                pub name: String,
                pub namespace: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemScmProviderTemplateSpecIgnoreDifferencesItem {
                pub group: String,
                pub jq_path_expressions: Vec<String>,
                pub json_pointers: Vec<String>,
                pub kind: String,
                pub managed_fields_managers: Vec<String>,
                pub name: String,
                pub namespace: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecTemplateSpecIgnoreDifferencesItem {
                pub group: String,
                pub jq_path_expressions: Vec<String>,
                pub json_pointers: Vec<String>,
                pub kind: String,
                pub managed_fields_managers: Vec<String>,
                pub name: String,
                pub namespace: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClusterDecisionResourceTemplateSpecInfoItem {
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClustersTemplateSpecInfoItem {
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemGitTemplateSpecInfoItem {
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemListTemplateSpecInfoItem {
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClusterDecisionResourceTemplateSpecInfoItem {
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClustersTemplateSpecInfoItem {
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemGitTemplateSpecInfoItem {
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemListTemplateSpecInfoItem {
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemPullRequestTemplateSpecInfoItem {
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemScmProviderTemplateSpecInfoItem {
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixTemplateSpecInfoItem {
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClusterDecisionResourceTemplateSpecInfoItem {
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClustersTemplateSpecInfoItem {
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemGitTemplateSpecInfoItem {
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemListTemplateSpecInfoItem {
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemPullRequestTemplateSpecInfoItem {
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemScmProviderTemplateSpecInfoItem {
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeTemplateSpecInfoItem {
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemPullRequestTemplateSpecInfoItem {
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemScmProviderTemplateSpecInfoItem {
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecTemplateSpecInfoItem {
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClusterDecisionResourceTemplateSpecSourceDirectoryJsonnet {
            pub ext_vars: Vec<SpecGeneratorsItemClusterDecisionResourceTemplateSpecSourceDirectoryJsonnetExtVarsItem>,
            pub libs: Vec<String>,
            pub tlas: Vec<SpecGeneratorsItemClusterDecisionResourceTemplateSpecSourceDirectoryJsonnetTlasItem>,
        }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClustersTemplateSpecSourceDirectoryJsonnet {
                pub ext_vars:
                    Vec<SpecGeneratorsItemClustersTemplateSpecSourceDirectoryJsonnetExtVarsItem>,
                pub libs: Vec<String>,
                pub tlas: Vec<SpecGeneratorsItemClustersTemplateSpecSourceDirectoryJsonnetTlasItem>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemGitTemplateSpecSourceDirectoryJsonnet {
                pub ext_vars:
                    Vec<SpecGeneratorsItemGitTemplateSpecSourceDirectoryJsonnetExtVarsItem>,
                pub libs: Vec<String>,
                pub tlas: Vec<SpecGeneratorsItemGitTemplateSpecSourceDirectoryJsonnetTlasItem>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemListTemplateSpecSourceDirectoryJsonnet {
                pub ext_vars:
                    Vec<SpecGeneratorsItemListTemplateSpecSourceDirectoryJsonnetExtVarsItem>,
                pub libs: Vec<String>,
                pub tlas: Vec<SpecGeneratorsItemListTemplateSpecSourceDirectoryJsonnetTlasItem>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClusterDecisionResourceTemplateSpecSourceDirectoryJsonnet {
            pub ext_vars: Vec<MatrixGeneratorsItemClusterDecisionResourceTemplateSpecSourceDirectoryJsonnetExtVarsItem>,
            pub libs: Vec<String>,
            pub tlas: Vec<MatrixGeneratorsItemClusterDecisionResourceTemplateSpecSourceDirectoryJsonnetTlasItem>,
        }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClustersTemplateSpecSourceDirectoryJsonnet {
                pub ext_vars:
                    Vec<MatrixGeneratorsItemClustersTemplateSpecSourceDirectoryJsonnetExtVarsItem>,
                pub libs: Vec<String>,
                pub tlas:
                    Vec<MatrixGeneratorsItemClustersTemplateSpecSourceDirectoryJsonnetTlasItem>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemGitTemplateSpecSourceDirectoryJsonnet {
                pub ext_vars:
                    Vec<MatrixGeneratorsItemGitTemplateSpecSourceDirectoryJsonnetExtVarsItem>,
                pub libs: Vec<String>,
                pub tlas: Vec<MatrixGeneratorsItemGitTemplateSpecSourceDirectoryJsonnetTlasItem>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemListTemplateSpecSourceDirectoryJsonnet {
                pub ext_vars:
                    Vec<MatrixGeneratorsItemListTemplateSpecSourceDirectoryJsonnetExtVarsItem>,
                pub libs: Vec<String>,
                pub tlas: Vec<MatrixGeneratorsItemListTemplateSpecSourceDirectoryJsonnetTlasItem>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemPullRequestTemplateSpecSourceDirectoryJsonnet {
                pub ext_vars: Vec<
                    MatrixGeneratorsItemPullRequestTemplateSpecSourceDirectoryJsonnetExtVarsItem,
                >,
                pub libs: Vec<String>,
                pub tlas:
                    Vec<MatrixGeneratorsItemPullRequestTemplateSpecSourceDirectoryJsonnetTlasItem>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemScmProviderTemplateSpecSourceDirectoryJsonnet {
                pub ext_vars: Vec<
                    MatrixGeneratorsItemScmProviderTemplateSpecSourceDirectoryJsonnetExtVarsItem,
                >,
                pub libs: Vec<String>,
                pub tlas:
                    Vec<MatrixGeneratorsItemScmProviderTemplateSpecSourceDirectoryJsonnetTlasItem>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixTemplateSpecSourceDirectoryJsonnet {
                pub ext_vars: Vec<MatrixTemplateSpecSourceDirectoryJsonnetExtVarsItem>,
                pub libs: Vec<String>,
                pub tlas: Vec<MatrixTemplateSpecSourceDirectoryJsonnetTlasItem>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClusterDecisionResourceTemplateSpecSourceDirectoryJsonnet {
            pub ext_vars: Vec<MergeGeneratorsItemClusterDecisionResourceTemplateSpecSourceDirectoryJsonnetExtVarsItem>,
            pub libs: Vec<String>,
            pub tlas: Vec<MergeGeneratorsItemClusterDecisionResourceTemplateSpecSourceDirectoryJsonnetTlasItem>,
        }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClustersTemplateSpecSourceDirectoryJsonnet {
                pub ext_vars:
                    Vec<MergeGeneratorsItemClustersTemplateSpecSourceDirectoryJsonnetExtVarsItem>,
                pub libs: Vec<String>,
                pub tlas:
                    Vec<MergeGeneratorsItemClustersTemplateSpecSourceDirectoryJsonnetTlasItem>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemGitTemplateSpecSourceDirectoryJsonnet {
                pub ext_vars:
                    Vec<MergeGeneratorsItemGitTemplateSpecSourceDirectoryJsonnetExtVarsItem>,
                pub libs: Vec<String>,
                pub tlas: Vec<MergeGeneratorsItemGitTemplateSpecSourceDirectoryJsonnetTlasItem>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemListTemplateSpecSourceDirectoryJsonnet {
                pub ext_vars:
                    Vec<MergeGeneratorsItemListTemplateSpecSourceDirectoryJsonnetExtVarsItem>,
                pub libs: Vec<String>,
                pub tlas: Vec<MergeGeneratorsItemListTemplateSpecSourceDirectoryJsonnetTlasItem>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemPullRequestTemplateSpecSourceDirectoryJsonnet {
                pub ext_vars: Vec<
                    MergeGeneratorsItemPullRequestTemplateSpecSourceDirectoryJsonnetExtVarsItem,
                >,
                pub libs: Vec<String>,
                pub tlas:
                    Vec<MergeGeneratorsItemPullRequestTemplateSpecSourceDirectoryJsonnetTlasItem>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemScmProviderTemplateSpecSourceDirectoryJsonnet {
                pub ext_vars: Vec<
                    MergeGeneratorsItemScmProviderTemplateSpecSourceDirectoryJsonnetExtVarsItem,
                >,
                pub libs: Vec<String>,
                pub tlas:
                    Vec<MergeGeneratorsItemScmProviderTemplateSpecSourceDirectoryJsonnetTlasItem>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeTemplateSpecSourceDirectoryJsonnet {
                pub ext_vars: Vec<MergeTemplateSpecSourceDirectoryJsonnetExtVarsItem>,
                pub libs: Vec<String>,
                pub tlas: Vec<MergeTemplateSpecSourceDirectoryJsonnetTlasItem>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemPullRequestTemplateSpecSourceDirectoryJsonnet {
                pub ext_vars:
                    Vec<SpecGeneratorsItemPullRequestTemplateSpecSourceDirectoryJsonnetExtVarsItem>,
                pub libs: Vec<String>,
                pub tlas:
                    Vec<SpecGeneratorsItemPullRequestTemplateSpecSourceDirectoryJsonnetTlasItem>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemScmProviderTemplateSpecSourceDirectoryJsonnet {
                pub ext_vars:
                    Vec<SpecGeneratorsItemScmProviderTemplateSpecSourceDirectoryJsonnetExtVarsItem>,
                pub libs: Vec<String>,
                pub tlas:
                    Vec<SpecGeneratorsItemScmProviderTemplateSpecSourceDirectoryJsonnetTlasItem>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecTemplateSpecSourceDirectoryJsonnet {
                pub ext_vars: Vec<SpecTemplateSpecSourceDirectoryJsonnetExtVarsItem>,
                pub libs: Vec<String>,
                pub tlas: Vec<SpecTemplateSpecSourceDirectoryJsonnetTlasItem>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClusterDecisionResourceTemplateSpecSourceKustomize {
            pub common_annotations: SpecGeneratorsItemClusterDecisionResourceTemplateSpecSourceKustomizeCommonAnnotations,
            pub common_labels: SpecGeneratorsItemClusterDecisionResourceTemplateSpecSourceKustomizeCommonLabels,
            pub force_common_annotations: bool,
            pub force_common_labels: bool,
            pub images: Vec<String>,
            pub name_prefix: String,
            pub name_suffix: String,
            pub version: String,
        }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClustersTemplateSpecSourceKustomize {
                pub common_annotations:
                    SpecGeneratorsItemClustersTemplateSpecSourceKustomizeCommonAnnotations,
                pub common_labels:
                    SpecGeneratorsItemClustersTemplateSpecSourceKustomizeCommonLabels,
                pub force_common_annotations: bool,
                pub force_common_labels: bool,
                pub images: Vec<String>,
                pub name_prefix: String,
                pub name_suffix: String,
                pub version: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemGitTemplateSpecSourceKustomize {
                pub common_annotations:
                    SpecGeneratorsItemGitTemplateSpecSourceKustomizeCommonAnnotations,
                pub common_labels: SpecGeneratorsItemGitTemplateSpecSourceKustomizeCommonLabels,
                pub force_common_annotations: bool,
                pub force_common_labels: bool,
                pub images: Vec<String>,
                pub name_prefix: String,
                pub name_suffix: String,
                pub version: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemListTemplateSpecSourceKustomize {
                pub common_annotations:
                    SpecGeneratorsItemListTemplateSpecSourceKustomizeCommonAnnotations,
                pub common_labels: SpecGeneratorsItemListTemplateSpecSourceKustomizeCommonLabels,
                pub force_common_annotations: bool,
                pub force_common_labels: bool,
                pub images: Vec<String>,
                pub name_prefix: String,
                pub name_suffix: String,
                pub version: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClusterDecisionResourceTemplateSpecSourceKustomize {
            pub common_annotations: MatrixGeneratorsItemClusterDecisionResourceTemplateSpecSourceKustomizeCommonAnnotations,
            pub common_labels: MatrixGeneratorsItemClusterDecisionResourceTemplateSpecSourceKustomizeCommonLabels,
            pub force_common_annotations: bool,
            pub force_common_labels: bool,
            pub images: Vec<String>,
            pub name_prefix: String,
            pub name_suffix: String,
            pub version: String,
        }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClustersTemplateSpecSourceKustomize {
                pub common_annotations:
                    MatrixGeneratorsItemClustersTemplateSpecSourceKustomizeCommonAnnotations,
                pub common_labels:
                    MatrixGeneratorsItemClustersTemplateSpecSourceKustomizeCommonLabels,
                pub force_common_annotations: bool,
                pub force_common_labels: bool,
                pub images: Vec<String>,
                pub name_prefix: String,
                pub name_suffix: String,
                pub version: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemGitTemplateSpecSourceKustomize {
                pub common_annotations:
                    MatrixGeneratorsItemGitTemplateSpecSourceKustomizeCommonAnnotations,
                pub common_labels: MatrixGeneratorsItemGitTemplateSpecSourceKustomizeCommonLabels,
                pub force_common_annotations: bool,
                pub force_common_labels: bool,
                pub images: Vec<String>,
                pub name_prefix: String,
                pub name_suffix: String,
                pub version: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemListTemplateSpecSourceKustomize {
                pub common_annotations:
                    MatrixGeneratorsItemListTemplateSpecSourceKustomizeCommonAnnotations,
                pub common_labels: MatrixGeneratorsItemListTemplateSpecSourceKustomizeCommonLabels,
                pub force_common_annotations: bool,
                pub force_common_labels: bool,
                pub images: Vec<String>,
                pub name_prefix: String,
                pub name_suffix: String,
                pub version: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemPullRequestTemplateSpecSourceKustomize {
                pub common_annotations:
                    MatrixGeneratorsItemPullRequestTemplateSpecSourceKustomizeCommonAnnotations,
                pub common_labels:
                    MatrixGeneratorsItemPullRequestTemplateSpecSourceKustomizeCommonLabels,
                pub force_common_annotations: bool,
                pub force_common_labels: bool,
                pub images: Vec<String>,
                pub name_prefix: String,
                pub name_suffix: String,
                pub version: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemScmProviderTemplateSpecSourceKustomize {
                pub common_annotations:
                    MatrixGeneratorsItemScmProviderTemplateSpecSourceKustomizeCommonAnnotations,
                pub common_labels:
                    MatrixGeneratorsItemScmProviderTemplateSpecSourceKustomizeCommonLabels,
                pub force_common_annotations: bool,
                pub force_common_labels: bool,
                pub images: Vec<String>,
                pub name_prefix: String,
                pub name_suffix: String,
                pub version: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixTemplateSpecSourceKustomize {
                pub common_annotations: MatrixTemplateSpecSourceKustomizeCommonAnnotations,
                pub common_labels: MatrixTemplateSpecSourceKustomizeCommonLabels,
                pub force_common_annotations: bool,
                pub force_common_labels: bool,
                pub images: Vec<String>,
                pub name_prefix: String,
                pub name_suffix: String,
                pub version: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClusterDecisionResourceTemplateSpecSourceKustomize {
            pub common_annotations: MergeGeneratorsItemClusterDecisionResourceTemplateSpecSourceKustomizeCommonAnnotations,
            pub common_labels: MergeGeneratorsItemClusterDecisionResourceTemplateSpecSourceKustomizeCommonLabels,
            pub force_common_annotations: bool,
            pub force_common_labels: bool,
            pub images: Vec<String>,
            pub name_prefix: String,
            pub name_suffix: String,
            pub version: String,
        }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClustersTemplateSpecSourceKustomize {
                pub common_annotations:
                    MergeGeneratorsItemClustersTemplateSpecSourceKustomizeCommonAnnotations,
                pub common_labels:
                    MergeGeneratorsItemClustersTemplateSpecSourceKustomizeCommonLabels,
                pub force_common_annotations: bool,
                pub force_common_labels: bool,
                pub images: Vec<String>,
                pub name_prefix: String,
                pub name_suffix: String,
                pub version: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemGitTemplateSpecSourceKustomize {
                pub common_annotations:
                    MergeGeneratorsItemGitTemplateSpecSourceKustomizeCommonAnnotations,
                pub common_labels: MergeGeneratorsItemGitTemplateSpecSourceKustomizeCommonLabels,
                pub force_common_annotations: bool,
                pub force_common_labels: bool,
                pub images: Vec<String>,
                pub name_prefix: String,
                pub name_suffix: String,
                pub version: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemListTemplateSpecSourceKustomize {
                pub common_annotations:
                    MergeGeneratorsItemListTemplateSpecSourceKustomizeCommonAnnotations,
                pub common_labels: MergeGeneratorsItemListTemplateSpecSourceKustomizeCommonLabels,
                pub force_common_annotations: bool,
                pub force_common_labels: bool,
                pub images: Vec<String>,
                pub name_prefix: String,
                pub name_suffix: String,
                pub version: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemPullRequestTemplateSpecSourceKustomize {
                pub common_annotations:
                    MergeGeneratorsItemPullRequestTemplateSpecSourceKustomizeCommonAnnotations,
                pub common_labels:
                    MergeGeneratorsItemPullRequestTemplateSpecSourceKustomizeCommonLabels,
                pub force_common_annotations: bool,
                pub force_common_labels: bool,
                pub images: Vec<String>,
                pub name_prefix: String,
                pub name_suffix: String,
                pub version: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemScmProviderTemplateSpecSourceKustomize {
                pub common_annotations:
                    MergeGeneratorsItemScmProviderTemplateSpecSourceKustomizeCommonAnnotations,
                pub common_labels:
                    MergeGeneratorsItemScmProviderTemplateSpecSourceKustomizeCommonLabels,
                pub force_common_annotations: bool,
                pub force_common_labels: bool,
                pub images: Vec<String>,
                pub name_prefix: String,
                pub name_suffix: String,
                pub version: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeTemplateSpecSourceKustomize {
                pub common_annotations: MergeTemplateSpecSourceKustomizeCommonAnnotations,
                pub common_labels: MergeTemplateSpecSourceKustomizeCommonLabels,
                pub force_common_annotations: bool,
                pub force_common_labels: bool,
                pub images: Vec<String>,
                pub name_prefix: String,
                pub name_suffix: String,
                pub version: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemPullRequestTemplateSpecSourceKustomize {
                pub common_annotations:
                    SpecGeneratorsItemPullRequestTemplateSpecSourceKustomizeCommonAnnotations,
                pub common_labels:
                    SpecGeneratorsItemPullRequestTemplateSpecSourceKustomizeCommonLabels,
                pub force_common_annotations: bool,
                pub force_common_labels: bool,
                pub images: Vec<String>,
                pub name_prefix: String,
                pub name_suffix: String,
                pub version: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemScmProviderTemplateSpecSourceKustomize {
                pub common_annotations:
                    SpecGeneratorsItemScmProviderTemplateSpecSourceKustomizeCommonAnnotations,
                pub common_labels:
                    SpecGeneratorsItemScmProviderTemplateSpecSourceKustomizeCommonLabels,
                pub force_common_annotations: bool,
                pub force_common_labels: bool,
                pub images: Vec<String>,
                pub name_prefix: String,
                pub name_suffix: String,
                pub version: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecTemplateSpecSourceKustomize {
                pub common_annotations: SpecTemplateSpecSourceKustomizeCommonAnnotations,
                pub common_labels: SpecTemplateSpecSourceKustomizeCommonLabels,
                pub force_common_annotations: bool,
                pub force_common_labels: bool,
                pub images: Vec<String>,
                pub name_prefix: String,
                pub name_suffix: String,
                pub version: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClusterDecisionResourceLabelSelector {
                pub match_expressions:
                    Vec<SpecGeneratorsItemClusterDecisionResourceLabelSelectorMatchExpressionsItem>,
                pub match_labels: SpecGeneratorsItemClusterDecisionResourceLabelSelectorMatchLabels,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClusterDecisionResourceLabelSelector {
                pub match_expressions: Vec<
                    MatrixGeneratorsItemClusterDecisionResourceLabelSelectorMatchExpressionsItem,
                >,
                pub match_labels:
                    MatrixGeneratorsItemClusterDecisionResourceLabelSelectorMatchLabels,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClusterDecisionResourceLabelSelector {
                pub match_expressions: Vec<
                    MergeGeneratorsItemClusterDecisionResourceLabelSelectorMatchExpressionsItem,
                >,
                pub match_labels:
                    MergeGeneratorsItemClusterDecisionResourceLabelSelectorMatchLabels,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClusterDecisionResourceTemplateMetadataLabels {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClustersTemplateMetadataLabels {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemGitTemplateMetadataLabels {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemListTemplateMetadataLabels {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClusterDecisionResourceTemplateMetadataLabels {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClustersTemplateMetadataLabels {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemGitTemplateMetadataLabels {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemListTemplateMetadataLabels {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemPullRequestTemplateMetadataLabels {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemScmProviderTemplateMetadataLabels {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixTemplateMetadataLabels {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClusterDecisionResourceTemplateMetadataLabels {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClustersTemplateMetadataLabels {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemGitTemplateMetadataLabels {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemListTemplateMetadataLabels {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemPullRequestTemplateMetadataLabels {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemScmProviderTemplateMetadataLabels {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeTemplateMetadataLabels {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemPullRequestTemplateMetadataLabels {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemScmProviderTemplateMetadataLabels {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecTemplateMetadataLabels {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemList {
                pub elements: Vec<serde_json::Map<String, serde_json::Value>>,
                pub template: SpecGeneratorsItemListTemplate,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemList {
                pub elements: Vec<serde_json::Map<String, serde_json::Value>>,
                pub template: MatrixGeneratorsItemListTemplate,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemList {
                pub elements: Vec<serde_json::Map<String, serde_json::Value>>,
                pub template: MergeGeneratorsItemListTemplate,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClusterDecisionResourceLabelSelectorMatchExpressionsItem {
                pub key: String,
                pub operator: String,
                pub values: Vec<String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClustersSelectorMatchExpressionsItem {
                pub key: String,
                pub operator: String,
                pub values: Vec<String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClusterDecisionResourceLabelSelectorMatchExpressionsItem {
                pub key: String,
                pub operator: String,
                pub values: Vec<String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClustersSelectorMatchExpressionsItem {
                pub key: String,
                pub operator: String,
                pub values: Vec<String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClusterDecisionResourceLabelSelectorMatchExpressionsItem {
                pub key: String,
                pub operator: String,
                pub values: Vec<String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClustersSelectorMatchExpressionsItem {
                pub key: String,
                pub operator: String,
                pub values: Vec<String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClusterDecisionResourceLabelSelectorMatchLabels {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClustersSelectorMatchLabels {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClusterDecisionResourceLabelSelectorMatchLabels {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClustersSelectorMatchLabels {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClusterDecisionResourceLabelSelectorMatchLabels {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClustersSelectorMatchLabels {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct Matrix {
                pub generators: Vec<MatrixGeneratorsItem>,
                pub template: MatrixTemplate,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct Merge {
                pub generators: Vec<MergeGeneratorsItem>,
                pub merge_keys: Vec<String>,
                pub template: MergeTemplate,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClusterDecisionResourceTemplateMetadata {
                pub annotations:
                    SpecGeneratorsItemClusterDecisionResourceTemplateMetadataAnnotations,
                pub finalizers: Vec<String>,
                pub labels: SpecGeneratorsItemClusterDecisionResourceTemplateMetadataLabels,
                pub name: String,
                pub namespace: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClustersTemplateMetadata {
                pub annotations: SpecGeneratorsItemClustersTemplateMetadataAnnotations,
                pub finalizers: Vec<String>,
                pub labels: SpecGeneratorsItemClustersTemplateMetadataLabels,
                pub name: String,
                pub namespace: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemGitTemplateMetadata {
                pub annotations: SpecGeneratorsItemGitTemplateMetadataAnnotations,
                pub finalizers: Vec<String>,
                pub labels: SpecGeneratorsItemGitTemplateMetadataLabels,
                pub name: String,
                pub namespace: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemListTemplateMetadata {
                pub annotations: SpecGeneratorsItemListTemplateMetadataAnnotations,
                pub finalizers: Vec<String>,
                pub labels: SpecGeneratorsItemListTemplateMetadataLabels,
                pub name: String,
                pub namespace: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClusterDecisionResourceTemplateMetadata {
                pub annotations:
                    MatrixGeneratorsItemClusterDecisionResourceTemplateMetadataAnnotations,
                pub finalizers: Vec<String>,
                pub labels: MatrixGeneratorsItemClusterDecisionResourceTemplateMetadataLabels,
                pub name: String,
                pub namespace: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClustersTemplateMetadata {
                pub annotations: MatrixGeneratorsItemClustersTemplateMetadataAnnotations,
                pub finalizers: Vec<String>,
                pub labels: MatrixGeneratorsItemClustersTemplateMetadataLabels,
                pub name: String,
                pub namespace: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemGitTemplateMetadata {
                pub annotations: MatrixGeneratorsItemGitTemplateMetadataAnnotations,
                pub finalizers: Vec<String>,
                pub labels: MatrixGeneratorsItemGitTemplateMetadataLabels,
                pub name: String,
                pub namespace: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemListTemplateMetadata {
                pub annotations: MatrixGeneratorsItemListTemplateMetadataAnnotations,
                pub finalizers: Vec<String>,
                pub labels: MatrixGeneratorsItemListTemplateMetadataLabels,
                pub name: String,
                pub namespace: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemPullRequestTemplateMetadata {
                pub annotations: MatrixGeneratorsItemPullRequestTemplateMetadataAnnotations,
                pub finalizers: Vec<String>,
                pub labels: MatrixGeneratorsItemPullRequestTemplateMetadataLabels,
                pub name: String,
                pub namespace: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemScmProviderTemplateMetadata {
                pub annotations: MatrixGeneratorsItemScmProviderTemplateMetadataAnnotations,
                pub finalizers: Vec<String>,
                pub labels: MatrixGeneratorsItemScmProviderTemplateMetadataLabels,
                pub name: String,
                pub namespace: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixTemplateMetadata {
                pub annotations: MatrixTemplateMetadataAnnotations,
                pub finalizers: Vec<String>,
                pub labels: MatrixTemplateMetadataLabels,
                pub name: String,
                pub namespace: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClusterDecisionResourceTemplateMetadata {
                pub annotations:
                    MergeGeneratorsItemClusterDecisionResourceTemplateMetadataAnnotations,
                pub finalizers: Vec<String>,
                pub labels: MergeGeneratorsItemClusterDecisionResourceTemplateMetadataLabels,
                pub name: String,
                pub namespace: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClustersTemplateMetadata {
                pub annotations: MergeGeneratorsItemClustersTemplateMetadataAnnotations,
                pub finalizers: Vec<String>,
                pub labels: MergeGeneratorsItemClustersTemplateMetadataLabels,
                pub name: String,
                pub namespace: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemGitTemplateMetadata {
                pub annotations: MergeGeneratorsItemGitTemplateMetadataAnnotations,
                pub finalizers: Vec<String>,
                pub labels: MergeGeneratorsItemGitTemplateMetadataLabels,
                pub name: String,
                pub namespace: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemListTemplateMetadata {
                pub annotations: MergeGeneratorsItemListTemplateMetadataAnnotations,
                pub finalizers: Vec<String>,
                pub labels: MergeGeneratorsItemListTemplateMetadataLabels,
                pub name: String,
                pub namespace: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemPullRequestTemplateMetadata {
                pub annotations: MergeGeneratorsItemPullRequestTemplateMetadataAnnotations,
                pub finalizers: Vec<String>,
                pub labels: MergeGeneratorsItemPullRequestTemplateMetadataLabels,
                pub name: String,
                pub namespace: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemScmProviderTemplateMetadata {
                pub annotations: MergeGeneratorsItemScmProviderTemplateMetadataAnnotations,
                pub finalizers: Vec<String>,
                pub labels: MergeGeneratorsItemScmProviderTemplateMetadataLabels,
                pub name: String,
                pub namespace: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeTemplateMetadata {
                pub annotations: MergeTemplateMetadataAnnotations,
                pub finalizers: Vec<String>,
                pub labels: MergeTemplateMetadataLabels,
                pub name: String,
                pub namespace: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemPullRequestTemplateMetadata {
                pub annotations: SpecGeneratorsItemPullRequestTemplateMetadataAnnotations,
                pub finalizers: Vec<String>,
                pub labels: SpecGeneratorsItemPullRequestTemplateMetadataLabels,
                pub name: String,
                pub namespace: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemScmProviderTemplateMetadata {
                pub annotations: SpecGeneratorsItemScmProviderTemplateMetadataAnnotations,
                pub finalizers: Vec<String>,
                pub labels: SpecGeneratorsItemScmProviderTemplateMetadataLabels,
                pub name: String,
                pub namespace: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecTemplateMetadata {
                pub annotations: SpecTemplateMetadataAnnotations,
                pub finalizers: Vec<String>,
                pub labels: SpecTemplateMetadataLabels,
                pub name: String,
                pub namespace: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClusterDecisionResourceTemplateSpecSourceHelmParametersItem {
                pub force_string: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClustersTemplateSpecSourceHelmParametersItem {
                pub force_string: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemGitTemplateSpecSourceHelmParametersItem {
                pub force_string: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemListTemplateSpecSourceHelmParametersItem {
                pub force_string: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClusterDecisionResourceTemplateSpecSourceHelmParametersItem {
                pub force_string: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClustersTemplateSpecSourceHelmParametersItem {
                pub force_string: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemGitTemplateSpecSourceHelmParametersItem {
                pub force_string: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemListTemplateSpecSourceHelmParametersItem {
                pub force_string: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemPullRequestTemplateSpecSourceHelmParametersItem {
                pub force_string: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemScmProviderTemplateSpecSourceHelmParametersItem {
                pub force_string: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixTemplateSpecSourceHelmParametersItem {
                pub force_string: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClusterDecisionResourceTemplateSpecSourceHelmParametersItem {
                pub force_string: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClustersTemplateSpecSourceHelmParametersItem {
                pub force_string: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemGitTemplateSpecSourceHelmParametersItem {
                pub force_string: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemListTemplateSpecSourceHelmParametersItem {
                pub force_string: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemPullRequestTemplateSpecSourceHelmParametersItem {
                pub force_string: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemScmProviderTemplateSpecSourceHelmParametersItem {
                pub force_string: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeTemplateSpecSourceHelmParametersItem {
                pub force_string: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemPullRequestTemplateSpecSourceHelmParametersItem {
                pub force_string: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemScmProviderTemplateSpecSourceHelmParametersItem {
                pub force_string: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecTemplateSpecSourceHelmParametersItem {
                pub force_string: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemPullRequestBitbucketServerBasicAuthPasswordRef {
                pub key: String,
                pub secret_name: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemScmProviderBitbucketServerBasicAuthPasswordRef {
                pub key: String,
                pub secret_name: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemPullRequestBitbucketServerBasicAuthPasswordRef {
                pub key: String,
                pub secret_name: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemScmProviderBitbucketServerBasicAuthPasswordRef {
                pub key: String,
                pub secret_name: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemPullRequestBitbucketServerBasicAuthPasswordRef {
                pub key: String,
                pub secret_name: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemScmProviderBitbucketServerBasicAuthPasswordRef {
                pub key: String,
                pub secret_name: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClusterDecisionResourceTemplateSpecSourcePlugin {
                pub env:
                    Vec<SpecGeneratorsItemClusterDecisionResourceTemplateSpecSourcePluginEnvItem>,
                pub name: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClustersTemplateSpecSourcePlugin {
                pub env: Vec<SpecGeneratorsItemClustersTemplateSpecSourcePluginEnvItem>,
                pub name: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemGitTemplateSpecSourcePlugin {
                pub env: Vec<SpecGeneratorsItemGitTemplateSpecSourcePluginEnvItem>,
                pub name: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemListTemplateSpecSourcePlugin {
                pub env: Vec<SpecGeneratorsItemListTemplateSpecSourcePluginEnvItem>,
                pub name: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClusterDecisionResourceTemplateSpecSourcePlugin {
                pub env:
                    Vec<MatrixGeneratorsItemClusterDecisionResourceTemplateSpecSourcePluginEnvItem>,
                pub name: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClustersTemplateSpecSourcePlugin {
                pub env: Vec<MatrixGeneratorsItemClustersTemplateSpecSourcePluginEnvItem>,
                pub name: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemGitTemplateSpecSourcePlugin {
                pub env: Vec<MatrixGeneratorsItemGitTemplateSpecSourcePluginEnvItem>,
                pub name: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemListTemplateSpecSourcePlugin {
                pub env: Vec<MatrixGeneratorsItemListTemplateSpecSourcePluginEnvItem>,
                pub name: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemPullRequestTemplateSpecSourcePlugin {
                pub env: Vec<MatrixGeneratorsItemPullRequestTemplateSpecSourcePluginEnvItem>,
                pub name: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemScmProviderTemplateSpecSourcePlugin {
                pub env: Vec<MatrixGeneratorsItemScmProviderTemplateSpecSourcePluginEnvItem>,
                pub name: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixTemplateSpecSourcePlugin {
                pub env: Vec<MatrixTemplateSpecSourcePluginEnvItem>,
                pub name: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClusterDecisionResourceTemplateSpecSourcePlugin {
                pub env:
                    Vec<MergeGeneratorsItemClusterDecisionResourceTemplateSpecSourcePluginEnvItem>,
                pub name: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClustersTemplateSpecSourcePlugin {
                pub env: Vec<MergeGeneratorsItemClustersTemplateSpecSourcePluginEnvItem>,
                pub name: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemGitTemplateSpecSourcePlugin {
                pub env: Vec<MergeGeneratorsItemGitTemplateSpecSourcePluginEnvItem>,
                pub name: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemListTemplateSpecSourcePlugin {
                pub env: Vec<MergeGeneratorsItemListTemplateSpecSourcePluginEnvItem>,
                pub name: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemPullRequestTemplateSpecSourcePlugin {
                pub env: Vec<MergeGeneratorsItemPullRequestTemplateSpecSourcePluginEnvItem>,
                pub name: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemScmProviderTemplateSpecSourcePlugin {
                pub env: Vec<MergeGeneratorsItemScmProviderTemplateSpecSourcePluginEnvItem>,
                pub name: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeTemplateSpecSourcePlugin {
                pub env: Vec<MergeTemplateSpecSourcePluginEnvItem>,
                pub name: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemPullRequestTemplateSpecSourcePlugin {
                pub env: Vec<SpecGeneratorsItemPullRequestTemplateSpecSourcePluginEnvItem>,
                pub name: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemScmProviderTemplateSpecSourcePlugin {
                pub env: Vec<SpecGeneratorsItemScmProviderTemplateSpecSourcePluginEnvItem>,
                pub name: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecTemplateSpecSourcePlugin {
                pub env: Vec<SpecTemplateSpecSourcePluginEnvItem>,
                pub name: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemPullRequest {
                pub bitbucket_server: SpecGeneratorsItemPullRequestBitbucketServer,
                pub filters: Vec<SpecGeneratorsItemPullRequestFiltersItem>,
                pub gitea: SpecGeneratorsItemPullRequestGitea,
                pub github: SpecGeneratorsItemPullRequestGithub,
                pub gitlab: SpecGeneratorsItemPullRequestGitlab,
                pub requeue_after_seconds: i64,
                pub template: SpecGeneratorsItemPullRequestTemplate,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemPullRequest {
                pub bitbucket_server: MatrixGeneratorsItemPullRequestBitbucketServer,
                pub filters: Vec<MatrixGeneratorsItemPullRequestFiltersItem>,
                pub gitea: MatrixGeneratorsItemPullRequestGitea,
                pub github: MatrixGeneratorsItemPullRequestGithub,
                pub gitlab: MatrixGeneratorsItemPullRequestGitlab,
                pub requeue_after_seconds: i64,
                pub template: MatrixGeneratorsItemPullRequestTemplate,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemPullRequest {
                pub bitbucket_server: MergeGeneratorsItemPullRequestBitbucketServer,
                pub filters: Vec<MergeGeneratorsItemPullRequestFiltersItem>,
                pub gitea: MergeGeneratorsItemPullRequestGitea,
                pub github: MergeGeneratorsItemPullRequestGithub,
                pub gitlab: MergeGeneratorsItemPullRequestGitlab,
                pub requeue_after_seconds: i64,
                pub template: MergeGeneratorsItemPullRequestTemplate,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClusterDecisionResourceTemplateSpecSyncPolicyRetry {
                pub backoff:
                    SpecGeneratorsItemClusterDecisionResourceTemplateSpecSyncPolicyRetryBackoff,
                pub limit: i64,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClustersTemplateSpecSyncPolicyRetry {
                pub backoff: SpecGeneratorsItemClustersTemplateSpecSyncPolicyRetryBackoff,
                pub limit: i64,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemGitTemplateSpecSyncPolicyRetry {
                pub backoff: SpecGeneratorsItemGitTemplateSpecSyncPolicyRetryBackoff,
                pub limit: i64,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemListTemplateSpecSyncPolicyRetry {
                pub backoff: SpecGeneratorsItemListTemplateSpecSyncPolicyRetryBackoff,
                pub limit: i64,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClusterDecisionResourceTemplateSpecSyncPolicyRetry {
                pub backoff:
                    MatrixGeneratorsItemClusterDecisionResourceTemplateSpecSyncPolicyRetryBackoff,
                pub limit: i64,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClustersTemplateSpecSyncPolicyRetry {
                pub backoff: MatrixGeneratorsItemClustersTemplateSpecSyncPolicyRetryBackoff,
                pub limit: i64,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemGitTemplateSpecSyncPolicyRetry {
                pub backoff: MatrixGeneratorsItemGitTemplateSpecSyncPolicyRetryBackoff,
                pub limit: i64,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemListTemplateSpecSyncPolicyRetry {
                pub backoff: MatrixGeneratorsItemListTemplateSpecSyncPolicyRetryBackoff,
                pub limit: i64,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemPullRequestTemplateSpecSyncPolicyRetry {
                pub backoff: MatrixGeneratorsItemPullRequestTemplateSpecSyncPolicyRetryBackoff,
                pub limit: i64,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemScmProviderTemplateSpecSyncPolicyRetry {
                pub backoff: MatrixGeneratorsItemScmProviderTemplateSpecSyncPolicyRetryBackoff,
                pub limit: i64,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixTemplateSpecSyncPolicyRetry {
                pub backoff: MatrixTemplateSpecSyncPolicyRetryBackoff,
                pub limit: i64,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClusterDecisionResourceTemplateSpecSyncPolicyRetry {
                pub backoff:
                    MergeGeneratorsItemClusterDecisionResourceTemplateSpecSyncPolicyRetryBackoff,
                pub limit: i64,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClustersTemplateSpecSyncPolicyRetry {
                pub backoff: MergeGeneratorsItemClustersTemplateSpecSyncPolicyRetryBackoff,
                pub limit: i64,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemGitTemplateSpecSyncPolicyRetry {
                pub backoff: MergeGeneratorsItemGitTemplateSpecSyncPolicyRetryBackoff,
                pub limit: i64,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemListTemplateSpecSyncPolicyRetry {
                pub backoff: MergeGeneratorsItemListTemplateSpecSyncPolicyRetryBackoff,
                pub limit: i64,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemPullRequestTemplateSpecSyncPolicyRetry {
                pub backoff: MergeGeneratorsItemPullRequestTemplateSpecSyncPolicyRetryBackoff,
                pub limit: i64,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemScmProviderTemplateSpecSyncPolicyRetry {
                pub backoff: MergeGeneratorsItemScmProviderTemplateSpecSyncPolicyRetryBackoff,
                pub limit: i64,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeTemplateSpecSyncPolicyRetry {
                pub backoff: MergeTemplateSpecSyncPolicyRetryBackoff,
                pub limit: i64,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemPullRequestTemplateSpecSyncPolicyRetry {
                pub backoff: SpecGeneratorsItemPullRequestTemplateSpecSyncPolicyRetryBackoff,
                pub limit: i64,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemScmProviderTemplateSpecSyncPolicyRetry {
                pub backoff: SpecGeneratorsItemScmProviderTemplateSpecSyncPolicyRetryBackoff,
                pub limit: i64,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecTemplateSpecSyncPolicyRetry {
                pub backoff: SpecTemplateSpecSyncPolicyRetryBackoff,
                pub limit: i64,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemScmProvider {
                pub azure_dev_ops: SpecGeneratorsItemScmProviderAzureDevOps,
                pub bitbucket: SpecGeneratorsItemScmProviderBitbucket,
                pub bitbucket_server: SpecGeneratorsItemScmProviderBitbucketServer,
                pub clone_protocol: String,
                pub filters: Vec<SpecGeneratorsItemScmProviderFiltersItem>,
                pub gitea: SpecGeneratorsItemScmProviderGitea,
                pub github: SpecGeneratorsItemScmProviderGithub,
                pub gitlab: SpecGeneratorsItemScmProviderGitlab,
                pub requeue_after_seconds: i64,
                pub template: SpecGeneratorsItemScmProviderTemplate,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemScmProvider {
                pub azure_dev_ops: MatrixGeneratorsItemScmProviderAzureDevOps,
                pub bitbucket: MatrixGeneratorsItemScmProviderBitbucket,
                pub bitbucket_server: MatrixGeneratorsItemScmProviderBitbucketServer,
                pub clone_protocol: String,
                pub filters: Vec<MatrixGeneratorsItemScmProviderFiltersItem>,
                pub gitea: MatrixGeneratorsItemScmProviderGitea,
                pub github: MatrixGeneratorsItemScmProviderGithub,
                pub gitlab: MatrixGeneratorsItemScmProviderGitlab,
                pub requeue_after_seconds: i64,
                pub template: MatrixGeneratorsItemScmProviderTemplate,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemScmProvider {
                pub azure_dev_ops: MergeGeneratorsItemScmProviderAzureDevOps,
                pub bitbucket: MergeGeneratorsItemScmProviderBitbucket,
                pub bitbucket_server: MergeGeneratorsItemScmProviderBitbucketServer,
                pub clone_protocol: String,
                pub filters: Vec<MergeGeneratorsItemScmProviderFiltersItem>,
                pub gitea: MergeGeneratorsItemScmProviderGitea,
                pub github: MergeGeneratorsItemScmProviderGithub,
                pub gitlab: MergeGeneratorsItemScmProviderGitlab,
                pub requeue_after_seconds: i64,
                pub template: MergeGeneratorsItemScmProviderTemplate,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClustersSelector {
                pub match_expressions: Vec<SpecGeneratorsItemClustersSelectorMatchExpressionsItem>,
                pub match_labels: SpecGeneratorsItemClustersSelectorMatchLabels,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClustersSelector {
                pub match_expressions:
                    Vec<MatrixGeneratorsItemClustersSelectorMatchExpressionsItem>,
                pub match_labels: MatrixGeneratorsItemClustersSelectorMatchLabels,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClustersSelector {
                pub match_expressions: Vec<MergeGeneratorsItemClustersSelectorMatchExpressionsItem>,
                pub match_labels: MergeGeneratorsItemClustersSelectorMatchLabels,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClusterDecisionResourceTemplateSpecSource {
                pub chart: String,
                pub directory: SpecGeneratorsItemClusterDecisionResourceTemplateSpecSourceDirectory,
                pub helm: SpecGeneratorsItemClusterDecisionResourceTemplateSpecSourceHelm,
                pub kustomize: SpecGeneratorsItemClusterDecisionResourceTemplateSpecSourceKustomize,
                pub path: String,
                pub plugin: SpecGeneratorsItemClusterDecisionResourceTemplateSpecSourcePlugin,
                pub repo_u_r_l: String,
                pub target_revision: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClustersTemplateSpecSource {
                pub chart: String,
                pub directory: SpecGeneratorsItemClustersTemplateSpecSourceDirectory,
                pub helm: SpecGeneratorsItemClustersTemplateSpecSourceHelm,
                pub kustomize: SpecGeneratorsItemClustersTemplateSpecSourceKustomize,
                pub path: String,
                pub plugin: SpecGeneratorsItemClustersTemplateSpecSourcePlugin,
                pub repo_u_r_l: String,
                pub target_revision: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemGitTemplateSpecSource {
                pub chart: String,
                pub directory: SpecGeneratorsItemGitTemplateSpecSourceDirectory,
                pub helm: SpecGeneratorsItemGitTemplateSpecSourceHelm,
                pub kustomize: SpecGeneratorsItemGitTemplateSpecSourceKustomize,
                pub path: String,
                pub plugin: SpecGeneratorsItemGitTemplateSpecSourcePlugin,
                pub repo_u_r_l: String,
                pub target_revision: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemListTemplateSpecSource {
                pub chart: String,
                pub directory: SpecGeneratorsItemListTemplateSpecSourceDirectory,
                pub helm: SpecGeneratorsItemListTemplateSpecSourceHelm,
                pub kustomize: SpecGeneratorsItemListTemplateSpecSourceKustomize,
                pub path: String,
                pub plugin: SpecGeneratorsItemListTemplateSpecSourcePlugin,
                pub repo_u_r_l: String,
                pub target_revision: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClusterDecisionResourceTemplateSpecSource {
                pub chart: String,
                pub directory:
                    MatrixGeneratorsItemClusterDecisionResourceTemplateSpecSourceDirectory,
                pub helm: MatrixGeneratorsItemClusterDecisionResourceTemplateSpecSourceHelm,
                pub kustomize:
                    MatrixGeneratorsItemClusterDecisionResourceTemplateSpecSourceKustomize,
                pub path: String,
                pub plugin: MatrixGeneratorsItemClusterDecisionResourceTemplateSpecSourcePlugin,
                pub repo_u_r_l: String,
                pub target_revision: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClustersTemplateSpecSource {
                pub chart: String,
                pub directory: MatrixGeneratorsItemClustersTemplateSpecSourceDirectory,
                pub helm: MatrixGeneratorsItemClustersTemplateSpecSourceHelm,
                pub kustomize: MatrixGeneratorsItemClustersTemplateSpecSourceKustomize,
                pub path: String,
                pub plugin: MatrixGeneratorsItemClustersTemplateSpecSourcePlugin,
                pub repo_u_r_l: String,
                pub target_revision: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemGitTemplateSpecSource {
                pub chart: String,
                pub directory: MatrixGeneratorsItemGitTemplateSpecSourceDirectory,
                pub helm: MatrixGeneratorsItemGitTemplateSpecSourceHelm,
                pub kustomize: MatrixGeneratorsItemGitTemplateSpecSourceKustomize,
                pub path: String,
                pub plugin: MatrixGeneratorsItemGitTemplateSpecSourcePlugin,
                pub repo_u_r_l: String,
                pub target_revision: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemListTemplateSpecSource {
                pub chart: String,
                pub directory: MatrixGeneratorsItemListTemplateSpecSourceDirectory,
                pub helm: MatrixGeneratorsItemListTemplateSpecSourceHelm,
                pub kustomize: MatrixGeneratorsItemListTemplateSpecSourceKustomize,
                pub path: String,
                pub plugin: MatrixGeneratorsItemListTemplateSpecSourcePlugin,
                pub repo_u_r_l: String,
                pub target_revision: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemPullRequestTemplateSpecSource {
                pub chart: String,
                pub directory: MatrixGeneratorsItemPullRequestTemplateSpecSourceDirectory,
                pub helm: MatrixGeneratorsItemPullRequestTemplateSpecSourceHelm,
                pub kustomize: MatrixGeneratorsItemPullRequestTemplateSpecSourceKustomize,
                pub path: String,
                pub plugin: MatrixGeneratorsItemPullRequestTemplateSpecSourcePlugin,
                pub repo_u_r_l: String,
                pub target_revision: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemScmProviderTemplateSpecSource {
                pub chart: String,
                pub directory: MatrixGeneratorsItemScmProviderTemplateSpecSourceDirectory,
                pub helm: MatrixGeneratorsItemScmProviderTemplateSpecSourceHelm,
                pub kustomize: MatrixGeneratorsItemScmProviderTemplateSpecSourceKustomize,
                pub path: String,
                pub plugin: MatrixGeneratorsItemScmProviderTemplateSpecSourcePlugin,
                pub repo_u_r_l: String,
                pub target_revision: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixTemplateSpecSource {
                pub chart: String,
                pub directory: MatrixTemplateSpecSourceDirectory,
                pub helm: MatrixTemplateSpecSourceHelm,
                pub kustomize: MatrixTemplateSpecSourceKustomize,
                pub path: String,
                pub plugin: MatrixTemplateSpecSourcePlugin,
                pub repo_u_r_l: String,
                pub target_revision: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClusterDecisionResourceTemplateSpecSource {
                pub chart: String,
                pub directory:
                    MergeGeneratorsItemClusterDecisionResourceTemplateSpecSourceDirectory,
                pub helm: MergeGeneratorsItemClusterDecisionResourceTemplateSpecSourceHelm,
                pub kustomize:
                    MergeGeneratorsItemClusterDecisionResourceTemplateSpecSourceKustomize,
                pub path: String,
                pub plugin: MergeGeneratorsItemClusterDecisionResourceTemplateSpecSourcePlugin,
                pub repo_u_r_l: String,
                pub target_revision: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClustersTemplateSpecSource {
                pub chart: String,
                pub directory: MergeGeneratorsItemClustersTemplateSpecSourceDirectory,
                pub helm: MergeGeneratorsItemClustersTemplateSpecSourceHelm,
                pub kustomize: MergeGeneratorsItemClustersTemplateSpecSourceKustomize,
                pub path: String,
                pub plugin: MergeGeneratorsItemClustersTemplateSpecSourcePlugin,
                pub repo_u_r_l: String,
                pub target_revision: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemGitTemplateSpecSource {
                pub chart: String,
                pub directory: MergeGeneratorsItemGitTemplateSpecSourceDirectory,
                pub helm: MergeGeneratorsItemGitTemplateSpecSourceHelm,
                pub kustomize: MergeGeneratorsItemGitTemplateSpecSourceKustomize,
                pub path: String,
                pub plugin: MergeGeneratorsItemGitTemplateSpecSourcePlugin,
                pub repo_u_r_l: String,
                pub target_revision: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemListTemplateSpecSource {
                pub chart: String,
                pub directory: MergeGeneratorsItemListTemplateSpecSourceDirectory,
                pub helm: MergeGeneratorsItemListTemplateSpecSourceHelm,
                pub kustomize: MergeGeneratorsItemListTemplateSpecSourceKustomize,
                pub path: String,
                pub plugin: MergeGeneratorsItemListTemplateSpecSourcePlugin,
                pub repo_u_r_l: String,
                pub target_revision: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemPullRequestTemplateSpecSource {
                pub chart: String,
                pub directory: MergeGeneratorsItemPullRequestTemplateSpecSourceDirectory,
                pub helm: MergeGeneratorsItemPullRequestTemplateSpecSourceHelm,
                pub kustomize: MergeGeneratorsItemPullRequestTemplateSpecSourceKustomize,
                pub path: String,
                pub plugin: MergeGeneratorsItemPullRequestTemplateSpecSourcePlugin,
                pub repo_u_r_l: String,
                pub target_revision: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemScmProviderTemplateSpecSource {
                pub chart: String,
                pub directory: MergeGeneratorsItemScmProviderTemplateSpecSourceDirectory,
                pub helm: MergeGeneratorsItemScmProviderTemplateSpecSourceHelm,
                pub kustomize: MergeGeneratorsItemScmProviderTemplateSpecSourceKustomize,
                pub path: String,
                pub plugin: MergeGeneratorsItemScmProviderTemplateSpecSourcePlugin,
                pub repo_u_r_l: String,
                pub target_revision: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeTemplateSpecSource {
                pub chart: String,
                pub directory: MergeTemplateSpecSourceDirectory,
                pub helm: MergeTemplateSpecSourceHelm,
                pub kustomize: MergeTemplateSpecSourceKustomize,
                pub path: String,
                pub plugin: MergeTemplateSpecSourcePlugin,
                pub repo_u_r_l: String,
                pub target_revision: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemPullRequestTemplateSpecSource {
                pub chart: String,
                pub directory: SpecGeneratorsItemPullRequestTemplateSpecSourceDirectory,
                pub helm: SpecGeneratorsItemPullRequestTemplateSpecSourceHelm,
                pub kustomize: SpecGeneratorsItemPullRequestTemplateSpecSourceKustomize,
                pub path: String,
                pub plugin: SpecGeneratorsItemPullRequestTemplateSpecSourcePlugin,
                pub repo_u_r_l: String,
                pub target_revision: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemScmProviderTemplateSpecSource {
                pub chart: String,
                pub directory: SpecGeneratorsItemScmProviderTemplateSpecSourceDirectory,
                pub helm: SpecGeneratorsItemScmProviderTemplateSpecSourceHelm,
                pub kustomize: SpecGeneratorsItemScmProviderTemplateSpecSourceKustomize,
                pub path: String,
                pub plugin: SpecGeneratorsItemScmProviderTemplateSpecSourcePlugin,
                pub repo_u_r_l: String,
                pub target_revision: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecTemplateSpecSource {
                pub chart: String,
                pub directory: SpecTemplateSpecSourceDirectory,
                pub helm: SpecTemplateSpecSourceHelm,
                pub kustomize: SpecTemplateSpecSourceKustomize,
                pub path: String,
                pub plugin: SpecTemplateSpecSourcePlugin,
                pub repo_u_r_l: String,
                pub target_revision: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct Spec {
                pub generators: Vec<SpecGeneratorsItem>,
                pub sync_policy: SpecSyncPolicy,
                pub template: SpecTemplate,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClusterDecisionResourceTemplateSpec {
                pub destination: SpecGeneratorsItemClusterDecisionResourceTemplateSpecDestination,
                pub ignore_differences:
                    Vec<SpecGeneratorsItemClusterDecisionResourceTemplateSpecIgnoreDifferencesItem>,
                pub info: Vec<SpecGeneratorsItemClusterDecisionResourceTemplateSpecInfoItem>,
                pub project: String,
                pub revision_history_limit: i64,
                pub source: SpecGeneratorsItemClusterDecisionResourceTemplateSpecSource,
                pub sync_policy: SpecGeneratorsItemClusterDecisionResourceTemplateSpecSyncPolicy,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClustersTemplateSpec {
                pub destination: SpecGeneratorsItemClustersTemplateSpecDestination,
                pub ignore_differences:
                    Vec<SpecGeneratorsItemClustersTemplateSpecIgnoreDifferencesItem>,
                pub info: Vec<SpecGeneratorsItemClustersTemplateSpecInfoItem>,
                pub project: String,
                pub revision_history_limit: i64,
                pub source: SpecGeneratorsItemClustersTemplateSpecSource,
                pub sync_policy: SpecGeneratorsItemClustersTemplateSpecSyncPolicy,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemGitTemplateSpec {
                pub destination: SpecGeneratorsItemGitTemplateSpecDestination,
                pub ignore_differences: Vec<SpecGeneratorsItemGitTemplateSpecIgnoreDifferencesItem>,
                pub info: Vec<SpecGeneratorsItemGitTemplateSpecInfoItem>,
                pub project: String,
                pub revision_history_limit: i64,
                pub source: SpecGeneratorsItemGitTemplateSpecSource,
                pub sync_policy: SpecGeneratorsItemGitTemplateSpecSyncPolicy,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemListTemplateSpec {
                pub destination: SpecGeneratorsItemListTemplateSpecDestination,
                pub ignore_differences:
                    Vec<SpecGeneratorsItemListTemplateSpecIgnoreDifferencesItem>,
                pub info: Vec<SpecGeneratorsItemListTemplateSpecInfoItem>,
                pub project: String,
                pub revision_history_limit: i64,
                pub source: SpecGeneratorsItemListTemplateSpecSource,
                pub sync_policy: SpecGeneratorsItemListTemplateSpecSyncPolicy,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClusterDecisionResourceTemplateSpec {
                pub destination: MatrixGeneratorsItemClusterDecisionResourceTemplateSpecDestination,
                pub ignore_differences: Vec<
                    MatrixGeneratorsItemClusterDecisionResourceTemplateSpecIgnoreDifferencesItem,
                >,
                pub info: Vec<MatrixGeneratorsItemClusterDecisionResourceTemplateSpecInfoItem>,
                pub project: String,
                pub revision_history_limit: i64,
                pub source: MatrixGeneratorsItemClusterDecisionResourceTemplateSpecSource,
                pub sync_policy: MatrixGeneratorsItemClusterDecisionResourceTemplateSpecSyncPolicy,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClustersTemplateSpec {
                pub destination: MatrixGeneratorsItemClustersTemplateSpecDestination,
                pub ignore_differences:
                    Vec<MatrixGeneratorsItemClustersTemplateSpecIgnoreDifferencesItem>,
                pub info: Vec<MatrixGeneratorsItemClustersTemplateSpecInfoItem>,
                pub project: String,
                pub revision_history_limit: i64,
                pub source: MatrixGeneratorsItemClustersTemplateSpecSource,
                pub sync_policy: MatrixGeneratorsItemClustersTemplateSpecSyncPolicy,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemGitTemplateSpec {
                pub destination: MatrixGeneratorsItemGitTemplateSpecDestination,
                pub ignore_differences:
                    Vec<MatrixGeneratorsItemGitTemplateSpecIgnoreDifferencesItem>,
                pub info: Vec<MatrixGeneratorsItemGitTemplateSpecInfoItem>,
                pub project: String,
                pub revision_history_limit: i64,
                pub source: MatrixGeneratorsItemGitTemplateSpecSource,
                pub sync_policy: MatrixGeneratorsItemGitTemplateSpecSyncPolicy,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemListTemplateSpec {
                pub destination: MatrixGeneratorsItemListTemplateSpecDestination,
                pub ignore_differences:
                    Vec<MatrixGeneratorsItemListTemplateSpecIgnoreDifferencesItem>,
                pub info: Vec<MatrixGeneratorsItemListTemplateSpecInfoItem>,
                pub project: String,
                pub revision_history_limit: i64,
                pub source: MatrixGeneratorsItemListTemplateSpecSource,
                pub sync_policy: MatrixGeneratorsItemListTemplateSpecSyncPolicy,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemPullRequestTemplateSpec {
                pub destination: MatrixGeneratorsItemPullRequestTemplateSpecDestination,
                pub ignore_differences:
                    Vec<MatrixGeneratorsItemPullRequestTemplateSpecIgnoreDifferencesItem>,
                pub info: Vec<MatrixGeneratorsItemPullRequestTemplateSpecInfoItem>,
                pub project: String,
                pub revision_history_limit: i64,
                pub source: MatrixGeneratorsItemPullRequestTemplateSpecSource,
                pub sync_policy: MatrixGeneratorsItemPullRequestTemplateSpecSyncPolicy,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemScmProviderTemplateSpec {
                pub destination: MatrixGeneratorsItemScmProviderTemplateSpecDestination,
                pub ignore_differences:
                    Vec<MatrixGeneratorsItemScmProviderTemplateSpecIgnoreDifferencesItem>,
                pub info: Vec<MatrixGeneratorsItemScmProviderTemplateSpecInfoItem>,
                pub project: String,
                pub revision_history_limit: i64,
                pub source: MatrixGeneratorsItemScmProviderTemplateSpecSource,
                pub sync_policy: MatrixGeneratorsItemScmProviderTemplateSpecSyncPolicy,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixTemplateSpec {
                pub destination: MatrixTemplateSpecDestination,
                pub ignore_differences: Vec<MatrixTemplateSpecIgnoreDifferencesItem>,
                pub info: Vec<MatrixTemplateSpecInfoItem>,
                pub project: String,
                pub revision_history_limit: i64,
                pub source: MatrixTemplateSpecSource,
                pub sync_policy: MatrixTemplateSpecSyncPolicy,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClusterDecisionResourceTemplateSpec {
                pub destination: MergeGeneratorsItemClusterDecisionResourceTemplateSpecDestination,
                pub ignore_differences: Vec<
                    MergeGeneratorsItemClusterDecisionResourceTemplateSpecIgnoreDifferencesItem,
                >,
                pub info: Vec<MergeGeneratorsItemClusterDecisionResourceTemplateSpecInfoItem>,
                pub project: String,
                pub revision_history_limit: i64,
                pub source: MergeGeneratorsItemClusterDecisionResourceTemplateSpecSource,
                pub sync_policy: MergeGeneratorsItemClusterDecisionResourceTemplateSpecSyncPolicy,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClustersTemplateSpec {
                pub destination: MergeGeneratorsItemClustersTemplateSpecDestination,
                pub ignore_differences:
                    Vec<MergeGeneratorsItemClustersTemplateSpecIgnoreDifferencesItem>,
                pub info: Vec<MergeGeneratorsItemClustersTemplateSpecInfoItem>,
                pub project: String,
                pub revision_history_limit: i64,
                pub source: MergeGeneratorsItemClustersTemplateSpecSource,
                pub sync_policy: MergeGeneratorsItemClustersTemplateSpecSyncPolicy,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemGitTemplateSpec {
                pub destination: MergeGeneratorsItemGitTemplateSpecDestination,
                pub ignore_differences:
                    Vec<MergeGeneratorsItemGitTemplateSpecIgnoreDifferencesItem>,
                pub info: Vec<MergeGeneratorsItemGitTemplateSpecInfoItem>,
                pub project: String,
                pub revision_history_limit: i64,
                pub source: MergeGeneratorsItemGitTemplateSpecSource,
                pub sync_policy: MergeGeneratorsItemGitTemplateSpecSyncPolicy,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemListTemplateSpec {
                pub destination: MergeGeneratorsItemListTemplateSpecDestination,
                pub ignore_differences:
                    Vec<MergeGeneratorsItemListTemplateSpecIgnoreDifferencesItem>,
                pub info: Vec<MergeGeneratorsItemListTemplateSpecInfoItem>,
                pub project: String,
                pub revision_history_limit: i64,
                pub source: MergeGeneratorsItemListTemplateSpecSource,
                pub sync_policy: MergeGeneratorsItemListTemplateSpecSyncPolicy,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemPullRequestTemplateSpec {
                pub destination: MergeGeneratorsItemPullRequestTemplateSpecDestination,
                pub ignore_differences:
                    Vec<MergeGeneratorsItemPullRequestTemplateSpecIgnoreDifferencesItem>,
                pub info: Vec<MergeGeneratorsItemPullRequestTemplateSpecInfoItem>,
                pub project: String,
                pub revision_history_limit: i64,
                pub source: MergeGeneratorsItemPullRequestTemplateSpecSource,
                pub sync_policy: MergeGeneratorsItemPullRequestTemplateSpecSyncPolicy,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemScmProviderTemplateSpec {
                pub destination: MergeGeneratorsItemScmProviderTemplateSpecDestination,
                pub ignore_differences:
                    Vec<MergeGeneratorsItemScmProviderTemplateSpecIgnoreDifferencesItem>,
                pub info: Vec<MergeGeneratorsItemScmProviderTemplateSpecInfoItem>,
                pub project: String,
                pub revision_history_limit: i64,
                pub source: MergeGeneratorsItemScmProviderTemplateSpecSource,
                pub sync_policy: MergeGeneratorsItemScmProviderTemplateSpecSyncPolicy,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeTemplateSpec {
                pub destination: MergeTemplateSpecDestination,
                pub ignore_differences: Vec<MergeTemplateSpecIgnoreDifferencesItem>,
                pub info: Vec<MergeTemplateSpecInfoItem>,
                pub project: String,
                pub revision_history_limit: i64,
                pub source: MergeTemplateSpecSource,
                pub sync_policy: MergeTemplateSpecSyncPolicy,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemPullRequestTemplateSpec {
                pub destination: SpecGeneratorsItemPullRequestTemplateSpecDestination,
                pub ignore_differences:
                    Vec<SpecGeneratorsItemPullRequestTemplateSpecIgnoreDifferencesItem>,
                pub info: Vec<SpecGeneratorsItemPullRequestTemplateSpecInfoItem>,
                pub project: String,
                pub revision_history_limit: i64,
                pub source: SpecGeneratorsItemPullRequestTemplateSpecSource,
                pub sync_policy: SpecGeneratorsItemPullRequestTemplateSpecSyncPolicy,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemScmProviderTemplateSpec {
                pub destination: SpecGeneratorsItemScmProviderTemplateSpecDestination,
                pub ignore_differences:
                    Vec<SpecGeneratorsItemScmProviderTemplateSpecIgnoreDifferencesItem>,
                pub info: Vec<SpecGeneratorsItemScmProviderTemplateSpecInfoItem>,
                pub project: String,
                pub revision_history_limit: i64,
                pub source: SpecGeneratorsItemScmProviderTemplateSpecSource,
                pub sync_policy: SpecGeneratorsItemScmProviderTemplateSpecSyncPolicy,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecTemplateSpec {
                pub destination: SpecTemplateSpecDestination,
                pub ignore_differences: Vec<SpecTemplateSpecIgnoreDifferencesItem>,
                pub info: Vec<SpecTemplateSpecInfoItem>,
                pub project: String,
                pub revision_history_limit: i64,
                pub source: SpecTemplateSpecSource,
                pub sync_policy: SpecTemplateSpecSyncPolicy,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct Status {
                pub conditions: Vec<ConditionsItem>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecSyncPolicy {
                pub preserve_resources_on_deletion: bool,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClusterDecisionResourceTemplateSpecSyncPolicy {
                pub automated:
                    SpecGeneratorsItemClusterDecisionResourceTemplateSpecSyncPolicyAutomated,
                pub retry: SpecGeneratorsItemClusterDecisionResourceTemplateSpecSyncPolicyRetry,
                pub sync_options: Vec<String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClustersTemplateSpecSyncPolicy {
                pub automated: SpecGeneratorsItemClustersTemplateSpecSyncPolicyAutomated,
                pub retry: SpecGeneratorsItemClustersTemplateSpecSyncPolicyRetry,
                pub sync_options: Vec<String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemGitTemplateSpecSyncPolicy {
                pub automated: SpecGeneratorsItemGitTemplateSpecSyncPolicyAutomated,
                pub retry: SpecGeneratorsItemGitTemplateSpecSyncPolicyRetry,
                pub sync_options: Vec<String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemListTemplateSpecSyncPolicy {
                pub automated: SpecGeneratorsItemListTemplateSpecSyncPolicyAutomated,
                pub retry: SpecGeneratorsItemListTemplateSpecSyncPolicyRetry,
                pub sync_options: Vec<String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClusterDecisionResourceTemplateSpecSyncPolicy {
                pub automated:
                    MatrixGeneratorsItemClusterDecisionResourceTemplateSpecSyncPolicyAutomated,
                pub retry: MatrixGeneratorsItemClusterDecisionResourceTemplateSpecSyncPolicyRetry,
                pub sync_options: Vec<String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClustersTemplateSpecSyncPolicy {
                pub automated: MatrixGeneratorsItemClustersTemplateSpecSyncPolicyAutomated,
                pub retry: MatrixGeneratorsItemClustersTemplateSpecSyncPolicyRetry,
                pub sync_options: Vec<String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemGitTemplateSpecSyncPolicy {
                pub automated: MatrixGeneratorsItemGitTemplateSpecSyncPolicyAutomated,
                pub retry: MatrixGeneratorsItemGitTemplateSpecSyncPolicyRetry,
                pub sync_options: Vec<String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemListTemplateSpecSyncPolicy {
                pub automated: MatrixGeneratorsItemListTemplateSpecSyncPolicyAutomated,
                pub retry: MatrixGeneratorsItemListTemplateSpecSyncPolicyRetry,
                pub sync_options: Vec<String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemPullRequestTemplateSpecSyncPolicy {
                pub automated: MatrixGeneratorsItemPullRequestTemplateSpecSyncPolicyAutomated,
                pub retry: MatrixGeneratorsItemPullRequestTemplateSpecSyncPolicyRetry,
                pub sync_options: Vec<String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemScmProviderTemplateSpecSyncPolicy {
                pub automated: MatrixGeneratorsItemScmProviderTemplateSpecSyncPolicyAutomated,
                pub retry: MatrixGeneratorsItemScmProviderTemplateSpecSyncPolicyRetry,
                pub sync_options: Vec<String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixTemplateSpecSyncPolicy {
                pub automated: MatrixTemplateSpecSyncPolicyAutomated,
                pub retry: MatrixTemplateSpecSyncPolicyRetry,
                pub sync_options: Vec<String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClusterDecisionResourceTemplateSpecSyncPolicy {
                pub automated:
                    MergeGeneratorsItemClusterDecisionResourceTemplateSpecSyncPolicyAutomated,
                pub retry: MergeGeneratorsItemClusterDecisionResourceTemplateSpecSyncPolicyRetry,
                pub sync_options: Vec<String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClustersTemplateSpecSyncPolicy {
                pub automated: MergeGeneratorsItemClustersTemplateSpecSyncPolicyAutomated,
                pub retry: MergeGeneratorsItemClustersTemplateSpecSyncPolicyRetry,
                pub sync_options: Vec<String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemGitTemplateSpecSyncPolicy {
                pub automated: MergeGeneratorsItemGitTemplateSpecSyncPolicyAutomated,
                pub retry: MergeGeneratorsItemGitTemplateSpecSyncPolicyRetry,
                pub sync_options: Vec<String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemListTemplateSpecSyncPolicy {
                pub automated: MergeGeneratorsItemListTemplateSpecSyncPolicyAutomated,
                pub retry: MergeGeneratorsItemListTemplateSpecSyncPolicyRetry,
                pub sync_options: Vec<String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemPullRequestTemplateSpecSyncPolicy {
                pub automated: MergeGeneratorsItemPullRequestTemplateSpecSyncPolicyAutomated,
                pub retry: MergeGeneratorsItemPullRequestTemplateSpecSyncPolicyRetry,
                pub sync_options: Vec<String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemScmProviderTemplateSpecSyncPolicy {
                pub automated: MergeGeneratorsItemScmProviderTemplateSpecSyncPolicyAutomated,
                pub retry: MergeGeneratorsItemScmProviderTemplateSpecSyncPolicyRetry,
                pub sync_options: Vec<String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeTemplateSpecSyncPolicy {
                pub automated: MergeTemplateSpecSyncPolicyAutomated,
                pub retry: MergeTemplateSpecSyncPolicyRetry,
                pub sync_options: Vec<String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemPullRequestTemplateSpecSyncPolicy {
                pub automated: SpecGeneratorsItemPullRequestTemplateSpecSyncPolicyAutomated,
                pub retry: SpecGeneratorsItemPullRequestTemplateSpecSyncPolicyRetry,
                pub sync_options: Vec<String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemScmProviderTemplateSpecSyncPolicy {
                pub automated: SpecGeneratorsItemScmProviderTemplateSpecSyncPolicyAutomated,
                pub retry: SpecGeneratorsItemScmProviderTemplateSpecSyncPolicyRetry,
                pub sync_options: Vec<String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecTemplateSpecSyncPolicy {
                pub automated: SpecTemplateSpecSyncPolicyAutomated,
                pub retry: SpecTemplateSpecSyncPolicyRetry,
                pub sync_options: Vec<String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecTemplate {
                pub metadata: SpecTemplateMetadata,
                pub spec: SpecTemplateSpec,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClusterDecisionResourceTemplate {
                pub metadata: SpecGeneratorsItemClusterDecisionResourceTemplateMetadata,
                pub spec: SpecGeneratorsItemClusterDecisionResourceTemplateSpec,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClustersTemplate {
                pub metadata: SpecGeneratorsItemClustersTemplateMetadata,
                pub spec: SpecGeneratorsItemClustersTemplateSpec,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemGitTemplate {
                pub metadata: SpecGeneratorsItemGitTemplateMetadata,
                pub spec: SpecGeneratorsItemGitTemplateSpec,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemListTemplate {
                pub metadata: SpecGeneratorsItemListTemplateMetadata,
                pub spec: SpecGeneratorsItemListTemplateSpec,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixTemplate {
                pub metadata: MatrixTemplateMetadata,
                pub spec: MatrixTemplateSpec,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClusterDecisionResourceTemplate {
                pub metadata: MatrixGeneratorsItemClusterDecisionResourceTemplateMetadata,
                pub spec: MatrixGeneratorsItemClusterDecisionResourceTemplateSpec,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClustersTemplate {
                pub metadata: MatrixGeneratorsItemClustersTemplateMetadata,
                pub spec: MatrixGeneratorsItemClustersTemplateSpec,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemGitTemplate {
                pub metadata: MatrixGeneratorsItemGitTemplateMetadata,
                pub spec: MatrixGeneratorsItemGitTemplateSpec,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemListTemplate {
                pub metadata: MatrixGeneratorsItemListTemplateMetadata,
                pub spec: MatrixGeneratorsItemListTemplateSpec,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemPullRequestTemplate {
                pub metadata: MatrixGeneratorsItemPullRequestTemplateMetadata,
                pub spec: MatrixGeneratorsItemPullRequestTemplateSpec,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemScmProviderTemplate {
                pub metadata: MatrixGeneratorsItemScmProviderTemplateMetadata,
                pub spec: MatrixGeneratorsItemScmProviderTemplateSpec,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeTemplate {
                pub metadata: MergeTemplateMetadata,
                pub spec: MergeTemplateSpec,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClusterDecisionResourceTemplate {
                pub metadata: MergeGeneratorsItemClusterDecisionResourceTemplateMetadata,
                pub spec: MergeGeneratorsItemClusterDecisionResourceTemplateSpec,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClustersTemplate {
                pub metadata: MergeGeneratorsItemClustersTemplateMetadata,
                pub spec: MergeGeneratorsItemClustersTemplateSpec,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemGitTemplate {
                pub metadata: MergeGeneratorsItemGitTemplateMetadata,
                pub spec: MergeGeneratorsItemGitTemplateSpec,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemListTemplate {
                pub metadata: MergeGeneratorsItemListTemplateMetadata,
                pub spec: MergeGeneratorsItemListTemplateSpec,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemPullRequestTemplate {
                pub metadata: MergeGeneratorsItemPullRequestTemplateMetadata,
                pub spec: MergeGeneratorsItemPullRequestTemplateSpec,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemScmProviderTemplate {
                pub metadata: MergeGeneratorsItemScmProviderTemplateMetadata,
                pub spec: MergeGeneratorsItemScmProviderTemplateSpec,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemPullRequestTemplate {
                pub metadata: SpecGeneratorsItemPullRequestTemplateMetadata,
                pub spec: SpecGeneratorsItemPullRequestTemplateSpec,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemScmProviderTemplate {
                pub metadata: SpecGeneratorsItemScmProviderTemplateMetadata,
                pub spec: SpecGeneratorsItemScmProviderTemplateSpec,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClusterDecisionResourceTemplateSpecSourceDirectoryJsonnetTlasItem {
                pub code: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClustersTemplateSpecSourceDirectoryJsonnetTlasItem {
                pub code: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemGitTemplateSpecSourceDirectoryJsonnetTlasItem {
                pub code: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemListTemplateSpecSourceDirectoryJsonnetTlasItem {
                pub code: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClusterDecisionResourceTemplateSpecSourceDirectoryJsonnetTlasItem {
                pub code: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClustersTemplateSpecSourceDirectoryJsonnetTlasItem {
                pub code: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemGitTemplateSpecSourceDirectoryJsonnetTlasItem {
                pub code: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemListTemplateSpecSourceDirectoryJsonnetTlasItem {
                pub code: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemPullRequestTemplateSpecSourceDirectoryJsonnetTlasItem {
                pub code: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemScmProviderTemplateSpecSourceDirectoryJsonnetTlasItem {
                pub code: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixTemplateSpecSourceDirectoryJsonnetTlasItem {
                pub code: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClusterDecisionResourceTemplateSpecSourceDirectoryJsonnetTlasItem {
                pub code: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClustersTemplateSpecSourceDirectoryJsonnetTlasItem {
                pub code: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemGitTemplateSpecSourceDirectoryJsonnetTlasItem {
                pub code: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemListTemplateSpecSourceDirectoryJsonnetTlasItem {
                pub code: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemPullRequestTemplateSpecSourceDirectoryJsonnetTlasItem {
                pub code: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemScmProviderTemplateSpecSourceDirectoryJsonnetTlasItem {
                pub code: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeTemplateSpecSourceDirectoryJsonnetTlasItem {
                pub code: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemPullRequestTemplateSpecSourceDirectoryJsonnetTlasItem {
                pub code: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemScmProviderTemplateSpecSourceDirectoryJsonnetTlasItem {
                pub code: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecTemplateSpecSourceDirectoryJsonnetTlasItem {
                pub code: bool,
                pub name: String,
                pub value: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemPullRequestGiteaTokenRef {
                pub key: String,
                pub secret_name: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemPullRequestGithubTokenRef {
                pub key: String,
                pub secret_name: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemPullRequestGitlabTokenRef {
                pub key: String,
                pub secret_name: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemScmProviderGiteaTokenRef {
                pub key: String,
                pub secret_name: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemScmProviderGithubTokenRef {
                pub key: String,
                pub secret_name: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemScmProviderGitlabTokenRef {
                pub key: String,
                pub secret_name: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemPullRequestGiteaTokenRef {
                pub key: String,
                pub secret_name: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemPullRequestGithubTokenRef {
                pub key: String,
                pub secret_name: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemPullRequestGitlabTokenRef {
                pub key: String,
                pub secret_name: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemScmProviderGiteaTokenRef {
                pub key: String,
                pub secret_name: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemScmProviderGithubTokenRef {
                pub key: String,
                pub secret_name: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemScmProviderGitlabTokenRef {
                pub key: String,
                pub secret_name: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemPullRequestGiteaTokenRef {
                pub key: String,
                pub secret_name: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemPullRequestGithubTokenRef {
                pub key: String,
                pub secret_name: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemPullRequestGitlabTokenRef {
                pub key: String,
                pub secret_name: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemScmProviderGiteaTokenRef {
                pub key: String,
                pub secret_name: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemScmProviderGithubTokenRef {
                pub key: String,
                pub secret_name: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemScmProviderGitlabTokenRef {
                pub key: String,
                pub secret_name: String,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClusterDecisionResourceValues {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct SpecGeneratorsItemClustersValues {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClusterDecisionResourceValues {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MatrixGeneratorsItemClustersValues {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClusterDecisionResourceValues {
                pub properties: std::collections::HashMap<String, String>,
            }

            #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
            #[serde(rename_all = "camelCase")]
            pub struct MergeGeneratorsItemClustersValues {
                pub properties: std::collections::HashMap<String, String>,
            }
        }
    }
}