std

package
v1.6.2 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 10, 2024 License: Apache-2.0 Imports: 6 Imported by: 0

Documentation

Overview

Standard library functions

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AbsArgs 

type AbsArgs struct {
	Input float64 `pulumi:"input"`
}

type AbsOutputArgs 

type AbsOutputArgs struct {
	Input pulumi.Float64Input `pulumi:"input"`
}

func (AbsOutputArgs) ElementType 

func (AbsOutputArgs) ElementType() reflect.Type

type AbsResult 

type AbsResult struct {
	Result float64 `pulumi:"result"`
}

func Abs 

func Abs(ctx *pulumi.Context, args *AbsArgs, opts ...pulumi.InvokeOption) (*AbsResult, error)

Returns the absolute value of a given float. Example: abs(1) returns 1, and abs(-1) would also return 1, whereas abs(-3.14) would return 3.14.

type AbsResultOutput 

type AbsResultOutput struct{ *pulumi.OutputState }

func AbsOutput 

func AbsOutput(ctx *pulumi.Context, args AbsOutputArgs, opts ...pulumi.InvokeOption) AbsResultOutput

func (AbsResultOutput) ElementType 

func (AbsResultOutput) ElementType() reflect.Type

func (AbsResultOutput) Result 

func (o AbsResultOutput) Result() pulumi.Float64Output

func (AbsResultOutput) ToAbsResultOutput 

func (o AbsResultOutput) ToAbsResultOutput() AbsResultOutput

func (AbsResultOutput) ToAbsResultOutputWithContext 

func (o AbsResultOutput) ToAbsResultOutputWithContext(ctx context.Context) AbsResultOutput

type AbspathArgs 

type AbspathArgs struct {
	Input string `pulumi:"input"`
}

type AbspathOutputArgs 

type AbspathOutputArgs struct {
	Input pulumi.StringInput `pulumi:"input"`
}

func (AbspathOutputArgs) ElementType 

func (AbspathOutputArgs) ElementType() reflect.Type

type AbspathResult 

type AbspathResult struct {
	Result string `pulumi:"result"`
}

func Abspath 

func Abspath(ctx *pulumi.Context, args *AbspathArgs, opts ...pulumi.InvokeOption) (*AbspathResult, error)

Returns an absolute representation of the specified path. If the path is not absolute it will be joined with the current working directory to turn it into an absolute path.

type AbspathResultOutput 

type AbspathResultOutput struct{ *pulumi.OutputState }

func AbspathOutput 

func AbspathOutput(ctx *pulumi.Context, args AbspathOutputArgs, opts ...pulumi.InvokeOption) AbspathResultOutput

func (AbspathResultOutput) ElementType 

func (AbspathResultOutput) ElementType() reflect.Type

func (AbspathResultOutput) Result 

func (o AbspathResultOutput) Result() pulumi.StringOutput

func (AbspathResultOutput) ToAbspathResultOutput 

func (o AbspathResultOutput) ToAbspathResultOutput() AbspathResultOutput

func (AbspathResultOutput) ToAbspathResultOutputWithContext 

func (o AbspathResultOutput) ToAbspathResultOutputWithContext(ctx context.Context) AbspathResultOutput

type AlltrueArgs 

type AlltrueArgs struct {
	Input []interface{} `pulumi:"input"`
}

type AlltrueOutputArgs 

type AlltrueOutputArgs struct {
	Input pulumi.ArrayInput `pulumi:"input"`
}

func (AlltrueOutputArgs) ElementType 

func (AlltrueOutputArgs) ElementType() reflect.Type

type AlltrueResult 

type AlltrueResult struct {
	Result bool `pulumi:"result"`
}

func Alltrue 

func Alltrue(ctx *pulumi.Context, args *AlltrueArgs, opts ...pulumi.InvokeOption) (*AlltrueResult, error)

Returns true if all elements in a given collection are true or \"true\". It also returns true if the collection is empty.

type AlltrueResultOutput 

type AlltrueResultOutput struct{ *pulumi.OutputState }

func AlltrueOutput 

func AlltrueOutput(ctx *pulumi.Context, args AlltrueOutputArgs, opts ...pulumi.InvokeOption) AlltrueResultOutput

func (AlltrueResultOutput) ElementType 

func (AlltrueResultOutput) ElementType() reflect.Type

func (AlltrueResultOutput) Result 

func (o AlltrueResultOutput) Result() pulumi.BoolOutput

func (AlltrueResultOutput) ToAlltrueResultOutput 

func (o AlltrueResultOutput) ToAlltrueResultOutput() AlltrueResultOutput

func (AlltrueResultOutput) ToAlltrueResultOutputWithContext 

func (o AlltrueResultOutput) ToAlltrueResultOutputWithContext(ctx context.Context) AlltrueResultOutput

type AnytrueArgs 

type AnytrueArgs struct {
	Input []interface{} `pulumi:"input"`
}

type AnytrueOutputArgs 

type AnytrueOutputArgs struct {
	Input pulumi.ArrayInput `pulumi:"input"`
}

func (AnytrueOutputArgs) ElementType 

func (AnytrueOutputArgs) ElementType() reflect.Type

type AnytrueResult 

type AnytrueResult struct {
	Result bool `pulumi:"result"`
}

func Anytrue 

func Anytrue(ctx *pulumi.Context, args *AnytrueArgs, opts ...pulumi.InvokeOption) (*AnytrueResult, error)

Returns true if any of the elements in a given collection are true or \"true\". It also returns false if the collection is empty.

type AnytrueResultOutput 

type AnytrueResultOutput struct{ *pulumi.OutputState }

func AnytrueOutput 

func AnytrueOutput(ctx *pulumi.Context, args AnytrueOutputArgs, opts ...pulumi.InvokeOption) AnytrueResultOutput

func (AnytrueResultOutput) ElementType 

func (AnytrueResultOutput) ElementType() reflect.Type

func (AnytrueResultOutput) Result 

func (o AnytrueResultOutput) Result() pulumi.BoolOutput

func (AnytrueResultOutput) ToAnytrueResultOutput 

func (o AnytrueResultOutput) ToAnytrueResultOutput() AnytrueResultOutput

func (AnytrueResultOutput) ToAnytrueResultOutputWithContext 

func (o AnytrueResultOutput) ToAnytrueResultOutputWithContext(ctx context.Context) AnytrueResultOutput

type Base64decodeArgs 

type Base64decodeArgs struct {
	Input string `pulumi:"input"`
}

type Base64decodeOutputArgs 

type Base64decodeOutputArgs struct {
	Input pulumi.StringInput `pulumi:"input"`
}

func (Base64decodeOutputArgs) ElementType 

func (Base64decodeOutputArgs) ElementType() reflect.Type

type Base64decodeResult 

type Base64decodeResult struct {
	Result string `pulumi:"result"`
}

func Base64decode 

func Base64decode(ctx *pulumi.Context, args *Base64decodeArgs, opts ...pulumi.InvokeOption) (*Base64decodeResult, error)

Given a base64-encoded string, decodes it and returns the original string.

type Base64decodeResultOutput 

type Base64decodeResultOutput struct{ *pulumi.OutputState }

func Base64decodeOutput 

func Base64decodeOutput(ctx *pulumi.Context, args Base64decodeOutputArgs, opts ...pulumi.InvokeOption) Base64decodeResultOutput

func (Base64decodeResultOutput) ElementType 

func (Base64decodeResultOutput) ElementType() reflect.Type

func (Base64decodeResultOutput) Result 

func (o Base64decodeResultOutput) Result() pulumi.StringOutput

func (Base64decodeResultOutput) ToBase64decodeResultOutput 

func (o Base64decodeResultOutput) ToBase64decodeResultOutput() Base64decodeResultOutput

func (Base64decodeResultOutput) ToBase64decodeResultOutputWithContext 

func (o Base64decodeResultOutput) ToBase64decodeResultOutputWithContext(ctx context.Context) Base64decodeResultOutput

type Base64encodeArgs 

type Base64encodeArgs struct {
	Input string `pulumi:"input"`
}

type Base64encodeOutputArgs 

type Base64encodeOutputArgs struct {
	Input pulumi.StringInput `pulumi:"input"`
}

func (Base64encodeOutputArgs) ElementType 

func (Base64encodeOutputArgs) ElementType() reflect.Type

type Base64encodeResult 

type Base64encodeResult struct {
	Result string `pulumi:"result"`
}

func Base64encode 

func Base64encode(ctx *pulumi.Context, args *Base64encodeArgs, opts ...pulumi.InvokeOption) (*Base64encodeResult, error)

Returns a base64-encoded representation of the given string.

type Base64encodeResultOutput 

type Base64encodeResultOutput struct{ *pulumi.OutputState }

func Base64encodeOutput 

func Base64encodeOutput(ctx *pulumi.Context, args Base64encodeOutputArgs, opts ...pulumi.InvokeOption) Base64encodeResultOutput

func (Base64encodeResultOutput) ElementType 

func (Base64encodeResultOutput) ElementType() reflect.Type

func (Base64encodeResultOutput) Result 

func (o Base64encodeResultOutput) Result() pulumi.StringOutput

func (Base64encodeResultOutput) ToBase64encodeResultOutput 

func (o Base64encodeResultOutput) ToBase64encodeResultOutput() Base64encodeResultOutput

func (Base64encodeResultOutput) ToBase64encodeResultOutputWithContext 

func (o Base64encodeResultOutput) ToBase64encodeResultOutputWithContext(ctx context.Context) Base64encodeResultOutput

type Base64gzipArgs 

type Base64gzipArgs struct {
	Input string `pulumi:"input"`
}

type Base64gzipOutputArgs 

type Base64gzipOutputArgs struct {
	Input pulumi.StringInput `pulumi:"input"`
}

func (Base64gzipOutputArgs) ElementType 

func (Base64gzipOutputArgs) ElementType() reflect.Type

type Base64gzipResult 

type Base64gzipResult struct {
	Result string `pulumi:"result"`
}

func Base64gzip 

func Base64gzip(ctx *pulumi.Context, args *Base64gzipArgs, opts ...pulumi.InvokeOption) (*Base64gzipResult, error)

Compresses the given string with gzip and then encodes the result to base64.

type Base64gzipResultOutput 

type Base64gzipResultOutput struct{ *pulumi.OutputState }

func Base64gzipOutput 

func Base64gzipOutput(ctx *pulumi.Context, args Base64gzipOutputArgs, opts ...pulumi.InvokeOption) Base64gzipResultOutput

func (Base64gzipResultOutput) ElementType 

func (Base64gzipResultOutput) ElementType() reflect.Type

func (Base64gzipResultOutput) Result 

func (o Base64gzipResultOutput) Result() pulumi.StringOutput

func (Base64gzipResultOutput) ToBase64gzipResultOutput 

func (o Base64gzipResultOutput) ToBase64gzipResultOutput() Base64gzipResultOutput

func (Base64gzipResultOutput) ToBase64gzipResultOutputWithContext 

func (o Base64gzipResultOutput) ToBase64gzipResultOutputWithContext(ctx context.Context) Base64gzipResultOutput

type Base64sha256Args 

type Base64sha256Args struct {
	Input string `pulumi:"input"`
}

type Base64sha256OutputArgs 

type Base64sha256OutputArgs struct {
	Input pulumi.StringInput `pulumi:"input"`
}

func (Base64sha256OutputArgs) ElementType 

func (Base64sha256OutputArgs) ElementType() reflect.Type

type Base64sha256Result 

type Base64sha256Result struct {
	Result string `pulumi:"result"`
}

func Base64sha256 

func Base64sha256(ctx *pulumi.Context, args *Base64sha256Args, opts ...pulumi.InvokeOption) (*Base64sha256Result, error)

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.

type Base64sha256ResultOutput 

type Base64sha256ResultOutput struct{ *pulumi.OutputState }

func Base64sha256Output 

func Base64sha256Output(ctx *pulumi.Context, args Base64sha256OutputArgs, opts ...pulumi.InvokeOption) Base64sha256ResultOutput

func (Base64sha256ResultOutput) ElementType 

func (Base64sha256ResultOutput) ElementType() reflect.Type

func (Base64sha256ResultOutput) Result 

func (o Base64sha256ResultOutput) Result() pulumi.StringOutput

func (Base64sha256ResultOutput) ToBase64sha256ResultOutput 

func (o Base64sha256ResultOutput) ToBase64sha256ResultOutput() Base64sha256ResultOutput

func (Base64sha256ResultOutput) ToBase64sha256ResultOutputWithContext 

func (o Base64sha256ResultOutput) ToBase64sha256ResultOutputWithContext(ctx context.Context) Base64sha256ResultOutput

type Base64sha512Args 

type Base64sha512Args struct {
	Input string `pulumi:"input"`
}

type Base64sha512OutputArgs 

type Base64sha512OutputArgs struct {
	Input pulumi.StringInput `pulumi:"input"`
}

func (Base64sha512OutputArgs) ElementType 

func (Base64sha512OutputArgs) ElementType() reflect.Type

type Base64sha512Result 

type Base64sha512Result struct {
	Result string `pulumi:"result"`
}

func Base64sha512 

func Base64sha512(ctx *pulumi.Context, args *Base64sha512Args, opts ...pulumi.InvokeOption) (*Base64sha512Result, error)

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.

type Base64sha512ResultOutput 

type Base64sha512ResultOutput struct{ *pulumi.OutputState }

func Base64sha512Output 

func Base64sha512Output(ctx *pulumi.Context, args Base64sha512OutputArgs, opts ...pulumi.InvokeOption) Base64sha512ResultOutput

func (Base64sha512ResultOutput) ElementType 

func (Base64sha512ResultOutput) ElementType() reflect.Type

func (Base64sha512ResultOutput) Result 

func (o Base64sha512ResultOutput) Result() pulumi.StringOutput

func (Base64sha512ResultOutput) ToBase64sha512ResultOutput 

func (o Base64sha512ResultOutput) ToBase64sha512ResultOutput() Base64sha512ResultOutput

func (Base64sha512ResultOutput) ToBase64sha512ResultOutputWithContext 

func (o Base64sha512ResultOutput) ToBase64sha512ResultOutputWithContext(ctx context.Context) Base64sha512ResultOutput

type BasenameArgs 

type BasenameArgs struct {
	Input string `pulumi:"input"`
}

type BasenameOutputArgs 

type BasenameOutputArgs struct {
	Input pulumi.StringInput `pulumi:"input"`
}

func (BasenameOutputArgs) ElementType 

func (BasenameOutputArgs) ElementType() reflect.Type

type BasenameResult 

type BasenameResult struct {
	Result string `pulumi:"result"`
}

func Basename 

func Basename(ctx *pulumi.Context, args *BasenameArgs, opts ...pulumi.InvokeOption) (*BasenameResult, error)

Returns the last element of the input path.

type BasenameResultOutput 

type BasenameResultOutput struct{ *pulumi.OutputState }

func BasenameOutput 

func BasenameOutput(ctx *pulumi.Context, args BasenameOutputArgs, opts ...pulumi.InvokeOption) BasenameResultOutput

func (BasenameResultOutput) ElementType 

func (BasenameResultOutput) ElementType() reflect.Type

func (BasenameResultOutput) Result 

func (o BasenameResultOutput) Result() pulumi.StringOutput

func (BasenameResultOutput) ToBasenameResultOutput 

func (o BasenameResultOutput) ToBasenameResultOutput() BasenameResultOutput

func (BasenameResultOutput) ToBasenameResultOutputWithContext 

func (o BasenameResultOutput) ToBasenameResultOutputWithContext(ctx context.Context) BasenameResultOutput

type BcryptArgs 

type BcryptArgs struct {
	Cost  *int   `pulumi:"cost"`
	Input string `pulumi:"input"`
}

type BcryptOutputArgs 

type BcryptOutputArgs struct {
	Cost  pulumi.IntPtrInput `pulumi:"cost"`
	Input pulumi.StringInput `pulumi:"input"`
}

func (BcryptOutputArgs) ElementType 

func (BcryptOutputArgs) ElementType() reflect.Type

type BcryptResult 

type BcryptResult struct {
	Result string `pulumi:"result"`
}

func Bcrypt 

func Bcrypt(ctx *pulumi.Context, args *BcryptArgs, opts ...pulumi.InvokeOption) (*BcryptResult, error)

Returns the Blowfish encrypted hash of the string at the given cost. A default cost of 10 will be used if not provided.

type BcryptResultOutput 

type BcryptResultOutput struct{ *pulumi.OutputState }

func BcryptOutput 

func BcryptOutput(ctx *pulumi.Context, args BcryptOutputArgs, opts ...pulumi.InvokeOption) BcryptResultOutput

func (BcryptResultOutput) ElementType 

func (BcryptResultOutput) ElementType() reflect.Type

func (BcryptResultOutput) Result 

func (o BcryptResultOutput) Result() pulumi.StringOutput

func (BcryptResultOutput) ToBcryptResultOutput 

func (o BcryptResultOutput) ToBcryptResultOutput() BcryptResultOutput

func (BcryptResultOutput) ToBcryptResultOutputWithContext 

func (o BcryptResultOutput) ToBcryptResultOutputWithContext(ctx context.Context) BcryptResultOutput

type CeilArgs 

type CeilArgs struct {
	Input float64 `pulumi:"input"`
}

type CeilOutputArgs 

type CeilOutputArgs struct {
	Input pulumi.Float64Input `pulumi:"input"`
}

func (CeilOutputArgs) ElementType 

func (CeilOutputArgs) ElementType() reflect.Type

type CeilResult 

type CeilResult struct {
	Result float64 `pulumi:"result"`
}

func Ceil 

func Ceil(ctx *pulumi.Context, args *CeilArgs, opts ...pulumi.InvokeOption) (*CeilResult, error)

Returns the least integer value greater than or equal to the argument.

type CeilResultOutput 

type CeilResultOutput struct{ *pulumi.OutputState }

func CeilOutput 

