pulumi-gcp 8.3.1a1727284265__py3-none-any.whl → 8.4.0a1727795436__py3-none-any.whl

pulumi_gcp/looker/instance.py

@@ -33,6 +33,8 @@ class InstanceArgs:
                  platform_edition: Optional[pulumi.Input[str]] = None,
                  private_ip_enabled: Optional[pulumi.Input[bool]] = None,
                  project: Optional[pulumi.Input[str]] = None,
+                 psc_config: Optional[pulumi.Input['InstancePscConfigArgs']] = None,
+                 psc_enabled: Optional[pulumi.Input[bool]] = None,
                  public_ip_enabled: Optional[pulumi.Input[bool]] = None,
                  region: Optional[pulumi.Input[str]] = None,
                  reserved_range: Optional[pulumi.Input[str]] = None,
@@ -75,6 +77,9 @@ class InstanceArgs:
         :param pulumi.Input[bool] private_ip_enabled: Whether private IP is enabled on the Looker instance.
         :param pulumi.Input[str] project: The ID of the project in which the resource belongs.
                If it is not provided, the provider project is used.
+        :param pulumi.Input['InstancePscConfigArgs'] psc_config: Information for Private Service Connect (PSC) setup for a Looker instance.
+               Structure is documented below.
+        :param pulumi.Input[bool] psc_enabled: Whether Public Service Connect (PSC) is enabled on the Looker instance
         :param pulumi.Input[bool] public_ip_enabled: Whether public IP is enabled on the Looker instance.
         :param pulumi.Input[str] region: The name of the Looker region of the instance.
         :param pulumi.Input[str] reserved_range: Name of a reserved IP address range within the consumer network, to be used for
@@ -112,6 +117,10 @@ class InstanceArgs:
             pulumi.set(__self__, "private_ip_enabled", private_ip_enabled)
         if project is not None:
             pulumi.set(__self__, "project", project)
+        if psc_config is not None:
+            pulumi.set(__self__, "psc_config", psc_config)
+        if psc_enabled is not None:
+            pulumi.set(__self__, "psc_enabled", psc_enabled)
         if public_ip_enabled is not None:
             pulumi.set(__self__, "public_ip_enabled", public_ip_enabled)
         if region is not None:
@@ -289,6 +298,31 @@ class InstanceArgs:
     def project(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "project", value)
 
+    @property
+    @pulumi.getter(name="pscConfig")
+    def psc_config(self) -> Optional[pulumi.Input['InstancePscConfigArgs']]:
+        """
+        Information for Private Service Connect (PSC) setup for a Looker instance.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "psc_config")
+
+    @psc_config.setter
+    def psc_config(self, value: Optional[pulumi.Input['InstancePscConfigArgs']]):
+        pulumi.set(self, "psc_config", value)
+
+    @property
+    @pulumi.getter(name="pscEnabled")
+    def psc_enabled(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Whether Public Service Connect (PSC) is enabled on the Looker instance
+        """
+        return pulumi.get(self, "psc_enabled")
+
+    @psc_enabled.setter
+    def psc_enabled(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "psc_enabled", value)
+
     @property
     @pulumi.getter(name="publicIpEnabled")
     def public_ip_enabled(self) -> Optional[pulumi.Input[bool]]:
@@ -367,6 +401,8 @@ class _InstanceState:
                  platform_edition: Optional[pulumi.Input[str]] = None,
                  private_ip_enabled: Optional[pulumi.Input[bool]] = None,
                  project: Optional[pulumi.Input[str]] = None,
+                 psc_config: Optional[pulumi.Input['InstancePscConfigArgs']] = None,
+                 psc_enabled: Optional[pulumi.Input[bool]] = None,
                  public_ip_enabled: Optional[pulumi.Input[bool]] = None,
                  region: Optional[pulumi.Input[str]] = None,
                  reserved_range: Optional[pulumi.Input[str]] = None,
@@ -417,6 +453,9 @@ class _InstanceState:
         :param pulumi.Input[bool] private_ip_enabled: Whether private IP is enabled on the Looker instance.
         :param pulumi.Input[str] project: The ID of the project in which the resource belongs.
                If it is not provided, the provider project is used.
