pulumi-gcp 7.29.0a1719416802__py3-none-any.whl → 7.30.0__py3-none-any.whl

pulumi_gcp/cloudfunctionsv2/_inputs.py

@@ -4,38 +4,120 @@
 
 import copy
 import warnings
+import sys
 import pulumi
 import pulumi.runtime
 from typing import Any, Mapping, Optional, Sequence, Union, overload
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, TypedDict, TypeAlias
+else:
+    from typing_extensions import NotRequired, TypedDict, TypeAlias
 from .. import _utilities
 
 __all__ = [
     'FunctionBuildConfigArgs',
+    'FunctionBuildConfigArgsDict',
+    'FunctionBuildConfigAutomaticUpdatePolicyArgs',
+    'FunctionBuildConfigAutomaticUpdatePolicyArgsDict',
+    'FunctionBuildConfigOnDeployUpdatePolicyArgs',
+    'FunctionBuildConfigOnDeployUpdatePolicyArgsDict',
     'FunctionBuildConfigSourceArgs',
+    'FunctionBuildConfigSourceArgsDict',
     'FunctionBuildConfigSourceRepoSourceArgs',
+    'FunctionBuildConfigSourceRepoSourceArgsDict',
     'FunctionBuildConfigSourceStorageSourceArgs',
+    'FunctionBuildConfigSourceStorageSourceArgsDict',
     'FunctionEventTriggerArgs',
+    'FunctionEventTriggerArgsDict',
     'FunctionEventTriggerEventFilterArgs',
+    'FunctionEventTriggerEventFilterArgsDict',
     'FunctionIamBindingConditionArgs',
+    'FunctionIamBindingConditionArgsDict',
     'FunctionIamMemberConditionArgs',
+    'FunctionIamMemberConditionArgsDict',
     'FunctionServiceConfigArgs',
+    'FunctionServiceConfigArgsDict',
     'FunctionServiceConfigSecretEnvironmentVariableArgs',
+    'FunctionServiceConfigSecretEnvironmentVariableArgsDict',
     'FunctionServiceConfigSecretVolumeArgs',
+    'FunctionServiceConfigSecretVolumeArgsDict',
     'FunctionServiceConfigSecretVolumeVersionArgs',
+    'FunctionServiceConfigSecretVolumeVersionArgsDict',
 ]
 
+MYPY = False
+
+if not MYPY:
+    class FunctionBuildConfigArgsDict(TypedDict):
+        automatic_update_policy: NotRequired[pulumi.Input['FunctionBuildConfigAutomaticUpdatePolicyArgsDict']]
+        """
+        Security patches are applied automatically to the runtime without requiring
+        the function to be redeployed.
+        """
+        build: NotRequired[pulumi.Input[str]]
+        """
+        (Output)
+        The Cloud Build name of the latest successful
+        deployment of the function.
+        """
+        docker_repository: NotRequired[pulumi.Input[str]]
+        """
+        User managed repository created in Artifact Registry optionally with a customer managed encryption key.
+        """
+        entry_point: NotRequired[pulumi.Input[str]]
+        """
+        The name of the function (as defined in source code) that will be executed.
+        Defaults to the resource name suffix, if not specified. For backward
+        compatibility, if function with given name is not found, then the system
+        will try to use function named "function". For Node.js this is name of a
+        function exported by the module specified in source_location.
+        """
+        environment_variables: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        User-provided build-time environment variables for the function.
+        """
+        on_deploy_update_policy: NotRequired[pulumi.Input['FunctionBuildConfigOnDeployUpdatePolicyArgsDict']]
+        """
+        Security patches are only applied when a function is redeployed.
+        Structure is documented below.
+        """
+        runtime: NotRequired[pulumi.Input[str]]
+        """
+        The runtime in which to run the function. Required when deploying a new
+        function, optional when updating an existing function.
+        """
+        service_account: NotRequired[pulumi.Input[str]]
+        """
+        The fully-qualified name of the service account to be used for building the container.
+        """
+        source: NotRequired[pulumi.Input['FunctionBuildConfigSourceArgsDict']]
+        """
+        The location of the function source code.
+        Structure is documented below.
+        """
+        worker_pool: NotRequired[pulumi.Input[str]]
+        """
+        Name of the Cloud Build Custom Worker Pool that should be used to build the function.
+        """
+elif False:
+    FunctionBuildConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class FunctionBuildConfigArgs:
     def __init__(__self__, *,
+                 automatic_update_policy: Optional[pulumi.Input['FunctionBuildConfigAutomaticUpdatePolicyArgs']] = None,
                  build: Optional[pulumi.Input[str]] = None,
                  docker_repository: Optional[pulumi.Input[str]] = None,
                  entry_point: Optional[pulumi.Input[str]] = None,
                  environment_variables: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
+                 on_deploy_update_policy: Optional[pulumi.Input['FunctionBuildConfigOnDeployUpdatePolicyArgs']] = None,
                  runtime: Optional[pulumi.Input[str]] = None,
                  service_account: Optional[pulumi.Input[str]] = None,
                  source: Optional[pulumi.Input['FunctionBuildConfigSourceArgs']] = None,
                  worker_pool: Optional[pulumi.Input[str]] = None):
         """