func CeilOutput(ctx *pulumi.Context, args CeilOutputArgs, opts ...pulumi.InvokeOption) CeilResultOutput

func (CeilResultOutput) ElementType 

func (CeilResultOutput) ElementType() reflect.Type

func (CeilResultOutput) Result 

func (o CeilResultOutput) Result() pulumi.Float64Output

func (CeilResultOutput) ToCeilResultOutput 

func (o CeilResultOutput) ToCeilResultOutput() CeilResultOutput

func (CeilResultOutput) ToCeilResultOutputWithContext 

func (o CeilResultOutput) ToCeilResultOutputWithContext(ctx context.Context) CeilResultOutput

type ChompArgs 

type ChompArgs struct {
	Input string `pulumi:"input"`
}

type ChompOutputArgs 

type ChompOutputArgs struct {
	Input pulumi.StringInput `pulumi:"input"`
}

func (ChompOutputArgs) ElementType 

func (ChompOutputArgs) ElementType() reflect.Type

type ChompResult 

type ChompResult struct {
	Result string `pulumi:"result"`
}

func Chomp 

func Chomp(ctx *pulumi.Context, args *ChompArgs, opts ...pulumi.InvokeOption) (*ChompResult, error)

Removes one or more newline characters from the end of the given string.

type ChompResultOutput 

type ChompResultOutput struct{ *pulumi.OutputState }

func ChompOutput 

func ChompOutput(ctx *pulumi.Context, args ChompOutputArgs, opts ...pulumi.InvokeOption) ChompResultOutput

func (ChompResultOutput) ElementType 

func (ChompResultOutput) ElementType() reflect.Type

func (ChompResultOutput) Result 

func (o ChompResultOutput) Result() pulumi.StringOutput

func (ChompResultOutput) ToChompResultOutput 

func (o ChompResultOutput) ToChompResultOutput() ChompResultOutput

func (ChompResultOutput) ToChompResultOutputWithContext 

func (o ChompResultOutput) ToChompResultOutputWithContext(ctx context.Context) ChompResultOutput

type ChunklistArgs 

type ChunklistArgs struct {
	Input []interface{} `pulumi:"input"`
	Size  int           `pulumi:"size"`
}

type ChunklistOutputArgs 

type ChunklistOutputArgs struct {
	Input pulumi.ArrayInput `pulumi:"input"`
	Size  pulumi.IntInput   `pulumi:"size"`
}

func (ChunklistOutputArgs) ElementType 

func (ChunklistOutputArgs) ElementType() reflect.Type

type ChunklistResult 

type ChunklistResult struct {
	Result []interface{} `pulumi:"result"`
}

func Chunklist 

func Chunklist(ctx *pulumi.Context, args *ChunklistArgs, opts ...pulumi.InvokeOption) (*ChunklistResult, error)

Splits a single list into multiple lists where each has at most the given number of elements.

type ChunklistResultOutput 

type ChunklistResultOutput struct{ *pulumi.OutputState }

func ChunklistOutput 

func ChunklistOutput(ctx *pulumi.Context, args ChunklistOutputArgs, opts ...pulumi.InvokeOption) ChunklistResultOutput

func (ChunklistResultOutput) ElementType 

func (ChunklistResultOutput) ElementType() reflect.Type

func (ChunklistResultOutput) Result 

func (o ChunklistResultOutput) Result() pulumi.ArrayOutput

func (ChunklistResultOutput) ToChunklistResultOutput 

func (o ChunklistResultOutput) ToChunklistResultOutput() ChunklistResultOutput

func (ChunklistResultOutput) ToChunklistResultOutputWithContext 

func (o ChunklistResultOutput) ToChunklistResultOutputWithContext(ctx context.Context) ChunklistResultOutput

type CidrhostArgs 

type CidrhostArgs struct {
	Host  int    `pulumi:"host"`
	Input string `pulumi:"input"`
}

type CidrhostOutputArgs 

type CidrhostOutputArgs struct {
	Host  pulumi.IntInput    `pulumi:"host"`
	Input pulumi.StringInput `pulumi:"input"`
}

func (CidrhostOutputArgs) ElementType 

func (CidrhostOutputArgs) ElementType() reflect.Type

type CidrhostResult 

type CidrhostResult struct {
	Result string `pulumi:"result"`
}

func Cidrhost 

func Cidrhost(ctx *pulumi.Context, args *CidrhostArgs, opts ...pulumi.InvokeOption) (*CidrhostResult, error)

Takes an IP address range in CIDR notation as input and creates an IP address with the given host number. If given host number is negative, the count starts from the end of the range. For example, cidrhost("10.0.0.0/8", 2) returns 10.0.0.2 and cidrhost("10.0.0.0/8", -2) returns 10.255.255.254.

type CidrhostResultOutput 

type CidrhostResultOutput struct{ *pulumi.OutputState }

func CidrhostOutput 

func CidrhostOutput(ctx *pulumi.Context, args CidrhostOutputArgs, opts ...pulumi.InvokeOption) CidrhostResultOutput

func (CidrhostResultOutput) ElementType 

func (CidrhostResultOutput) ElementType() reflect.Type

func (CidrhostResultOutput) Result 

func (o CidrhostResultOutput) Result() pulumi.StringOutput

func (CidrhostResultOutput) ToCidrhostResultOutput 

func (o CidrhostResultOutput) ToCidrhostResultOutput() CidrhostResultOutput

func (CidrhostResultOutput) ToCidrhostResultOutputWithContext 

func (o CidrhostResultOutput) ToCidrhostResultOutputWithContext(ctx context.Context) CidrhostResultOutput

type CidrnetmaskArgs 

type CidrnetmaskArgs struct {
	Input string `pulumi:"input"`
}

type CidrnetmaskOutputArgs 

type CidrnetmaskOutputArgs struct {
	Input pulumi.StringInput `pulumi:"input"`
}

func (CidrnetmaskOutputArgs) ElementType 

func (CidrnetmaskOutputArgs) ElementType() reflect.Type

type CidrnetmaskResult 

type CidrnetmaskResult struct {
	Result string `pulumi:"result"`
}

func Cidrnetmask 

func Cidrnetmask(ctx *pulumi.Context, args *CidrnetmaskArgs, opts ...pulumi.InvokeOption) (*CidrnetmaskResult, error)

Takes an IP address range in CIDR notation and returns the address-formatted subnet mask format that some systems expect for IPv4 interfaces. For example, cidrnetmask("10.0.0.0/8") returns 255.0.0.0. Not applicable to IPv6 networks since CIDR notation is the only valid notation for IPv6.

type CidrnetmaskResultOutput 

type CidrnetmaskResultOutput struct{ *pulumi.OutputState }

func CidrnetmaskOutput 

func CidrnetmaskOutput(ctx *pulumi.Context, args CidrnetmaskOutputArgs, opts ...pulumi.InvokeOption) CidrnetmaskResultOutput

func (CidrnetmaskResultOutput) ElementType 

func (CidrnetmaskResultOutput) ElementType() reflect.Type

func (CidrnetmaskResultOutput) Result 

func (o CidrnetmaskResultOutput) Result() pulumi.StringOutput

func (CidrnetmaskResultOutput) ToCidrnetmaskResultOutput 

func (o CidrnetmaskResultOutput) ToCidrnetmaskResultOutput() CidrnetmaskResultOutput

func (CidrnetmaskResultOutput) ToCidrnetmaskResultOutputWithContext 

func (o CidrnetmaskResultOutput) ToCidrnetmaskResultOutputWithContext(ctx context.Context) CidrnetmaskResultOutput

type CidrsubnetArgs 

type CidrsubnetArgs struct {
	Input   string `pulumi:"input"`
	Netnum  int    `pulumi:"netnum"`
	Newbits int    `pulumi:"newbits"`
}

type CidrsubnetOutputArgs 

type CidrsubnetOutputArgs struct {
	Input   pulumi.StringInput `pulumi:"input"`
	Netnum  pulumi.IntInput    `pulumi:"netnum"`
	Newbits pulumi.IntInput    `pulumi:"newbits"`
}

func (CidrsubnetOutputArgs) ElementType 

func (CidrsubnetOutputArgs) ElementType() reflect.Type

type CidrsubnetResult 

type CidrsubnetResult struct {
	Result string `pulumi:"result"`
}

func Cidrsubnet 

func Cidrsubnet(ctx *pulumi.Context, args *CidrsubnetArgs, opts ...pulumi.InvokeOption) (*CidrsubnetResult, error)

Takes an IP address range in CIDR notation (like 10.0.0.0/8) and extends its prefix to include an additional subnet number. For example, cidrsubnet("10.0.0.0/8", 8, 2) returns 10.2.0.0/16; cidrsubnet("2607:f298:6051:516c::/64", 8, 2) returns 2607:f298:6051:516c:200::/72.

type CidrsubnetResultOutput 

type CidrsubnetResultOutput struct{ *pulumi.OutputState }

func CidrsubnetOutput 

func CidrsubnetOutput(ctx *pulumi.Context, args CidrsubnetOutputArgs, opts ...pulumi.InvokeOption) CidrsubnetResultOutput

func (CidrsubnetResultOutput) ElementType 

func (CidrsubnetResultOutput) ElementType() reflect.Type

func (CidrsubnetResultOutput) Result 

func (o CidrsubnetResultOutput) Result() pulumi.StringOutput

func (CidrsubnetResultOutput) ToCidrsubnetResultOutput 

func (o CidrsubnetResultOutput) ToCidrsubnetResultOutput() CidrsubnetResultOutput

func (CidrsubnetResultOutput) ToCidrsubnetResultOutputWithContext 

func (o CidrsubnetResultOutput) ToCidrsubnetResultOutputWithContext(ctx context.Context) CidrsubnetResultOutput

type CoalesceArgs 

type CoalesceArgs struct {
	Input []string `pulumi:"input"`
}

type CoalesceOutputArgs 

type CoalesceOutputArgs struct {
	Input pulumi.StringArrayInput `pulumi:"input"`
}

func (CoalesceOutputArgs) ElementType 

func (CoalesceOutputArgs) ElementType() reflect.Type

type CoalesceResult 

type CoalesceResult struct {
	Result string `pulumi:"result"`
}

func Coalesce 

func Coalesce(ctx *pulumi.Context, args *CoalesceArgs, opts ...pulumi.InvokeOption) (*CoalesceResult, error)

Returns the first non-empty value from the given arguments.

type CoalesceResultOutput 

type CoalesceResultOutput struct{ *pulumi.OutputState }

func CoalesceOutput 

func CoalesceOutput(ctx *pulumi.Context, args CoalesceOutputArgs, opts ...pulumi.InvokeOption) CoalesceResultOutput

func (CoalesceResultOutput) ElementType 

func (CoalesceResultOutput) ElementType() reflect.Type

func (CoalesceResultOutput) Result 

func (o CoalesceResultOutput) Result() pulumi.StringOutput

func (CoalesceResultOutput) ToCoalesceResultOutput 

func (o CoalesceResultOutput) ToCoalesceResultOutput() CoalesceResultOutput

func (CoalesceResultOutput) ToCoalesceResultOutputWithContext 

func (o CoalesceResultOutput) ToCoalesceResultOutputWithContext(ctx context.Context) CoalesceResultOutput

type CoalescelistArgs 

type CoalescelistArgs struct {
	Input [][]interface{} `pulumi:"input"`
}

type CoalescelistOutputArgs 

type CoalescelistOutputArgs struct {
	Input pulumi.ArrayArrayInput `pulumi:"input"`
}

func (CoalescelistOutputArgs) ElementType 

func (CoalescelistOutputArgs) ElementType() reflect.Type

type CoalescelistResult 

type CoalescelistResult struct {
	Result []interface{} `pulumi:"result"`
}

func Coalescelist 

func Coalescelist(ctx *pulumi.Context, args *CoalescelistArgs, opts ...pulumi.InvokeOption) (*CoalescelistResult, error)

Returns the first non-empty list from the given list of lists.

type CoalescelistResultOutput 

type CoalescelistResultOutput struct{ *pulumi.OutputState }

func CoalescelistOutput 

func CoalescelistOutput(ctx *pulumi.Context, args CoalescelistOutputArgs, opts ...pulumi.InvokeOption) CoalescelistResultOutput

func (CoalescelistResultOutput) ElementType 

func (CoalescelistResultOutput) ElementType() reflect.Type

func (CoalescelistResultOutput) Result 

func (o CoalescelistResultOutput) Result() pulumi.ArrayOutput

func (CoalescelistResultOutput) ToCoalescelistResultOutput 

func (o CoalescelistResultOutput) ToCoalescelistResultOutput() CoalescelistResultOutput

func (CoalescelistResultOutput) ToCoalescelistResultOutputWithContext 

func (o CoalescelistResultOutput) ToCoalescelistResultOutputWithContext(ctx context.Context) CoalescelistResultOutput

type CompactArgs 

type CompactArgs struct {
	Input []string `pulumi:"input"`
}

type CompactOutputArgs 

type CompactOutputArgs struct {
	Input pulumi.StringArrayInput `pulumi:"input"`
}

func (CompactOutputArgs) ElementType 

func (CompactOutputArgs) ElementType() reflect.Type

type CompactResult 

type CompactResult struct {
	Result []string `pulumi:"result"`
}

func Compact 

func Compact(ctx *pulumi.Context, args *CompactArgs, opts ...pulumi.InvokeOption) (*CompactResult, error)

Removes empty string elements from a list.

type CompactResultOutput 

type CompactResultOutput struct{ *pulumi.OutputState }

func CompactOutput 

func CompactOutput(ctx *pulumi.Context, args CompactOutputArgs, opts ...pulumi.InvokeOption) CompactResultOutput

func (CompactResultOutput) ElementType 

func (CompactResultOutput) ElementType() reflect.Type

func (CompactResultOutput) Result 

func (o CompactResultOutput) Result() pulumi.StringArrayOutput

func (CompactResultOutput) ToCompactResultOutput 

func (o CompactResultOutput) ToCompactResultOutput() CompactResultOutput

func (CompactResultOutput) ToCompactResultOutputWithContext 

func (o CompactResultOutput) ToCompactResultOutputWithContext(ctx context.Context) CompactResultOutput

type ConcatArgs 

type ConcatArgs struct {
	Input [][]interface{} `pulumi:"input"`
}

type ConcatOutputArgs 

type ConcatOutputArgs struct {
	Input pulumi.ArrayArrayInput `pulumi:"input"`
}

func (ConcatOutputArgs) ElementType 

func (ConcatOutputArgs) ElementType() reflect.Type

type ConcatResult 

type ConcatResult struct {
	Result []interface{} `pulumi:"result"`
}

func Concat 

func Concat(ctx *pulumi.Context, args *ConcatArgs, opts ...pulumi.InvokeOption) (*ConcatResult, error)

Combines two or more lists into a single list.

type ConcatResultOutput 

type ConcatResultOutput struct{ *pulumi.OutputState }

func ConcatOutput 

func ConcatOutput(ctx *pulumi.Context, args ConcatOutputArgs, opts ...pulumi.InvokeOption) ConcatResultOutput

func (ConcatResultOutput) ElementType 

func (ConcatResultOutput) ElementType() reflect.Type

func (ConcatResultOutput) Result 

func (o ConcatResultOutput) Result() pulumi.ArrayOutput

func (ConcatResultOutput) ToConcatResultOutput 

func (o ConcatResultOutput) ToConcatResultOutput() ConcatResultOutput

func (ConcatResultOutput) ToConcatResultOutputWithContext 

func (o ConcatResultOutput) ToConcatResultOutputWithContext(ctx context.Context) ConcatResultOutput

type ContainsArgs 

type ContainsArgs struct {
	Element interface{}   `pulumi:"element"`
	Input   []interface{} `pulumi:"input"`
}

type ContainsOutputArgs 

type ContainsOutputArgs struct {
	Element pulumi.Input      `pulumi:"element"`
	Input   pulumi.ArrayInput `pulumi:"input"`
}

func (ContainsOutputArgs) ElementType 

func (ContainsOutputArgs) ElementType() reflect.Type

type ContainsResult 

type ContainsResult struct {
	Result bool `pulumi:"result"`
}

func Contains 

func Contains(ctx *pulumi.Context, args *ContainsArgs, opts ...pulumi.InvokeOption) (*ContainsResult, error)

Returns true if a list contains the given element and returns false otherwise.

type ContainsResultOutput 

type ContainsResultOutput struct{ *pulumi.OutputState }

func ContainsOutput 

func ContainsOutput(ctx *pulumi.Context, args ContainsOutputArgs, opts ...pulumi.InvokeOption) ContainsResultOutput

func (ContainsResultOutput) ElementType 

func (ContainsResultOutput) ElementType() reflect.Type

func (ContainsResultOutput) Result 

func (o ContainsResultOutput) Result() pulumi.BoolOutput

func (ContainsResultOutput) ToContainsResultOutput 

func (o ContainsResultOutput) ToContainsResultOutput() ContainsResultOutput

func (ContainsResultOutput) ToContainsResultOutputWithContext 

func (o ContainsResultOutput) ToContainsResultOutputWithContext(ctx context.Context) ContainsResultOutput

type CsvdecodeArgs 

type CsvdecodeArgs struct {
	Input string `pulumi:"input"`
}

type CsvdecodeOutputArgs 

type CsvdecodeOutputArgs struct {
	Input pulumi.StringInput `pulumi:"input"`
}

func (CsvdecodeOutputArgs) ElementType 

func (CsvdecodeOutputArgs) ElementType() reflect.Type

type CsvdecodeResult 

type CsvdecodeResult struct {
	Result []map[string]string `pulumi:"result"`
}

func Csvdecode 

func Csvdecode(ctx *pulumi.Context, args *CsvdecodeArgs, opts ...pulumi.InvokeOption) (*CsvdecodeResult, error)

Decodes a string containing CSV-formatted data and produces a list of maps representing that data. 

