pulumi-gcp 9.0.0a1__py3-none-any.whl → 9.0.0a1758219982__py3-none-any.whl

pulumi_gcp/saasruntime/outputs.py

@@ -13,9 +13,17 @@ if sys.version_info >= (3, 11):
 else:
     from typing_extensions import NotRequired, TypedDict, TypeAlias
 from .. import _utilities
+from . import outputs
 
 __all__ = [
     'SaaSLocation',
+    'UnitKindDependency',
+    'UnitKindInputVariableMapping',
+    'UnitKindInputVariableMappingFrom',
+    'UnitKindInputVariableMappingTo',
+    'UnitKindOutputVariableMapping',
+    'UnitKindOutputVariableMappingFrom',
+    'UnitKindOutputVariableMappingTo',
 ]
 
 @pulumi.output_type
@@ -37,3 +45,387 @@ class SaaSLocation(dict):
         return pulumi.get(self, "name")
 
 
+@pulumi.output_type
+class UnitKindDependency(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "unitKind":
+            suggest = "unit_kind"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in UnitKindDependency. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        UnitKindDependency.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        UnitKindDependency.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 alias: _builtins.str,
+                 unit_kind: _builtins.str):
+        """
+        :param _builtins.str alias: An alias for the dependency. Used for input variable mapping.
+        :param _builtins.str unit_kind: The unit kind of the dependency.
+        """
+        pulumi.set(__self__, "alias", alias)
+        pulumi.set(__self__, "unit_kind", unit_kind)
+
+    @_builtins.property
+    @pulumi.getter
+    def alias(self) -> _builtins.str:
+        """
+        An alias for the dependency. Used for input variable mapping.
+        """
+        return pulumi.get(self, "alias")
+
+    @_builtins.property
+    @pulumi.getter(name="unitKind")
+    def unit_kind(self) -> _builtins.str:
+        """
+        The unit kind of the dependency.
+        """
+        return pulumi.get(self, "unit_kind")
+
+
+@pulumi.output_type
+class UnitKindInputVariableMapping(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "from":
+            suggest = "from_"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in UnitKindInputVariableMapping. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        UnitKindInputVariableMapping.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        UnitKindInputVariableMapping.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 variable: _builtins.str,
+                 from_: Optional['outputs.UnitKindInputVariableMappingFrom'] = None,
+                 to: Optional['outputs.UnitKindInputVariableMappingTo'] = None):
+        """
+        :param _builtins.str variable: name of the variable
+        :param 'UnitKindInputVariableMappingFromArgs' from_: Output variables whose values will be passed on to dependencies
+               Structure is documented below.
+        :param 'UnitKindInputVariableMappingToArgs' to: Input variables whose values will be passed on to dependencies
+               Structure is documented below.
+        """
+        pulumi.set(__self__, "variable", variable)
+        if from_ is not None:
+            pulumi.set(__self__, "from_", from_)
+        if to is not None:
+            pulumi.set(__self__, "to", to)
+
+    @_builtins.property
+    @pulumi.getter
+    def variable(self) -> _builtins.str:
+        """
+        name of the variable
+        """
+        return pulumi.get(self, "variable")
+
+    @_builtins.property
+    @pulumi.getter(name="from")
+    def from_(self) -> Optional['outputs.UnitKindInputVariableMappingFrom']:
+        """
+        Output variables whose values will be passed on to dependencies
+        Structure is documented below.
+        """
+        return pulumi.get(self, "from_")
+
+    @_builtins.property
+    @pulumi.getter
+    def to(self) -> Optional['outputs.UnitKindInputVariableMappingTo']:
+        """
+        Input variables whose values will be passed on to dependencies
+        Structure is documented below.
+        """
+        return pulumi.get(self, "to")
+
+
+@pulumi.output_type
+class UnitKindInputVariableMappingFrom(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "outputVariable":
+            suggest = "output_variable"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in UnitKindInputVariableMappingFrom. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        UnitKindInputVariableMappingFrom.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        UnitKindInputVariableMappingFrom.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 dependency: _builtins.str,
+                 output_variable: _builtins.str):
+        """
+        :param _builtins.str dependency: Alias of the dependency that the outputVariable will pass its value to
+        :param _builtins.str output_variable: Name of the outputVariable on the dependency
+        """
+        pulumi.set(__self__, "dependency", dependency)
+        pulumi.set(__self__, "output_variable", output_variable)
+
+    @_builtins.property
+    @pulumi.getter
+    def dependency(self) -> _builtins.str:
+        """
+        Alias of the dependency that the outputVariable will pass its value to
+        """
+        return pulumi.get(self, "dependency")
+
+    @_builtins.property
+    @pulumi.getter(name="outputVariable")
+    def output_variable(self) -> _builtins.str:
+        """
+        Name of the outputVariable on the dependency
+        """
+        return pulumi.get(self, "output_variable")
+
+
+@pulumi.output_type
+class UnitKindInputVariableMappingTo(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "inputVariable":
+            suggest = "input_variable"
+        elif key == "ignoreForLookup":
+            suggest = "ignore_for_lookup"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in UnitKindInputVariableMappingTo. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        UnitKindInputVariableMappingTo.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        UnitKindInputVariableMappingTo.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 dependency: _builtins.str,
+                 input_variable: _builtins.str,
+                 ignore_for_lookup: Optional[_builtins.bool] = None):
+        """
+        :param _builtins.str dependency: Alias of the dependency that the inputVariable will pass its value to
+        :param _builtins.str input_variable: Name of the inputVariable on the dependency
+        :param _builtins.bool ignore_for_lookup: Tells SaaS Runtime if this mapping should be used during lookup or not
+        """
+        pulumi.set(__self__, "dependency", dependency)
+        pulumi.set(__self__, "input_variable", input_variable)
+        if ignore_for_lookup is not None:
+            pulumi.set(__self__, "ignore_for_lookup", ignore_for_lookup)
+
+    @_builtins.property
+    @pulumi.getter
+    def dependency(self) -> _builtins.str:
+        """
+        Alias of the dependency that the inputVariable will pass its value to
+        """
+        return pulumi.get(self, "dependency")
+
+    @_builtins.property
+    @pulumi.getter(name="inputVariable")
+    def input_variable(self) -> _builtins.str:
+        """
+        Name of the inputVariable on the dependency
+        """
+        return pulumi.get(self, "input_variable")
+
+    @_builtins.property
+    @pulumi.getter(name="ignoreForLookup")
+    def ignore_for_lookup(self) -> Optional[_builtins.bool]:
+        """
+        Tells SaaS Runtime if this mapping should be used during lookup or not
+        """
+        return pulumi.get(self, "ignore_for_lookup")
+
+
+@pulumi.output_type
+class UnitKindOutputVariableMapping(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "from":
+            suggest = "from_"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in UnitKindOutputVariableMapping. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        UnitKindOutputVariableMapping.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        UnitKindOutputVariableMapping.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 variable: _builtins.str,
+                 from_: Optional['outputs.UnitKindOutputVariableMappingFrom'] = None,
+                 to: Optional['outputs.UnitKindOutputVariableMappingTo'] = None):
+        """
+        :param _builtins.str variable: name of the variable
+        :param 'UnitKindOutputVariableMappingFromArgs' from_: Output variables whose values will be passed on to dependencies
+               Structure is documented below.
+        :param 'UnitKindOutputVariableMappingToArgs' to: Input variables whose values will be passed on to dependencies
+               Structure is documented below.
+        """
+        pulumi.set(__self__, "variable", variable)
+        if from_ is not None:
+            pulumi.set(__self__, "from_", from_)
+        if to is not None:
+            pulumi.set(__self__, "to", to)
+
+    @_builtins.property
+    @pulumi.getter
+    def variable(self) -> _builtins.str:
+        """
+        name of the variable
+        """
+        return pulumi.get(self, "variable")
+
+    @_builtins.property
+    @pulumi.getter(name="from")
+    def from_(self) -> Optional['outputs.UnitKindOutputVariableMappingFrom']:
+        """
+        Output variables whose values will be passed on to dependencies
+        Structure is documented below.
+        """
+        return pulumi.get(self, "from_")
+
+    @_builtins.property
+    @pulumi.getter
+    def to(self) -> Optional['outputs.UnitKindOutputVariableMappingTo']:
+        """
+        Input variables whose values will be passed on to dependencies
+        Structure is documented below.
+        """
+        return pulumi.get(self, "to")
+
+
+@pulumi.output_type
+class UnitKindOutputVariableMappingFrom(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "outputVariable":
+            suggest = "output_variable"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in UnitKindOutputVariableMappingFrom. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        UnitKindOutputVariableMappingFrom.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        UnitKindOutputVariableMappingFrom.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 dependency: _builtins.str,
+                 output_variable: _builtins.str):
+        """
+        :param _builtins.str dependency: Alias of the dependency that the outputVariable will pass its value to
+        :param _builtins.str output_variable: Name of the outputVariable on the dependency
+        """
+        pulumi.set(__self__, "dependency", dependency)
+        pulumi.set(__self__, "output_variable", output_variable)
+
+    @_builtins.property
+    @pulumi.getter
+    def dependency(self) -> _builtins.str:
+        """
+        Alias of the dependency that the outputVariable will pass its value to
+        """
+        return pulumi.get(self, "dependency")
+
+    @_builtins.property
+    @pulumi.getter(name="outputVariable")
+    def output_variable(self) -> _builtins.str:
+        """
+        Name of the outputVariable on the dependency
+        """
+        return pulumi.get(self, "output_variable")
+
+
+@pulumi.output_type
+class UnitKindOutputVariableMappingTo(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "inputVariable":
+            suggest = "input_variable"
+        elif key == "ignoreForLookup":
+            suggest = "ignore_for_lookup"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in UnitKindOutputVariableMappingTo. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        UnitKindOutputVariableMappingTo.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        UnitKindOutputVariableMappingTo.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 dependency: _builtins.str,
+                 input_variable: _builtins.str,
+                 ignore_for_lookup: Optional[_builtins.bool] = None):
+        """
+        :param _builtins.str dependency: Alias of the dependency that the inputVariable will pass its value to
+        :param _builtins.str input_variable: Name of the inputVariable on the dependency
+        :param _builtins.bool ignore_for_lookup: Tells SaaS Runtime if this mapping should be used during lookup or not
+        """
+        pulumi.set(__self__, "dependency", dependency)
+        pulumi.set(__self__, "input_variable", input_variable)
+        if ignore_for_lookup is not None:
+            pulumi.set(__self__, "ignore_for_lookup", ignore_for_lookup)
+
+    @_builtins.property
+    @pulumi.getter
+    def dependency(self) -> _builtins.str:
+        """
+        Alias of the dependency that the inputVariable will pass its value to
+        """
+        return pulumi.get(self, "dependency")
+
+    @_builtins.property
+    @pulumi.getter(name="inputVariable")
+    def input_variable(self) -> _builtins.str:
+        """
+        Name of the inputVariable on the dependency
+        """
+        return pulumi.get(self, "input_variable")
+
+    @_builtins.property
+    @pulumi.getter(name="ignoreForLookup")
+    def ignore_for_lookup(self) -> Optional[_builtins.bool]:
+        """
+        Tells SaaS Runtime if this mapping should be used during lookup or not
+        """
+        return pulumi.get(self, "ignore_for_lookup")
+
+

pulumi_gcp/saasruntime/saa_s.py

@@ -428,6 +428,8 @@ class SaaS(pulumi.CustomResource):
                  saas_id: Optional[pulumi.Input[_builtins.str]] = None,
                  __props__=None):
         """
+        A Saas resource is the top-level representation of a SaaS service managed by a producer. It contains a list of locations where the service is available, which is used by the Rollout system to generate a rollout plan.
+
         ## Example Usage
 
         ### Saas Runtime Saas Basic
@@ -500,6 +502,8 @@ class SaaS(pulumi.CustomResource):
                  args: SaaSArgs,
                  opts: Optional[pulumi.ResourceOptions] = None):
         """
+        A Saas resource is the top-level representation of a SaaS service managed by a producer. It contains a list of locations where the service is available, which is used by the Rollout system to generate a rollout plan.
+
         ## Example Usage
 
         ### Saas Runtime Saas Basic