+        :param pulumi.Input['InstancePscConfigArgs'] psc_config: Information for Private Service Connect (PSC) setup for a Looker instance.
+               Structure is documented below.
+        :param pulumi.Input[bool] psc_enabled: Whether Public Service Connect (PSC) is enabled on the Looker instance
         :param pulumi.Input[bool] public_ip_enabled: Whether public IP is enabled on the Looker instance.
         :param pulumi.Input[str] region: The name of the Looker region of the instance.
         :param pulumi.Input[str] reserved_range: Name of a reserved IP address range within the consumer network, to be used for
@@ -468,6 +507,10 @@ class _InstanceState:
             pulumi.set(__self__, "private_ip_enabled", private_ip_enabled)
         if project is not None:
             pulumi.set(__self__, "project", project)
+        if psc_config is not None:
+            pulumi.set(__self__, "psc_config", psc_config)
+        if psc_enabled is not None:
+            pulumi.set(__self__, "psc_enabled", psc_enabled)
         if public_ip_enabled is not None:
             pulumi.set(__self__, "public_ip_enabled", public_ip_enabled)
         if region is not None:
@@ -720,6 +763,31 @@ class _InstanceState:
     def project(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "project", value)
 
+    @property
+    @pulumi.getter(name="pscConfig")
+    def psc_config(self) -> Optional[pulumi.Input['InstancePscConfigArgs']]:
+        """
+        Information for Private Service Connect (PSC) setup for a Looker instance.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "psc_config")
+
+    @psc_config.setter
+    def psc_config(self, value: Optional[pulumi.Input['InstancePscConfigArgs']]):
+        pulumi.set(self, "psc_config", value)
+
+    @property
+    @pulumi.getter(name="pscEnabled")
+    def psc_enabled(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Whether Public Service Connect (PSC) is enabled on the Looker instance
+        """
+        return pulumi.get(self, "psc_enabled")
+
+    @psc_enabled.setter
+    def psc_enabled(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "psc_enabled", value)
+
     @property
     @pulumi.getter(name="publicIpEnabled")
     def public_ip_enabled(self) -> Optional[pulumi.Input[bool]]:
@@ -807,6 +875,8 @@ class Instance(pulumi.CustomResource):
                  platform_edition: Optional[pulumi.Input[str]] = None,
                  private_ip_enabled: Optional[pulumi.Input[bool]] = None,
                  project: Optional[pulumi.Input[str]] = None,
+                 psc_config: Optional[pulumi.Input[Union['InstancePscConfigArgs', 'InstancePscConfigArgsDict']]] = None,
+                 psc_enabled: Optional[pulumi.Input[bool]] = None,
                  public_ip_enabled: Optional[pulumi.Input[bool]] = None,
                  region: Optional[pulumi.Input[str]] = None,
                  reserved_range: Optional[pulumi.Input[str]] = None,
@@ -989,6 +1059,27 @@ class Instance(pulumi.CustomResource):
                 "domain": "my-custom-domain.com",
             })
         ```
+        ### Looker Instance Psc
+
+        ```python
+        import pulumi
+        import pulumi_gcp as gcp
+
+        looker_instance = gcp.looker.Instance("looker-instance",
+            name="my-instance",
+            platform_edition="LOOKER_CORE_ENTERPRISE_ANNUAL",
+            region="us-central1",
+            private_ip_enabled=False,
+            public_ip_enabled=False,
+            psc_enabled=True,
+            oauth_config={
+                "client_id": "my-client-id",
+                "client_secret": "my-client-secret",
+            },
+            psc_config={
+                "allowed_vpcs": ["projects/test-project/global/networks/test"],
+            })
+        ```
 
         ## Import
 
@@ -1058,6 +1149,9 @@ class Instance(pulumi.CustomResource):
         :param pulumi.Input[bool] private_ip_enabled: Whether private IP is enabled on the Looker instance.
         :param pulumi.Input[str] project: The ID of the project in which the resource belongs.
                If it is not provided, the provider project is used.
+        :param pulumi.Input[Union['InstancePscConfigArgs', 'InstancePscConfigArgsDict']] psc_config: Information for Private Service Connect (PSC) setup for a Looker instance.
+               Structure is documented below.
+        :param pulumi.Input[bool] psc_enabled: Whether Public Service Connect (PSC) is enabled on the Looker instance
         :param pulumi.Input[bool] public_ip_enabled: Whether public IP is enabled on the Looker instance.
         :param pulumi.Input[str] region: The name of the Looker region of the instance.
         :param pulumi.Input[str] reserved_range: Name of a reserved IP address range within the consumer network, to be used for
@@ -1254,6 +1348,27 @@ class Instance(pulumi.CustomResource):
                 "domain": "my-custom-domain.com",
             })
         ```
