std

package module
v0.0.0-...-79ed7e4 Latest Latest
Warning

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

 Go to latest Published: Jul 17, 2024 License: Apache-2.0 Imports: 37 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func Provider 

func Provider() p.Provider

Types

type Abs 

type Abs struct{}

func (*Abs) Annotate 

func (r *Abs) Annotate(a infer.Annotator)

func (*Abs) Call 

func (*Abs) Call(_ p.Context, input AbsArgs) (AbsResult, error)

type AbsArgs 

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

type AbsResult 

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

type Abspath 

type Abspath struct{}

func (*Abspath) Annotate 

func (r *Abspath) Annotate(a infer.Annotator)

func (*Abspath) Call 

func (*Abspath) Call(_ p.Context, args AbspathArgs) (AbspathResult, error)

type AbspathArgs 

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

type AbspathResult 

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

type Alltrue 

type Alltrue struct{}

func (*Alltrue) Annotate 

func (r *Alltrue) Annotate(a infer.Annotator)

func (*Alltrue) Call 

func (*Alltrue) Call(_ p.Context, args AlltrueArgs) (AlltrueResult, error)

type AlltrueArgs 

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

type AlltrueResult 

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

type Anytrue 

type Anytrue struct{}

func (*Anytrue) Annotate 

func (r *Anytrue) Annotate(a infer.Annotator)

func (*Anytrue) Call 

func (*Anytrue) Call(_ p.Context, args AnytrueArgs) (AnytrueResult, error)

type AnytrueArgs 

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

type AnytrueResult 

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

type Base64DecodeArgs 

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

type Base64DecodeResult 

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

type Base64EncodeArgs 

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

type Base64EncodeResult 

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

type Base64GzipArgs 

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

type Base64GzipResult 

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

type Base64Sha256Args 

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

type Base64Sha256Result 

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

type Base64Sha512Args 

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

type Base64Sha512Result 

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

type Base64decode 

type Base64decode struct{}

func (*Base64decode) Annotate 

func (r *Base64decode) Annotate(a infer.Annotator)

func (*Base64decode) Call 

func (*Base64decode) Call(_ p.Context, args Base64DecodeArgs) (Base64DecodeResult, error)

type Base64encode 

type Base64encode struct{}

func (*Base64encode) Annotate 

func (r *Base64encode) Annotate(a infer.Annotator)

func (*Base64encode) Call 

func (*Base64encode) Call(_ p.Context, args Base64EncodeArgs) (Base64EncodeResult, error)

type Base64gzip 

type Base64gzip struct{}

func (*Base64gzip) Annotate 

func (r *Base64gzip) Annotate(a infer.Annotator)

func (*Base64gzip) Call 

func (*Base64gzip) Call(_ p.Context, args Base64GzipArgs) (Base64GzipResult, error)

type Base64sha256 

type Base64sha256 struct{}

func (*Base64sha256) Annotate 

func (r *Base64sha256) Annotate(a infer.Annotator)

func (*Base64sha256) Call 

func (*Base64sha256) Call(_ p.Context, args Base64Sha256Args) (Base64Sha256Result, error)

type Base64sha512 

type Base64sha512 struct{}

func (*Base64sha512) Annotate 

func (r *Base64sha512) Annotate(a infer.Annotator)

func (*Base64sha512) Call 

func (*Base64sha512) Call(_ p.Context, args Base64Sha512Args) (Base64Sha512Result, error)

type Basename 

type Basename struct{}

func (*Basename) Annotate 

func (r *Basename) Annotate(a infer.Annotator)

func (*Basename) Call 

func (*Basename) Call(_ p.Context, args BasenameArgs) (BasenameResult, error)

type BasenameArgs 

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

type BasenameResult 

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

type Bcrypt 

type Bcrypt struct{}

func (*Bcrypt) Annotate 

func (r *Bcrypt) Annotate(a infer.Annotator)