+        :param pulumi.Input['FunctionBuildConfigAutomaticUpdatePolicyArgs'] automatic_update_policy: Security patches are applied automatically to the runtime without requiring
+               the function to be redeployed.
         :param pulumi.Input[str] build: (Output)
                The Cloud Build name of the latest successful
                deployment of the function.
@@ -46,6 +128,8 @@ class FunctionBuildConfigArgs:
                will try to use function named "function". For Node.js this is name of a
                function exported by the module specified in source_location.
         :param pulumi.Input[Mapping[str, pulumi.Input[str]]] environment_variables: User-provided build-time environment variables for the function.
+        :param pulumi.Input['FunctionBuildConfigOnDeployUpdatePolicyArgs'] on_deploy_update_policy: Security patches are only applied when a function is redeployed.
+               Structure is documented below.
         :param pulumi.Input[str] runtime: The runtime in which to run the function. Required when deploying a new
                function, optional when updating an existing function.
         :param pulumi.Input[str] service_account: The fully-qualified name of the service account to be used for building the container.
@@ -53,6 +137,8 @@ class FunctionBuildConfigArgs:
                Structure is documented below.
         :param pulumi.Input[str] worker_pool: Name of the Cloud Build Custom Worker Pool that should be used to build the function.
         """
+        if automatic_update_policy is not None:
+            pulumi.set(__self__, "automatic_update_policy", automatic_update_policy)
         if build is not None:
             pulumi.set(__self__, "build", build)
         if docker_repository is not None:
@@ -61,6 +147,8 @@ class FunctionBuildConfigArgs:
             pulumi.set(__self__, "entry_point", entry_point)
         if environment_variables is not None:
             pulumi.set(__self__, "environment_variables", environment_variables)
+        if on_deploy_update_policy is not None:
+            pulumi.set(__self__, "on_deploy_update_policy", on_deploy_update_policy)
         if runtime is not None:
             pulumi.set(__self__, "runtime", runtime)
         if service_account is not None:
@@ -70,6 +158,19 @@ class FunctionBuildConfigArgs:
         if worker_pool is not None:
             pulumi.set(__self__, "worker_pool", worker_pool)
 
+    @property
+    @pulumi.getter(name="automaticUpdatePolicy")
+    def automatic_update_policy(self) -> Optional[pulumi.Input['FunctionBuildConfigAutomaticUpdatePolicyArgs']]:
+        """
+        Security patches are applied automatically to the runtime without requiring
+        the function to be redeployed.
+        """
+        return pulumi.get(self, "automatic_update_policy")
+
+    @automatic_update_policy.setter
+    def automatic_update_policy(self, value: Optional[pulumi.Input['FunctionBuildConfigAutomaticUpdatePolicyArgs']]):
+        pulumi.set(self, "automatic_update_policy", value)
+
     @property
     @pulumi.getter
     def build(self) -> Optional[pulumi.Input[str]]:
@@ -124,6 +225,19 @@ class FunctionBuildConfigArgs:
     def environment_variables(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
         pulumi.set(self, "environment_variables", value)
 
+    @property
+    @pulumi.getter(name="onDeployUpdatePolicy")
+    def on_deploy_update_policy(self) -> Optional[pulumi.Input['FunctionBuildConfigOnDeployUpdatePolicyArgs']]:
+        """
+        Security patches are only applied when a function is redeployed.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "on_deploy_update_policy")
+
+    @on_deploy_update_policy.setter
+    def on_deploy_update_policy(self, value: Optional[pulumi.Input['FunctionBuildConfigOnDeployUpdatePolicyArgs']]):
+        pulumi.set(self, "on_deploy_update_policy", value)
+
     @property
     @pulumi.getter
     def runtime(self) -> Optional[pulumi.Input[str]]:
