pulumi-std 2.3.0a1770334078__py3-none-any.whl

pulumi_std/rsadecrypt.py

@@ -0,0 +1,74 @@
+# coding=utf-8
+# *** WARNING: this file was generated by pulumi-language-python. ***
+# *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+import builtins as _builtins
+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__ = [
+    'RsadecryptResult',
+    'AwaitableRsadecryptResult',
+    'rsadecrypt',
+    'rsadecrypt_output',
+]
+
+@pulumi.output_type
+class RsadecryptResult:
+    def __init__(__self__, result=None):
+        if result and not isinstance(result, str):
+            raise TypeError("Expected argument 'result' to be a str")
+        pulumi.set(__self__, "result", result)
+
+    @_builtins.property
+    @pulumi.getter
+    def result(self) -> _builtins.str:
+        return pulumi.get(self, "result")
+
+
+class AwaitableRsadecryptResult(RsadecryptResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return RsadecryptResult(
+            result=self.result)
+
+
+def rsadecrypt(cipher_text: Optional[_builtins.str] = None,
+               key: Optional[_builtins.str] = None,
+               opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableRsadecryptResult:
+    """
+    Decrypts an RSA-encrypted ciphertext.
+    The cipher text must be base64-encoded and the key must be in PEM format.
+    """
+    __args__ = dict()
+    __args__['cipherText'] = cipher_text
+    __args__['key'] = key
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('std:index:rsadecrypt', __args__, opts=opts, typ=RsadecryptResult).value
+
+    return AwaitableRsadecryptResult(
+        result=pulumi.get(__ret__, 'result'))
+def rsadecrypt_output(cipher_text: Optional[pulumi.Input[_builtins.str]] = None,
+                      key: Optional[pulumi.Input[_builtins.str]] = None,
+                      opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[RsadecryptResult]:
+    """
+    Decrypts an RSA-encrypted ciphertext.
+    The cipher text must be base64-encoded and the key must be in PEM format.
+    """
+    __args__ = dict()
+    __args__['cipherText'] = cipher_text
+    __args__['key'] = key
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('std:index:rsadecrypt', __args__, opts=opts, typ=RsadecryptResult)
+    return __ret__.apply(lambda __response__: RsadecryptResult(
+        result=pulumi.get(__response__, 'result')))

pulumi_std/setintersection.py

@@ -0,0 +1,68 @@
+# coding=utf-8
+# *** WARNING: this file was generated by pulumi-language-python. ***
+# *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+import builtins as _builtins
+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__ = [
+    'SetintersectionResult',
+    'AwaitableSetintersectionResult',
+    'setintersection',
+    'setintersection_output',
+]
+
+@pulumi.output_type
+class SetintersectionResult:
+    def __init__(__self__, result=None):
+        if result and not isinstance(result, list):
+            raise TypeError("Expected argument 'result' to be a list")
+        pulumi.set(__self__, "result", result)
+
+    @_builtins.property
+    @pulumi.getter
+    def result(self) -> Sequence[Any]:
+        return pulumi.get(self, "result")
+
+
+class AwaitableSetintersectionResult(SetintersectionResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return SetintersectionResult(
+            result=self.result)
+
+
+def setintersection(input: Optional[Sequence[Sequence[Any]]] = None,
+                    opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableSetintersectionResult:
+    """
+    Returns the set of elements that all the input sets have in common.
+    """
+    __args__ = dict()
+    __args__['input'] = input
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('std:index:setintersection', __args__, opts=opts, typ=SetintersectionResult).value
+
+    return AwaitableSetintersectionResult(
+        result=pulumi.get(__ret__, 'result'))
+def setintersection_output(input: Optional[pulumi.Input[Sequence[Sequence[Any]]]] = None,
+                           opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[SetintersectionResult]:
+    """
+    Returns the set of elements that all the input sets have in common.
+    """
+    __args__ = dict()
+    __args__['input'] = input
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('std:index:setintersection', __args__, opts=opts, typ=SetintersectionResult)
+    return __ret__.apply(lambda __response__: SetintersectionResult(
+        result=pulumi.get(__response__, 'result')))

pulumi_std/sha1.py

@@ -0,0 +1,68 @@
+# coding=utf-8
+# *** WARNING: this file was generated by pulumi-language-python. ***
+# *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+import builtins as _builtins
+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__ = [
+    'Sha1Result',
+    'AwaitableSha1Result',
+    'sha1',
+    'sha1_output',
+]
+
+@pulumi.output_type
+class Sha1Result:
+    def __init__(__self__, result=None):
+        if result and not isinstance(result, str):
+            raise TypeError("Expected argument 'result' to be a str")
+        pulumi.set(__self__, "result", result)
+
+    @_builtins.property
+    @pulumi.getter
+    def result(self) -> _builtins.str:
+        return pulumi.get(self, "result")
+
+
+class AwaitableSha1Result(Sha1Result):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return Sha1Result(
+            result=self.result)
+
+
+def sha1(input: Optional[_builtins.str] = None,
+         opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableSha1Result:
+    """
+    Returns a hexadecimal representation of the SHA-1 hash of the given string.
+    """
+    __args__ = dict()
+    __args__['input'] = input
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('std:index:sha1', __args__, opts=opts, typ=Sha1Result).value
+
+    return AwaitableSha1Result(
+        result=pulumi.get(__ret__, 'result'))
+def sha1_output(input: Optional[pulumi.Input[_builtins.str]] = None,
+                opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[Sha1Result]:
+    """
+    Returns a hexadecimal representation of the SHA-1 hash of the given string.
+    """
+    __args__ = dict()
+    __args__['input'] = input
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('std:index:sha1', __args__, opts=opts, typ=Sha1Result)
+    return __ret__.apply(lambda __response__: Sha1Result(
+        result=pulumi.get(__response__, 'result')))

pulumi_std/sha256.py

@@ -0,0 +1,68 @@
+# coding=utf-8
+# *** WARNING: this file was generated by pulumi-language-python. ***
+# *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+import builtins as _builtins
+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__ = [
+    'Sha256Result',
+    'AwaitableSha256Result',
+    'sha256',
+    'sha256_output',
+]
+
+@pulumi.output_type
+class Sha256Result:
+    def __init__(__self__, result=None):
+        if result and not isinstance(result, str):
+            raise TypeError("Expected argument 'result' to be a str")
+        pulumi.set(__self__, "result", result)
+
+    @_builtins.property
+    @pulumi.getter
+    def result(self) -> _builtins.str:
+        return pulumi.get(self, "result")
+
+
+class AwaitableSha256Result(Sha256Result):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return Sha256Result(
+            result=self.result)
+
+
+def sha256(input: Optional[_builtins.str] = None,
+           opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableSha256Result:
+    """
+    Returns a hexadecimal representation of the SHA-256 hash of the given string.
+    """
+    __args__ = dict()
+    __args__['input'] = input
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('std:index:sha256', __args__, opts=opts, typ=Sha256Result).value
+
+    return AwaitableSha256Result(
+        result=pulumi.get(__ret__, 'result'))
+def sha256_output(input: Optional[pulumi.Input[_builtins.str]] = None,
+                  opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[Sha256Result]:
+    """
+    Returns a hexadecimal representation of the SHA-256 hash of the given string.
+    """
+    __args__ = dict()
+    __args__['input'] = input
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('std:index:sha256', __args__, opts=opts, typ=Sha256Result)
+    return __ret__.apply(lambda __response__: Sha256Result(
+        result=pulumi.get(__response__, 'result')))

pulumi_std/sha512.py

@@ -0,0 +1,68 @@
+# coding=utf-8
+# *** WARNING: this file was generated by pulumi-language-python. ***
+# *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+import builtins as _builtins
+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__ = [
+    'Sha512Result',
+    'AwaitableSha512Result',
+    'sha512',
+    'sha512_output',
+]
+
+@pulumi.output_type
+class Sha512Result:
+    def __init__(__self__, result=None):
+        if result and not isinstance(result, str):
+            raise TypeError("Expected argument 'result' to be a str")
+        pulumi.set(__self__, "result", result)
+
+    @_builtins.property
+    @pulumi.getter
+    def result(self) -> _builtins.str:
+        return pulumi.get(self, "result")
+
+
+class AwaitableSha512Result(Sha512Result):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return Sha512Result(
+            result=self.result)
+
+
+def sha512(input: Optional[_builtins.str] = None,
+           opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableSha512Result:
+    """
+    Returns a hexadecimal representation of the SHA-512 hash of the given string.
+    """
+    __args__ = dict()
+    __args__['input'] = input
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('std:index:sha512', __args__, opts=opts, typ=Sha512Result).value
+
+    return AwaitableSha512Result(
+        result=pulumi.get(__ret__, 'result'))
+def sha512_output(input: Optional[pulumi.Input[_builtins.str]] = None,
+                  opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[Sha512Result]:
+    """
+    Returns a hexadecimal representation of the SHA-512 hash of the given string.
+    """
+    __args__ = dict()
+    __args__['input'] = input
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('std:index:sha512', __args__, opts=opts, typ=Sha512Result)
+    return __ret__.apply(lambda __response__: Sha512Result(
+        result=pulumi.get(__response__, 'result')))

pulumi_std/signum.py

@@ -0,0 +1,68 @@
+# coding=utf-8
+# *** WARNING: this file was generated by pulumi-language-python. ***
+# *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+import builtins as _builtins
+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__ = [
+    'SignumResult',
+    'AwaitableSignumResult',
+    'signum',
+    'signum_output',
+]
+
+@pulumi.output_type
+class SignumResult:
+    def __init__(__self__, result=None):
+        if result and not isinstance(result, float):
+            raise TypeError("Expected argument 'result' to be a float")
+        pulumi.set(__self__, "result", result)
+
+    @_builtins.property
+    @pulumi.getter
+    def result(self) -> _builtins.float:
+        return pulumi.get(self, "result")
+
+
+class AwaitableSignumResult(SignumResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return SignumResult(
+            result=self.result)
+
+
+def signum(input: Optional[_builtins.float] = None,
+           opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableSignumResult:
+    """
+    Returns the greatest integer value less than or equal to the argument.
+    """
+    __args__ = dict()
+    __args__['input'] = input
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('std:index:signum', __args__, opts=opts, typ=SignumResult).value
+
+    return AwaitableSignumResult(
+        result=pulumi.get(__ret__, 'result'))
+def signum_output(input: Optional[pulumi.Input[_builtins.float]] = None,
+                  opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[SignumResult]:
+    """
+    Returns the greatest integer value less than or equal to the argument.
+    """
+    __args__ = dict()
+    __args__['input'] = input
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('std:index:signum', __args__, opts=opts, typ=SignumResult)
+    return __ret__.apply(lambda __response__: SignumResult(
+        result=pulumi.get(__response__, 'result')))

pulumi_std/slice.py

@@ -0,0 +1,76 @@
+# coding=utf-8
+# *** WARNING: this file was generated by pulumi-language-python. ***
+# *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+import builtins as _builtins
+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__ = [
+    'SliceResult',
+    'AwaitableSliceResult',
+    'slice',
+    'slice_output',
+]
+
+@pulumi.output_type
+class SliceResult:
+    def __init__(__self__, result=None):
+        if result and not isinstance(result, list):
+            raise TypeError("Expected argument 'result' to be a list")
+        pulumi.set(__self__, "result", result)
+
+    @_builtins.property
+    @pulumi.getter
+    def result(self) -> Sequence[Any]:
+        return pulumi.get(self, "result")
+
+
+class AwaitableSliceResult(SliceResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return SliceResult(
+            result=self.result)
+
+
+def slice(from_: Optional[_builtins.int] = None,
+          list: Optional[Sequence[Any]] = None,
+          to: Optional[_builtins.int] = None,
+          opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableSliceResult:
+    """
+    Returns the portion of list between from (inclusive) and to (exclusive).
+    """
+    __args__ = dict()
+    __args__['from'] = from_
+    __args__['list'] = list
+    __args__['to'] = to
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('std:index:slice', __args__, opts=opts, typ=SliceResult).value
+
+    return AwaitableSliceResult(
+        result=pulumi.get(__ret__, 'result'))
+def slice_output(from_: Optional[pulumi.Input[Optional[_builtins.int]]] = None,
+                 list: Optional[pulumi.Input[Sequence[Any]]] = None,
+                 to: Optional[pulumi.Input[Optional[_builtins.int]]] = None,
+                 opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[SliceResult]:
+    """
+    Returns the portion of list between from (inclusive) and to (exclusive).
+    """
+    __args__ = dict()
+    __args__['from'] = from_
+    __args__['list'] = list
+    __args__['to'] = to
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('std:index:slice', __args__, opts=opts, typ=SliceResult)
+    return __ret__.apply(lambda __response__: SliceResult(
+        result=pulumi.get(__response__, 'result')))

pulumi_std/sort.py

@@ -0,0 +1,68 @@
+# coding=utf-8
+# *** WARNING: this file was generated by pulumi-language-python. ***
+# *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+import builtins as _builtins
+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__ = [
+    'SortResult',
+    'AwaitableSortResult',
+    'sort',
+    'sort_output',
+]
+
+@pulumi.output_type
+class SortResult:
+    def __init__(__self__, result=None):
+        if result and not isinstance(result, list):
+            raise TypeError("Expected argument 'result' to be a list")
+        pulumi.set(__self__, "result", result)
+
+    @_builtins.property
+    @pulumi.getter
+    def result(self) -> Sequence[_builtins.str]:
+        return pulumi.get(self, "result")
+
+
+class AwaitableSortResult(SortResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return SortResult(
+            result=self.result)
+
+
+def sort(input: Optional[Sequence[_builtins.str]] = None,
+         opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableSortResult:
+    """
+    Returns a list of strings sorted lexicographically.
+    """
+    __args__ = dict()
+    __args__['input'] = input
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('std:index:sort', __args__, opts=opts, typ=SortResult).value
+
+    return AwaitableSortResult(
+        result=pulumi.get(__ret__, 'result'))
+def sort_output(input: Optional[pulumi.Input[Sequence[_builtins.str]]] = None,
+                opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[SortResult]:
+    """
+    Returns a list of strings sorted lexicographically.
+    """
+    __args__ = dict()
+    __args__['input'] = input
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('std:index:sort', __args__, opts=opts, typ=SortResult)
+    return __ret__.apply(lambda __response__: SortResult(
+        result=pulumi.get(__response__, 'result')))

pulumi_std/split.py

@@ -0,0 +1,72 @@
+# coding=utf-8
+# *** WARNING: this file was generated by pulumi-language-python. ***
+# *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+import builtins as _builtins
+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__ = [
+    'SplitResult',
+    'AwaitableSplitResult',
+    'split',
+    'split_output',
+]
+
+@pulumi.output_type
+class SplitResult:
+    def __init__(__self__, result=None):
+        if result and not isinstance(result, list):
+            raise TypeError("Expected argument 'result' to be a list")
+        pulumi.set(__self__, "result", result)
+
+    @_builtins.property
+    @pulumi.getter
+    def result(self) -> Sequence[_builtins.str]:
+        return pulumi.get(self, "result")
+
+
+class AwaitableSplitResult(SplitResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return SplitResult(
+            result=self.result)
+
+
+def split(separator: Optional[_builtins.str] = None,
+          text: Optional[_builtins.str] = None,
+          opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableSplitResult:
+    """
+    Produces a list by dividing a given string at all occurrences of a given separator
+    """
+    __args__ = dict()
+    __args__['separator'] = separator
+    __args__['text'] = text
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('std:index:split', __args__, opts=opts, typ=SplitResult).value
+
+    return AwaitableSplitResult(
+        result=pulumi.get(__ret__, 'result'))
+def split_output(separator: Optional[pulumi.Input[_builtins.str]] = None,
+                 text: Optional[pulumi.Input[_builtins.str]] = None,
+                 opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[SplitResult]:
+    """
+    Produces a list by dividing a given string at all occurrences of a given separator
+    """
+    __args__ = dict()
+    __args__['separator'] = separator
+    __args__['text'] = text
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('std:index:split', __args__, opts=opts, typ=SplitResult)
+    return __ret__.apply(lambda __response__: SplitResult(
+        result=pulumi.get(__response__, 'result')))