func (*Bcrypt) Call 

func (*Bcrypt) Call(_ p.Context, args BcryptArgs) (BcryptResult, error)

type BcryptArgs 

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

type BcryptResult 

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

type Ceil 

type Ceil struct{}

func (*Ceil) Annotate 

func (r *Ceil) Annotate(a infer.Annotator)

func (*Ceil) Call 

func (*Ceil) Call(_ p.Context, input CeilArgs) (CeilResult, error)

type CeilArgs 

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

type CeilResult 

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

type Chomp 

type Chomp struct{}

func (*Chomp) Annotate 

func (r *Chomp) Annotate(a infer.Annotator)

func (*Chomp) Call 

func (*Chomp) Call(_ p.Context, args ChompArgs) (ChompResult, error)

type ChompArgs 

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

type ChompResult 

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

type Chunklist 

type Chunklist struct{}

func (*Chunklist) Annotate 

func (r *Chunklist) Annotate(a infer.Annotator)

func (*Chunklist) Call 

func (*Chunklist) Call(_ p.Context, args ChunklistArgs) (ChunklistResult, error)

type ChunklistArgs 

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

type ChunklistResult 

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

type Cidrhost 

type Cidrhost struct{}

func (*Cidrhost) Annotate 

func (r *Cidrhost) Annotate(a infer.Annotator)

func (*Cidrhost) Call 

func (*Cidrhost) Call(_ p.Context, args CidrhostArgs) (CidrhostResult, error)

type CidrhostArgs 

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

type CidrhostResult 

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

type Cidrnetmask 

type Cidrnetmask struct{}

func (*Cidrnetmask) Annotate 

func (r *Cidrnetmask) Annotate(a infer.Annotator)

func (*Cidrnetmask) Call 

func (*Cidrnetmask) Call(_ p.Context, args CidrnetmaskArgs) (CidrnetmaskResult, error)

type CidrnetmaskArgs 

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

type CidrnetmaskResult 

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

type Cidrsubnet 

type Cidrsubnet struct{}

func (*Cidrsubnet) Annotate 

func (r *Cidrsubnet) Annotate(a infer.Annotator)

func (*Cidrsubnet) Call 

func (*Cidrsubnet) Call(_ p.Context, args CidrsubnetArgs) (CidrsubnetResult, error)

type CidrsubnetArgs 

type CidrsubnetArgs struct {
	// The IP address range in CIDR notation.
	Input   string `pulumi:"input"`
	Newbits int    `pulumi:"newbits"`
	Netnum  int    `pulumi:"netnum"`
}

type CidrsubnetResult 

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

type Coalesce 

type Coalesce struct{}

func (*Coalesce) Annotate 

func (r *Coalesce) Annotate(a infer.Annotator)

func (*Coalesce) Call 

func (*Coalesce) Call(_ p.Context, args CoalesceArgs) (CoalesceResult, error)

type CoalesceArgs 

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

type CoalesceResult 

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

type Coalescelist 

type Coalescelist struct{}

func (*Coalescelist) Annotate 

func (r *Coalescelist) Annotate(a infer.Annotator)

func (*Coalescelist) Call 

func (*Coalescelist) Call(_ p.Context, args CoalescelistArgs) (CoalescelistResult, error)

type CoalescelistArgs 

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

type CoalescelistResult 

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

type Compact 

type Compact struct{}

func (*Compact) Annotate 

func (r *Compact) Annotate(a infer.Annotator)

func (*Compact) Call 

func (*Compact) Call(_ p.Context, args CompactArgs) (CompactResult, error)

type CompactArgs 

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

type CompactResult 

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

type Concat 

type Concat struct{}

func (*Concat) Annotate 

func (r *Concat) Annotate(a infer.Annotator)

func (*Concat) Call 

func (*Concat) Call(_ p.Context, args ConcatArgs) (ConcatResult, error)