The first line of the CSV data is interpreted as a "header" row: the values given
are used as the keys in the resulting maps.
Each subsequent line becomes a single map in the resulting list,
matching the keys from the header row with the given values by index.
All lines in the file must contain the same number of fields,
or this function will produce an error.
Follows the format defined in RFC 4180.

type CsvdecodeResultOutput 

type CsvdecodeResultOutput struct{ *pulumi.OutputState }

func CsvdecodeOutput 

func CsvdecodeOutput(ctx *pulumi.Context, args CsvdecodeOutputArgs, opts ...pulumi.InvokeOption) CsvdecodeResultOutput

func (CsvdecodeResultOutput) ElementType 

func (CsvdecodeResultOutput) ElementType() reflect.Type

func (CsvdecodeResultOutput) Result 

func (o CsvdecodeResultOutput) Result() pulumi.StringMapArrayOutput

func (CsvdecodeResultOutput) ToCsvdecodeResultOutput 

func (o CsvdecodeResultOutput) ToCsvdecodeResultOutput() CsvdecodeResultOutput

func (CsvdecodeResultOutput) ToCsvdecodeResultOutputWithContext 

func (o CsvdecodeResultOutput) ToCsvdecodeResultOutputWithContext(ctx context.Context) CsvdecodeResultOutput

type DirnameArgs 

type DirnameArgs struct {
	Input string `pulumi:"input"`
}

type DirnameOutputArgs 

type DirnameOutputArgs struct {
	Input pulumi.StringInput `pulumi:"input"`
}

func (DirnameOutputArgs) ElementType 

func (DirnameOutputArgs) ElementType() reflect.Type

type DirnameResult 

type DirnameResult struct {
	Result string `pulumi:"result"`
}

func Dirname 

func Dirname(ctx *pulumi.Context, args *DirnameArgs, opts ...pulumi.InvokeOption) (*DirnameResult, error)

Returns all but the last element of path, typically the path's directory.

type DirnameResultOutput 

type DirnameResultOutput struct{ *pulumi.OutputState }

func DirnameOutput 

func DirnameOutput(ctx *pulumi.Context, args DirnameOutputArgs, opts ...pulumi.InvokeOption) DirnameResultOutput

func (DirnameResultOutput) ElementType 

func (DirnameResultOutput) ElementType() reflect.Type

func (DirnameResultOutput) Result 

func (o DirnameResultOutput) Result() pulumi.StringOutput

func (DirnameResultOutput) ToDirnameResultOutput 

func (o DirnameResultOutput) ToDirnameResultOutput() DirnameResultOutput

func (DirnameResultOutput) ToDirnameResultOutputWithContext 

func (o DirnameResultOutput) ToDirnameResultOutputWithContext(ctx context.Context) DirnameResultOutput

type DistinctArgs 

type DistinctArgs struct {
	Input []interface{} `pulumi:"input"`
}

type DistinctOutputArgs 

type DistinctOutputArgs struct {
	Input pulumi.ArrayInput `pulumi:"input"`
}

func (DistinctOutputArgs) ElementType 

func (DistinctOutputArgs) ElementType() reflect.Type

type DistinctResult 

type DistinctResult struct {
	Result []interface{} `pulumi:"result"`
}

func Distinct 

func Distinct(ctx *pulumi.Context, args *DistinctArgs, opts ...pulumi.InvokeOption) (*DistinctResult, error)

Removes duplicate items from a list.

type DistinctResultOutput 

type DistinctResultOutput struct{ *pulumi.OutputState }

func DistinctOutput 

func DistinctOutput(ctx *pulumi.Context, args DistinctOutputArgs, opts ...pulumi.InvokeOption) DistinctResultOutput

func (DistinctResultOutput) ElementType 

func (DistinctResultOutput) ElementType() reflect.Type

func (DistinctResultOutput) Result 

func (o DistinctResultOutput) Result() pulumi.ArrayOutput

func (DistinctResultOutput) ToDistinctResultOutput 

func (o DistinctResultOutput) ToDistinctResultOutput() DistinctResultOutput

func (DistinctResultOutput) ToDistinctResultOutputWithContext 

func (o DistinctResultOutput) ToDistinctResultOutputWithContext(ctx context.Context) DistinctResultOutput

type ElementArgs 

type ElementArgs struct {
	Index int           `pulumi:"index"`
	Input []interface{} `pulumi:"input"`
}

type ElementOutputArgs 

type ElementOutputArgs struct {
	Index pulumi.IntInput   `pulumi:"index"`
	Input pulumi.ArrayInput `pulumi:"input"`
}

func (ElementOutputArgs) ElementType 

func (ElementOutputArgs) ElementType() reflect.Type

type ElementResult 

type ElementResult struct {
	Result interface{} `pulumi:"result"`
}

func Element 

func Element(ctx *pulumi.Context, args *ElementArgs, opts ...pulumi.InvokeOption) (*ElementResult, error)

Returns the element at the specified index.

type ElementResultOutput 

type ElementResultOutput struct{ *pulumi.OutputState }

func ElementOutput 

func ElementOutput(ctx *pulumi.Context, args ElementOutputArgs, opts ...pulumi.InvokeOption) ElementResultOutput

func (ElementResultOutput) ElementType 

func (ElementResultOutput) ElementType() reflect.Type

func (ElementResultOutput) Result 

func (o ElementResultOutput) Result() pulumi.AnyOutput

func (ElementResultOutput) ToElementResultOutput 

func (o ElementResultOutput) ToElementResultOutput() ElementResultOutput

func (ElementResultOutput) ToElementResultOutputWithContext 

func (o ElementResultOutput) ToElementResultOutputWithContext(ctx context.Context) ElementResultOutput

type EndswithArgs 

type EndswithArgs struct {
	Input  string `pulumi:"input"`
	Suffix string `pulumi:"suffix"`
}

type EndswithOutputArgs 

type EndswithOutputArgs struct {
	Input  pulumi.StringInput `pulumi:"input"`
	Suffix pulumi.StringInput `pulumi:"suffix"`
}

func (EndswithOutputArgs) ElementType 

func (EndswithOutputArgs) ElementType() reflect.Type

type EndswithResult 

type EndswithResult struct {
	Result bool `pulumi:"result"`
}

func Endswith 

func Endswith(ctx *pulumi.Context, args *EndswithArgs, opts ...pulumi.InvokeOption) (*EndswithResult, error)

Determines if the input string ends with the suffix.

type EndswithResultOutput 

type EndswithResultOutput struct{ *pulumi.OutputState }

func EndswithOutput 

func EndswithOutput(ctx *pulumi.Context, args EndswithOutputArgs, opts ...pulumi.InvokeOption) EndswithResultOutput

func (EndswithResultOutput) ElementType 

func (EndswithResultOutput) ElementType() reflect.Type

func (EndswithResultOutput) Result 

func (o EndswithResultOutput) Result() pulumi.BoolOutput

func (EndswithResultOutput) ToEndswithResultOutput 

func (o EndswithResultOutput) ToEndswithResultOutput() EndswithResultOutput

func (EndswithResultOutput) ToEndswithResultOutputWithContext 

func (o EndswithResultOutput) ToEndswithResultOutputWithContext(ctx context.Context) EndswithResultOutput

type FileArgs 

type FileArgs struct {
	Input string `pulumi:"input"`
}

type FileOutputArgs 

type FileOutputArgs struct {
	Input pulumi.StringInput `pulumi:"input"`
}

func (FileOutputArgs) ElementType 

func (FileOutputArgs) ElementType() reflect.Type

type FileResult 

type FileResult struct {
	Result string `pulumi:"result"`
}

func File 

func File(ctx *pulumi.Context, args *FileArgs, opts ...pulumi.InvokeOption) (*FileResult, error)

Reads the contents of a file into the string.

type FileResultOutput 

type FileResultOutput struct{ *pulumi.OutputState }

func FileOutput 

func FileOutput(ctx *pulumi.Context, args FileOutputArgs, opts ...pulumi.InvokeOption) FileResultOutput

func (FileResultOutput) ElementType 

func (FileResultOutput) ElementType() reflect.Type

func (FileResultOutput) Result 

func (o FileResultOutput) Result() pulumi.StringOutput

func (FileResultOutput) ToFileResultOutput 

func (o FileResultOutput) ToFileResultOutput() FileResultOutput

func (FileResultOutput) ToFileResultOutputWithContext 

func (o FileResultOutput) ToFileResultOutputWithContext(ctx context.Context) FileResultOutput

type Filebase64Args 

type Filebase64Args struct {
	Input string `pulumi:"input"`
}

type Filebase64OutputArgs 

type Filebase64OutputArgs struct {
	Input pulumi.StringInput `pulumi:"input"`
}

func (Filebase64OutputArgs) ElementType 

func (Filebase64OutputArgs) ElementType() reflect.Type

type Filebase64Result 

type Filebase64Result struct {
	Result string `pulumi:"result"`
}

func Filebase64 

func Filebase64(ctx *pulumi.Context, args *Filebase64Args, opts ...pulumi.InvokeOption) (*Filebase64Result, error)

Reads the contents of a file and returns them as a base64-encoded string.

type Filebase64ResultOutput 

type Filebase64ResultOutput struct{ *pulumi.OutputState }

func Filebase64Output 

func Filebase64Output(ctx *pulumi.Context, args Filebase64OutputArgs, opts ...pulumi.InvokeOption) Filebase64ResultOutput

func (Filebase64ResultOutput) ElementType 

func (Filebase64ResultOutput) ElementType() reflect.Type

func (Filebase64ResultOutput) Result 

func (o Filebase64ResultOutput) Result() pulumi.StringOutput

func (Filebase64ResultOutput) ToFilebase64ResultOutput 

func (o Filebase64ResultOutput) ToFilebase64ResultOutput() Filebase64ResultOutput

func (Filebase64ResultOutput) ToFilebase64ResultOutputWithContext 

func (o Filebase64ResultOutput) ToFilebase64ResultOutputWithContext(ctx context.Context) Filebase64ResultOutput

type Filebase64sha256Args 

type Filebase64sha256Args struct {
	Input string `pulumi:"input"`
}

type Filebase64sha256OutputArgs 

type Filebase64sha256OutputArgs struct {
	Input pulumi.StringInput `pulumi:"input"`
}

func (Filebase64sha256OutputArgs) ElementType 

func (Filebase64sha256OutputArgs) ElementType() reflect.Type

type Filebase64sha256Result 

type Filebase64sha256Result struct {
	Result string `pulumi:"result"`
}

func Filebase64sha256 

func Filebase64sha256(ctx *pulumi.Context, args *Filebase64sha256Args, opts ...pulumi.InvokeOption) (*Filebase64sha256Result, error)

Reads the contents of a file into a string and returns the base64-encoded SHA256 hash of it.

type Filebase64sha256ResultOutput 

type Filebase64sha256ResultOutput struct{ *pulumi.OutputState }

func Filebase64sha256Output 

func Filebase64sha256Output(ctx *pulumi.Context, args Filebase64sha256OutputArgs, opts ...pulumi.InvokeOption) Filebase64sha256ResultOutput

func (Filebase64sha256ResultOutput) ElementType 

func (Filebase64sha256ResultOutput) ElementType() reflect.Type

func (Filebase64sha256ResultOutput) Result 

func (o Filebase64sha256ResultOutput) Result() pulumi.StringOutput

func (Filebase64sha256ResultOutput) ToFilebase64sha256ResultOutput 

func (o Filebase64sha256ResultOutput) ToFilebase64sha256ResultOutput() Filebase64sha256ResultOutput

func (Filebase64sha256ResultOutput) ToFilebase64sha256ResultOutputWithContext 

func (o Filebase64sha256ResultOutput) ToFilebase64sha256ResultOutputWithContext(ctx context.Context) Filebase64sha256ResultOutput

type Filebase64sha512Args 

type Filebase64sha512Args struct {
	Input string `pulumi:"input"`
}

type Filebase64sha512OutputArgs 

type Filebase64sha512OutputArgs struct {
	Input pulumi.StringInput `pulumi:"input"`
}

func (Filebase64sha512OutputArgs) ElementType 

func (Filebase64sha512OutputArgs) ElementType() reflect.Type

type Filebase64sha512Result 

type Filebase64sha512Result struct {
	Result string `pulumi:"result"`
}

func Filebase64sha512 

func Filebase64sha512(ctx *pulumi.Context, args *Filebase64sha512Args, opts ...pulumi.InvokeOption) (*Filebase64sha512Result, error)

Reads the contents of a file into a string and returns the base64-encoded SHA512 hash of it.

type Filebase64sha512ResultOutput 

type Filebase64sha512ResultOutput struct{ *pulumi.OutputState }

func Filebase64sha512Output 

func Filebase64sha512Output(ctx *pulumi.Context, args Filebase64sha512OutputArgs, opts ...pulumi.InvokeOption) Filebase64sha512ResultOutput

func (Filebase64sha512ResultOutput) ElementType 

func (Filebase64sha512ResultOutput) ElementType() reflect.Type

func (Filebase64sha512ResultOutput) Result 

func (o Filebase64sha512ResultOutput) Result() pulumi.StringOutput

func (Filebase64sha512ResultOutput) ToFilebase64sha512ResultOutput 

func (o Filebase64sha512ResultOutput) ToFilebase64sha512ResultOutput() Filebase64sha512ResultOutput

func (Filebase64sha512ResultOutput) ToFilebase64sha512ResultOutputWithContext 

func (o Filebase64sha512ResultOutput) ToFilebase64sha512ResultOutputWithContext(ctx context.Context) Filebase64sha512ResultOutput

type FileexistsArgs 

type FileexistsArgs struct {
	Input string `pulumi:"input"`
}

type FileexistsOutputArgs 

type FileexistsOutputArgs struct {
	Input pulumi.StringInput `pulumi:"input"`
}

func (FileexistsOutputArgs) ElementType 

func (FileexistsOutputArgs) ElementType() reflect.Type

type FileexistsResult 

type FileexistsResult struct {
	Result bool `pulumi:"result"`
}

func Fileexists 

func Fileexists(ctx *pulumi.Context, args *FileexistsArgs, opts ...pulumi.InvokeOption) (*FileexistsResult, error)

Determines whether a file exists at a given path.

type FileexistsResultOutput 

type FileexistsResultOutput struct{ *pulumi.OutputState }

func FileexistsOutput 

func FileexistsOutput(ctx *pulumi.Context, args FileexistsOutputArgs, opts ...pulumi.InvokeOption) FileexistsResultOutput

func (FileexistsResultOutput) ElementType 

func (FileexistsResultOutput) ElementType() reflect.Type

func (FileexistsResultOutput) Result 

func (o FileexistsResultOutput) Result() pulumi.BoolOutput

func (FileexistsResultOutput) ToFileexistsResultOutput 

func (o FileexistsResultOutput) ToFileexistsResultOutput() FileexistsResultOutput

func (FileexistsResultOutput) ToFileexistsResultOutputWithContext 

func (o FileexistsResultOutput) ToFileexistsResultOutputWithContext(ctx context.Context) FileexistsResultOutput

type Filemd5Args 

type Filemd5Args struct {
	Input string `pulumi:"input"`
}

type Filemd5OutputArgs 

type Filemd5OutputArgs struct {
	Input pulumi.StringInput `pulumi:"input"`
}

func (Filemd5OutputArgs) ElementType 

func (Filemd5OutputArgs) ElementType() reflect.Type

type Filemd5Result 

type Filemd5Result struct {
	Result string `pulumi:"result"`
}

func Filemd5 

func Filemd5(ctx *pulumi.Context, args *Filemd5Args, opts ...pulumi.InvokeOption) (*Filemd5Result, error)

Reads the contents of a file into a string and returns the MD5 hash of it.

type Filemd5ResultOutput 

type Filemd5ResultOutput struct{ *pulumi.OutputState }

func Filemd5Output 

func Filemd5Output(ctx *pulumi.Context, args Filemd5OutputArgs, opts ...pulumi.InvokeOption) Filemd5ResultOutput

func (Filemd5ResultOutput) ElementType 

func (Filemd5ResultOutput) ElementType() reflect.Type

func (Filemd5ResultOutput) Result 

func (o Filemd5ResultOutput) Result() pulumi.StringOutput

func (Filemd5ResultOutput) ToFilemd5ResultOutput 

func (o Filemd5ResultOutput) ToFilemd5ResultOutput() Filemd5ResultOutput

func (Filemd5ResultOutput) ToFilemd5ResultOutputWithContext 

func (o Filemd5ResultOutput) ToFilemd5ResultOutputWithContext(ctx context.Context) Filemd5ResultOutput

type Filesha1Args 

type Filesha1Args struct {
	Input string `pulumi:"input"`
}

type Filesha1OutputArgs 

type Filesha1OutputArgs struct {
	Input pulumi.StringInput `pulumi:"input"`
}

func (Filesha1OutputArgs) ElementType 

func (Filesha1OutputArgs) ElementType() reflect.Type

type Filesha1Result 

type Filesha1Result struct {
	Result string `pulumi:"result"`
}

func Filesha1 

func Filesha1(ctx *pulumi.Context, args *Filesha1Args, opts ...pulumi.InvokeOption) (*Filesha1Result, error)

Reads the contents of a file into a string and returns the SHA1 hash of it.

type Filesha1ResultOutput 

type Filesha1ResultOutput struct{ *pulumi.OutputState }

func Filesha1Output 

func Filesha1Output(ctx *pulumi.Context, args Filesha1OutputArgs, opts ...pulumi.InvokeOption) Filesha1ResultOutput

func (Filesha1ResultOutput) ElementType 

func (Filesha1ResultOutput) ElementType() reflect.Type

func (Filesha1ResultOutput) Result 

func (o Filesha1ResultOutput) Result() pulumi.StringOutput

func (Filesha1ResultOutput) ToFilesha1ResultOutput 

func (o Filesha1ResultOutput) ToFilesha1ResultOutput() Filesha1ResultOutput

func (Filesha1ResultOutput) ToFilesha1ResultOutputWithContext 

func (o Filesha1ResultOutput) ToFilesha1ResultOutputWithContext(ctx context.Context) Filesha1ResultOutput

