pulumi-std 2.3.0a1770334078__py3-none-any.whl

pulumi_std/anytrue.py

@@ -0,0 +1,70 @@
+# 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__ = [
+    'AnytrueResult',
+    'AwaitableAnytrueResult',
+    'anytrue',
+    'anytrue_output',
+]
+
+@pulumi.output_type
+class AnytrueResult:
+    def __init__(__self__, result=None):
+        if result and not isinstance(result, bool):
+            raise TypeError("Expected argument 'result' to be a bool")
+        pulumi.set(__self__, "result", result)
+
+    @_builtins.property
+    @pulumi.getter
+    def result(self) -> _builtins.bool:
+        return pulumi.get(self, "result")
+
+
+class AwaitableAnytrueResult(AnytrueResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return AnytrueResult(
+            result=self.result)
+
+
+def anytrue(input: Optional[Sequence[Any]] = None,
+            opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableAnytrueResult:
+    """
+    Returns true if any of the elements in a given collection are true or \\"true\\".
+    It also returns false if the collection is empty.
+    """
+    __args__ = dict()
+    __args__['input'] = input
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('std:index:anytrue', __args__, opts=opts, typ=AnytrueResult).value
+
+    return AwaitableAnytrueResult(
+        result=pulumi.get(__ret__, 'result'))
+def anytrue_output(input: Optional[pulumi.Input[Sequence[Any]]] = None,
+                   opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[AnytrueResult]:
+    """
+    Returns true if any of the elements in a given collection are true or \\"true\\".
+    It also returns false if the collection is empty.
+    """
+    __args__ = dict()
+    __args__['input'] = input
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('std:index:anytrue', __args__, opts=opts, typ=AnytrueResult)
+    return __ret__.apply(lambda __response__: AnytrueResult(
+        result=pulumi.get(__response__, 'result')))

pulumi_std/base64decode.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__ = [
+    'Base64decodeResult',
+    'AwaitableBase64decodeResult',
+    'base64decode',
+    'base64decode_output',
+]
+
+@pulumi.output_type
+class Base64decodeResult:
+    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 AwaitableBase64decodeResult(Base64decodeResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return Base64decodeResult(
+            result=self.result)
+
+
+def base64decode(input: Optional[_builtins.str] = None,
+                 opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableBase64decodeResult:
+    """
+    Given a base64-encoded string, decodes it and returns the original string.
+    """
+    __args__ = dict()
+    __args__['input'] = input
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('std:index:base64decode', __args__, opts=opts, typ=Base64decodeResult).value
+
+    return AwaitableBase64decodeResult(
+        result=pulumi.get(__ret__, 'result'))
+def base64decode_output(input: Optional[pulumi.Input[_builtins.str]] = None,
+                        opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[Base64decodeResult]:
+    """
+    Given a base64-encoded string, decodes it and returns the original string.
+    """
+    __args__ = dict()
+    __args__['input'] = input
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('std:index:base64decode', __args__, opts=opts, typ=Base64decodeResult)
+    return __ret__.apply(lambda __response__: Base64decodeResult(
+        result=pulumi.get(__response__, 'result')))

pulumi_std/base64encode.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__ = [
+    'Base64encodeResult',
+    'AwaitableBase64encodeResult',
+    'base64encode',
+    'base64encode_output',
+]
+
+@pulumi.output_type
+class Base64encodeResult:
+    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 AwaitableBase64encodeResult(Base64encodeResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return Base64encodeResult(
+            result=self.result)
+
+
+def base64encode(input: Optional[_builtins.str] = None,
+                 opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableBase64encodeResult:
+    """
+    Returns a base64-encoded representation 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:base64encode', __args__, opts=opts, typ=Base64encodeResult).value
+
+    return AwaitableBase64encodeResult(
+        result=pulumi.get(__ret__, 'result'))
+def base64encode_output(input: Optional[pulumi.Input[_builtins.str]] = None,
+                        opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[Base64encodeResult]:
+    """
+    Returns a base64-encoded representation 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:base64encode', __args__, opts=opts, typ=Base64encodeResult)
+    return __ret__.apply(lambda __response__: Base64encodeResult(
+        result=pulumi.get(__response__, 'result')))

pulumi_std/base64gzip.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__ = [
+    'Base64gzipResult',
+    'AwaitableBase64gzipResult',
+    'base64gzip',
+    'base64gzip_output',
+]
+
+@pulumi.output_type
+class Base64gzipResult:
+    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 AwaitableBase64gzipResult(Base64gzipResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return Base64gzipResult(
+            result=self.result)
+
+
+def base64gzip(input: Optional[_builtins.str] = None,
+               opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableBase64gzipResult:
+    """
+    Compresses the given string with gzip and then encodes the result to base64.
+    """
+    __args__ = dict()
+    __args__['input'] = input
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('std:index:base64gzip', __args__, opts=opts, typ=Base64gzipResult).value
+
+    return AwaitableBase64gzipResult(
+        result=pulumi.get(__ret__, 'result'))
+def base64gzip_output(input: Optional[pulumi.Input[_builtins.str]] = None,
+                      opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[Base64gzipResult]:
+    """
+    Compresses the given string with gzip and then encodes the result to base64.
+    """
+    __args__ = dict()
+    __args__['input'] = input
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('std:index:base64gzip', __args__, opts=opts, typ=Base64gzipResult)
+    return __ret__.apply(lambda __response__: Base64gzipResult(
+        result=pulumi.get(__response__, 'result')))

pulumi_std/base64sha256.py

@@ -0,0 +1,70 @@
+# 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__ = [
+    'Base64sha256Result',
+    'AwaitableBase64sha256Result',
+    'base64sha256',
+    'base64sha256_output',
+]
+
+@pulumi.output_type
+class Base64sha256Result:
+    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 AwaitableBase64sha256Result(Base64sha256Result):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return Base64sha256Result(
+            result=self.result)
+
+
+def base64sha256(input: Optional[_builtins.str] = None,
+                 opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableBase64sha256Result:
+    """
+    Returns a base64-encoded representation of raw SHA-256 sum of the given string.
+    This is not equivalent of base64encode(sha256(string)) since sha256() returns hexadecimal representation.
+    """
+    __args__ = dict()
+    __args__['input'] = input
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('std:index:base64sha256', __args__, opts=opts, typ=Base64sha256Result).value
+
+    return AwaitableBase64sha256Result(
+        result=pulumi.get(__ret__, 'result'))
+def base64sha256_output(input: Optional[pulumi.Input[_builtins.str]] = None,
+                        opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[Base64sha256Result]:
+    """
+    Returns a base64-encoded representation of raw SHA-256 sum of the given string.
+    This is not equivalent of base64encode(sha256(string)) since sha256() returns hexadecimal representation.
+    """
+    __args__ = dict()
+    __args__['input'] = input
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('std:index:base64sha256', __args__, opts=opts, typ=Base64sha256Result)
+    return __ret__.apply(lambda __response__: Base64sha256Result(
+        result=pulumi.get(__response__, 'result')))

pulumi_std/base64sha512.py

@@ -0,0 +1,70 @@
+# 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__ = [
+    'Base64sha512Result',
+    'AwaitableBase64sha512Result',
+    'base64sha512',
+    'base64sha512_output',
+]
+
+@pulumi.output_type
+class Base64sha512Result:
+    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 AwaitableBase64sha512Result(Base64sha512Result):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return Base64sha512Result(
+            result=self.result)
+
+
+def base64sha512(input: Optional[_builtins.str] = None,
+                 opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableBase64sha512Result:
+    """
+    Returns a base64-encoded representation of raw SHA-512 sum of the given string.
+    This is not equivalent of base64encode(sha512(string)) since sha512() returns hexadecimal representation.
+    """
+    __args__ = dict()
+    __args__['input'] = input
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('std:index:base64sha512', __args__, opts=opts, typ=Base64sha512Result).value
+
+    return AwaitableBase64sha512Result(
+        result=pulumi.get(__ret__, 'result'))
+def base64sha512_output(input: Optional[pulumi.Input[_builtins.str]] = None,
+                        opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[Base64sha512Result]:
+    """
+    Returns a base64-encoded representation of raw SHA-512 sum of the given string.
+    This is not equivalent of base64encode(sha512(string)) since sha512() returns hexadecimal representation.
+    """
+    __args__ = dict()
+    __args__['input'] = input
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('std:index:base64sha512', __args__, opts=opts, typ=Base64sha512Result)
+    return __ret__.apply(lambda __response__: Base64sha512Result(
+        result=pulumi.get(__response__, 'result')))

pulumi_std/basename.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__ = [
+    'BasenameResult',
+    'AwaitableBasenameResult',
+    'basename',
+    'basename_output',
+]
+
+@pulumi.output_type
+class BasenameResult:
+    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 AwaitableBasenameResult(BasenameResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return BasenameResult(
+            result=self.result)
+
+
+def basename(input: Optional[_builtins.str] = None,
+             opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableBasenameResult:
+    """
+    Returns the last element of the input path.
+    """
+    __args__ = dict()
+    __args__['input'] = input
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('std:index:basename', __args__, opts=opts, typ=BasenameResult).value
+
+    return AwaitableBasenameResult(
+        result=pulumi.get(__ret__, 'result'))
+def basename_output(input: Optional[pulumi.Input[_builtins.str]] = None,
+                    opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[BasenameResult]:
+    """
+    Returns the last element of the input path.
+    """
+    __args__ = dict()
+    __args__['input'] = input
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('std:index:basename', __args__, opts=opts, typ=BasenameResult)
+    return __ret__.apply(lambda __response__: BasenameResult(
+        result=pulumi.get(__response__, 'result')))

pulumi_std/bcrypt.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__ = [
+    'BcryptResult',
+    'AwaitableBcryptResult',
+    'bcrypt',
+    'bcrypt_output',
+]
+
+@pulumi.output_type
+class BcryptResult:
+    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 AwaitableBcryptResult(BcryptResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return BcryptResult(
+            result=self.result)
+
+
+def bcrypt(cost: Optional[_builtins.int] = None,
+           input: Optional[_builtins.str] = None,
+           opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableBcryptResult:
+    """
+    Returns the Blowfish encrypted hash of the string at the given cost.
+    A default cost of 10 will be used if not provided.
+    """
+    __args__ = dict()
+    __args__['cost'] = cost
+    __args__['input'] = input
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('std:index:bcrypt', __args__, opts=opts, typ=BcryptResult).value
+
+    return AwaitableBcryptResult(
+        result=pulumi.get(__ret__, 'result'))
+def bcrypt_output(cost: Optional[pulumi.Input[Optional[_builtins.int]]] = None,
+                  input: Optional[pulumi.Input[_builtins.str]] = None,
+                  opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[BcryptResult]:
+    """
+    Returns the Blowfish encrypted hash of the string at the given cost.
+    A default cost of 10 will be used if not provided.
+    """
+    __args__ = dict()
+    __args__['cost'] = cost
+    __args__['input'] = input
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('std:index:bcrypt', __args__, opts=opts, typ=BcryptResult)
+    return __ret__.apply(lambda __response__: BcryptResult(
+        result=pulumi.get(__response__, 'result')))

pulumi_std/ceil.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__ = [
+    'CeilResult',
+    'AwaitableCeilResult',
+    'ceil',
+    'ceil_output',
+]
+
+@pulumi.output_type
+class CeilResult:
+    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 AwaitableCeilResult(CeilResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return CeilResult(
+            result=self.result)
+
+
+def ceil(input: Optional[_builtins.float] = None,
+         opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableCeilResult:
+    """
+    Returns the least integer value greater 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:ceil', __args__, opts=opts, typ=CeilResult).value
+
+    return AwaitableCeilResult(
+        result=pulumi.get(__ret__, 'result'))
+def ceil_output(input: Optional[pulumi.Input[_builtins.float]] = None,
+                opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[CeilResult]:
+    """
+    Returns the least integer value greater 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:ceil', __args__, opts=opts, typ=CeilResult)
+    return __ret__.apply(lambda __response__: CeilResult(
+        result=pulumi.get(__response__, 'result')))