type ConcatArgs 

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

type ConcatResult 

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

type Contains 

type Contains struct{}

func (*Contains) Annotate 

func (r *Contains) Annotate(a infer.Annotator)

func (*Contains) Call 

func (*Contains) Call(_ p.Context, args ContainsArgs) (ContainsResult, error)

type ContainsArgs 

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

type ContainsResult 

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

type Csvdecode 

type Csvdecode struct{}

func (*Csvdecode) Annotate 

func (r *Csvdecode) Annotate(a infer.Annotator)

func (*Csvdecode) Call 

func (*Csvdecode) Call(_ p.Context, args CsvdecodeArgs) (CsvdecodeResult, error)

type CsvdecodeArgs 

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

type CsvdecodeResult 

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

type Dirname 

type Dirname struct{}

func (*Dirname) Annotate 

func (r *Dirname) Annotate(a infer.Annotator)

func (*Dirname) Call 

func (*Dirname) Call(_ p.Context, args DirnameArgs) (DirnameResult, error)

type DirnameArgs 

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

type DirnameResult 

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

type Distinct 

type Distinct struct{}

func (*Distinct) Annotate 

func (r *Distinct) Annotate(a infer.Annotator)

func (*Distinct) Call 

func (*Distinct) Call(_ p.Context, args DistinctArgs) (DistinctResult, error)

type DistinctArgs 

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

type DistinctResult 

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

type Element 

type Element struct{}

func (*Element) Annotate 

func (r *Element) Annotate(a infer.Annotator)

func (*Element) Call 

func (*Element) Call(_ p.Context, args ElementArgs) (ElementResult, error)

type ElementArgs 

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

type ElementResult 

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

type Endswith 

type Endswith struct{}

func (*Endswith) Annotate 

func (r *Endswith) Annotate(a infer.Annotator)

func (*Endswith) Call 

func (*Endswith) Call(_ p.Context, args EndswithArgs) (EndswithResult, error)

type EndswithArgs 

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

type EndswithResult 

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

type File 

type File struct{}

func (*File) Annotate 

func (r *File) Annotate(a infer.Annotator)

func (*File) Call 

func (*File) Call(_ p.Context, args FileArgs) (FileResult, error)

type FileArgs 

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

type FileResult 

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

type Filebase64 

type Filebase64 struct{}

func (*Filebase64) Annotate 

func (r *Filebase64) Annotate(a infer.Annotator)

func (*Filebase64) Call 

func (*Filebase64) Call(_ p.Context, args Filebase64Args) (Filebase64Result, error)

type Filebase64Args 

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

type Filebase64Result 

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

type Filebase64sha256 

type Filebase64sha256 struct{}

func (*Filebase64sha256) Annotate 

func (r *Filebase64sha256) Annotate(a infer.Annotator)

func (*Filebase64sha256) Call 

func (*Filebase64sha256) Call(_ p.Context, args Filebase64sha256Args) (Filebase64sha256Result, error)

type Filebase64sha256Args 

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

type Filebase64sha256Result 

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

type Filebase64sha512 

type Filebase64sha512 struct{}

func (*Filebase64sha512) Annotate 

func (r *Filebase64sha512) Annotate(a infer.Annotator)

func (*Filebase64sha512) Call 

func (*Filebase64sha512) Call(_ p.Context, args Filebase64sha512Args) (Filebase64sha512Result, error)

type Filebase64sha512Args 

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

type Filebase64sha512Result 

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

type Fileexists 

type Fileexists struct{}

func (*Fileexists) Annotate 

func (r *Fileexists) Annotate(a infer.Annotator)

func (*Fileexists) Call 

func (*Fileexists) Call(_ p.Context, args FileexistsArgs) (FileexistsResult, error)

type FileexistsArgs 

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

type FileexistsResult 

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

type Filemd5 

type Filemd5 struct{}

func (*Filemd5) Annotate 