type Filesha256Args 

type Filesha256Args struct {
	Input string `pulumi:"input"`
}

type Filesha256OutputArgs 

type Filesha256OutputArgs struct {
	Input pulumi.StringInput `pulumi:"input"`
}

func (Filesha256OutputArgs) ElementType 

func (Filesha256OutputArgs) ElementType() reflect.Type

type Filesha256Result 

type Filesha256Result struct {
	Result string `pulumi:"result"`
}

func Filesha256 

func Filesha256(ctx *pulumi.Context, args *Filesha256Args, opts ...pulumi.InvokeOption) (*Filesha256Result, error)

Reads the contents of a file into a string and returns the SHA256 hash of it.

type Filesha256ResultOutput 

type Filesha256ResultOutput struct{ *pulumi.OutputState }

func Filesha256Output 

func Filesha256Output(ctx *pulumi.Context, args Filesha256OutputArgs, opts ...pulumi.InvokeOption) Filesha256ResultOutput

func (Filesha256ResultOutput) ElementType 

func (Filesha256ResultOutput) ElementType() reflect.Type

func (Filesha256ResultOutput) Result 

func (o Filesha256ResultOutput) Result() pulumi.StringOutput

func (Filesha256ResultOutput) ToFilesha256ResultOutput 

func (o Filesha256ResultOutput) ToFilesha256ResultOutput() Filesha256ResultOutput

func (Filesha256ResultOutput) ToFilesha256ResultOutputWithContext 

func (o Filesha256ResultOutput) ToFilesha256ResultOutputWithContext(ctx context.Context) Filesha256ResultOutput

type Filesha512Args 

type Filesha512Args struct {
	Input string `pulumi:"input"`
}

type Filesha512OutputArgs 

type Filesha512OutputArgs struct {
	Input pulumi.StringInput `pulumi:"input"`
}

func (Filesha512OutputArgs) ElementType 

func (Filesha512OutputArgs) ElementType() reflect.Type

type Filesha512Result 

type Filesha512Result struct {
	Result string `pulumi:"result"`
}

func Filesha512 

func Filesha512(ctx *pulumi.Context, args *Filesha512Args, opts ...pulumi.InvokeOption) (*Filesha512Result, error)

Reads the contents of a file into a string and returns the SHA512 hash of it.

type Filesha512ResultOutput 

type Filesha512ResultOutput struct{ *pulumi.OutputState }

func Filesha512Output 

func Filesha512Output(ctx *pulumi.Context, args Filesha512OutputArgs, opts ...pulumi.InvokeOption) Filesha512ResultOutput

func (Filesha512ResultOutput) ElementType 

func (Filesha512ResultOutput) ElementType() reflect.Type

func (Filesha512ResultOutput) Result 

func (o Filesha512ResultOutput) Result() pulumi.StringOutput

func (Filesha512ResultOutput) ToFilesha512ResultOutput 

func (o Filesha512ResultOutput) ToFilesha512ResultOutput() Filesha512ResultOutput

func (Filesha512ResultOutput) ToFilesha512ResultOutputWithContext 

func (o Filesha512ResultOutput) ToFilesha512ResultOutputWithContext(ctx context.Context) Filesha512ResultOutput

type FlattenArgs 

type FlattenArgs struct {
	Input []interface{} `pulumi:"input"`
}

type FlattenOutputArgs 

type FlattenOutputArgs struct {
	Input pulumi.ArrayInput `pulumi:"input"`
}

func (FlattenOutputArgs) ElementType 

func (FlattenOutputArgs) ElementType() reflect.Type

type FlattenResult 

type FlattenResult struct {
	Result []interface{} `pulumi:"result"`
}

func Flatten 

func Flatten(ctx *pulumi.Context, args *FlattenArgs, opts ...pulumi.InvokeOption) (*FlattenResult, error)

Flattens lists of lists down to a flat list of primitive values, eliminating any nested lists recursively.

type FlattenResultOutput 

type FlattenResultOutput struct{ *pulumi.OutputState }

func FlattenOutput 

func FlattenOutput(ctx *pulumi.Context, args FlattenOutputArgs, opts ...pulumi.InvokeOption) FlattenResultOutput

func (FlattenResultOutput) ElementType 

func (FlattenResultOutput) ElementType() reflect.Type

func (FlattenResultOutput) Result 

func (o FlattenResultOutput) Result() pulumi.ArrayOutput

func (FlattenResultOutput) ToFlattenResultOutput 

func (o FlattenResultOutput) ToFlattenResultOutput() FlattenResultOutput

func (FlattenResultOutput) ToFlattenResultOutputWithContext 

func (o FlattenResultOutput) ToFlattenResultOutputWithContext(ctx context.Context) FlattenResultOutput

type FloorArgs 

type FloorArgs struct {
	Input float64 `pulumi:"input"`
}

type FloorOutputArgs 

type FloorOutputArgs struct {
	Input pulumi.Float64Input `pulumi:"input"`
}

func (FloorOutputArgs) ElementType 

func (FloorOutputArgs) ElementType() reflect.Type

type FloorResult 

type FloorResult struct {
	Result float64 `pulumi:"result"`
}

func Floor 

func Floor(ctx *pulumi.Context, args *FloorArgs, opts ...pulumi.InvokeOption) (*FloorResult, error)

Returns the greatest integer value less than or equal to the argument.

type FloorResultOutput 

type FloorResultOutput struct{ *pulumi.OutputState }

func FloorOutput 

func FloorOutput(ctx *pulumi.Context, args FloorOutputArgs, opts ...pulumi.InvokeOption) FloorResultOutput

func (FloorResultOutput) ElementType 

func (FloorResultOutput) ElementType() reflect.Type

func (FloorResultOutput) Result 

func (o FloorResultOutput) Result() pulumi.Float64Output

func (FloorResultOutput) ToFloorResultOutput 

func (o FloorResultOutput) ToFloorResultOutput() FloorResultOutput

func (FloorResultOutput) ToFloorResultOutputWithContext 

func (o FloorResultOutput) ToFloorResultOutputWithContext(ctx context.Context) FloorResultOutput

type FormatArgs 

type FormatArgs struct {
	Args  []interface{} `pulumi:"args"`
	Input string        `pulumi:"input"`
}

type FormatOutputArgs 

type FormatOutputArgs struct {
	Args  pulumi.ArrayInput  `pulumi:"args"`
	Input pulumi.StringInput `pulumi:"input"`
}

func (FormatOutputArgs) ElementType 

func (FormatOutputArgs) ElementType() reflect.Type

type FormatResult 

type FormatResult struct {
	Result string `pulumi:"result"`
}

func Format 

func Format(ctx *pulumi.Context, args *FormatArgs, opts ...pulumi.InvokeOption) (*FormatResult, error)

Formats a string according to the given format. The syntax for the format is standard sprintf syntax.

type FormatResultOutput 

type FormatResultOutput struct{ *pulumi.OutputState }

func FormatOutput 

func FormatOutput(ctx *pulumi.Context, args FormatOutputArgs, opts ...pulumi.InvokeOption) FormatResultOutput

func (FormatResultOutput) ElementType 

func (FormatResultOutput) ElementType() reflect.Type

func (FormatResultOutput) Result 

func (o FormatResultOutput) Result() pulumi.StringOutput

func (FormatResultOutput) ToFormatResultOutput 

func (o FormatResultOutput) ToFormatResultOutput() FormatResultOutput

func (FormatResultOutput) ToFormatResultOutputWithContext 

func (o FormatResultOutput) ToFormatResultOutputWithContext(ctx context.Context) FormatResultOutput

type IndentArgs 

type IndentArgs struct {
	Input  string `pulumi:"input"`
	Spaces int    `pulumi:"spaces"`
}

type IndentOutputArgs 

type IndentOutputArgs struct {
	Input  pulumi.StringInput `pulumi:"input"`
	Spaces pulumi.IntInput    `pulumi:"spaces"`
}

func (IndentOutputArgs) ElementType 

func (IndentOutputArgs) ElementType() reflect.Type

type IndentResult 

type IndentResult struct {
	Result string `pulumi:"result"`
}

func Indent 

func Indent(ctx *pulumi.Context, args *IndentArgs, opts ...pulumi.InvokeOption) (*IndentResult, error)

Adds a given number of spaces after each newline character in the given string.

type IndentResultOutput 

type IndentResultOutput struct{ *pulumi.OutputState }

func IndentOutput 

func IndentOutput(ctx *pulumi.Context, args IndentOutputArgs, opts ...pulumi.InvokeOption) IndentResultOutput

func (IndentResultOutput) ElementType 

func (IndentResultOutput) ElementType() reflect.Type

func (IndentResultOutput) Result 

func (o IndentResultOutput) Result() pulumi.StringOutput

func (IndentResultOutput) ToIndentResultOutput 

func (o IndentResultOutput) ToIndentResultOutput() IndentResultOutput

func (IndentResultOutput) ToIndentResultOutputWithContext 

func (o IndentResultOutput) ToIndentResultOutputWithContext(ctx context.Context) IndentResultOutput

type IndexArgs 

type IndexArgs struct {
	Element interface{}   `pulumi:"element"`
	Input   []interface{} `pulumi:"input"`
}

type IndexOutputArgs 

type IndexOutputArgs struct {
	Element pulumi.Input      `pulumi:"element"`
	Input   pulumi.ArrayInput `pulumi:"input"`
}

func (IndexOutputArgs) ElementType 

func (IndexOutputArgs) ElementType() reflect.Type

type IndexResult 

type IndexResult struct {
	Result int `pulumi:"result"`
}

func Index 

func Index(ctx *pulumi.Context, args *IndexArgs, opts ...pulumi.InvokeOption) (*IndexResult, error)

Finds the index of a given element in a list.

type IndexResultOutput 

type IndexResultOutput struct{ *pulumi.OutputState }

func IndexOutput 

func IndexOutput(ctx *pulumi.Context, args IndexOutputArgs, opts ...pulumi.InvokeOption) IndexResultOutput

func (IndexResultOutput) ElementType 

func (IndexResultOutput) ElementType() reflect.Type

func (IndexResultOutput) Result 

func (o IndexResultOutput) Result() pulumi.IntOutput

func (IndexResultOutput) ToIndexResultOutput 

func (o IndexResultOutput) ToIndexResultOutput() IndexResultOutput

func (IndexResultOutput) ToIndexResultOutputWithContext 

func (o IndexResultOutput) ToIndexResultOutputWithContext(ctx context.Context) IndexResultOutput

type JoinArgs 

type JoinArgs struct {
	Input     []string `pulumi:"input"`
	Separator string   `pulumi:"separator"`
}

type JoinOutputArgs 

type JoinOutputArgs struct {
	Input     pulumi.StringArrayInput `pulumi:"input"`
	Separator pulumi.StringInput      `pulumi:"separator"`
}

func (JoinOutputArgs) ElementType 

func (JoinOutputArgs) ElementType() reflect.Type

type JoinResult 

type JoinResult struct {
	Result string `pulumi:"result"`
}

func Join 

func Join(ctx *pulumi.Context, args *JoinArgs, opts ...pulumi.InvokeOption) (*JoinResult, error)

Joins the list with the delimiter for a resultant string.

type JoinResultOutput 

type JoinResultOutput struct{ *pulumi.OutputState }

func JoinOutput 

func JoinOutput(ctx *pulumi.Context, args JoinOutputArgs, opts ...pulumi.InvokeOption) JoinResultOutput

func (JoinResultOutput) ElementType 

func (JoinResultOutput) ElementType() reflect.Type

func (JoinResultOutput) Result 

func (o JoinResultOutput) Result() pulumi.StringOutput

func (JoinResultOutput) ToJoinResultOutput 

func (o JoinResultOutput) ToJoinResultOutput() JoinResultOutput

func (JoinResultOutput) ToJoinResultOutputWithContext 

func (o JoinResultOutput) ToJoinResultOutputWithContext(ctx context.Context) JoinResultOutput

type JsondecodeArgs 

type JsondecodeArgs struct {
	Input string `pulumi:"input"`
}

type JsondecodeOutputArgs 

type JsondecodeOutputArgs struct {
	Input pulumi.StringInput `pulumi:"input"`
}

func (JsondecodeOutputArgs) ElementType 

func (JsondecodeOutputArgs) ElementType() reflect.Type

type JsondecodeResult 

type JsondecodeResult struct {
	Result interface{} `pulumi:"result"`
}

func Jsondecode 

func Jsondecode(ctx *pulumi.Context, args *JsondecodeArgs, opts ...pulumi.InvokeOption) (*JsondecodeResult, error)

Interprets a given string as JSON and returns a represetation 

of the result of decoding that string.
If input is not valid JSON, the result will be the input unchanged.

type JsondecodeResultOutput 

type JsondecodeResultOutput struct{ *pulumi.OutputState }

func JsondecodeOutput 

func JsondecodeOutput(ctx *pulumi.Context, args JsondecodeOutputArgs, opts ...pulumi.InvokeOption) JsondecodeResultOutput

func (JsondecodeResultOutput) ElementType 

func (JsondecodeResultOutput) ElementType() reflect.Type

func (JsondecodeResultOutput) Result 

func (o JsondecodeResultOutput) Result() pulumi.AnyOutput

func (JsondecodeResultOutput) ToJsondecodeResultOutput 

func (o JsondecodeResultOutput) ToJsondecodeResultOutput() JsondecodeResultOutput

func (JsondecodeResultOutput) ToJsondecodeResultOutputWithContext 

func (o JsondecodeResultOutput) ToJsondecodeResultOutputWithContext(ctx context.Context) JsondecodeResultOutput

type JsonencodeArgs 

type JsonencodeArgs struct {
	Input interface{} `pulumi:"input"`
}

type JsonencodeOutputArgs 

type JsonencodeOutputArgs struct {
	Input pulumi.Input `pulumi:"input"`
}

func (JsonencodeOutputArgs) ElementType 

func (JsonencodeOutputArgs) ElementType() reflect.Type

type JsonencodeResult 

type JsonencodeResult struct {
	Result string `pulumi:"result"`
}

func Jsonencode 

func Jsonencode(ctx *pulumi.Context, args *JsonencodeArgs, opts ...pulumi.InvokeOption) (*JsonencodeResult, error)

Returns a JSON-encoded representation of the given value, which can contain arbitrarily-nested lists and maps. Note that if the value is a string then its value will be placed in quotes.

type JsonencodeResultOutput 

type JsonencodeResultOutput struct{ *pulumi.OutputState }

func JsonencodeOutput 

func JsonencodeOutput(ctx *pulumi.Context, args JsonencodeOutputArgs, opts ...pulumi.InvokeOption) JsonencodeResultOutput

func (JsonencodeResultOutput) ElementType 

func (JsonencodeResultOutput) ElementType() reflect.Type

func (JsonencodeResultOutput) Result 

func (o JsonencodeResultOutput) Result() pulumi.StringOutput

func (JsonencodeResultOutput) ToJsonencodeResultOutput 

func (o JsonencodeResultOutput) ToJsonencodeResultOutput() JsonencodeResultOutput

func (JsonencodeResultOutput) ToJsonencodeResultOutputWithContext 

func (o JsonencodeResultOutput) ToJsonencodeResultOutputWithContext(ctx context.Context) JsonencodeResultOutput

type KeysArgs 

type KeysArgs struct {
	Input map[string]interface{} `pulumi:"input"`
}

type KeysOutputArgs 

type KeysOutputArgs struct {
	Input pulumi.MapInput `pulumi:"input"`
}

func (KeysOutputArgs) ElementType 

func (KeysOutputArgs) ElementType() reflect.Type

type KeysResult 

type KeysResult struct {
	Result []string `pulumi:"result"`
}

func Keys 

func Keys(ctx *pulumi.Context, args *KeysArgs, opts ...pulumi.InvokeOption) (*KeysResult, error)

Returns a lexically sorted list of the map keys.

type KeysResultOutput 

type KeysResultOutput struct{ *pulumi.OutputState }

func KeysOutput 

func KeysOutput(ctx *pulumi.Context, args KeysOutputArgs, opts ...pulumi.InvokeOption) KeysResultOutput

func (KeysResultOutput) ElementType 

func (KeysResultOutput) ElementType() reflect.Type

func (KeysResultOutput) Result 

func (o KeysResultOutput) Result() pulumi.StringArrayOutput

func (KeysResultOutput) ToKeysResultOutput 

func (o KeysResultOutput) ToKeysResultOutput() KeysResultOutput

func (KeysResultOutput) ToKeysResultOutputWithContext 

func (o KeysResultOutput) ToKeysResultOutputWithContext(ctx context.Context) KeysResultOutput

type LengthArgs 

type LengthArgs struct {
	Input interface{} `pulumi:"input"`
}

type LengthOutputArgs 

type LengthOutputArgs struct {
	Input pulumi.Input `pulumi:"input"`
}

func (LengthOutputArgs) ElementType 

func (LengthOutputArgs) ElementType() reflect.Type

type LengthResult 

type LengthResult struct {
	Result int `pulumi:"result"`
}

func Length 

func Length(ctx *pulumi.Context, args *LengthArgs, opts ...pulumi.InvokeOption) (*LengthResult, error)

Determines the length of a given list, map, or string.

type LengthResultOutput 

type LengthResultOutput struct{ *pulumi.OutputState }

func LengthOutput 

func LengthOutput(ctx *pulumi.Context, args LengthOutputArgs, opts ...pulumi.InvokeOption) LengthResultOutput

func (LengthResultOutput) ElementType 

func (LengthResultOutput) ElementType() reflect.Type

func (LengthResultOutput) Result 

func (o LengthResultOutput) Result() pulumi.IntOutput

func (LengthResultOutput) ToLengthResultOutput 

func (o LengthResultOutput) ToLengthResultOutput() LengthResultOutput

func (LengthResultOutput) ToLengthResultOutputWithContext 

func (o LengthResultOutput) ToLengthResultOutputWithContext(ctx context.Context) LengthResultOutput