@@ -175,6 +289,68 @@ class FunctionBuildConfigArgs:
         pulumi.set(self, "worker_pool", value)
 
 
+if not MYPY:
+    class FunctionBuildConfigAutomaticUpdatePolicyArgsDict(TypedDict):
+        pass
+elif False:
+    FunctionBuildConfigAutomaticUpdatePolicyArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class FunctionBuildConfigAutomaticUpdatePolicyArgs:
+    def __init__(__self__):
+        pass
+
+
+if not MYPY:
+    class FunctionBuildConfigOnDeployUpdatePolicyArgsDict(TypedDict):
+        runtime_version: NotRequired[pulumi.Input[str]]
+        """
+        (Output)
+        The runtime version which was used during latest function deployment.
+        """
+elif False:
+    FunctionBuildConfigOnDeployUpdatePolicyArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class FunctionBuildConfigOnDeployUpdatePolicyArgs:
+    def __init__(__self__, *,
+                 runtime_version: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] runtime_version: (Output)
+               The runtime version which was used during latest function deployment.
+        """
+        if runtime_version is not None:
+            pulumi.set(__self__, "runtime_version", runtime_version)
+
+    @property
+    @pulumi.getter(name="runtimeVersion")
+    def runtime_version(self) -> Optional[pulumi.Input[str]]:
+        """
+        (Output)
+        The runtime version which was used during latest function deployment.
+        """
+        return pulumi.get(self, "runtime_version")
+
+    @runtime_version.setter
+    def runtime_version(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "runtime_version", value)
+
+
+if not MYPY:
+    class FunctionBuildConfigSourceArgsDict(TypedDict):
+        repo_source: NotRequired[pulumi.Input['FunctionBuildConfigSourceRepoSourceArgsDict']]
+        """
+        If provided, get the source from this location in a Cloud Source Repository.
+        Structure is documented below.
+        """
+        storage_source: NotRequired[pulumi.Input['FunctionBuildConfigSourceStorageSourceArgsDict']]
+        """
+        If provided, get the source from this location in Google Cloud Storage.
+        Structure is documented below.
+        """
+elif False:
+    FunctionBuildConfigSourceArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class FunctionBuildConfigSourceArgs:
     def __init__(__self__, *,
@@ -218,6 +394,41 @@ class FunctionBuildConfigSourceArgs:
         pulumi.set(self, "storage_source", value)
 
 
+if not MYPY:
+    class FunctionBuildConfigSourceRepoSourceArgsDict(TypedDict):
+        branch_name: NotRequired[pulumi.Input[str]]
+        """
+        Regex matching branches to build.
+        """
+        commit_sha: NotRequired[pulumi.Input[str]]
+        """
+        Regex matching tags to build.
+        """
+        dir: NotRequired[pulumi.Input[str]]
+        """
+        Directory, relative to the source root, in which to run the build.
+        """
+        invert_regex: NotRequired[pulumi.Input[bool]]
+        """
+        Only trigger a build if the revision regex does
+        NOT match the revision regex.
+        """
+        project_id: NotRequired[pulumi.Input[str]]
+        """
+        ID of the project that owns the Cloud Source Repository. If omitted, the
+        project ID requesting the build is assumed.
+        """
+        repo_name: NotRequired[pulumi.Input[str]]
+        """
+        Name of the Cloud Source Repository.
+        """
+        tag_name: NotRequired[pulumi.Input[str]]
+        """
+        Regex matching tags to build.
+        """
+elif False:
+    FunctionBuildConfigSourceRepoSourceArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class FunctionBuildConfigSourceRepoSourceArgs:
     def __init__(__self__, *,
@@ -341,6 +552,24 @@ class FunctionBuildConfigSourceRepoSourceArgs:
         pulumi.set(self, "tag_name", value)
 
 
+if not MYPY:
+    class FunctionBuildConfigSourceStorageSourceArgsDict(TypedDict):
+        bucket: NotRequired[pulumi.Input[str]]
+        """
+        Google Cloud Storage bucket containing the source
+        """
+        generation: NotRequired[pulumi.Input[int]]
+        """
+        Google Cloud Storage generation for the object. If the generation
+        is omitted, the latest generation will be used.
+        """
+        object: NotRequired[pulumi.Input[str]]
+        """
+        Google Cloud Storage object containing the source.
+        """
+elif False:
+    FunctionBuildConfigSourceStorageSourceArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class FunctionBuildConfigSourceStorageSourceArgs:
     def __init__(__self__, *,
@@ -398,6 +627,49 @@ class FunctionBuildConfigSourceStorageSourceArgs:
         pulumi.set(self, "object", value)
 
 
+if not MYPY:
+    class FunctionEventTriggerArgsDict(TypedDict):
+        event_filters: NotRequired[pulumi.Input[Sequence[pulumi.Input['FunctionEventTriggerEventFilterArgsDict']]]]
+        """
+        Criteria used to filter events.
+        Structure is documented below.
+        """
+        event_type: NotRequired[pulumi.Input[str]]
+        """
+        Required. The type of event to observe.
+        """
+        pubsub_topic: NotRequired[pulumi.Input[str]]
+        """
+        The name of a Pub/Sub topic in the same project that will be used
+        as the transport topic for the event delivery.
+        """
+        retry_policy: NotRequired[pulumi.Input[str]]
+        """
+        Describes the retry policy in case of function's execution failure.
+        Retried execution is charged as any other execution.
+        Possible values are: `RETRY_POLICY_UNSPECIFIED`, `RETRY_POLICY_DO_NOT_RETRY`, `RETRY_POLICY_RETRY`.
+        """
+        service_account_email: NotRequired[pulumi.Input[str]]
+        """
+        Optional. The email of the trigger's service account. The service account
+        must have permission to invoke Cloud Run services. If empty, defaults to the
+        Compute Engine default service account: {project_number}-compute@developer.gserviceaccount.com.
+        """
+        trigger: NotRequired[pulumi.Input[str]]
+        """
+        (Output)
+        Output only. The resource name of the Eventarc trigger.
+        """
+        trigger_region: NotRequired[pulumi.Input[str]]
+        """
+        The region that the trigger will be in. The trigger will only receive
+        events originating in this region. It can be the same
+        region as the function, a different region or multi-region, or the global
+        region. If not provided, defaults to the same region as the function.
+        """
+elif False:
+    FunctionEventTriggerArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class FunctionEventTriggerArgs:
     def __init__(__self__, *,
@@ -537,6 +809,30 @@ class FunctionEventTriggerArgs:
         pulumi.set(self, "trigger_region", value)
 
 
+if not MYPY:
+    class FunctionEventTriggerEventFilterArgsDict(TypedDict):
+        attribute: pulumi.Input[str]
+        """
+        'Required. The name of a CloudEvents attribute.
+        Currently, only a subset of attributes are supported for filtering. Use the `gcloud eventarc providers describe` command to learn more about events and their attributes.
+        Do not filter for the 'type' attribute here, as this is already achieved by the resource's `event_type` attribute.
+        """
+        value: pulumi.Input[str]
+        """
+        Required. The value for the attribute.
+        If the operator field is set as `match-path-pattern`, this value can be a path pattern instead of an exact value.
+        """
+        operator: NotRequired[pulumi.Input[str]]
+        """
+        Optional. The operator used for matching the events with the value of
+        the filter. If not specified, only events that have an exact key-value
+        pair specified in the filter are matched.
+        The only allowed value is `match-path-pattern`.
+        [See documentation on path patterns here](https://cloud.google.com/eventarc/docs/path-patterns)'
+        """
+elif False:
+    FunctionEventTriggerEventFilterArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class FunctionEventTriggerEventFilterArgs:
     def __init__(__self__, *,
@@ -604,6 +900,14 @@ class FunctionEventTriggerEventFilterArgs:
         pulumi.set(self, "operator", value)
 
 
+if not MYPY:
+    class FunctionIamBindingConditionArgsDict(TypedDict):
+        expression: pulumi.Input[str]
+        title: pulumi.Input[str]
+        description: NotRequired[pulumi.Input[str]]
+elif False:
+    FunctionIamBindingConditionArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class FunctionIamBindingConditionArgs:
     def __init__(__self__, *,
@@ -643,6 +947,14 @@ class FunctionIamBindingConditionArgs:
         pulumi.set(self, "description", value)
 
 
+if not MYPY:
+    class FunctionIamMemberConditionArgsDict(TypedDict):
+        expression: pulumi.Input[str]
+        title: pulumi.Input[str]
+        description: NotRequired[pulumi.Input[str]]
+elif False:
+    FunctionIamMemberConditionArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class FunctionIamMemberConditionArgs:
     def __init__(__self__, *,
@@ -682,6 +994,92 @@ class FunctionIamMemberConditionArgs:
         pulumi.set(self, "description", value)
 
 
+if not MYPY:
+    class FunctionServiceConfigArgsDict(TypedDict):
+        all_traffic_on_latest_revision: NotRequired[pulumi.Input[bool]]
+        """
+        Whether 100% of traffic is routed to the latest revision. Defaults to true.
+        """
+        available_cpu: NotRequired[pulumi.Input[str]]
+        """
+        The number of CPUs used in a single container instance. Default value is calculated from available memory.
+        """
+        available_memory: NotRequired[pulumi.Input[str]]
+        """
+        The amount of memory available for a function.
+        Defaults to 256M. Supported units are k, M, G, Mi, Gi. If no unit is
+        supplied the value is interpreted as bytes.
+        """
+        environment_variables: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        Environment variables that shall be available during function execution.
+        """
+        gcf_uri: NotRequired[pulumi.Input[str]]
+        """
+        (Output)
+        URIs of the Service deployed
+        """
+        ingress_settings: NotRequired[pulumi.Input[str]]
+        """
+        Available ingress settings. Defaults to "ALLOW_ALL" if unspecified.
+        Default value is `ALLOW_ALL`.
+        Possible values are: `ALLOW_ALL`, `ALLOW_INTERNAL_ONLY`, `ALLOW_INTERNAL_AND_GCLB`.
+        """
+        max_instance_count: NotRequired[pulumi.Input[int]]
+        """
+        The limit on the maximum number of function instances that may coexist at a
+        given time.
+        """
+        max_instance_request_concurrency: NotRequired[pulumi.Input[int]]
+        """
+        Sets the maximum number of concurrent requests that each instance can receive. Defaults to 1.
+        """
+        min_instance_count: NotRequired[pulumi.Input[int]]
+        """
+        The limit on the minimum number of function instances that may coexist at a
+        given time.
+        """
+        secret_environment_variables: NotRequired[pulumi.Input[Sequence[pulumi.Input['FunctionServiceConfigSecretEnvironmentVariableArgsDict']]]]
+        """
+        Secret environment variables configuration.
+        Structure is documented below.
+        """
+        secret_volumes: NotRequired[pulumi.Input[Sequence[pulumi.Input['FunctionServiceConfigSecretVolumeArgsDict']]]]
+        """
+        Secret volumes configuration.
+        Structure is documented below.
+        """
+        service: NotRequired[pulumi.Input[str]]
+        """
+        Name of the service associated with a Function.
+        """
+        service_account_email: NotRequired[pulumi.Input[str]]
+        """
+        The email of the service account for this function.
+        """
+        timeout_seconds: NotRequired[pulumi.Input[int]]
+        """
+        The function execution timeout. Execution is considered failed and
+        can be terminated if the function is not completed at the end of the
+        timeout period. Defaults to 60 seconds.
+        """
+        uri: NotRequired[pulumi.Input[str]]
+        """
+        (Output)
+        URI of the Service deployed.
+        """
+        vpc_connector: NotRequired[pulumi.Input[str]]
+        """
+        The Serverless VPC Access connector that this cloud function can connect to.
+        """
+        vpc_connector_egress_settings: NotRequired[pulumi.Input[str]]
+        """
+        Available egress settings.
+        Possible values are: `VPC_CONNECTOR_EGRESS_SETTINGS_UNSPECIFIED`, `PRIVATE_RANGES_ONLY`, `ALL_TRAFFIC`.
+        """
+elif False:
+    FunctionServiceConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class FunctionServiceConfigArgs:
     def __init__(__self__, *,
@@ -987,6 +1385,27 @@ class FunctionServiceConfigArgs:
         pulumi.set(self, "vpc_connector_egress_settings", value)
 
 
+if not MYPY:
+    class FunctionServiceConfigSecretEnvironmentVariableArgsDict(TypedDict):
+        key: pulumi.Input[str]
+        """
+        Name of the environment variable.
+        """
+        project_id: pulumi.Input[str]
+        """
+        Project identifier (preferrably project number but can also be the project ID) of the project that contains the secret. If not set, it will be populated with the function's project assuming that the secret exists in the same project as of the function.
+        """
+        secret: pulumi.Input[str]
+        """
+        Name of the secret in secret manager (not the full resource name).
+        """
+        version: pulumi.Input[str]
+        """
+        Version of the secret (version number or the string 'latest'). It is recommended to use a numeric version for secret environment variables as any updates to the secret value is not reflected until new instances start.
+        """
+elif False:
+    FunctionServiceConfigSecretEnvironmentVariableArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class FunctionServiceConfigSecretEnvironmentVariableArgs:
     def __init__(__self__, *,
@@ -1054,6 +1473,28 @@ class FunctionServiceConfigSecretEnvironmentVariableArgs:
         pulumi.set(self, "version", value)
 
 
+if not MYPY:
+    class FunctionServiceConfigSecretVolumeArgsDict(TypedDict):
+        mount_path: pulumi.Input[str]
+        """
+        The path within the container to mount the secret volume. For example, setting the mountPath as /etc/secrets would mount the secret value files under the /etc/secrets directory. This directory will also be completely shadowed and unavailable to mount any other secrets. Recommended mount path: /etc/secrets
+        """
+        project_id: pulumi.Input[str]
+        """
+        Project identifier (preferrably project number but can also be the project ID) of the project that contains the secret. If not set, it will be populated with the function's project assuming that the secret exists in the same project as of the function.
+        """
+        secret: pulumi.Input[str]
+        """
+        Name of the secret in secret manager (not the full resource name).
+        """
+        versions: NotRequired[pulumi.Input[Sequence[pulumi.Input['FunctionServiceConfigSecretVolumeVersionArgsDict']]]]
+        """
+        List of secret versions to mount for this secret. If empty, the latest version of the secret will be made available in a file named after the secret under the mount point.'
+        Structure is documented below.
+        """
+elif False:
+    FunctionServiceConfigSecretVolumeArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class FunctionServiceConfigSecretVolumeArgs:
     def __init__(__self__, *,
@@ -1124,6 +1565,19 @@ class FunctionServiceConfigSecretVolumeArgs:
         pulumi.set(self, "versions", value)
 
 
+if not MYPY:
+    class FunctionServiceConfigSecretVolumeVersionArgsDict(TypedDict):
+        path: pulumi.Input[str]
+        """
+        Relative path of the file under the mount path where the secret value for this version will be fetched and made available. For example, setting the mountPath as '/etc/secrets' and path as secret_foo would mount the secret value file at /etc/secrets/secret_foo.
+        """
+        version: pulumi.Input[str]
+        """
+        Version of the secret (version number or the string 'latest'). It is preferable to use latest version with secret volumes as secret value changes are reflected immediately.
+        """
+elif False:
+    FunctionServiceConfigSecretVolumeVersionArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class FunctionServiceConfigSecretVolumeVersionArgs:
     def __init__(__self__, *,