pulumiverse-scaleway 1.26.0a1742897201__py3-none-any.whl → 1.27.0__py3-none-any.whl

pulumiverse_scaleway/_inputs.py

@@ -69,6 +69,22 @@ __all__ = [
     'DomainRecordViewArgsDict',
     'DomainRecordWeightedArgs',
     'DomainRecordWeightedArgsDict',
+    'EdgeServicesBackendStageLbBackendConfigArgs',
+    'EdgeServicesBackendStageLbBackendConfigArgsDict',
+    'EdgeServicesBackendStageLbBackendConfigLbConfigArgs',
+    'EdgeServicesBackendStageLbBackendConfigLbConfigArgsDict',
+    'EdgeServicesBackendStageS3BackendConfigArgs',
+    'EdgeServicesBackendStageS3BackendConfigArgsDict',
+    'EdgeServicesCacheStagePurgeRequestArgs',
+    'EdgeServicesCacheStagePurgeRequestArgsDict',
+    'EdgeServicesRouteStageRuleArgs',
+    'EdgeServicesRouteStageRuleArgsDict',
+    'EdgeServicesRouteStageRuleRuleHttpMatchArgs',
+    'EdgeServicesRouteStageRuleRuleHttpMatchArgsDict',
+    'EdgeServicesRouteStageRuleRuleHttpMatchPathFilterArgs',
+    'EdgeServicesRouteStageRuleRuleHttpMatchPathFilterArgsDict',
+    'EdgeServicesTlsStageSecretArgs',
+    'EdgeServicesTlsStageSecretArgsDict',
     'FunctionTriggerNatsArgs',
     'FunctionTriggerNatsArgsDict',
     'FunctionTriggerSqsArgs',
@@ -121,6 +137,8 @@ __all__ = [
     'IpamIpSourceArgsDict',
     'JobDefinitionCronArgs',
     'JobDefinitionCronArgsDict',
+    'JobDefinitionSecretReferenceArgs',
+    'JobDefinitionSecretReferenceArgsDict',
     'KubernetesClusterAutoUpgradeArgs',
     'KubernetesClusterAutoUpgradeArgsDict',
     'KubernetesClusterAutoscalerConfigArgs',
@@ -201,6 +219,8 @@ __all__ = [
     'RedisClusterPublicNetworkArgsDict',
     'SecretEphemeralPolicyArgs',
     'SecretEphemeralPolicyArgsDict',
+    'SecretVersionArgs',
+    'SecretVersionArgsDict',
     'TemDomainReputationArgs',
     'TemDomainReputationArgsDict',
     'VpcGatewayNetworkIpamConfigArgs',
@@ -2677,6 +2697,499 @@ class DomainRecordWeightedArgs:
         pulumi.set(self, "weight", value)
 
 
+if not MYPY:
+    class EdgeServicesBackendStageLbBackendConfigArgsDict(TypedDict):
+        lb_config: NotRequired[pulumi.Input['EdgeServicesBackendStageLbBackendConfigLbConfigArgsDict']]
+        """
+        The Load Balancer config.
+        """
+elif False:
+    EdgeServicesBackendStageLbBackendConfigArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class EdgeServicesBackendStageLbBackendConfigArgs:
+    def __init__(__self__, *,
+                 lb_config: Optional[pulumi.Input['EdgeServicesBackendStageLbBackendConfigLbConfigArgs']] = None):
+        """
+        :param pulumi.Input['EdgeServicesBackendStageLbBackendConfigLbConfigArgs'] lb_config: The Load Balancer config.
+        """
+        if lb_config is not None:
+            pulumi.set(__self__, "lb_config", lb_config)
+
+    @property
+    @pulumi.getter(name="lbConfig")
+    def lb_config(self) -> Optional[pulumi.Input['EdgeServicesBackendStageLbBackendConfigLbConfigArgs']]:
+        """
+        The Load Balancer config.
+        """
+        return pulumi.get(self, "lb_config")
+
+    @lb_config.setter
+    def lb_config(self, value: Optional[pulumi.Input['EdgeServicesBackendStageLbBackendConfigLbConfigArgs']]):
+        pulumi.set(self, "lb_config", value)
+
+
+if not MYPY:
+    class EdgeServicesBackendStageLbBackendConfigLbConfigArgsDict(TypedDict):
+        domain_name: NotRequired[pulumi.Input[str]]
+        """
+        The Fully Qualified Domain Name (in the format subdomain.example.com) to use in HTTP requests sent towards your Load Balancer.
+        """
+        frontend_id: NotRequired[pulumi.Input[str]]
+        """
+        The ID of the frontend.
+        """
+        id: NotRequired[pulumi.Input[str]]
+        """
+        The ID of the Load Balancer.
+        """
+        is_ssl: NotRequired[pulumi.Input[bool]]
+        """
+        Defines whether the Load Balancer's frontend handles SSL connections.
+        """
+        zone: NotRequired[pulumi.Input[str]]
+        """
+        `zone`) The zone of the Load Balancer.
+        """
+elif False:
+    EdgeServicesBackendStageLbBackendConfigLbConfigArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class EdgeServicesBackendStageLbBackendConfigLbConfigArgs:
+    def __init__(__self__, *,
+                 domain_name: Optional[pulumi.Input[str]] = None,
+                 frontend_id: Optional[pulumi.Input[str]] = None,
+                 id: Optional[pulumi.Input[str]] = None,
+                 is_ssl: Optional[pulumi.Input[bool]] = None,
+                 zone: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] domain_name: The Fully Qualified Domain Name (in the format subdomain.example.com) to use in HTTP requests sent towards your Load Balancer.
+        :param pulumi.Input[str] frontend_id: The ID of the frontend.
+        :param pulumi.Input[str] id: The ID of the Load Balancer.
+        :param pulumi.Input[bool] is_ssl: Defines whether the Load Balancer's frontend handles SSL connections.
+        :param pulumi.Input[str] zone: `zone`) The zone of the Load Balancer.
+        """
+        if domain_name is not None:
+            pulumi.set(__self__, "domain_name", domain_name)
+        if frontend_id is not None:
+            pulumi.set(__self__, "frontend_id", frontend_id)
+        if id is not None:
+            pulumi.set(__self__, "id", id)
+        if is_ssl is not None:
+            pulumi.set(__self__, "is_ssl", is_ssl)
+        if zone is not None:
+            pulumi.set(__self__, "zone", zone)
+
+    @property
+    @pulumi.getter(name="domainName")
+    def domain_name(self) -> Optional[pulumi.Input[str]]:
+        """
+        The Fully Qualified Domain Name (in the format subdomain.example.com) to use in HTTP requests sent towards your Load Balancer.
+        """
+        return pulumi.get(self, "domain_name")
+
+    @domain_name.setter
+    def domain_name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "domain_name", value)
+
+    @property
+    @pulumi.getter(name="frontendId")
+    def frontend_id(self) -> Optional[pulumi.Input[str]]:
+        """
+        The ID of the frontend.
+        """
+        return pulumi.get(self, "frontend_id")
+
+    @frontend_id.setter
+    def frontend_id(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "frontend_id", value)
+
+    @property
+    @pulumi.getter
+    def id(self) -> Optional[pulumi.Input[str]]:
+        """
+        The ID of the Load Balancer.
+        """
+        return pulumi.get(self, "id")
+
+    @id.setter
+    def id(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "id", value)
+
+    @property
+    @pulumi.getter(name="isSsl")
+    def is_ssl(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Defines whether the Load Balancer's frontend handles SSL connections.
+        """
+        return pulumi.get(self, "is_ssl")
+
+    @is_ssl.setter
+    def is_ssl(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "is_ssl", value)
+
+    @property
+    @pulumi.getter
+    def zone(self) -> Optional[pulumi.Input[str]]:
+        """
+        `zone`) The zone of the Load Balancer.
+        """
+        return pulumi.get(self, "zone")
+
+    @zone.setter
+    def zone(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "zone", value)
+
+
+if not MYPY:
+    class EdgeServicesBackendStageS3BackendConfigArgsDict(TypedDict):
+        bucket_name: NotRequired[pulumi.Input[str]]
+        """
+        The name of the Bucket.
+        """
+        bucket_region: NotRequired[pulumi.Input[str]]
+        """
+        The region of the Bucket.
+        """
+        is_website: NotRequired[pulumi.Input[bool]]
+        """
+        Defines whether the bucket website feature is enabled.
+        """
+elif False:
+    EdgeServicesBackendStageS3BackendConfigArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class EdgeServicesBackendStageS3BackendConfigArgs:
+    def __init__(__self__, *,
+                 bucket_name: Optional[pulumi.Input[str]] = None,
+                 bucket_region: Optional[pulumi.Input[str]] = None,
+                 is_website: Optional[pulumi.Input[bool]] = None):
+        """
+        :param pulumi.Input[str] bucket_name: The name of the Bucket.
+        :param pulumi.Input[str] bucket_region: The region of the Bucket.
+        :param pulumi.Input[bool] is_website: Defines whether the bucket website feature is enabled.
+        """
+        if bucket_name is not None:
+            pulumi.set(__self__, "bucket_name", bucket_name)
+        if bucket_region is not None:
+            pulumi.set(__self__, "bucket_region", bucket_region)
+        if is_website is not None:
+            pulumi.set(__self__, "is_website", is_website)
+
+    @property
+    @pulumi.getter(name="bucketName")
+    def bucket_name(self) -> Optional[pulumi.Input[str]]:
+        """
+        The name of the Bucket.
+        """
+        return pulumi.get(self, "bucket_name")
+
+    @bucket_name.setter
+    def bucket_name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "bucket_name", value)
+
+    @property
+    @pulumi.getter(name="bucketRegion")
+    def bucket_region(self) -> Optional[pulumi.Input[str]]:
+        """
+        The region of the Bucket.
+        """
+        return pulumi.get(self, "bucket_region")
+
+    @bucket_region.setter
+    def bucket_region(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "bucket_region", value)
+
+    @property
+    @pulumi.getter(name="isWebsite")
+    def is_website(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Defines whether the bucket website feature is enabled.
+        """
+        return pulumi.get(self, "is_website")
+
+    @is_website.setter
+    def is_website(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "is_website", value)
+
+
+if not MYPY:
+    class EdgeServicesCacheStagePurgeRequestArgsDict(TypedDict):
+        all: NotRequired[pulumi.Input[bool]]
+        """
+        Defines whether to purge all content.
+        """
+        assets: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        The list of asserts to purge.
+        """
+        pipeline_id: NotRequired[pulumi.Input[str]]
+        """
+        The pipeline ID in which the purge request will be created.
+        """
+elif False:
+    EdgeServicesCacheStagePurgeRequestArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class EdgeServicesCacheStagePurgeRequestArgs:
+    def __init__(__self__, *,
+                 all: Optional[pulumi.Input[bool]] = None,
+                 assets: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 pipeline_id: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[bool] all: Defines whether to purge all content.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] assets: The list of asserts to purge.
+        :param pulumi.Input[str] pipeline_id: The pipeline ID in which the purge request will be created.
+        """
+        if all is not None:
+            pulumi.set(__self__, "all", all)
+        if assets is not None:
+            pulumi.set(__self__, "assets", assets)
+        if pipeline_id is not None:
+            pulumi.set(__self__, "pipeline_id", pipeline_id)
+
+    @property
+    @pulumi.getter
+    def all(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Defines whether to purge all content.
+        """
+        return pulumi.get(self, "all")
+
+    @all.setter
+    def all(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "all", value)
+
+    @property
+    @pulumi.getter
+    def assets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        The list of asserts to purge.
+        """
+        return pulumi.get(self, "assets")
+
+    @assets.setter
+    def assets(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "assets", value)
+
+    @property
+    @pulumi.getter(name="pipelineId")
+    def pipeline_id(self) -> Optional[pulumi.Input[str]]:
+        """
+        The pipeline ID in which the purge request will be created.
+        """
+        return pulumi.get(self, "pipeline_id")
+
+    @pipeline_id.setter
+    def pipeline_id(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "pipeline_id", value)
+
+
+if not MYPY:
+    class EdgeServicesRouteStageRuleArgsDict(TypedDict):
+        backend_stage_id: pulumi.Input[str]
+        """
+        The ID of the backend stage that requests matching the rule should be forwarded to.
+        """
+        rule_http_match: NotRequired[pulumi.Input['EdgeServicesRouteStageRuleRuleHttpMatchArgsDict']]
+        """
+        The rule condition to be matched. Requests matching the condition defined here will be directly forwarded to the backend specified by the `backend_stage_id` field. Requests that do not match will be checked by the next rule's condition.
+        """
+elif False:
+    EdgeServicesRouteStageRuleArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class EdgeServicesRouteStageRuleArgs:
+    def __init__(__self__, *,
+                 backend_stage_id: pulumi.Input[str],
+                 rule_http_match: Optional[pulumi.Input['EdgeServicesRouteStageRuleRuleHttpMatchArgs']] = None):
+        """
+        :param pulumi.Input[str] backend_stage_id: The ID of the backend stage that requests matching the rule should be forwarded to.
+        :param pulumi.Input['EdgeServicesRouteStageRuleRuleHttpMatchArgs'] rule_http_match: The rule condition to be matched. Requests matching the condition defined here will be directly forwarded to the backend specified by the `backend_stage_id` field. Requests that do not match will be checked by the next rule's condition.
+        """
+        pulumi.set(__self__, "backend_stage_id", backend_stage_id)
+        if rule_http_match is not None:
+            pulumi.set(__self__, "rule_http_match", rule_http_match)
+
+    @property
+    @pulumi.getter(name="backendStageId")
+    def backend_stage_id(self) -> pulumi.Input[str]:
+        """
+        The ID of the backend stage that requests matching the rule should be forwarded to.
+        """
+        return pulumi.get(self, "backend_stage_id")
+
+    @backend_stage_id.setter
+    def backend_stage_id(self, value: pulumi.Input[str]):
+        pulumi.set(self, "backend_stage_id", value)
+
+    @property
+    @pulumi.getter(name="ruleHttpMatch")
+    def rule_http_match(self) -> Optional[pulumi.Input['EdgeServicesRouteStageRuleRuleHttpMatchArgs']]:
+        """
+        The rule condition to be matched. Requests matching the condition defined here will be directly forwarded to the backend specified by the `backend_stage_id` field. Requests that do not match will be checked by the next rule's condition.
+        """
+        return pulumi.get(self, "rule_http_match")
+
+    @rule_http_match.setter
+    def rule_http_match(self, value: Optional[pulumi.Input['EdgeServicesRouteStageRuleRuleHttpMatchArgs']]):
+        pulumi.set(self, "rule_http_match", value)
+
+
+if not MYPY:
+    class EdgeServicesRouteStageRuleRuleHttpMatchArgsDict(TypedDict):
+        method_filters: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        HTTP methods to filter for. A request using any of these methods will be considered to match the rule. Possible values are `get`, `post`, `put`, `patch`, `delete`, `head`, `options`. All methods will match if none is provided.
+        """
+        path_filter: NotRequired[pulumi.Input['EdgeServicesRouteStageRuleRuleHttpMatchPathFilterArgsDict']]
+        """
+        HTTP URL path to filter for. A request whose path matches the given filter will be considered to match the rule. All paths will match if none is provided.
+        """
+elif False:
+    EdgeServicesRouteStageRuleRuleHttpMatchArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class EdgeServicesRouteStageRuleRuleHttpMatchArgs:
+    def __init__(__self__, *,
+                 method_filters: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 path_filter: Optional[pulumi.Input['EdgeServicesRouteStageRuleRuleHttpMatchPathFilterArgs']] = None):
+        """
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] method_filters: HTTP methods to filter for. A request using any of these methods will be considered to match the rule. Possible values are `get`, `post`, `put`, `patch`, `delete`, `head`, `options`. All methods will match if none is provided.
+        :param pulumi.Input['EdgeServicesRouteStageRuleRuleHttpMatchPathFilterArgs'] path_filter: HTTP URL path to filter for. A request whose path matches the given filter will be considered to match the rule. All paths will match if none is provided.
+        """
+        if method_filters is not None:
+            pulumi.set(__self__, "method_filters", method_filters)
+        if path_filter is not None:
+            pulumi.set(__self__, "path_filter", path_filter)
+
+    @property
+    @pulumi.getter(name="methodFilters")
+    def method_filters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        HTTP methods to filter for. A request using any of these methods will be considered to match the rule. Possible values are `get`, `post`, `put`, `patch`, `delete`, `head`, `options`. All methods will match if none is provided.
+        """
+        return pulumi.get(self, "method_filters")
+
+    @method_filters.setter
+    def method_filters(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "method_filters", value)
+
+    @property
+    @pulumi.getter(name="pathFilter")
+    def path_filter(self) -> Optional[pulumi.Input['EdgeServicesRouteStageRuleRuleHttpMatchPathFilterArgs']]:
+        """
+        HTTP URL path to filter for. A request whose path matches the given filter will be considered to match the rule. All paths will match if none is provided.
+        """
+        return pulumi.get(self, "path_filter")
+
+    @path_filter.setter
+    def path_filter(self, value: Optional[pulumi.Input['EdgeServicesRouteStageRuleRuleHttpMatchPathFilterArgs']]):
+        pulumi.set(self, "path_filter", value)
+
+
+if not MYPY:
+    class EdgeServicesRouteStageRuleRuleHttpMatchPathFilterArgsDict(TypedDict):
+        path_filter_type: pulumi.Input[str]
+        """
+        The type of filter to match for the HTTP URL path. For now, all path filters must be written in regex and use the `regex` type.
+        """
+        value: pulumi.Input[str]
+        """
+        The value to be matched for the HTTP URL path.
+        """
+elif False:
+    EdgeServicesRouteStageRuleRuleHttpMatchPathFilterArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class EdgeServicesRouteStageRuleRuleHttpMatchPathFilterArgs:
+    def __init__(__self__, *,
+                 path_filter_type: pulumi.Input[str],
+                 value: pulumi.Input[str]):
+        """
+        :param pulumi.Input[str] path_filter_type: The type of filter to match for the HTTP URL path. For now, all path filters must be written in regex and use the `regex` type.
+        :param pulumi.Input[str] value: The value to be matched for the HTTP URL path.
+        """
+        pulumi.set(__self__, "path_filter_type", path_filter_type)
+        pulumi.set(__self__, "value", value)
+
+    @property
+    @pulumi.getter(name="pathFilterType")
+    def path_filter_type(self) -> pulumi.Input[str]:
+        """
+        The type of filter to match for the HTTP URL path. For now, all path filters must be written in regex and use the `regex` type.
+        """
+        return pulumi.get(self, "path_filter_type")
+
+    @path_filter_type.setter
+    def path_filter_type(self, value: pulumi.Input[str]):
+        pulumi.set(self, "path_filter_type", value)
+
+    @property
+    @pulumi.getter
+    def value(self) -> pulumi.Input[str]:
+        """
+        The value to be matched for the HTTP URL path.
+        """
+        return pulumi.get(self, "value")
+
+    @value.setter
+    def value(self, value: pulumi.Input[str]):
+        pulumi.set(self, "value", value)
+
+
+if not MYPY:
+    class EdgeServicesTlsStageSecretArgsDict(TypedDict):
+        region: NotRequired[pulumi.Input[str]]
+        """
+        The region of the secret.
+        """
+        secret_id: NotRequired[pulumi.Input[str]]
+        """
+        The ID of the Secret
+        """
+elif False:
+    EdgeServicesTlsStageSecretArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class EdgeServicesTlsStageSecretArgs:
+    def __init__(__self__, *,
+                 region: Optional[pulumi.Input[str]] = None,
+                 secret_id: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] region: The region of the secret.
+        :param pulumi.Input[str] secret_id: The ID of the Secret
+        """
+        if region is not None:
+            pulumi.set(__self__, "region", region)
+        if secret_id is not None:
+            pulumi.set(__self__, "secret_id", secret_id)
+
+    @property
+    @pulumi.getter
+    def region(self) -> Optional[pulumi.Input[str]]:
+        """
+        The region of the secret.
+        """
+        return pulumi.get(self, "region")
+
+    @region.setter
+    def region(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "region", value)
+
+    @property
+    @pulumi.getter(name="secretId")
+    def secret_id(self) -> Optional[pulumi.Input[str]]:
+        """
+        The ID of the Secret
+        """
+        return pulumi.get(self, "secret_id")
+
+    @secret_id.setter
+    def secret_id(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "secret_id", value)
+
+
 if not MYPY:
     class FunctionTriggerNatsArgsDict(TypedDict):
         subject: pulumi.Input[str]
@@ -5181,6 +5694,117 @@ class JobDefinitionCronArgs:
         pulumi.set(self, "timezone", value)
 
 
+if not MYPY:
+    class JobDefinitionSecretReferenceArgsDict(TypedDict):
+        secret_id: pulumi.Input[str]
+        """
+        The secret unique identifier, it could be formatted as region/UUID or UUID. In case the region is passed, it must be the same as the job definition. You could reference the same secret multiple times in the same job definition.
+        """
+        environment: NotRequired[pulumi.Input[str]]
+        """
+        An environment variable containing the secret value. Must be specified if `file` is not specified.
+        """
+        file: NotRequired[pulumi.Input[str]]
+        """
+        The absolute file path where the secret will be mounted. Must be specified if `environment` is not specified.
+        """
+        secret_reference_id: NotRequired[pulumi.Input[str]]
+        """
+        The secret reference UUID that is automatically generated by the provider.
+        """
+        secret_version: NotRequired[pulumi.Input[str]]
+        """
+        The secret version.
+        """
+elif False:
+    JobDefinitionSecretReferenceArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class JobDefinitionSecretReferenceArgs:
+    def __init__(__self__, *,
+                 secret_id: pulumi.Input[str],
+                 environment: Optional[pulumi.Input[str]] = None,
+                 file: Optional[pulumi.Input[str]] = None,
+                 secret_reference_id: Optional[pulumi.Input[str]] = None,
+                 secret_version: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] secret_id: The secret unique identifier, it could be formatted as region/UUID or UUID. In case the region is passed, it must be the same as the job definition. You could reference the same secret multiple times in the same job definition.
+        :param pulumi.Input[str] environment: An environment variable containing the secret value. Must be specified if `file` is not specified.
+        :param pulumi.Input[str] file: The absolute file path where the secret will be mounted. Must be specified if `environment` is not specified.
+        :param pulumi.Input[str] secret_reference_id: The secret reference UUID that is automatically generated by the provider.
+        :param pulumi.Input[str] secret_version: The secret version.
+        """
+        pulumi.set(__self__, "secret_id", secret_id)
+        if environment is not None:
+            pulumi.set(__self__, "environment", environment)
+        if file is not None:
+            pulumi.set(__self__, "file", file)
+        if secret_reference_id is not None:
+            pulumi.set(__self__, "secret_reference_id", secret_reference_id)
+        if secret_version is not None:
+            pulumi.set(__self__, "secret_version", secret_version)
+
+    @property
+    @pulumi.getter(name="secretId")
+    def secret_id(self) -> pulumi.Input[str]:
+        """
+        The secret unique identifier, it could be formatted as region/UUID or UUID. In case the region is passed, it must be the same as the job definition. You could reference the same secret multiple times in the same job definition.
+        """
+        return pulumi.get(self, "secret_id")
+
+    @secret_id.setter
+    def secret_id(self, value: pulumi.Input[str]):
+        pulumi.set(self, "secret_id", value)
+
+    @property
+    @pulumi.getter
+    def environment(self) -> Optional[pulumi.Input[str]]:
+        """
+        An environment variable containing the secret value. Must be specified if `file` is not specified.
+        """
+        return pulumi.get(self, "environment")
+
+    @environment.setter
+    def environment(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "environment", value)
+
+    @property
+    @pulumi.getter
+    def file(self) -> Optional[pulumi.Input[str]]:
+        """
+        The absolute file path where the secret will be mounted. Must be specified if `environment` is not specified.
+        """
+        return pulumi.get(self, "file")
+
+    @file.setter
+    def file(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "file", value)
+
+    @property
+    @pulumi.getter(name="secretReferenceId")
+    def secret_reference_id(self) -> Optional[pulumi.Input[str]]:
+        """
+        The secret reference UUID that is automatically generated by the provider.
+        """
+        return pulumi.get(self, "secret_reference_id")
+
+    @secret_reference_id.setter
+    def secret_reference_id(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "secret_reference_id", value)
+
+    @property
+    @pulumi.getter(name="secretVersion")
+    def secret_version(self) -> Optional[pulumi.Input[str]]:
+        """
+        The secret version.
+        """
+        return pulumi.get(self, "secret_version")
+
+    @secret_version.setter
+    def secret_version(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "secret_version", value)
+
+
 if not MYPY:
     class KubernetesClusterAutoUpgradeArgsDict(TypedDict):
         enable: pulumi.Input[bool]
@@ -8406,6 +9030,158 @@ class SecretEphemeralPolicyArgs:
         pulumi.set(self, "ttl", value)
 
 
+if not MYPY:
+    class SecretVersionArgsDict(TypedDict):
+        created_at: NotRequired[pulumi.Input[str]]
+        """
+        Date and time of the secret's creation (in RFC 3339 format).
+        """
+        description: NotRequired[pulumi.Input[str]]
+        """
+        Description of the secret (e.g. `my-new-description`).
+        """
+        latest: NotRequired[pulumi.Input[bool]]
+        """
+        Returns true if the version is the latest.
+        """
+        revision: NotRequired[pulumi.Input[str]]
+        """
+        The revision of secret version
+        """
+        secret_id: NotRequired[pulumi.Input[str]]
+        """
+        The secret ID associated with this version
+        """
+        status: NotRequired[pulumi.Input[str]]
+        """
+        The status of the secret.
+        """
+        updated_at: NotRequired[pulumi.Input[str]]
+        """
+        Date and time of the secret's last update (in RFC 3339 format).
+        """
+elif False:
+    SecretVersionArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class SecretVersionArgs:
+    def __init__(__self__, *,
+                 created_at: Optional[pulumi.Input[str]] = None,
+                 description: Optional[pulumi.Input[str]] = None,
+                 latest: Optional[pulumi.Input[bool]] = None,
+                 revision: Optional[pulumi.Input[str]] = None,
+                 secret_id: Optional[pulumi.Input[str]] = None,
+                 status: Optional[pulumi.Input[str]] = None,
+                 updated_at: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] created_at: Date and time of the secret's creation (in RFC 3339 format).
+        :param pulumi.Input[str] description: Description of the secret (e.g. `my-new-description`).
+        :param pulumi.Input[bool] latest: Returns true if the version is the latest.
+        :param pulumi.Input[str] revision: The revision of secret version
+        :param pulumi.Input[str] secret_id: The secret ID associated with this version
+        :param pulumi.Input[str] status: The status of the secret.
+        :param pulumi.Input[str] updated_at: Date and time of the secret's last update (in RFC 3339 format).
+        """
+        if created_at is not None:
+            pulumi.set(__self__, "created_at", created_at)
+        if description is not None:
+            pulumi.set(__self__, "description", description)
+        if latest is not None:
+            pulumi.set(__self__, "latest", latest)
+        if revision is not None:
+            pulumi.set(__self__, "revision", revision)
+        if secret_id is not None:
+            pulumi.set(__self__, "secret_id", secret_id)
+        if status is not None:
+            pulumi.set(__self__, "status", status)
+        if updated_at is not None:
+            pulumi.set(__self__, "updated_at", updated_at)
+
+    @property
+    @pulumi.getter(name="createdAt")
+    def created_at(self) -> Optional[pulumi.Input[str]]:
+        """
+        Date and time of the secret's creation (in RFC 3339 format).
+        """
+        return pulumi.get(self, "created_at")
+
+    @created_at.setter
+    def created_at(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "created_at", value)
+
+    @property
+    @pulumi.getter
+    def description(self) -> Optional[pulumi.Input[str]]:
+        """
+        Description of the secret (e.g. `my-new-description`).
+        """
+        return pulumi.get(self, "description")
+
+    @description.setter
+    def description(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "description", value)
+
+    @property
+    @pulumi.getter
+    def latest(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Returns true if the version is the latest.
+        """
+        return pulumi.get(self, "latest")
+
+    @latest.setter
+    def latest(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "latest", value)
+
+    @property
+    @pulumi.getter
+    def revision(self) -> Optional[pulumi.Input[str]]:
+        """
+        The revision of secret version
+        """
+        return pulumi.get(self, "revision")
+
+    @revision.setter
+    def revision(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "revision", value)
+
+    @property
+    @pulumi.getter(name="secretId")
+    def secret_id(self) -> Optional[pulumi.Input[str]]:
+        """
+        The secret ID associated with this version
+        """
+        return pulumi.get(self, "secret_id")
+
+    @secret_id.setter
+    def secret_id(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "secret_id", value)
+
+    @property
+    @pulumi.getter
+    def status(self) -> Optional[pulumi.Input[str]]:
+        """
+        The status of the secret.
+        """
+        return pulumi.get(self, "status")
+
+    @status.setter
+    def status(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "status", value)
+
+    @property
+    @pulumi.getter(name="updatedAt")
+    def updated_at(self) -> Optional[pulumi.Input[str]]:
+        """
+        Date and time of the secret's last update (in RFC 3339 format).
+        """
+        return pulumi.get(self, "updated_at")
+
+    @updated_at.setter
+    def updated_at(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "updated_at", value)
+
+
 if not MYPY:
     class TemDomainReputationArgsDict(TypedDict):
         previous_score: NotRequired[pulumi.Input[int]]