type LogArgs 

type LogArgs struct {
	Base  float64 `pulumi:"base"`
	Input float64 `pulumi:"input"`
}

type LogOutputArgs 

type LogOutputArgs struct {
	Base  pulumi.Float64Input `pulumi:"base"`
	Input pulumi.Float64Input `pulumi:"input"`
}

func (LogOutputArgs) ElementType 

func (LogOutputArgs) ElementType() reflect.Type

type LogResult 

type LogResult struct {
	Result float64 `pulumi:"result"`
}

func Log 

func Log(ctx *pulumi.Context, args *LogArgs, opts ...pulumi.InvokeOption) (*LogResult, error)

Returns the greatest integer value less than or equal to the argument.

type LogResultOutput 

type LogResultOutput struct{ *pulumi.OutputState }

func LogOutput 

func LogOutput(ctx *pulumi.Context, args LogOutputArgs, opts ...pulumi.InvokeOption) LogResultOutput

func (LogResultOutput) ElementType 

func (LogResultOutput) ElementType() reflect.Type

func (LogResultOutput) Result 

func (o LogResultOutput) Result() pulumi.Float64Output

func (LogResultOutput) ToLogResultOutput 

func (o LogResultOutput) ToLogResultOutput() LogResultOutput

func (LogResultOutput) ToLogResultOutputWithContext 

func (o LogResultOutput) ToLogResultOutputWithContext(ctx context.Context) LogResultOutput

type LookupArgs 

type LookupArgs struct {
	Default interface{}            `pulumi:"default"`
	Key     string                 `pulumi:"key"`
	Map     map[string]interface{} `pulumi:"map"`
}

type LookupOutputArgs 

type LookupOutputArgs struct {
	Default pulumi.Input       `pulumi:"default"`
	Key     pulumi.StringInput `pulumi:"key"`
	Map     pulumi.MapInput    `pulumi:"map"`
}

func (LookupOutputArgs) ElementType 

func (LookupOutputArgs) ElementType() reflect.Type

type LookupResult 

type LookupResult struct {
	Result interface{} `pulumi:"result"`
}

func Lookup 

func Lookup(ctx *pulumi.Context, args *LookupArgs, opts ...pulumi.InvokeOption) (*LookupResult, error)

Performs a dynamic lookup into a map variable.

type LookupResultOutput 

type LookupResultOutput struct{ *pulumi.OutputState }

func LookupOutput 

func LookupOutput(ctx *pulumi.Context, args LookupOutputArgs, opts ...pulumi.InvokeOption) LookupResultOutput

func (LookupResultOutput) ElementType 

func (LookupResultOutput) ElementType() reflect.Type

func (LookupResultOutput) Result 

func (o LookupResultOutput) Result() pulumi.AnyOutput

func (LookupResultOutput) ToLookupResultOutput 

func (o LookupResultOutput) ToLookupResultOutput() LookupResultOutput

func (LookupResultOutput) ToLookupResultOutputWithContext 

func (o LookupResultOutput) ToLookupResultOutputWithContext(ctx context.Context) LookupResultOutput

type LowerArgs 

type LowerArgs struct {
	Input string `pulumi:"input"`
}

type LowerOutputArgs 

type LowerOutputArgs struct {
	Input pulumi.StringInput `pulumi:"input"`
}

func (LowerOutputArgs) ElementType 

func (LowerOutputArgs) ElementType() reflect.Type

type LowerResult 

type LowerResult struct {
	Result string `pulumi:"result"`
}

func Lower 

func Lower(ctx *pulumi.Context, args *LowerArgs, opts ...pulumi.InvokeOption) (*LowerResult, error)

Returns a copy of the string with all Unicode letters mapped to their lower case.

type LowerResultOutput 

type LowerResultOutput struct{ *pulumi.OutputState }

func LowerOutput 

func LowerOutput(ctx *pulumi.Context, args LowerOutputArgs, opts ...pulumi.InvokeOption) LowerResultOutput

func (LowerResultOutput) ElementType 

func (LowerResultOutput) ElementType() reflect.Type

func (LowerResultOutput) Result 

func (o LowerResultOutput) Result() pulumi.StringOutput

func (LowerResultOutput) ToLowerResultOutput 

func (o LowerResultOutput) ToLowerResultOutput() LowerResultOutput

func (LowerResultOutput) ToLowerResultOutputWithContext 

func (o LowerResultOutput) ToLowerResultOutputWithContext(ctx context.Context) LowerResultOutput

type MapArgs 

type MapArgs struct {
	Args []interface{} `pulumi:"args"`
}

type MapOutputArgs 

type MapOutputArgs struct {
	Args pulumi.ArrayInput `pulumi:"args"`
}

func (MapOutputArgs) ElementType 

func (MapOutputArgs) ElementType() reflect.Type

type MapResult 

type MapResult struct {
	Result map[string]interface{} `pulumi:"result"`
}

func Map 

func Map(ctx *pulumi.Context, args *MapArgs, opts ...pulumi.InvokeOption) (*MapResult, error)

Returns a map consisting of the key/value pairs specified as arguments.

type MapResultOutput 

type MapResultOutput struct{ *pulumi.OutputState }

func MapOutput 

func MapOutput(ctx *pulumi.Context, args MapOutputArgs, opts ...pulumi.InvokeOption) MapResultOutput

func (MapResultOutput) ElementType 

func (MapResultOutput) ElementType() reflect.Type

func (MapResultOutput) Result 

func (o MapResultOutput) Result() pulumi.MapOutput

func (MapResultOutput) ToMapResultOutput 

func (o MapResultOutput) ToMapResultOutput() MapResultOutput

func (MapResultOutput) ToMapResultOutputWithContext 

func (o MapResultOutput) ToMapResultOutputWithContext(ctx context.Context) MapResultOutput

type MatchkeysArgs 

type MatchkeysArgs struct {
	SearchList []string `pulumi:"searchList"`
	Values     []string `pulumi:"values"`
}

type MatchkeysOutputArgs 

type MatchkeysOutputArgs struct {
	SearchList pulumi.StringArrayInput `pulumi:"searchList"`
	Values     pulumi.StringArrayInput `pulumi:"values"`
}

func (MatchkeysOutputArgs) ElementType 

func (MatchkeysOutputArgs) ElementType() reflect.Type

type MatchkeysResult 

type MatchkeysResult struct {
	Result []string `pulumi:"result"`
}

func Matchkeys 

func Matchkeys(ctx *pulumi.Context, args *MatchkeysArgs, opts ...pulumi.InvokeOption) (*MatchkeysResult, error)

For two lists values and keys of equal length, returns all elements from values where the corresponding element from keys exists in the searchset list.

type MatchkeysResultOutput 

type MatchkeysResultOutput struct{ *pulumi.OutputState }

func MatchkeysOutput 

func MatchkeysOutput(ctx *pulumi.Context, args MatchkeysOutputArgs, opts ...pulumi.InvokeOption) MatchkeysResultOutput

func (MatchkeysResultOutput) ElementType 

func (MatchkeysResultOutput) ElementType() reflect.Type

func (MatchkeysResultOutput) Result 

func (o MatchkeysResultOutput) Result() pulumi.StringArrayOutput

func (MatchkeysResultOutput) ToMatchkeysResultOutput 

func (o MatchkeysResultOutput) ToMatchkeysResultOutput() MatchkeysResultOutput

func (MatchkeysResultOutput) ToMatchkeysResultOutputWithContext 

func (o MatchkeysResultOutput) ToMatchkeysResultOutputWithContext(ctx context.Context) MatchkeysResultOutput

type MaxArgs 

type MaxArgs struct {
	Input []float64 `pulumi:"input"`
}

type MaxOutputArgs 

type MaxOutputArgs struct {
	Input pulumi.Float64ArrayInput `pulumi:"input"`
}

func (MaxOutputArgs) ElementType 

func (MaxOutputArgs) ElementType() reflect.Type

type MaxResult 

type MaxResult struct {
	Result float64 `pulumi:"result"`
}

func Max 

func Max(ctx *pulumi.Context, args *MaxArgs, opts ...pulumi.InvokeOption) (*MaxResult, error)

Returns the largest of the floats.

type MaxResultOutput 

type MaxResultOutput struct{ *pulumi.OutputState }

func MaxOutput 

func MaxOutput(ctx *pulumi.Context, args MaxOutputArgs, opts ...pulumi.InvokeOption) MaxResultOutput

func (MaxResultOutput) ElementType 

func (MaxResultOutput) ElementType() reflect.Type

func (MaxResultOutput) Result 

func (o MaxResultOutput) Result() pulumi.Float64Output

func (MaxResultOutput) ToMaxResultOutput 

func (o MaxResultOutput) ToMaxResultOutput() MaxResultOutput

func (MaxResultOutput) ToMaxResultOutputWithContext 

func (o MaxResultOutput) ToMaxResultOutputWithContext(ctx context.Context) MaxResultOutput

type Md5Args 

type Md5Args struct {
	Input string `pulumi:"input"`
}

type Md5OutputArgs 

type Md5OutputArgs struct {
	Input pulumi.StringInput `pulumi:"input"`
}

func (Md5OutputArgs) ElementType 

func (Md5OutputArgs) ElementType() reflect.Type

type Md5Result 

type Md5Result struct {
	Result string `pulumi:"result"`
}

func Md5 

func Md5(ctx *pulumi.Context, args *Md5Args, opts ...pulumi.InvokeOption) (*Md5Result, error)

Returns a (conventional) hexadecimal representation of the MD5 hash of the given string.

type Md5ResultOutput 

type Md5ResultOutput struct{ *pulumi.OutputState }

func Md5Output 

func Md5Output(ctx *pulumi.Context, args Md5OutputArgs, opts ...pulumi.InvokeOption) Md5ResultOutput

func (Md5ResultOutput) ElementType 

func (Md5ResultOutput) ElementType() reflect.Type

func (Md5ResultOutput) Result 

func (o Md5ResultOutput) Result() pulumi.StringOutput

func (Md5ResultOutput) ToMd5ResultOutput 

func (o Md5ResultOutput) ToMd5ResultOutput() Md5ResultOutput

func (Md5ResultOutput) ToMd5ResultOutputWithContext 

func (o Md5ResultOutput) ToMd5ResultOutputWithContext(ctx context.Context) Md5ResultOutput

type MergeArgs 

type MergeArgs struct {
	Input []map[string]interface{} `pulumi:"input"`
}

type MergeOutputArgs 

type MergeOutputArgs struct {
	Input pulumi.MapArrayInput `pulumi:"input"`
}

func (MergeOutputArgs) ElementType 

func (MergeOutputArgs) ElementType() reflect.Type

type MergeResult 

type MergeResult struct {
	Result map[string]interface{} `pulumi:"result"`
}

func Merge 

func Merge(ctx *pulumi.Context, args *MergeArgs, opts ...pulumi.InvokeOption) (*MergeResult, error)

Returns the union of 2 or more maps. The maps are consumed in the order provided, and duplicate keys overwrite previous entries.

type MergeResultOutput 

type MergeResultOutput struct{ *pulumi.OutputState }

func MergeOutput 

func MergeOutput(ctx *pulumi.Context, args MergeOutputArgs, opts ...pulumi.InvokeOption) MergeResultOutput

func (MergeResultOutput) ElementType 

func (MergeResultOutput) ElementType() reflect.Type

func (MergeResultOutput) Result 

func (o MergeResultOutput) Result() pulumi.MapOutput

func (MergeResultOutput) ToMergeResultOutput 

func (o MergeResultOutput) ToMergeResultOutput() MergeResultOutput

func (MergeResultOutput) ToMergeResultOutputWithContext 

func (o MergeResultOutput) ToMergeResultOutputWithContext(ctx context.Context) MergeResultOutput

type MinArgs 

type MinArgs struct {
	Input []float64 `pulumi:"input"`
}

type MinOutputArgs 

type MinOutputArgs struct {
	Input pulumi.Float64ArrayInput `pulumi:"input"`
}

func (MinOutputArgs) ElementType 

func (MinOutputArgs) ElementType() reflect.Type

type MinResult 

type MinResult struct {
	Result float64 `pulumi:"result"`
}

func Min 

func Min(ctx *pulumi.Context, args *MinArgs, opts ...pulumi.InvokeOption) (*MinResult, error)

Returns the smallest of the floats.

type MinResultOutput 

type MinResultOutput struct{ *pulumi.OutputState }

func MinOutput 

func MinOutput(ctx *pulumi.Context, args MinOutputArgs, opts ...pulumi.InvokeOption) MinResultOutput

func (MinResultOutput) ElementType 

func (MinResultOutput) ElementType() reflect.Type

func (MinResultOutput) Result 

func (o MinResultOutput) Result() pulumi.Float64Output

func (MinResultOutput) ToMinResultOutput 

func (o MinResultOutput) ToMinResultOutput() MinResultOutput

func (MinResultOutput) ToMinResultOutputWithContext 

func (o MinResultOutput) ToMinResultOutputWithContext(ctx context.Context) MinResultOutput

type ParseintArgs 

type ParseintArgs struct {
	Base  *int   `pulumi:"base"`
	Input string `pulumi:"input"`
}

type ParseintOutputArgs 

type ParseintOutputArgs struct {
	Base  pulumi.IntPtrInput `pulumi:"base"`
	Input pulumi.StringInput `pulumi:"input"`
}

func (ParseintOutputArgs) ElementType 

func (ParseintOutputArgs) ElementType() reflect.Type

type ParseintResult 

type ParseintResult struct {
	Result int `pulumi:"result"`
}

func Parseint 

func Parseint(ctx *pulumi.Context, args *ParseintArgs, opts ...pulumi.InvokeOption) (*ParseintResult, error)

Parses the given string as a representation of an integer in the specified base and returns the resulting number. The base must be between 2 and 62 inclusive. 

.

type ParseintResultOutput 

type ParseintResultOutput struct{ *pulumi.OutputState }

func ParseintOutput 

func ParseintOutput(ctx *pulumi.Context, args ParseintOutputArgs, opts ...pulumi.InvokeOption) ParseintResultOutput

func (ParseintResultOutput) ElementType 

func (ParseintResultOutput) ElementType() reflect.Type

func (ParseintResultOutput) Result 

func (o ParseintResultOutput) Result() pulumi.IntOutput

func (ParseintResultOutput) ToParseintResultOutput 

func (o ParseintResultOutput) ToParseintResultOutput() ParseintResultOutput

func (ParseintResultOutput) ToParseintResultOutputWithContext 

func (o ParseintResultOutput) ToParseintResultOutputWithContext(ctx context.Context) ParseintResultOutput

type PathexpandArgs 

type PathexpandArgs struct {
	Input string `pulumi:"input"`
}

type PathexpandOutputArgs 

type PathexpandOutputArgs struct {
	Input pulumi.StringInput `pulumi:"input"`
}

func (PathexpandOutputArgs) ElementType 

func (PathexpandOutputArgs) ElementType() reflect.Type

type PathexpandResult 

type PathexpandResult struct {
	Result string `pulumi:"result"`
}

func Pathexpand 

func Pathexpand(ctx *pulumi.Context, args *PathexpandArgs, opts ...pulumi.InvokeOption) (*PathexpandResult, error)

Returns a filepath string with ~ expanded to the home directory.

type PathexpandResultOutput 

type PathexpandResultOutput struct{ *pulumi.OutputState }

func PathexpandOutput 

func PathexpandOutput(ctx *pulumi.Context, args PathexpandOutputArgs, opts ...pulumi.InvokeOption) PathexpandResultOutput

func (PathexpandResultOutput) ElementType 

func (PathexpandResultOutput) ElementType() reflect.Type

func (PathexpandResultOutput) Result 

func (o PathexpandResultOutput) Result() pulumi.StringOutput

func (PathexpandResultOutput) ToPathexpandResultOutput 

func (o PathexpandResultOutput) ToPathexpandResultOutput() PathexpandResultOutput

func (PathexpandResultOutput) ToPathexpandResultOutputWithContext 

func (o PathexpandResultOutput) ToPathexpandResultOutputWithContext(ctx context.Context) PathexpandResultOutput

type PowArgs 

type PowArgs struct {
	Base     float64 `pulumi:"base"`
	Exponent float64 `pulumi:"exponent"`
}

type PowOutputArgs 

type PowOutputArgs struct {
	Base     pulumi.Float64Input `pulumi:"base"`
	Exponent pulumi.Float64Input `pulumi:"exponent"`
}

func (PowOutputArgs) ElementType 

func (PowOutputArgs) ElementType() reflect.Type

type PowResult 

type PowResult struct {
	Result float64 `pulumi:"result"`
}

func Pow 

func Pow(ctx *pulumi.Context, args *PowArgs, opts ...pulumi.InvokeOption) (*PowResult, error)

Returns the base input raised to the power of the exponent.

type PowResultOutput 

type PowResultOutput struct{ *pulumi.OutputState }

func PowOutput 

func PowOutput(ctx *pulumi.Context, args PowOutputArgs, opts ...pulumi.InvokeOption) PowResultOutput

func (PowResultOutput) ElementType 

func (PowResultOutput) ElementType() reflect.Type

func (PowResultOutput) Result 

func (o PowResultOutput) Result() pulumi.Float64Output

func (PowResultOutput) ToPowResultOutput 

func (o PowResultOutput) ToPowResultOutput() PowResultOutput

func (PowResultOutput) ToPowResultOutputWithContext 

func (o PowResultOutput) ToPowResultOutputWithContext(ctx context.Context) PowResultOutput

type Provider 

type Provider struct {
	pulumi.ProviderResourceState
}

func NewProvider 

func NewProvider(ctx *pulumi.Context,
	name string, args *ProviderArgs, opts ...pulumi.ResourceOption) (*Provider, error)

NewProvider registers a new resource with the given unique name, arguments, and options.

func (*Provider) ElementType 

func (*Provider) ElementType() reflect.Type

func (*Provider) ToProviderOutput 