func (r *Filemd5) Annotate(a infer.Annotator)

func (*Filemd5) Call 

func (*Filemd5) Call(_ p.Context, args Filemd5Args) (Filemd5Result, error)

type Filemd5Args 

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

type Filemd5Result 

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

type Filesha1 

type Filesha1 struct{}

func (*Filesha1) Annotate 

func (r *Filesha1) Annotate(a infer.Annotator)

func (*Filesha1) Call 

func (*Filesha1) Call(_ p.Context, args Filesha1Args) (Filesha1Result, error)

type Filesha1Args 

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

type Filesha1Result 

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

type Filesha256 

type Filesha256 struct{}

func (*Filesha256) Annotate 

func (r *Filesha256) Annotate(a infer.Annotator)

func (*Filesha256) Call 

func (*Filesha256) Call(_ p.Context, args Filesha256Args) (Filesha256Result, error)

type Filesha256Args 

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

type Filesha256Result 

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

type Filesha512 

type Filesha512 struct{}

func (*Filesha512) Annotate 

func (r *Filesha512) Annotate(a infer.Annotator)

func (*Filesha512) Call 

func (*Filesha512) Call(_ p.Context, args Filesha512Args) (Filesha512Result, error)

type Filesha512Args 

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

type Filesha512Result 

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

type Flatten 

type Flatten struct{}

func (*Flatten) Annotate 

func (r *Flatten) Annotate(a infer.Annotator)

func (*Flatten) Call 

func (*Flatten) Call(_ p.Context, args FlattenArgs) (FlattenResult, error)

type FlattenArgs 

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

type FlattenResult 

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

type Floor 

type Floor struct{}

func (*Floor) Annotate 

func (r *Floor) Annotate(a infer.Annotator)

func (*Floor) Call 

func (*Floor) Call(_ p.Context, input FloorArgs) (FloorResult, error)

type FloorArgs 

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

type FloorResult 

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

type Format 

type Format struct{}

func (*Format) Annotate 

func (r *Format) Annotate(a infer.Annotator)

func (*Format) Call 

func (*Format) Call(_ p.Context, args FormatArgs) (FormatResult, error)

type FormatArgs 

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

type FormatResult 

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

type Indent 

type Indent struct{}

func (*Indent) Annotate 

func (r *Indent) Annotate(a infer.Annotator)

func (*Indent) Call 

func (*Indent) Call(_ p.Context, args IndentArgs) (IndentResult, error)

type IndentArgs 

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

type IndentResult 

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

type Index 

type Index struct{}

func (*Index) Annotate 

func (r *Index) Annotate(a infer.Annotator)

func (*Index) Call 

func (*Index) Call(_ p.Context, args IndexArgs) (IndexResult, error)

type IndexArgs 

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

type IndexResult 

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

type Join 

type Join struct{}

func (*Join) Annotate 

func (r *Join) Annotate(a infer.Annotator)

func (*Join) Call 

func (*Join) Call(_ p.Context, args JoinArgs) (JoinResult, error)

type JoinArgs 

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

type JoinResult 

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

type Jsondecode 

type Jsondecode struct{}

func (*Jsondecode) Annotate 

func (r *Jsondecode) Annotate(a infer.Annotator)

func (*Jsondecode) Call 

func (*Jsondecode) Call(_ p.Context, args JsondecodeArgs) (JsondecodeResult, error)

type JsondecodeArgs 

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

type JsondecodeResult 

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

type Jsonencode 

type Jsonencode struct{}

func (*Jsonencode) Annotate 

func (r *Jsonencode) Annotate(a infer.Annotator)

func (*Jsonencode) Call 

func (*Jsonencode) Call(_ p.Context, args JsonencodeArgs) (JsonencodeResult, error)

type JsonencodeArgs 

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

type JsonencodeResult 

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

type Keys 

type Keys struct{}

func (*Keys) Annotate 