+        ### Looker Instance Psc
+
+        ```python
+        import pulumi
+        import pulumi_gcp as gcp
+
+        looker_instance = gcp.looker.Instance("looker-instance",
+            name="my-instance",
+            platform_edition="LOOKER_CORE_ENTERPRISE_ANNUAL",
+            region="us-central1",
+            private_ip_enabled=False,
+            public_ip_enabled=False,
+            psc_enabled=True,
+            oauth_config={
+                "client_id": "my-client-id",
+                "client_secret": "my-client-secret",
+            },
+            psc_config={
+                "allowed_vpcs": ["projects/test-project/global/networks/test"],
+            })
+        ```
 
         ## Import
 
@@ -1312,6 +1427,8 @@ class Instance(pulumi.CustomResource):
                  platform_edition: Optional[pulumi.Input[str]] = None,
                  private_ip_enabled: Optional[pulumi.Input[bool]] = None,
                  project: Optional[pulumi.Input[str]] = None,
+                 psc_config: Optional[pulumi.Input[Union['InstancePscConfigArgs', 'InstancePscConfigArgsDict']]] = None,
+                 psc_enabled: Optional[pulumi.Input[bool]] = None,
                  public_ip_enabled: Optional[pulumi.Input[bool]] = None,
                  region: Optional[pulumi.Input[str]] = None,
                  reserved_range: Optional[pulumi.Input[str]] = None,
@@ -1337,6 +1454,8 @@ class Instance(pulumi.CustomResource):
             __props__.__dict__["platform_edition"] = platform_edition
             __props__.__dict__["private_ip_enabled"] = private_ip_enabled
             __props__.__dict__["project"] = project
+            __props__.__dict__["psc_config"] = psc_config
+            __props__.__dict__["psc_enabled"] = psc_enabled
             __props__.__dict__["public_ip_enabled"] = public_ip_enabled
             __props__.__dict__["region"] = region
             __props__.__dict__["reserved_range"] = reserved_range
@@ -1376,6 +1495,8 @@ class Instance(pulumi.CustomResource):
             platform_edition: Optional[pulumi.Input[str]] = None,
             private_ip_enabled: Optional[pulumi.Input[bool]] = None,
             project: Optional[pulumi.Input[str]] = None,
+            psc_config: Optional[pulumi.Input[Union['InstancePscConfigArgs', 'InstancePscConfigArgsDict']]] = None,
+            psc_enabled: Optional[pulumi.Input[bool]] = None,
             public_ip_enabled: Optional[pulumi.Input[bool]] = None,
             region: Optional[pulumi.Input[str]] = None,
             reserved_range: Optional[pulumi.Input[str]] = None,
@@ -1431,6 +1552,9 @@ class Instance(pulumi.CustomResource):
         :param pulumi.Input[bool] private_ip_enabled: Whether private IP is enabled on the Looker instance.
         :param pulumi.Input[str] project: The ID of the project in which the resource belongs.
                If it is not provided, the provider project is used.
+        :param pulumi.Input[Union['InstancePscConfigArgs', 'InstancePscConfigArgsDict']] psc_config: Information for Private Service Connect (PSC) setup for a Looker instance.
+               Structure is documented below.
+        :param pulumi.Input[bool] psc_enabled: Whether Public Service Connect (PSC) is enabled on the Looker instance
         :param pulumi.Input[bool] public_ip_enabled: Whether public IP is enabled on the Looker instance.
         :param pulumi.Input[str] region: The name of the Looker region of the instance.
         :param pulumi.Input[str] reserved_range: Name of a reserved IP address range within the consumer network, to be used for
@@ -1468,6 +1592,8 @@ class Instance(pulumi.CustomResource):
         __props__.__dict__["platform_edition"] = platform_edition
         __props__.__dict__["private_ip_enabled"] = private_ip_enabled
         __props__.__dict__["project"] = project
+        __props__.__dict__["psc_config"] = psc_config
+        __props__.__dict__["psc_enabled"] = psc_enabled
         __props__.__dict__["public_ip_enabled"] = public_ip_enabled
         __props__.__dict__["region"] = region
         __props__.__dict__["reserved_range"] = reserved_range