func (i *Provider) ToProviderOutput() ProviderOutput

func (*Provider) ToProviderOutputWithContext 

func (i *Provider) ToProviderOutputWithContext(ctx context.Context) ProviderOutput

type ProviderArgs 

type ProviderArgs struct {
}

The set of arguments for constructing a Provider resource.

func (ProviderArgs) ElementType 

func (ProviderArgs) ElementType() reflect.Type

type ProviderInput 

type ProviderInput interface {
	pulumi.Input

	ToProviderOutput() ProviderOutput
	ToProviderOutputWithContext(ctx context.Context) ProviderOutput
}

type ProviderOutput 

type ProviderOutput struct{ *pulumi.OutputState }

func (ProviderOutput) ElementType 

func (ProviderOutput) ElementType() reflect.Type

func (ProviderOutput) ToProviderOutput 

func (o ProviderOutput) ToProviderOutput() ProviderOutput

func (ProviderOutput) ToProviderOutputWithContext 

func (o ProviderOutput) ToProviderOutputWithContext(ctx context.Context) ProviderOutput

type RangeArgs 

type RangeArgs struct {
	Limit float64  `pulumi:"limit"`
	Start *float64 `pulumi:"start"`
	Step  *float64 `pulumi:"step"`
}

type RangeOutputArgs 

type RangeOutputArgs struct {
	Limit pulumi.Float64Input    `pulumi:"limit"`
	Start pulumi.Float64PtrInput `pulumi:"start"`
	Step  pulumi.Float64PtrInput `pulumi:"step"`
}

func (RangeOutputArgs) ElementType 

func (RangeOutputArgs) ElementType() reflect.Type

type RangeResult 

type RangeResult struct {
	Result []float64 `pulumi:"result"`
}

func Range 

func Range(ctx *pulumi.Context, args *RangeArgs, opts ...pulumi.InvokeOption) (*RangeResult, error)

Generates a list of numbers using a start value, a limit value, and a step value. Start and step may be omitted, in which case start defaults to zero and step defaults to either one or negative one depending on whether limit is greater than or less than start.

type RangeResultOutput 

type RangeResultOutput struct{ *pulumi.OutputState }

func RangeOutput 

func RangeOutput(ctx *pulumi.Context, args RangeOutputArgs, opts ...pulumi.InvokeOption) RangeResultOutput

func (RangeResultOutput) ElementType 

func (RangeResultOutput) ElementType() reflect.Type

func (RangeResultOutput) Result 

func (o RangeResultOutput) Result() pulumi.Float64ArrayOutput

func (RangeResultOutput) ToRangeResultOutput 

func (o RangeResultOutput) ToRangeResultOutput() RangeResultOutput

func (RangeResultOutput) ToRangeResultOutputWithContext 

func (o RangeResultOutput) ToRangeResultOutputWithContext(ctx context.Context) RangeResultOutput

type ReplaceArgs 

type ReplaceArgs struct {
	Replace string `pulumi:"replace"`
	Search  string `pulumi:"search"`
	Text    string `pulumi:"text"`
}

type ReplaceOutputArgs 

type ReplaceOutputArgs struct {
	Replace pulumi.StringInput `pulumi:"replace"`
	Search  pulumi.StringInput `pulumi:"search"`
	Text    pulumi.StringInput `pulumi:"text"`
}

func (ReplaceOutputArgs) ElementType 

func (ReplaceOutputArgs) ElementType() reflect.Type

type ReplaceResult 

type ReplaceResult struct {
	Result string `pulumi:"result"`
}

func Replace 

func Replace(ctx *pulumi.Context, args *ReplaceArgs, opts ...pulumi.InvokeOption) (*ReplaceResult, error)

Does a search and replace on the given string. All instances of search are replaced with the value of replace. If search is wrapped in forward slashes, it is treated as a regular expression. If using a regular expression, replace can reference subcaptures in the regular expression by using $n where n is the index or name of the subcapture. If using a regular expression, the syntax conforms to the re2 regular expression syntax.

type ReplaceResultOutput 

type ReplaceResultOutput struct{ *pulumi.OutputState }

func ReplaceOutput 

func ReplaceOutput(ctx *pulumi.Context, args ReplaceOutputArgs, opts ...pulumi.InvokeOption) ReplaceResultOutput

func (ReplaceResultOutput) ElementType 

func (ReplaceResultOutput) ElementType() reflect.Type

func (ReplaceResultOutput) Result 

func (o ReplaceResultOutput) Result() pulumi.StringOutput

func (ReplaceResultOutput) ToReplaceResultOutput 

func (o ReplaceResultOutput) ToReplaceResultOutput() ReplaceResultOutput

func (ReplaceResultOutput) ToReplaceResultOutputWithContext 

func (o ReplaceResultOutput) ToReplaceResultOutputWithContext(ctx context.Context) ReplaceResultOutput

type ReverseArgs 

type ReverseArgs struct {
	Input []interface{} `pulumi:"input"`
}

type ReverseOutputArgs 

type ReverseOutputArgs struct {
	Input pulumi.ArrayInput `pulumi:"input"`
}

func (ReverseOutputArgs) ElementType 

func (ReverseOutputArgs) ElementType() reflect.Type

type ReverseResult 

type ReverseResult struct {
	Result []interface{} `pulumi:"result"`
}

func Reverse 

func Reverse(ctx *pulumi.Context, args *ReverseArgs, opts ...pulumi.InvokeOption) (*ReverseResult, error)

Returns a sequence with the same elements but in reverse order.

type ReverseResultOutput 

type ReverseResultOutput struct{ *pulumi.OutputState }

func ReverseOutput 

func ReverseOutput(ctx *pulumi.Context, args ReverseOutputArgs, opts ...pulumi.InvokeOption) ReverseResultOutput

func (ReverseResultOutput) ElementType 

func (ReverseResultOutput) ElementType() reflect.Type

func (ReverseResultOutput) Result 

func (o ReverseResultOutput) Result() pulumi.ArrayOutput

func (ReverseResultOutput) ToReverseResultOutput 

func (o ReverseResultOutput) ToReverseResultOutput() ReverseResultOutput

func (ReverseResultOutput) ToReverseResultOutputWithContext 

func (o ReverseResultOutput) ToReverseResultOutputWithContext(ctx context.Context) ReverseResultOutput

type RsadecryptArgs 

type RsadecryptArgs struct {
	CipherText string `pulumi:"cipherText"`
	Key        string `pulumi:"key"`
}

type RsadecryptOutputArgs 

type RsadecryptOutputArgs struct {
	CipherText pulumi.StringInput `pulumi:"cipherText"`
	Key        pulumi.StringInput `pulumi:"key"`
}

func (RsadecryptOutputArgs) ElementType 

func (RsadecryptOutputArgs) ElementType() reflect.Type

type RsadecryptResult 

type RsadecryptResult struct {
	Result string `pulumi:"result"`
}

func Rsadecrypt 

func Rsadecrypt(ctx *pulumi.Context, args *RsadecryptArgs, opts ...pulumi.InvokeOption) (*RsadecryptResult, error)

Decrypts an RSA-encrypted ciphertext. The cipher text must be base64-encoded and the key must be in PEM format.

type RsadecryptResultOutput 

type RsadecryptResultOutput struct{ *pulumi.OutputState }

func RsadecryptOutput 

func RsadecryptOutput(ctx *pulumi.Context, args RsadecryptOutputArgs, opts ...pulumi.InvokeOption) RsadecryptResultOutput

func (RsadecryptResultOutput) ElementType 

func (RsadecryptResultOutput) ElementType() reflect.Type

func (RsadecryptResultOutput) Result 

func (o RsadecryptResultOutput) Result() pulumi.StringOutput

func (RsadecryptResultOutput) ToRsadecryptResultOutput 

func (o RsadecryptResultOutput) ToRsadecryptResultOutput() RsadecryptResultOutput

func (RsadecryptResultOutput) ToRsadecryptResultOutputWithContext 

func (o RsadecryptResultOutput) ToRsadecryptResultOutputWithContext(ctx context.Context) RsadecryptResultOutput

type Sha1Args 

type Sha1Args struct {
	Input string `pulumi:"input"`
}

type Sha1OutputArgs 

type Sha1OutputArgs struct {
	Input pulumi.StringInput `pulumi:"input"`
}

func (Sha1OutputArgs) ElementType 

func (Sha1OutputArgs) ElementType() reflect.Type

type Sha1Result 

type Sha1Result struct {
	Result string `pulumi:"result"`
}

func Sha1 

func Sha1(ctx *pulumi.Context, args *Sha1Args, opts ...pulumi.InvokeOption) (*Sha1Result, error)

Returns a hexadecimal representation of the SHA-1 hash of the given string.

type Sha1ResultOutput 

type Sha1ResultOutput struct{ *pulumi.OutputState }

func Sha1Output 

func Sha1Output(ctx *pulumi.Context, args Sha1OutputArgs, opts ...pulumi.InvokeOption) Sha1ResultOutput

func (Sha1ResultOutput) ElementType 

func (Sha1ResultOutput) ElementType() reflect.Type

func (Sha1ResultOutput) Result 

func (o Sha1ResultOutput) Result() pulumi.StringOutput

func (Sha1ResultOutput) ToSha1ResultOutput 

func (o Sha1ResultOutput) ToSha1ResultOutput() Sha1ResultOutput

func (Sha1ResultOutput) ToSha1ResultOutputWithContext 

func (o Sha1ResultOutput) ToSha1ResultOutputWithContext(ctx context.Context) Sha1ResultOutput

type Sha256Args 

type Sha256Args struct {
	Input string `pulumi:"input"`
}

type Sha256OutputArgs 

type Sha256OutputArgs struct {
	Input pulumi.StringInput `pulumi:"input"`
}

func (Sha256OutputArgs) ElementType 

func (Sha256OutputArgs) ElementType() reflect.Type

type Sha256Result 

type Sha256Result struct {
	Result string `pulumi:"result"`
}

func Sha256 

func Sha256(ctx *pulumi.Context, args *Sha256Args, opts ...pulumi.InvokeOption) (*Sha256Result, error)

Returns a hexadecimal representation of the SHA-256 hash of the given string.

type Sha256ResultOutput 

type Sha256ResultOutput struct{ *pulumi.OutputState }

func Sha256Output 

func Sha256Output(ctx *pulumi.Context, args Sha256OutputArgs, opts ...pulumi.InvokeOption) Sha256ResultOutput

func (Sha256ResultOutput) ElementType 

func (Sha256ResultOutput) ElementType() reflect.Type

func (Sha256ResultOutput) Result 

func (o Sha256ResultOutput) Result() pulumi.StringOutput

func (Sha256ResultOutput) ToSha256ResultOutput 

func (o Sha256ResultOutput) ToSha256ResultOutput() Sha256ResultOutput

func (Sha256ResultOutput) ToSha256ResultOutputWithContext 

func (o Sha256ResultOutput) ToSha256ResultOutputWithContext(ctx context.Context) Sha256ResultOutput

type Sha512Args 

type Sha512Args struct {
	Input string `pulumi:"input"`
}

type Sha512OutputArgs 

type Sha512OutputArgs struct {
	Input pulumi.StringInput `pulumi:"input"`
}

func (Sha512OutputArgs) ElementType 

func (Sha512OutputArgs) ElementType() reflect.Type

type Sha512Result 

type Sha512Result struct {
	Result string `pulumi:"result"`
}

func Sha512 

func Sha512(ctx *pulumi.Context, args *Sha512Args, opts ...pulumi.InvokeOption) (*Sha512Result, error)

Returns a hexadecimal representation of the SHA-512 hash of the given string.

type Sha512ResultOutput 

type Sha512ResultOutput struct{ *pulumi.OutputState }

func Sha512Output 

func Sha512Output(ctx *pulumi.Context, args Sha512OutputArgs, opts ...pulumi.InvokeOption) Sha512ResultOutput

func (Sha512ResultOutput) ElementType 

func (Sha512ResultOutput) ElementType() reflect.Type

func (Sha512ResultOutput) Result 

func (o Sha512ResultOutput) Result() pulumi.StringOutput

func (Sha512ResultOutput) ToSha512ResultOutput 

func (o Sha512ResultOutput) ToSha512ResultOutput() Sha512ResultOutput

func (Sha512ResultOutput) ToSha512ResultOutputWithContext 

func (o Sha512ResultOutput) ToSha512ResultOutputWithContext(ctx context.Context) Sha512ResultOutput

type SignumArgs 

type SignumArgs struct {
	Input float64 `pulumi:"input"`
}

type SignumOutputArgs 

type SignumOutputArgs struct {
	Input pulumi.Float64Input `pulumi:"input"`
}

func (SignumOutputArgs) ElementType 

func (SignumOutputArgs) ElementType() reflect.Type

type SignumResult 

type SignumResult struct {
	Result float64 `pulumi:"result"`
}

func Signum 

func Signum(ctx *pulumi.Context, args *SignumArgs, opts ...pulumi.InvokeOption) (*SignumResult, error)

Returns the greatest integer value less than or equal to the argument.

type SignumResultOutput 

type SignumResultOutput struct{ *pulumi.OutputState }

func SignumOutput 

func SignumOutput(ctx *pulumi.Context, args SignumOutputArgs, opts ...pulumi.InvokeOption) SignumResultOutput

func (SignumResultOutput) ElementType 

func (SignumResultOutput) ElementType() reflect.Type

func (SignumResultOutput) Result 

func (o SignumResultOutput) Result() pulumi.Float64Output

func (SignumResultOutput) ToSignumResultOutput 

func (o SignumResultOutput) ToSignumResultOutput() SignumResultOutput

func (SignumResultOutput) ToSignumResultOutputWithContext 

func (o SignumResultOutput) ToSignumResultOutputWithContext(ctx context.Context) SignumResultOutput

type SliceArgs 

type SliceArgs struct {
	From *int          `pulumi:"from"`
	List []interface{} `pulumi:"list"`
	To   *int          `pulumi:"to"`
}

type SliceOutputArgs 

type SliceOutputArgs struct {
	From pulumi.IntPtrInput `pulumi:"from"`
	List pulumi.ArrayInput  `pulumi:"list"`
	To   pulumi.IntPtrInput `pulumi:"to"`
}

func (SliceOutputArgs) ElementType 

func (SliceOutputArgs) ElementType() reflect.Type

type SliceResult 

type SliceResult struct {
	Result []interface{} `pulumi:"result"`
}

func Slice 

func Slice(ctx *pulumi.Context, args *SliceArgs, opts ...pulumi.InvokeOption) (*SliceResult, error)

Returns the portion of list between from (inclusive) and to (exclusive).

type SliceResultOutput 

type SliceResultOutput struct{ *pulumi.OutputState }

func SliceOutput 

func SliceOutput(ctx *pulumi.Context, args SliceOutputArgs, opts ...pulumi.InvokeOption) SliceResultOutput

func (SliceResultOutput) ElementType 

func (SliceResultOutput) ElementType() reflect.Type

func (SliceResultOutput) Result 

func (o SliceResultOutput) Result() pulumi.ArrayOutput

func (SliceResultOutput) ToSliceResultOutput 

func (o SliceResultOutput) ToSliceResultOutput() SliceResultOutput

func (SliceResultOutput) ToSliceResultOutputWithContext 

func (o SliceResultOutput) ToSliceResultOutputWithContext(ctx context.Context) SliceResultOutput

type SortArgs 

type SortArgs struct {
	Input []string `pulumi:"input"`
}

type SortOutputArgs 

type SortOutputArgs struct {
	Input pulumi.StringArrayInput `pulumi:"input"`
}

func (SortOutputArgs) ElementType 

func (SortOutputArgs) ElementType() reflect.Type

type SortResult 

type SortResult struct {
	Result []string `pulumi:"result"`
}

func Sort 

func Sort(ctx *pulumi.Context, args *SortArgs, opts ...pulumi.InvokeOption) (*SortResult, error)

Returns a list of strings sorted lexicographically.

type SortResultOutput 

type SortResultOutput struct{ *pulumi.OutputState }

func SortOutput 

func SortOutput(ctx *pulumi.Context, args SortOutputArgs, opts ...pulumi.InvokeOption) SortResultOutput

func (SortResultOutput) ElementType 

func (SortResultOutput) ElementType() reflect.Type

func (SortResultOutput) Result 

func (o SortResultOutput) Result() pulumi.StringArrayOutput

func (SortResultOutput) ToSortResultOutput 

func (o SortResultOutput) ToSortResultOutput() SortResultOutput

func (SortResultOutput) ToSortResultOutputWithContext 

func (o SortResultOutput) ToSortResultOutputWithContext(ctx context.Context) SortResultOutput

type SplitArgs 

type SplitArgs struct {
	Separator string `pulumi:"separator"`
	Text      string `pulumi:"text"`
}

type SplitOutputArgs 

type SplitOutputArgs struct {
	Separator pulumi.StringInput `pulumi:"separator"`
	Text      pulumi.StringInput `pulumi:"text"`
}

func (SplitOutputArgs) ElementType 

func (SplitOutputArgs) ElementType() reflect.Type

type SplitResult 

type SplitResult struct {
	Result []string `pulumi:"result"`
}

func Split 

func Split(ctx *pulumi.Context, args *SplitArgs, opts ...pulumi.InvokeOption) (*SplitResult, error)

Produces a list by dividing a given string at all occurrences of a given separator

type SplitResultOutput 

type SplitResultOutput struct{ *pulumi.OutputState }

func SplitOutput 

func SplitOutput(ctx *pulumi.Context, args SplitOutputArgs, opts ...pulumi.InvokeOption) SplitResultOutput

func (SplitResultOutput) ElementType 

func (SplitResultOutput) ElementType() reflect.Type

func (SplitResultOutput) Result 

func (o SplitResultOutput) Result() pulumi.StringArrayOutput

func (SplitResultOutput) ToSplitResultOutput 

func (o SplitResultOutput) ToSplitResultOutput() SplitResultOutput