func (r *Keys) Annotate(a infer.Annotator)

func (*Keys) Call 

func (*Keys) Call(_ p.Context, args KeysArgs) (KeysResult, error)

type KeysArgs 

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

type KeysResult 

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

type Length 

type Length struct{}

func (*Length) Annotate 

func (r *Length) Annotate(a infer.Annotator)

func (*Length) Call 

func (*Length) Call(_ p.Context, args LengthArgs) (LengthResult, error)

type LengthArgs 

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

type LengthResult 

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

type Log 

type Log struct{}

func (*Log) Annotate 

func (r *Log) Annotate(a infer.Annotator)

func (*Log) Call 

func (*Log) Call(_ p.Context, args LogArgs) (LogResult, error)

type LogArgs 

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

type LogResult 

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

type Lookup 

type Lookup struct{}

func (*Lookup) Annotate 

func (r *Lookup) Annotate(a infer.Annotator)

func (*Lookup) Call 

func (*Lookup) Call(_ p.Context, args LookupArgs) (LookupResult, error)

type LookupArgs 

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

type LookupResult 

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

type Lower 

type Lower struct{}

func (*Lower) Annotate 

func (r *Lower) Annotate(a infer.Annotator)

func (*Lower) Call 

func (*Lower) Call(_ p.Context, args LowerArgs) (LowerResult, error)

type LowerArgs 

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

type LowerResult 

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

type Map 

type Map struct{}

func (*Map) Annotate 

func (r *Map) Annotate(a infer.Annotator)

func (*Map) Call 

func (*Map) Call(_ p.Context, args MapArgs) (MapResult, error)

type MapArgs 

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

type MapResult 

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

type Matchkeys 

type Matchkeys struct{}

func (*Matchkeys) Annotate 

func (r *Matchkeys) Annotate(a infer.Annotator)

func (*Matchkeys) Call 

func (*Matchkeys) Call(_ p.Context, args MatchkeysArgs) (MatchkeysResult, error)

type MatchkeysArgs 

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

	SearchList []string `pulumi:"searchList"`
	// contains filtered or unexported fields
}

type MatchkeysResult 

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

type Max 

type Max struct{}

func (*Max) Annotate 

func (r *Max) Annotate(a infer.Annotator)

func (*Max) Call 

func (*Max) Call(_ p.Context, args MaxArgs) (MaxResult, error)

type MaxArgs 

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

type MaxResult 

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

type Md5 

type Md5 struct{}

func (*Md5) Annotate 

func (r *Md5) Annotate(a infer.Annotator)

func (*Md5) Call 

func (*Md5) Call(_ p.Context, args Md5Args) (Md5Result, error)

type Md5Args 

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

type Md5Result 

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

type Merge 

type Merge struct{}

func (*Merge) Annotate 

func (r *Merge) Annotate(a infer.Annotator)

func (*Merge) Call 

func (*Merge) Call(_ p.Context, args MergeArgs) (MergeResult, error)

type MergeArgs 

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

type MergeResult 

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

type Min 

type Min struct{}

func (*Min) Annotate 

func (r *Min) Annotate(a infer.Annotator)

func (*Min) Call 

func (*Min) Call(_ p.Context, args MinArgs) (MinResult, error)

type MinArgs 

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

type MinResult 

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

type Parseint 

type Parseint struct{}

func (*Parseint) Annotate 

func (r *Parseint) Annotate(a infer.Annotator)

func (*Parseint) Call 

func (*Parseint) Call(_ p.Context, args ParseintArgs) (ParseintResult, error)

type ParseintArgs 

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

type ParseintResult 

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

type Pathexpand 

type Pathexpand struct{}

func (*Pathexpand) Annotate 

func (r *Pathexpand) Annotate(a infer.Annotator)

func (*Pathexpand) Call 

func (*Pathexpand) Call(_ p.Context, args PathexpandArgs) (PathexpandResult, error)