@@ -1644,6 +1770,23 @@ class Instance(pulumi.CustomResource):
         """
         return pulumi.get(self, "project")
 
+    @property
+    @pulumi.getter(name="pscConfig")
+    def psc_config(self) -> pulumi.Output[Optional['outputs.InstancePscConfig']]:
+        """
+        Information for Private Service Connect (PSC) setup for a Looker instance.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "psc_config")
+
+    @property
+    @pulumi.getter(name="pscEnabled")
+    def psc_enabled(self) -> pulumi.Output[Optional[bool]]:
+        """
+        Whether Public Service Connect (PSC) is enabled on the Looker instance
+        """
+        return pulumi.get(self, "psc_enabled")
+
     @property
     @pulumi.getter(name="publicIpEnabled")
     def public_ip_enabled(self) -> pulumi.Output[Optional[bool]]:

pulumi_gcp/looker/outputs.py

@@ -26,6 +26,8 @@ __all__ = [
     'InstanceMaintenanceWindow',
     'InstanceMaintenanceWindowStartTime',
     'InstanceOauthConfig',
+    'InstancePscConfig',
+    'InstancePscConfigServiceAttachment',
     'InstanceUserMetadata',
 ]
 
@@ -547,6 +549,140 @@ class InstanceOauthConfig(dict):
         return pulumi.get(self, "client_secret")
 
 
+@pulumi.output_type
+class InstancePscConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "allowedVpcs":
+            suggest = "allowed_vpcs"
+        elif key == "lookerServiceAttachmentUri":
+            suggest = "looker_service_attachment_uri"
+        elif key == "serviceAttachments":
+            suggest = "service_attachments"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in InstancePscConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        InstancePscConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        InstancePscConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 allowed_vpcs: Optional[Sequence[str]] = None,
+                 looker_service_attachment_uri: Optional[str] = None,
+                 service_attachments: Optional[Sequence['outputs.InstancePscConfigServiceAttachment']] = None):
+        """
+        :param Sequence[str] allowed_vpcs: List of VPCs that are allowed ingress into the Looker instance.
+        :param str looker_service_attachment_uri: (Output)
+               URI of the Looker service attachment.
+        :param Sequence['InstancePscConfigServiceAttachmentArgs'] service_attachments: List of egress service attachment configurations.
+               Structure is documented below.
+        """
+        if allowed_vpcs is not None:
+            pulumi.set(__self__, "allowed_vpcs", allowed_vpcs)
+        if looker_service_attachment_uri is not None:
+            pulumi.set(__self__, "looker_service_attachment_uri", looker_service_attachment_uri)
+        if service_attachments is not None:
+            pulumi.set(__self__, "service_attachments", service_attachments)
+
+    @property
+    @pulumi.getter(name="allowedVpcs")
+    def allowed_vpcs(self) -> Optional[Sequence[str]]:
+        """
+        List of VPCs that are allowed ingress into the Looker instance.
+        """
+        return pulumi.get(self, "allowed_vpcs")
+
+    @property
+    @pulumi.getter(name="lookerServiceAttachmentUri")
+    def looker_service_attachment_uri(self) -> Optional[str]:
+        """
+        (Output)
+        URI of the Looker service attachment.
+        """
+        return pulumi.get(self, "looker_service_attachment_uri")
+
+    @property
+    @pulumi.getter(name="serviceAttachments")
+    def service_attachments(self) -> Optional[Sequence['outputs.InstancePscConfigServiceAttachment']]:
+        """
+        List of egress service attachment configurations.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "service_attachments")
+
+
+@pulumi.output_type
+class InstancePscConfigServiceAttachment(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "connectionStatus":
+            suggest = "connection_status"
+        elif key == "localFqdn":
+            suggest = "local_fqdn"
+        elif key == "targetServiceAttachmentUri":
+            suggest = "target_service_attachment_uri"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in InstancePscConfigServiceAttachment. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        InstancePscConfigServiceAttachment.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        InstancePscConfigServiceAttachment.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 connection_status: Optional[str] = None,
+                 local_fqdn: Optional[str] = None,
+                 target_service_attachment_uri: Optional[str] = None):
+        """
+        :param str connection_status: (Output)
+               Status of the service attachment connection.
+        :param str local_fqdn: Fully qualified domain name that will be used in the private DNS record created for the service attachment.
+        :param str target_service_attachment_uri: URI of the service attachment to connect to.
+        """
+        if connection_status is not None:
+            pulumi.set(__self__, "connection_status", connection_status)
+        if local_fqdn is not None:
+            pulumi.set(__self__, "local_fqdn", local_fqdn)
+        if target_service_attachment_uri is not None:
+            pulumi.set(__self__, "target_service_attachment_uri", target_service_attachment_uri)
+
+    @property
+    @pulumi.getter(name="connectionStatus")
+    def connection_status(self) -> Optional[str]:
+        """
+        (Output)
+        Status of the service attachment connection.
+        """
+        return pulumi.get(self, "connection_status")
+
+    @property
+    @pulumi.getter(name="localFqdn")
+    def local_fqdn(self) -> Optional[str]:
+        """
+        Fully qualified domain name that will be used in the private DNS record created for the service attachment.
+        """
+        return pulumi.get(self, "local_fqdn")
+
+    @property
+    @pulumi.getter(name="targetServiceAttachmentUri")
+    def target_service_attachment_uri(self) -> Optional[str]:
+        """
+        URI of the service attachment to connect to.
+        """
+        return pulumi.get(self, "target_service_attachment_uri")
+
+
 @pulumi.output_type
 class InstanceUserMetadata(dict):
     @staticmethod

pulumi_gcp/networkconnectivity/_inputs.py

@@ -737,6 +737,11 @@ if not MYPY:
         """
         The URIs of linked interconnect attachment resources
         """
+        include_import_ranges: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        IP ranges allowed to be included during import from hub (does not control transit connectivity).
+        The only allowed value for now is "ALL_IPV4_RANGES".
+        """
 elif False:
     SpokeLinkedInterconnectAttachmentsArgsDict: TypeAlias = Mapping[str, Any]
 
