tests

type Config struct {
	Value string `pulumi:"value,optional"`
}

type ConfigCustom struct {
	Number  *float64 `pulumi:"number,optional"`
	Squared float64
}

type Echo struct{}

type EchoInputs struct {
	String string            `pulumi:"string"`
	Int    int               `pulumi:"int"`
	Map    map[string]string `pulumi:"strMap,optional"`
}

type EchoOutputs struct {
	EchoInputs
	Name      string            `pulumi:"nameOut"`
	StringOut string            `pulumi:"stringOut"`
	IntOut    int               `pulumi:"intOut"`
	MapOut    map[string]string `pulumi:"strMapOut,optional"`
}

type GetJoin struct{}

type Increment struct{}

type IncrementArgs struct {
	Number int `pulumi:"int"`
	Other  int `pulumi:"other,optional"`
}

type IncrementOutput struct{ IncrementArgs }

type JoinArgs struct {
	Elems []string `pulumi:"elems"`
	Sep   *string  `pulumi:"sep,optional"`
}

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

type NestedDefaults struct {
	// Direct vars. These don't allow setting zero values.
	String string  `pulumi:"s,optional"`
	Float  float64 `pulumi:"f,optional"`
	Int    int     `pulumi:"i,optional"`
	Bool   bool    `pulumi:"b,optional"`

	// Indirect vars. These should allow setting zero values.
	StringPtr *string  `pulumi:"ps,optional"`
	FloatPtr  *float64 `pulumi:"pf,optional"`
	IntPtr    *int     `pulumi:"pi,optional"`
	BoolPtr   *bool    `pulumi:"pb,optional"`

	// A triple indirect value, included to check that we can handle arbitrary
	// indirection.
	IntPtrPtrPtr ***int `pulumi:"pppi,optional"`
}

type NoDefaults struct {
	String string `pulumi:"s,optional"`
}

type OptWithReq struct {
	Required *string `pulumi:"req"`
	Optional *string `pulumi:"opt,optional"`
	Empty    *string `pulumi:"empty,optional"`
}

type ReadConfig struct{}

type ReadConfigArgs struct{}

type ReadConfigCustom struct{}

type ReadConfigCustomArgs struct{}

type ReadConfigCustomOutput struct {
	Config string `pulumi:"config"`
}

type ReadConfigOutput struct {
	Config string `pulumi:"config"`
}

type ReadEnv struct{}

type ReadEnvArgs struct {
	String  string  `pulumi:"s,optional"`
	Int     int     `pulumi:"i,optional"`
	Float64 float64 `pulumi:"f64,optional"`
	Bool    bool    `pulumi:"b,optional"`
}

type ReadEnvOutput struct{ ReadEnvArgs }

type Recursive struct{}

type RecursiveArgs struct {
	Value string         `pulumi:"value,optional"`
	Other *RecursiveArgs `pulumi:"other,optional"`
}

type RecursiveOutput struct{ RecursiveArgs }

type Wired struct{}

type WiredInputs struct {
	String string `pulumi:"string"`
	Int    int    `pulumi:"int"`
}

type WiredOutputs struct {
	Name         string `pulumi:"name"`
	StringAndInt string `pulumi:"stringAndInt"`
	StringPlus   string `pulumi:"stringPlus"`
}

type WiredPlus struct{}

type WiredPlusOutputs struct {
	WiredInputs
	WiredOutputs
}

type WithDefaults struct{}

type WithDefaultsArgs struct {
	// We sanity check with some primitive values, but most of this checking is in
	// NestedDefaults.
	String       string                     `pulumi:"s,optional"`
	IntPtr       *int                       `pulumi:"pi,optional"`
	Nested       NestedDefaults             `pulumi:"nested,optional"`
	NestedPtr    *NestedDefaults            `pulumi:"nestedPtr"`
	OptWithReq   *OptWithReq                `pulumi:"optWithReq,optional"`
	ArrNested    []NestedDefaults           `pulumi:"arrNested,optional"`
	ArrNestedPtr []*NestedDefaults          `pulumi:"arrNestedPtr,optional"`
	MapNested    map[string]NestedDefaults  `pulumi:"mapNested,optional"`
	MapNestedPtr map[string]*NestedDefaults `pulumi:"mapNestedPtr,optional"`

	NoDefaultsPtr *NoDefaults `pulumi:"noDefaults,optional"`
}

type WithDefaultsOutput struct{ WithDefaultsArgs }