type PathexpandArgs 

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

type PathexpandResult 

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

type Pow 

type Pow struct{}

func (*Pow) Annotate 

func (r *Pow) Annotate(a infer.Annotator)

func (*Pow) Call 

func (*Pow) Call(_ p.Context, args PowArgs) (PowResult, error)

type PowArgs 

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

type PowResult 

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

type Range 

type Range struct{}

func (*Range) Annotate 

func (r *Range) Annotate(a infer.Annotator)

func (*Range) Call 

func (*Range) Call(_ p.Context, args RangeArgs) (RangeResults, error)

type RangeArgs 

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

type RangeResults 

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

type Replace 

type Replace struct{}

func (*Replace) Annotate 

func (r *Replace) Annotate(a infer.Annotator)

func (*Replace) Call 

func (*Replace) Call(_ p.Context, args ReplaceArgs) (ReplaceResult, error)

type ReplaceArgs 

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

type ReplaceResult 

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

type Reverse 

type Reverse struct{}

func (*Reverse) Annotate 

func (r *Reverse) Annotate(a infer.Annotator)

func (*Reverse) Call 

func (*Reverse) Call(_ p.Context, args ReverseArgs) (ReverseResult, error)

type ReverseArgs 

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

type ReverseResult 

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

type Rsadecrypt 

type Rsadecrypt struct{}

func (*Rsadecrypt) Annotate 

func (r *Rsadecrypt) Annotate(a infer.Annotator)

func (*Rsadecrypt) Call 

func (*Rsadecrypt) Call(_ p.Context, args RsadecryptArgs) (RsadecryptResult, error)

type RsadecryptArgs 

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

type RsadecryptResult 

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

type Sha1 

type Sha1 struct{}

func (*Sha1) Annotate 

func (r *Sha1) Annotate(a infer.Annotator)

func (*Sha1) Call 

func (*Sha1) Call(_ p.Context, args Sha1Args) (Sha1Result, error)

type Sha1Args 

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

type Sha1Result 

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

type Sha256 

type Sha256 struct{}

func (*Sha256) Annotate 

func (r *Sha256) Annotate(a infer.Annotator)

func (*Sha256) Call 

func (*Sha256) Call(_ p.Context, args Sha256Args) (Sha256Result, error)

type Sha256Args 

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

type Sha256Result 

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

type Sha512 

type Sha512 struct{}

func (*Sha512) Annotate 

func (r *Sha512) Annotate(a infer.Annotator)

func (*Sha512) Call 

func (*Sha512) Call(_ p.Context, args Sha512Args) (Sha512Result, error)

type Sha512Args 

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

type Sha512Result 

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

type Signum 

type Signum struct{}

func (*Signum) Annotate 

func (r *Signum) Annotate(a infer.Annotator)

func (*Signum) Call 

func (*Signum) Call(_ p.Context, args SignumArgs) (SignumResult, error)

type SignumArgs 

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

type SignumResult 

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

type Slice 

type Slice struct{}

func (*Slice) Annotate 

func (r *Slice) Annotate(a infer.Annotator)

func (*Slice) Call 

func (*Slice) Call(_ p.Context, args SliceArgs) (SliceResult, error)

type SliceArgs 

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

type SliceResult 

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

type Sort 

type Sort struct{}

func (*Sort) Annotate 

func (r *Sort) Annotate(a infer.Annotator)

func (*Sort) Call 

func (*Sort) Call(_ p.Context, args SortArgs) (SortResult, error)

type SortArgs 

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

type SortResult 

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

type Split 

type Split struct{}

func (*Split) Annotate 

func (r *Split) Annotate(a infer.Annotator)

func (*Split) Call 

func (*Split) Call(_ p.Context, args SplitArgs) (SplitResult, error)

type SplitArgs 

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

type SplitResult 

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

type Startswith 

type Startswith struct{}

func (*Startswith) Annotate 