@@ -744,13 +749,18 @@ elif False:
 class SpokeLinkedInterconnectAttachmentsArgs:
     def __init__(__self__, *,
                  site_to_site_data_transfer: pulumi.Input[bool],
-                 uris: pulumi.Input[Sequence[pulumi.Input[str]]]):
+                 uris: pulumi.Input[Sequence[pulumi.Input[str]]],
+                 include_import_ranges: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
         """
         :param pulumi.Input[bool] site_to_site_data_transfer: A value that controls whether site-to-site data transfer is enabled for these resources. Note that data transfer is available only in supported locations.
         :param pulumi.Input[Sequence[pulumi.Input[str]]] uris: The URIs of linked interconnect attachment resources
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] include_import_ranges: IP ranges allowed to be included during import from hub (does not control transit connectivity).
+               The only allowed value for now is "ALL_IPV4_RANGES".
         """
         pulumi.set(__self__, "site_to_site_data_transfer", site_to_site_data_transfer)
         pulumi.set(__self__, "uris", uris)
+        if include_import_ranges is not None:
+            pulumi.set(__self__, "include_import_ranges", include_import_ranges)
 
     @property
     @pulumi.getter(name="siteToSiteDataTransfer")
@@ -776,6 +786,19 @@ class SpokeLinkedInterconnectAttachmentsArgs:
     def uris(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
         pulumi.set(self, "uris", value)
 
+    @property
+    @pulumi.getter(name="includeImportRanges")
+    def include_import_ranges(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        IP ranges allowed to be included during import from hub (does not control transit connectivity).
+        The only allowed value for now is "ALL_IPV4_RANGES".
+        """
+        return pulumi.get(self, "include_import_ranges")
+
+    @include_import_ranges.setter
+    def include_import_ranges(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "include_import_ranges", value)
+
 
 if not MYPY:
     class SpokeLinkedRouterApplianceInstancesArgsDict(TypedDict):
@@ -788,6 +811,11 @@ if not MYPY:
         """
         A value that controls whether site-to-site data transfer is enabled for these resources. Note that data transfer is available only in supported locations.
         """
+        include_import_ranges: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        IP ranges allowed to be included during import from hub (does not control transit connectivity).
+        The only allowed value for now is "ALL_IPV4_RANGES".
+        """
 elif False:
     SpokeLinkedRouterApplianceInstancesArgsDict: TypeAlias = Mapping[str, Any]
 
@@ -795,14 +823,19 @@ elif False:
 class SpokeLinkedRouterApplianceInstancesArgs:
     def __init__(__self__, *,
                  instances: pulumi.Input[Sequence[pulumi.Input['SpokeLinkedRouterApplianceInstancesInstanceArgs']]],
-                 site_to_site_data_transfer: pulumi.Input[bool]):
+                 site_to_site_data_transfer: pulumi.Input[bool],
+                 include_import_ranges: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
         """
         :param pulumi.Input[Sequence[pulumi.Input['SpokeLinkedRouterApplianceInstancesInstanceArgs']]] instances: The list of router appliance instances
                Structure is documented below.
         :param pulumi.Input[bool] site_to_site_data_transfer: A value that controls whether site-to-site data transfer is enabled for these resources. Note that data transfer is available only in supported locations.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] include_import_ranges: IP ranges allowed to be included during import from hub (does not control transit connectivity).
+               The only allowed value for now is "ALL_IPV4_RANGES".
         """
         pulumi.set(__self__, "instances", instances)
         pulumi.set(__self__, "site_to_site_data_transfer", site_to_site_data_transfer)
+        if include_import_ranges is not None:
+            pulumi.set(__self__, "include_import_ranges", include_import_ranges)
 
     @property
     @pulumi.getter
@@ -829,6 +862,19 @@ class SpokeLinkedRouterApplianceInstancesArgs:
     def site_to_site_data_transfer(self, value: pulumi.Input[bool]):
         pulumi.set(self, "site_to_site_data_transfer", value)
 
+    @property
+    @pulumi.getter(name="includeImportRanges")
+    def include_import_ranges(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        IP ranges allowed to be included during import from hub (does not control transit connectivity).
+        The only allowed value for now is "ALL_IPV4_RANGES".
+        """
+        return pulumi.get(self, "include_import_ranges")
+
+    @include_import_ranges.setter
+    def include_import_ranges(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "include_import_ranges", value)
+
 
 if not MYPY:
     class SpokeLinkedRouterApplianceInstancesInstanceArgsDict(TypedDict):
@@ -963,6 +1009,11 @@ if not MYPY:
         """
         The URIs of linked VPN tunnel resources.
         """
+        include_import_ranges: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        IP ranges allowed to be included during import from hub (does not control transit connectivity).
+        The only allowed value for now is "ALL_IPV4_RANGES".
+        """
 elif False:
     SpokeLinkedVpnTunnelsArgsDict: TypeAlias = Mapping[str, Any]
 
@@ -970,13 +1021,18 @@ elif False:
 class SpokeLinkedVpnTunnelsArgs:
     def __init__(__self__, *,
                  site_to_site_data_transfer: pulumi.Input[bool],
-                 uris: pulumi.Input[Sequence[pulumi.Input[str]]]):
+                 uris: pulumi.Input[Sequence[pulumi.Input[str]]],
+                 include_import_ranges: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
         """
         :param pulumi.Input[bool] site_to_site_data_transfer: A value that controls whether site-to-site data transfer is enabled for these resources. Note that data transfer is available only in supported locations.
         :param pulumi.Input[Sequence[pulumi.Input[str]]] uris: The URIs of linked VPN tunnel resources.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] include_import_ranges: IP ranges allowed to be included during import from hub (does not control transit connectivity).
+               The only allowed value for now is "ALL_IPV4_RANGES".
         """
         pulumi.set(__self__, "site_to_site_data_transfer", site_to_site_data_transfer)
         pulumi.set(__self__, "uris", uris)
+        if include_import_ranges is not None:
+            pulumi.set(__self__, "include_import_ranges", include_import_ranges)
 
     @property
     @pulumi.getter(name="siteToSiteDataTransfer")
@@ -1002,4 +1058,17 @@ class SpokeLinkedVpnTunnelsArgs:
     def uris(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
         pulumi.set(self, "uris", value)
 
+    @property
+    @pulumi.getter(name="includeImportRanges")
+    def include_import_ranges(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        IP ranges allowed to be included during import from hub (does not control transit connectivity).
+        The only allowed value for now is "ALL_IPV4_RANGES".
+        """
+        return pulumi.get(self, "include_import_ranges")
+
+    @include_import_ranges.setter
+    def include_import_ranges(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "include_import_ranges", value)
+