func (SplitResultOutput) ToSplitResultOutputWithContext 

func (o SplitResultOutput) ToSplitResultOutputWithContext(ctx context.Context) SplitResultOutput

type StartswithArgs 

type StartswithArgs struct {
	Input  string `pulumi:"input"`
	Prefix string `pulumi:"prefix"`
}

type StartswithOutputArgs 

type StartswithOutputArgs struct {
	Input  pulumi.StringInput `pulumi:"input"`
	Prefix pulumi.StringInput `pulumi:"prefix"`
}

func (StartswithOutputArgs) ElementType 

func (StartswithOutputArgs) ElementType() reflect.Type

type StartswithResult 

type StartswithResult struct {
	Result bool `pulumi:"result"`
}

func Startswith 

func Startswith(ctx *pulumi.Context, args *StartswithArgs, opts ...pulumi.InvokeOption) (*StartswithResult, error)

Determines if the input string starts with the suffix.

type StartswithResultOutput 

type StartswithResultOutput struct{ *pulumi.OutputState }

func StartswithOutput 

func StartswithOutput(ctx *pulumi.Context, args StartswithOutputArgs, opts ...pulumi.InvokeOption) StartswithResultOutput

func (StartswithResultOutput) ElementType 

func (StartswithResultOutput) ElementType() reflect.Type

func (StartswithResultOutput) Result 

func (o StartswithResultOutput) Result() pulumi.BoolOutput

func (StartswithResultOutput) ToStartswithResultOutput 

func (o StartswithResultOutput) ToStartswithResultOutput() StartswithResultOutput

func (StartswithResultOutput) ToStartswithResultOutputWithContext 

func (o StartswithResultOutput) ToStartswithResultOutputWithContext(ctx context.Context) StartswithResultOutput

type StrrevArgs 

type StrrevArgs struct {
	Input string `pulumi:"input"`
}

type StrrevOutputArgs 

type StrrevOutputArgs struct {
	Input pulumi.StringInput `pulumi:"input"`
}

func (StrrevOutputArgs) ElementType 

func (StrrevOutputArgs) ElementType() reflect.Type

type StrrevResult 

type StrrevResult struct {
	Result string `pulumi:"result"`
}

func Strrev 

func Strrev(ctx *pulumi.Context, args *StrrevArgs, opts ...pulumi.InvokeOption) (*StrrevResult, error)

Returns the given string with all of its Unicode characters in reverse order.

type StrrevResultOutput 

type StrrevResultOutput struct{ *pulumi.OutputState }

func StrrevOutput 

func StrrevOutput(ctx *pulumi.Context, args StrrevOutputArgs, opts ...pulumi.InvokeOption) StrrevResultOutput

func (StrrevResultOutput) ElementType 

func (StrrevResultOutput) ElementType() reflect.Type

func (StrrevResultOutput) Result 

func (o StrrevResultOutput) Result() pulumi.StringOutput

func (StrrevResultOutput) ToStrrevResultOutput 

func (o StrrevResultOutput) ToStrrevResultOutput() StrrevResultOutput

func (StrrevResultOutput) ToStrrevResultOutputWithContext 

func (o StrrevResultOutput) ToStrrevResultOutputWithContext(ctx context.Context) StrrevResultOutput

type SubstrArgs 

type SubstrArgs struct {
	Input  string `pulumi:"input"`
	Length int    `pulumi:"length"`
	Offset int    `pulumi:"offset"`
}

type SubstrOutputArgs 

type SubstrOutputArgs struct {
	Input  pulumi.StringInput `pulumi:"input"`
	Length pulumi.IntInput    `pulumi:"length"`
	Offset pulumi.IntInput    `pulumi:"offset"`
}

func (SubstrOutputArgs) ElementType 

func (SubstrOutputArgs) ElementType() reflect.Type

type SubstrResult 

type SubstrResult struct {
	Result string `pulumi:"result"`
}

func Substr 

func Substr(ctx *pulumi.Context, args *SubstrArgs, opts ...pulumi.InvokeOption) (*SubstrResult, error)

Extracts a substring from the given string.

type SubstrResultOutput 

type SubstrResultOutput struct{ *pulumi.OutputState }

func SubstrOutput 

func SubstrOutput(ctx *pulumi.Context, args SubstrOutputArgs, opts ...pulumi.InvokeOption) SubstrResultOutput

func (SubstrResultOutput) ElementType 

func (SubstrResultOutput) ElementType() reflect.Type

func (SubstrResultOutput) Result 

func (o SubstrResultOutput) Result() pulumi.StringOutput

func (SubstrResultOutput) ToSubstrResultOutput 

func (o SubstrResultOutput) ToSubstrResultOutput() SubstrResultOutput

func (SubstrResultOutput) ToSubstrResultOutputWithContext 

func (o SubstrResultOutput) ToSubstrResultOutputWithContext(ctx context.Context) SubstrResultOutput

type SumArgs 

type SumArgs struct {
	Input []float64 `pulumi:"input"`
}

type SumOutputArgs 

type SumOutputArgs struct {
	Input pulumi.Float64ArrayInput `pulumi:"input"`
}

func (SumOutputArgs) ElementType 

func (SumOutputArgs) ElementType() reflect.Type

type SumResult 

type SumResult struct {
	Result float64 `pulumi:"result"`
}

func Sum 

func Sum(ctx *pulumi.Context, args *SumArgs, opts ...pulumi.InvokeOption) (*SumResult, error)

Returns the total sum of the elements of the input list.

type SumResultOutput 

type SumResultOutput struct{ *pulumi.OutputState }

func SumOutput 

func SumOutput(ctx *pulumi.Context, args SumOutputArgs, opts ...pulumi.InvokeOption) SumResultOutput

func (SumResultOutput) ElementType 

func (SumResultOutput) ElementType() reflect.Type

func (SumResultOutput) Result 

func (o SumResultOutput) Result() pulumi.Float64Output

func (SumResultOutput) ToSumResultOutput 

func (o SumResultOutput) ToSumResultOutput() SumResultOutput

func (SumResultOutput) ToSumResultOutputWithContext 

func (o SumResultOutput) ToSumResultOutputWithContext(ctx context.Context) SumResultOutput

type TimeaddArgs 

type TimeaddArgs struct {
	Duration  string `pulumi:"duration"`
	Timestamp string `pulumi:"timestamp"`
}

type TimeaddOutputArgs 

type TimeaddOutputArgs struct {
	Duration  pulumi.StringInput `pulumi:"duration"`
	Timestamp pulumi.StringInput `pulumi:"timestamp"`
}

func (TimeaddOutputArgs) ElementType 

func (TimeaddOutputArgs) ElementType() reflect.Type

type TimeaddResult 

type TimeaddResult struct {
	Result string `pulumi:"result"`
}

func Timeadd 

func Timeadd(ctx *pulumi.Context, args *TimeaddArgs, opts ...pulumi.InvokeOption) (*TimeaddResult, error)

Adds a duration to a timestamp, returning a new timestamp. 

Timestamps are represented as strings using RFC 3339 "Date and time format" syntax.
'timestamp' must be a string adhering this syntax, i.e. "2017-11-22T00:00:00Z".
'duration' is a string representation of a time difference, comprised of sequences of
numbers and unit pairs, i.e. "3.5h" or "2h15m".
Accepted units are "ns", "us" or "µs", "ms", "s", "m", and "h". The first number may be negative
to provide a negative duration, i.e. "-2h15m".

type TimeaddResultOutput 

type TimeaddResultOutput struct{ *pulumi.OutputState }

func TimeaddOutput 

func TimeaddOutput(ctx *pulumi.Context, args TimeaddOutputArgs, opts ...pulumi.InvokeOption) TimeaddResultOutput

func (TimeaddResultOutput) ElementType 

func (TimeaddResultOutput) ElementType() reflect.Type

func (TimeaddResultOutput) Result 

func (o TimeaddResultOutput) Result() pulumi.StringOutput

func (TimeaddResultOutput) ToTimeaddResultOutput 

func (o TimeaddResultOutput) ToTimeaddResultOutput() TimeaddResultOutput

func (TimeaddResultOutput) ToTimeaddResultOutputWithContext 

func (o TimeaddResultOutput) ToTimeaddResultOutputWithContext(ctx context.Context) TimeaddResultOutput

type TimecmpArgs 

type TimecmpArgs struct {
	Timestampa string `pulumi:"timestampa"`
	Timestampb string `pulumi:"timestampb"`
}

type TimecmpOutputArgs 

type TimecmpOutputArgs struct {
	Timestampa pulumi.StringInput `pulumi:"timestampa"`
	Timestampb pulumi.StringInput `pulumi:"timestampb"`
}

func (TimecmpOutputArgs) ElementType 

func (TimecmpOutputArgs) ElementType() reflect.Type

type TimecmpResult 

type TimecmpResult struct {
	Result int `pulumi:"result"`
}

func Timecmp 

func Timecmp(ctx *pulumi.Context, args *TimecmpArgs, opts ...pulumi.InvokeOption) (*TimecmpResult, error)

Compares two timestamps and returns a number that represents the ordering 

of the instants those timestamps represent.
Timestamps are represented as strings using RFC 3339 "Date and time format" syntax.
Both timestamps must be strings adhering this syntax, i.e. "2017-11-22T00:00:00Z".
If 'timestamp_a' is before 'timestamp_b', -1 is returned.
If 'timestamp_a' is equal to 'timestamp_b', 0 is returned.
If 'timestamp_a' is after 'timestamp_b', 1 is returned.

type TimecmpResultOutput 

type TimecmpResultOutput struct{ *pulumi.OutputState }

func TimecmpOutput 

func TimecmpOutput(ctx *pulumi.Context, args TimecmpOutputArgs, opts ...pulumi.InvokeOption) TimecmpResultOutput

func (TimecmpResultOutput) ElementType 

func (TimecmpResultOutput) ElementType() reflect.Type

func (TimecmpResultOutput) Result 

func (o TimecmpResultOutput) Result() pulumi.IntOutput

func (TimecmpResultOutput) ToTimecmpResultOutput 

func (o TimecmpResultOutput) ToTimecmpResultOutput() TimecmpResultOutput

func (TimecmpResultOutput) ToTimecmpResultOutputWithContext 

func (o TimecmpResultOutput) ToTimecmpResultOutputWithContext(ctx context.Context) TimecmpResultOutput

type TimestampArgs 

type TimestampArgs struct {
}

type TimestampOutputArgs added in v1.6.2 

type TimestampOutputArgs struct {
}

func (TimestampOutputArgs) ElementType added in v1.6.2 

func (TimestampOutputArgs) ElementType() reflect.Type

type TimestampResult 

type TimestampResult struct {
	Result string `pulumi:"result"`
}

func Timestamp 

func Timestamp(ctx *pulumi.Context, args *TimestampArgs, opts ...pulumi.InvokeOption) (*TimestampResult, error)

Returns a UTC timestamp string of the current time in RFC 3339 format

type TimestampResultOutput added in v1.6.2 

type TimestampResultOutput struct{ *pulumi.OutputState }

func TimestampOutput added in v1.6.2 

func TimestampOutput(ctx *pulumi.Context, args TimestampOutputArgs, opts ...pulumi.InvokeOption) TimestampResultOutput

func (TimestampResultOutput) ElementType added in v1.6.2 

func (TimestampResultOutput) ElementType() reflect.Type

func (TimestampResultOutput) Result added in v1.6.2 

func (o TimestampResultOutput) Result() pulumi.StringOutput

func (TimestampResultOutput) ToTimestampResultOutput added in v1.6.2 

func (o TimestampResultOutput) ToTimestampResultOutput() TimestampResultOutput

func (TimestampResultOutput) ToTimestampResultOutputWithContext added in v1.6.2 

func (o TimestampResultOutput) ToTimestampResultOutputWithContext(ctx context.Context) TimestampResultOutput

type TitleArgs 

type TitleArgs struct {
	Input string `pulumi:"input"`
}

type TitleOutputArgs 

type TitleOutputArgs struct {
	Input pulumi.StringInput `pulumi:"input"`
}

func (TitleOutputArgs) ElementType 

func (TitleOutputArgs) ElementType() reflect.Type

type TitleResult 

type TitleResult struct {
	Result string `pulumi:"result"`
}

func Title 

func Title(ctx *pulumi.Context, args *TitleArgs, opts ...pulumi.InvokeOption) (*TitleResult, error)

Converts the first letter of each word in the given string to uppercase.

type TitleResultOutput 

type TitleResultOutput struct{ *pulumi.OutputState }

func TitleOutput 

func TitleOutput(ctx *pulumi.Context, args TitleOutputArgs, opts ...pulumi.InvokeOption) TitleResultOutput

func (TitleResultOutput) ElementType 

func (TitleResultOutput) ElementType() reflect.Type

func (TitleResultOutput) Result 

func (o TitleResultOutput) Result() pulumi.StringOutput

func (TitleResultOutput) ToTitleResultOutput 

func (o TitleResultOutput) ToTitleResultOutput() TitleResultOutput

func (TitleResultOutput) ToTitleResultOutputWithContext 

func (o TitleResultOutput) ToTitleResultOutputWithContext(ctx context.Context) TitleResultOutput

type ToboolArgs 

type ToboolArgs struct {
	Input interface{} `pulumi:"input"`
}

type ToboolOutputArgs 

type ToboolOutputArgs struct {
	Input pulumi.Input `pulumi:"input"`
}

func (ToboolOutputArgs) ElementType 

func (ToboolOutputArgs) ElementType() reflect.Type

type ToboolResult 

type ToboolResult struct {
	Result *bool `pulumi:"result"`
}

func Tobool 

func Tobool(ctx *pulumi.Context, args *ToboolArgs, opts ...pulumi.InvokeOption) (*ToboolResult, error)

Converts its argument to a boolean value. Only boolean values, null, and the exact strings 

"true" and "false" can be converted to boolean. All other values will result in an error.

type ToboolResultOutput 

type ToboolResultOutput struct{ *pulumi.OutputState }

func ToboolOutput 

func ToboolOutput(ctx *pulumi.Context, args ToboolOutputArgs, opts ...pulumi.InvokeOption) ToboolResultOutput

func (ToboolResultOutput) ElementType 

func (ToboolResultOutput) ElementType() reflect.Type

func (ToboolResultOutput) Result 

func (o ToboolResultOutput) Result() pulumi.BoolPtrOutput

func (ToboolResultOutput) ToToboolResultOutput 

func (o ToboolResultOutput) ToToboolResultOutput() ToboolResultOutput

func (ToboolResultOutput) ToToboolResultOutputWithContext 

func (o ToboolResultOutput) ToToboolResultOutputWithContext(ctx context.Context) ToboolResultOutput

type TolistArgs 

type TolistArgs struct {
	Input []interface{} `pulumi:"input"`
}

type TolistOutputArgs 

type TolistOutputArgs struct {
	Input pulumi.ArrayInput `pulumi:"input"`
}

func (TolistOutputArgs) ElementType 

func (TolistOutputArgs) ElementType() reflect.Type

type TolistResult 

type TolistResult struct {
	Result []interface{} `pulumi:"result"`
}

func Tolist 

func Tolist(ctx *pulumi.Context, args *TolistArgs, opts ...pulumi.InvokeOption) (*TolistResult, error)

Converts its argument to a list value.

type TolistResultOutput 

type TolistResultOutput struct{ *pulumi.OutputState }

func TolistOutput 

func TolistOutput(ctx *pulumi.Context, args TolistOutputArgs, opts ...pulumi.InvokeOption) TolistResultOutput

func (TolistResultOutput) ElementType 

func (TolistResultOutput) ElementType() reflect.Type

func (TolistResultOutput) Result 

func (o TolistResultOutput) Result() pulumi.ArrayOutput

func (TolistResultOutput) ToTolistResultOutput 

func (o TolistResultOutput) ToTolistResultOutput() TolistResultOutput

func (TolistResultOutput) ToTolistResultOutputWithContext 

func (o TolistResultOutput) ToTolistResultOutputWithContext(ctx context.Context) TolistResultOutput

type TonumberArgs 

type TonumberArgs struct {
	Input interface{} `pulumi:"input"`
}

type TonumberOutputArgs 

type TonumberOutputArgs struct {
	Input pulumi.Input `pulumi:"input"`
}

func (TonumberOutputArgs) ElementType 

func (TonumberOutputArgs) ElementType() reflect.Type

type TonumberResult 

type TonumberResult struct {
	Result *float64 `pulumi:"result"`
}

func Tonumber 

func Tonumber(ctx *pulumi.Context, args *TonumberArgs, opts ...pulumi.InvokeOption) (*TonumberResult, error)

Converts its argument to a number value. Only number values, null, and strings 

containing decimal representations of numbers can be converted to number. All other values will result in an error

type TonumberResultOutput 

type TonumberResultOutput struct{ *pulumi.OutputState }

func TonumberOutput 

func TonumberOutput(ctx *pulumi.Context, args TonumberOutputArgs, opts ...pulumi.InvokeOption) TonumberResultOutput

func (TonumberResultOutput) ElementType 

func (TonumberResultOutput) ElementType() reflect.Type

func (TonumberResultOutput) Result 

func (o TonumberResultOutput) Result() pulumi.Float64PtrOutput

func (TonumberResultOutput) ToTonumberResultOutput 

func (o TonumberResultOutput) ToTonumberResultOutput() TonumberResultOutput

func (TonumberResultOutput) ToTonumberResultOutputWithContext 

func (o TonumberResultOutput) ToTonumberResultOutputWithContext(ctx context.Context) TonumberResultOutput

type TosetArgs 

type TosetArgs struct {
	Input []interface{} `pulumi:"input"`
}

type TosetOutputArgs 

type TosetOutputArgs struct {
	Input pulumi.ArrayInput `pulumi:"input"`
}

func (TosetOutputArgs) ElementType 

func (TosetOutputArgs) ElementType() reflect.Type

type TosetResult 

type TosetResult struct {
	Result []interface{} `pulumi:"result"`
}