func (r *Startswith) Annotate(a infer.Annotator)

func (*Startswith) Call 

func (*Startswith) Call(_ p.Context, args StartswithArgs) (StartswithResult, error)

type StartswithArgs 

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

type StartswithResult 

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

type Strrev 

type Strrev struct{}

func (*Strrev) Annotate 

func (r *Strrev) Annotate(a infer.Annotator)

func (*Strrev) Call 

func (*Strrev) Call(_ p.Context, args StrrevArgs) (StrrevResult, error)

type StrrevArgs 

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

type StrrevResult 

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

type Substr 

type Substr struct{}

func (*Substr) Annotate 

func (r *Substr) Annotate(a infer.Annotator)

func (*Substr) Call 

func (*Substr) Call(_ p.Context, args SubstrArgs) (SubstrResult, error)

type SubstrArgs 

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

type SubstrResult 

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

type Sum 

type Sum struct{}

func (*Sum) Annotate 

func (r *Sum) Annotate(a infer.Annotator)

func (*Sum) Call 

func (*Sum) Call(_ p.Context, args SumArgs) (SumResult, error)

type SumArgs 

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

type SumResult 

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

type Timeadd 

type Timeadd struct{}

func (*Timeadd) Annotate 

func (r *Timeadd) Annotate(a infer.Annotator)

func (*Timeadd) Call 

func (*Timeadd) Call(_ p.Context, args TimeaddArgs) (TimeaddResult, error)

type TimeaddArgs 

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

type TimeaddResult 

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

type Timecmp 

type Timecmp struct{}

func (*Timecmp) Annotate 

func (r *Timecmp) Annotate(a infer.Annotator)

func (*Timecmp) Call 

func (*Timecmp) Call(_ p.Context, args TimecmpArgs) (TimecmpResult, error)

type TimecmpArgs 

type TimecmpArgs struct {
	TimestampA string `pulumi:"timestampa"`
	TimestampB string `pulumi:"timestampb"`
}

type TimecmpResult 

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

type Timestamp 

type Timestamp struct{}

func (*Timestamp) Annotate 

func (r *Timestamp) Annotate(a infer.Annotator)

func (*Timestamp) Call 

func (*Timestamp) Call(_ p.Context, _ TimestampArgs) (TimestampResult, error)

type TimestampArgs 

type TimestampArgs struct{}

type TimestampResult 

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

type Title 

type Title struct{}

func (*Title) Annotate 

func (r *Title) Annotate(a infer.Annotator)

func (*Title) Call 

func (*Title) Call(_ p.Context, args TitleArgs) (TitleResult, error)

type TitleArgs 

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

type TitleResult 

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

type Tobool 

type Tobool struct{}

func (*Tobool) Annotate 

func (r *Tobool) Annotate(a infer.Annotator)

func (*Tobool) Call 

func (*Tobool) Call(_ p.Context, args ToboolArgs) (ToboolResult, error)

type ToboolArgs 

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

type ToboolResult 

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

type Tolist 

type Tolist struct{}

func (*Tolist) Annotate 

func (r *Tolist) Annotate(a infer.Annotator)

func (*Tolist) Call 

func (*Tolist) Call(_ p.Context, args TolistArgs) (TolistResult, error)

type TolistArgs 

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

type TolistResult 

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

type Tonumber 

type Tonumber struct{}

func (*Tonumber) Annotate 

func (r *Tonumber) Annotate(a infer.Annotator)

func (*Tonumber) Call 

func (*Tonumber) Call(_ p.Context, args TonumberArgs) (TonumberResult, error)

type TonumberArgs 

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

type TonumberResult 

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

type Toset 

type Toset struct{}

func (*Toset) Annotate 

func (r *Toset) Annotate(a infer.Annotator)

func (*Toset) Call 

func (*Toset) Call(_ p.Context, args TosetArgs) (TosetResult, error)