func Toset 

func Toset(ctx *pulumi.Context, args *TosetArgs, opts ...pulumi.InvokeOption) (*TosetResult, error)

Converts its argument to a set value.

type TosetResultOutput 

type TosetResultOutput struct{ *pulumi.OutputState }

func TosetOutput 

func TosetOutput(ctx *pulumi.Context, args TosetOutputArgs, opts ...pulumi.InvokeOption) TosetResultOutput

func (TosetResultOutput) ElementType 

func (TosetResultOutput) ElementType() reflect.Type

func (TosetResultOutput) Result 

func (o TosetResultOutput) Result() pulumi.ArrayOutput

func (TosetResultOutput) ToTosetResultOutput 

func (o TosetResultOutput) ToTosetResultOutput() TosetResultOutput

func (TosetResultOutput) ToTosetResultOutputWithContext 

func (o TosetResultOutput) ToTosetResultOutputWithContext(ctx context.Context) TosetResultOutput

type TostringArgs 

type TostringArgs struct {
	Input interface{} `pulumi:"input"`
}

type TostringOutputArgs 

type TostringOutputArgs struct {
	Input pulumi.Input `pulumi:"input"`
}

func (TostringOutputArgs) ElementType 

func (TostringOutputArgs) ElementType() reflect.Type

type TostringResult 

type TostringResult struct {
	Result *string `pulumi:"result"`
}

func Tostring 

func Tostring(ctx *pulumi.Context, args *TostringArgs, opts ...pulumi.InvokeOption) (*TostringResult, error)

Converts its argument to a string value. Only primitive types (string, number, bool) 

and null can be converted to string. All other values will result in an error.

type TostringResultOutput 

type TostringResultOutput struct{ *pulumi.OutputState }

func TostringOutput 

func TostringOutput(ctx *pulumi.Context, args TostringOutputArgs, opts ...pulumi.InvokeOption) TostringResultOutput

func (TostringResultOutput) ElementType 

func (TostringResultOutput) ElementType() reflect.Type

func (TostringResultOutput) Result 

func (o TostringResultOutput) Result() pulumi.StringPtrOutput

func (TostringResultOutput) ToTostringResultOutput 

func (o TostringResultOutput) ToTostringResultOutput() TostringResultOutput

func (TostringResultOutput) ToTostringResultOutputWithContext 

func (o TostringResultOutput) ToTostringResultOutputWithContext(ctx context.Context) TostringResultOutput

type TransposeArgs 

type TransposeArgs struct {
	Input map[string][]string `pulumi:"input"`
}

type TransposeOutputArgs 

type TransposeOutputArgs struct {
	Input pulumi.StringArrayMapInput `pulumi:"input"`
}

func (TransposeOutputArgs) ElementType 

func (TransposeOutputArgs) ElementType() reflect.Type

type TransposeResult 

type TransposeResult struct {
	Result map[string][]string `pulumi:"result"`
}

func Transpose 

func Transpose(ctx *pulumi.Context, args *TransposeArgs, opts ...pulumi.InvokeOption) (*TransposeResult, error)

Takes a map of lists of strings and swaps the keys and values to return a new map of lists of strings.

type TransposeResultOutput 

type TransposeResultOutput struct{ *pulumi.OutputState }

func TransposeOutput 

func TransposeOutput(ctx *pulumi.Context, args TransposeOutputArgs, opts ...pulumi.InvokeOption) TransposeResultOutput

func (TransposeResultOutput) ElementType 

func (TransposeResultOutput) ElementType() reflect.Type

func (TransposeResultOutput) Result 

func (o TransposeResultOutput) Result() pulumi.StringArrayMapOutput

func (TransposeResultOutput) ToTransposeResultOutput 

func (o TransposeResultOutput) ToTransposeResultOutput() TransposeResultOutput

func (TransposeResultOutput) ToTransposeResultOutputWithContext 

func (o TransposeResultOutput) ToTransposeResultOutputWithContext(ctx context.Context) TransposeResultOutput

type TrimArgs 

type TrimArgs struct {
	Cutset string `pulumi:"cutset"`
	Input  string `pulumi:"input"`
}

type TrimOutputArgs 

type TrimOutputArgs struct {
	Cutset pulumi.StringInput `pulumi:"cutset"`
	Input  pulumi.StringInput `pulumi:"input"`
}

func (TrimOutputArgs) ElementType 

func (TrimOutputArgs) ElementType() reflect.Type

type TrimResult 

type TrimResult struct {
	Result string `pulumi:"result"`
}

func Trim 

func Trim(ctx *pulumi.Context, args *TrimArgs, opts ...pulumi.InvokeOption) (*TrimResult, error)

Removes the specified set of characters from the start and end of the given string.

type TrimResultOutput 

type TrimResultOutput struct{ *pulumi.OutputState }

func TrimOutput 

func TrimOutput(ctx *pulumi.Context, args TrimOutputArgs, opts ...pulumi.InvokeOption) TrimResultOutput

func (TrimResultOutput) ElementType 

func (TrimResultOutput) ElementType() reflect.Type

func (TrimResultOutput) Result 

func (o TrimResultOutput) Result() pulumi.StringOutput

func (TrimResultOutput) ToTrimResultOutput 

func (o TrimResultOutput) ToTrimResultOutput() TrimResultOutput

func (TrimResultOutput) ToTrimResultOutputWithContext 

func (o TrimResultOutput) ToTrimResultOutputWithContext(ctx context.Context) TrimResultOutput

type TrimprefixArgs 

type TrimprefixArgs struct {
	Input  string `pulumi:"input"`
	Prefix string `pulumi:"prefix"`
}

type TrimprefixOutputArgs 

type TrimprefixOutputArgs struct {
	Input  pulumi.StringInput `pulumi:"input"`
	Prefix pulumi.StringInput `pulumi:"prefix"`
}

func (TrimprefixOutputArgs) ElementType 

func (TrimprefixOutputArgs) ElementType() reflect.Type

type TrimprefixResult 

type TrimprefixResult struct {
	Result string `pulumi:"result"`
}

func Trimprefix 

func Trimprefix(ctx *pulumi.Context, args *TrimprefixArgs, opts ...pulumi.InvokeOption) (*TrimprefixResult, error)

Removes the specified prefix from the start of the given string, if present.

type TrimprefixResultOutput 

type TrimprefixResultOutput struct{ *pulumi.OutputState }

func TrimprefixOutput 

func TrimprefixOutput(ctx *pulumi.Context, args TrimprefixOutputArgs, opts ...pulumi.InvokeOption) TrimprefixResultOutput

func (TrimprefixResultOutput) ElementType 

func (TrimprefixResultOutput) ElementType() reflect.Type

func (TrimprefixResultOutput) Result 

func (o TrimprefixResultOutput) Result() pulumi.StringOutput

func (TrimprefixResultOutput) ToTrimprefixResultOutput 

func (o TrimprefixResultOutput) ToTrimprefixResultOutput() TrimprefixResultOutput

func (TrimprefixResultOutput) ToTrimprefixResultOutputWithContext 

func (o TrimprefixResultOutput) ToTrimprefixResultOutputWithContext(ctx context.Context) TrimprefixResultOutput

type TrimspaceArgs 

type TrimspaceArgs struct {
	Input string `pulumi:"input"`
}

type TrimspaceOutputArgs 

type TrimspaceOutputArgs struct {
	Input pulumi.StringInput `pulumi:"input"`
}

func (TrimspaceOutputArgs) ElementType 

func (TrimspaceOutputArgs) ElementType() reflect.Type

type TrimspaceResult 

type TrimspaceResult struct {
	Result string `pulumi:"result"`
}

func Trimspace 

func Trimspace(ctx *pulumi.Context, args *TrimspaceArgs, opts ...pulumi.InvokeOption) (*TrimspaceResult, error)

Removes any space characters from the start and end of the given string, 

following the Unicode definition of \"space\" (i.e. spaces, tabs, newline, etc.).

type TrimspaceResultOutput 

type TrimspaceResultOutput struct{ *pulumi.OutputState }

func TrimspaceOutput 

func TrimspaceOutput(ctx *pulumi.Context, args TrimspaceOutputArgs, opts ...pulumi.InvokeOption) TrimspaceResultOutput

func (TrimspaceResultOutput) ElementType 

func (TrimspaceResultOutput) ElementType() reflect.Type

func (TrimspaceResultOutput) Result 

func (o TrimspaceResultOutput) Result() pulumi.StringOutput

func (TrimspaceResultOutput) ToTrimspaceResultOutput 

func (o TrimspaceResultOutput) ToTrimspaceResultOutput() TrimspaceResultOutput

func (TrimspaceResultOutput) ToTrimspaceResultOutputWithContext 

func (o TrimspaceResultOutput) ToTrimspaceResultOutputWithContext(ctx context.Context) TrimspaceResultOutput

type TrimsuffixArgs 

type TrimsuffixArgs struct {
	Input  string `pulumi:"input"`
	Suffix string `pulumi:"suffix"`
}

type TrimsuffixOutputArgs 

type TrimsuffixOutputArgs struct {
	Input  pulumi.StringInput `pulumi:"input"`
	Suffix pulumi.StringInput `pulumi:"suffix"`
}

func (TrimsuffixOutputArgs) ElementType 

func (TrimsuffixOutputArgs) ElementType() reflect.Type

type TrimsuffixResult 

type TrimsuffixResult struct {
	Result string `pulumi:"result"`
}

func Trimsuffix 

func Trimsuffix(ctx *pulumi.Context, args *TrimsuffixArgs, opts ...pulumi.InvokeOption) (*TrimsuffixResult, error)

Removes the specified suffix from the end of the given string, if present.

type TrimsuffixResultOutput 

type TrimsuffixResultOutput struct{ *pulumi.OutputState }

func TrimsuffixOutput 

func TrimsuffixOutput(ctx *pulumi.Context, args TrimsuffixOutputArgs, opts ...pulumi.InvokeOption) TrimsuffixResultOutput

func (TrimsuffixResultOutput) ElementType 

func (TrimsuffixResultOutput) ElementType() reflect.Type

func (TrimsuffixResultOutput) Result 

func (o TrimsuffixResultOutput) Result() pulumi.StringOutput

func (TrimsuffixResultOutput) ToTrimsuffixResultOutput 

func (o TrimsuffixResultOutput) ToTrimsuffixResultOutput() TrimsuffixResultOutput

func (TrimsuffixResultOutput) ToTrimsuffixResultOutputWithContext 

func (o TrimsuffixResultOutput) ToTrimsuffixResultOutputWithContext(ctx context.Context) TrimsuffixResultOutput

type UpperArgs 

type UpperArgs struct {
	Input string `pulumi:"input"`
}

type UpperOutputArgs 

type UpperOutputArgs struct {
	Input pulumi.StringInput `pulumi:"input"`
}

func (UpperOutputArgs) ElementType 

func (UpperOutputArgs) ElementType() reflect.Type

type UpperResult 

type UpperResult struct {
	Result string `pulumi:"result"`
}

func Upper 

func Upper(ctx *pulumi.Context, args *UpperArgs, opts ...pulumi.InvokeOption) (*UpperResult, error)

Converts all cased letters in the given string to uppercase.

type UpperResultOutput 

type UpperResultOutput struct{ *pulumi.OutputState }

func UpperOutput 

func UpperOutput(ctx *pulumi.Context, args UpperOutputArgs, opts ...pulumi.InvokeOption) UpperResultOutput

func (UpperResultOutput) ElementType 

func (UpperResultOutput) ElementType() reflect.Type

func (UpperResultOutput) Result 

func (o UpperResultOutput) Result() pulumi.StringOutput

func (UpperResultOutput) ToUpperResultOutput 

func (o UpperResultOutput) ToUpperResultOutput() UpperResultOutput

func (UpperResultOutput) ToUpperResultOutputWithContext 

func (o UpperResultOutput) ToUpperResultOutputWithContext(ctx context.Context) UpperResultOutput

type UrlencodeArgs 

type UrlencodeArgs struct {
	Input string `pulumi:"input"`
}

type UrlencodeOutputArgs 

type UrlencodeOutputArgs struct {
	Input pulumi.StringInput `pulumi:"input"`
}

func (UrlencodeOutputArgs) ElementType 

func (UrlencodeOutputArgs) ElementType() reflect.Type

type UrlencodeResult 

type UrlencodeResult struct {
	Result string `pulumi:"result"`
}

func Urlencode 

func Urlencode(ctx *pulumi.Context, args *UrlencodeArgs, opts ...pulumi.InvokeOption) (*UrlencodeResult, error)

Applies URL encoding to a given string.

type UrlencodeResultOutput 

type UrlencodeResultOutput struct{ *pulumi.OutputState }

func UrlencodeOutput 

func UrlencodeOutput(ctx *pulumi.Context, args UrlencodeOutputArgs, opts ...pulumi.InvokeOption) UrlencodeResultOutput

func (UrlencodeResultOutput) ElementType 

func (UrlencodeResultOutput) ElementType() reflect.Type

func (UrlencodeResultOutput) Result 

func (o UrlencodeResultOutput) Result() pulumi.StringOutput

func (UrlencodeResultOutput) ToUrlencodeResultOutput 

func (o UrlencodeResultOutput) ToUrlencodeResultOutput() UrlencodeResultOutput

func (UrlencodeResultOutput) ToUrlencodeResultOutputWithContext 

func (o UrlencodeResultOutput) ToUrlencodeResultOutputWithContext(ctx context.Context) UrlencodeResultOutput

type UuidArgs 

type UuidArgs struct {
}

type UuidOutputArgs added in v1.6.2 

type UuidOutputArgs struct {
}

func (UuidOutputArgs) ElementType added in v1.6.2 

func (UuidOutputArgs) ElementType() reflect.Type

type UuidResult 

type UuidResult struct {
	Result string `pulumi:"result"`
}

func Uuid 

func Uuid(ctx *pulumi.Context, args *UuidArgs, opts ...pulumi.InvokeOption) (*UuidResult, error)

Returns a unique identifier string, generated and formatted as required by RFC 4122.

type UuidResultOutput added in v1.6.2 

type UuidResultOutput struct{ *pulumi.OutputState }

func UuidOutput added in v1.6.2 

func UuidOutput(ctx *pulumi.Context, args UuidOutputArgs, opts ...pulumi.InvokeOption) UuidResultOutput

func (UuidResultOutput) ElementType added in v1.6.2 

func (UuidResultOutput) ElementType() reflect.Type

func (UuidResultOutput) Result added in v1.6.2 

func (o UuidResultOutput) Result() pulumi.StringOutput

func (UuidResultOutput) ToUuidResultOutput added in v1.6.2 

func (o UuidResultOutput) ToUuidResultOutput() UuidResultOutput

func (UuidResultOutput) ToUuidResultOutputWithContext added in v1.6.2 

func (o UuidResultOutput) ToUuidResultOutputWithContext(ctx context.Context) UuidResultOutput

type ValuesArgs 

type ValuesArgs struct {
	Input map[string]interface{} `pulumi:"input"`
}

type ValuesOutputArgs 

type ValuesOutputArgs struct {
	Input pulumi.MapInput `pulumi:"input"`
}

func (ValuesOutputArgs) ElementType 

func (ValuesOutputArgs) ElementType() reflect.Type

type ValuesResult 

type ValuesResult struct {
	Result []interface{} `pulumi:"result"`
}

func Values 

func Values(ctx *pulumi.Context, args *ValuesArgs, opts ...pulumi.InvokeOption) (*ValuesResult, error)

Returns a list of the values of the map.

type ValuesResultOutput 

type ValuesResultOutput struct{ *pulumi.OutputState }

func ValuesOutput 

func ValuesOutput(ctx *pulumi.Context, args ValuesOutputArgs, opts ...pulumi.InvokeOption) ValuesResultOutput

func (ValuesResultOutput) ElementType 

func (ValuesResultOutput) ElementType() reflect.Type

func (ValuesResultOutput) Result 

func (o ValuesResultOutput) Result() pulumi.ArrayOutput

func (ValuesResultOutput) ToValuesResultOutput 

func (o ValuesResultOutput) ToValuesResultOutput() ValuesResultOutput

func (ValuesResultOutput) ToValuesResultOutputWithContext 

func (o ValuesResultOutput) ToValuesResultOutputWithContext(ctx context.Context) ValuesResultOutput

type ZipmapArgs 

type ZipmapArgs struct {
	Keys   []string      `pulumi:"keys"`
	Values []interface{} `pulumi:"values"`
}

type ZipmapOutputArgs 

type ZipmapOutputArgs struct {
	Keys   pulumi.StringArrayInput `pulumi:"keys"`
	Values pulumi.ArrayInput       `pulumi:"values"`
}

func (ZipmapOutputArgs) ElementType 

func (ZipmapOutputArgs) ElementType() reflect.Type

type ZipmapResult 

type ZipmapResult struct {
	Result map[string]interface{} `pulumi:"result"`
}

func Zipmap 

func Zipmap(ctx *pulumi.Context, args *ZipmapArgs, opts ...pulumi.InvokeOption) (*ZipmapResult, error)

Constructs a map from a list of keys and a corresponding list of values.

type ZipmapResultOutput 

type ZipmapResultOutput struct{ *pulumi.OutputState }

func ZipmapOutput 

func ZipmapOutput(ctx *pulumi.Context, args ZipmapOutputArgs, opts ...pulumi.InvokeOption) ZipmapResultOutput

func (ZipmapResultOutput) ElementType 

func (ZipmapResultOutput) ElementType() reflect.Type

func (ZipmapResultOutput) Result 

func (o ZipmapResultOutput) Result() pulumi.MapOutput

func (ZipmapResultOutput) ToZipmapResultOutput 

func (o ZipmapResultOutput) ToZipmapResultOutput() ZipmapResultOutput

func (ZipmapResultOutput) ToZipmapResultOutputWithContext 

func (o ZipmapResultOutput) ToZipmapResultOutputWithContext(ctx context.Context) ZipmapResultOutput

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.