type TosetArgs 

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

type TosetResult 

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

type Tostring 

type Tostring struct{}

func (*Tostring) Annotate 

func (r *Tostring) Annotate(a infer.Annotator)

func (*Tostring) Call 

func (*Tostring) Call(_ p.Context, args TostringArgs) (TostringResult, error)

type TostringArgs 

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

type TostringResult 

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

type Transpose 

type Transpose struct{}

func (*Transpose) Annotate 

func (r *Transpose) Annotate(a infer.Annotator)

func (*Transpose) Call 

func (*Transpose) Call(_ p.Context, args TransposeArgs) (TransposeResult, error)

type TransposeArgs 

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

type TransposeResult 

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

type Trim 

type Trim struct{}

func (*Trim) Annotate 

func (r *Trim) Annotate(a infer.Annotator)

func (*Trim) Call 

func (*Trim) Call(_ p.Context, args TrimArgs) (TrimResult, error)

type TrimArgs 

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

type TrimResult 

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

type Trimprefix 

type Trimprefix struct{}

func (*Trimprefix) Annotate 

func (r *Trimprefix) Annotate(a infer.Annotator)

func (*Trimprefix) Call 

func (*Trimprefix) Call(_ p.Context, args TrimprefixArgs) (TrimprefixResult, error)

type TrimprefixArgs 

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

type TrimprefixResult 

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

type Trimspace 

type Trimspace struct{}

func (*Trimspace) Annotate 

func (r *Trimspace) Annotate(a infer.Annotator)

func (*Trimspace) Call 

func (*Trimspace) Call(_ p.Context, args TrimspaceArgs) (TrimspaceResult, error)

type TrimspaceArgs 

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

type TrimspaceResult 

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

type Trimsuffix 

type Trimsuffix struct{}

func (*Trimsuffix) Annotate 

func (r *Trimsuffix) Annotate(a infer.Annotator)

func (*Trimsuffix) Call 

func (*Trimsuffix) Call(_ p.Context, args TrimsuffixArgs) (TrimsuffixResult, error)

type TrimsuffixArgs 

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

type TrimsuffixResult 

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

type Upper 

type Upper struct{}

func (*Upper) Annotate 

func (r *Upper) Annotate(a infer.Annotator)

func (*Upper) Call 

func (*Upper) Call(_ p.Context, args UpperArgs) (UpperResult, error)

type UpperArgs 

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

type UpperResult 

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

type Urlencode 

type Urlencode struct{}

func (*Urlencode) Annotate 

func (r *Urlencode) Annotate(a infer.Annotator)

func (*Urlencode) Call 

func (*Urlencode) Call(_ p.Context, args UrlencodeArgs) (UrlencodeResult, error)

type UrlencodeArgs 

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

type UrlencodeResult 

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

type Uuid 

type Uuid struct{}

nolint

func (*Uuid) Annotate 

func (r *Uuid) Annotate(a infer.Annotator)

func (*Uuid) Call 

func (*Uuid) Call(_ p.Context, _ UuidArgs) (UuidResult, error)

type UuidArgs 

type UuidArgs struct{}

nolint

type UuidResult 

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

nolint

type Values 

type Values struct{}

func (*Values) Annotate 

func (r *Values) Annotate(a infer.Annotator)

func (*Values) Call 

func (*Values) Call(_ p.Context, args ValuesArgs) (ValuesResult, error)

type ValuesArgs 

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

type ValuesResult 

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

type Zipmap 

type Zipmap struct{}

func (*Zipmap) Annotate 

func (r *Zipmap) Annotate(a infer.Annotator)

func (*Zipmap) Call 

func (*Zipmap) Call(_ p.Context, args ZipmapArgs) (ZipmapResult, error)

type ZipmapArgs 

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

type ZipmapResult 

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

Source Files

View all Source files

Directories

Path Synopsis
cmd
pulumi-resource-std

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.