Move Apply<TypeName> functions to global

sdk/go/pulumi/alias.go

@@ -82,17 +82,17 @@ func (a Alias) collapseToURN(defaultName, defaultType string, defaultParent Reso
 func CreateURN(name, t, parent, project, stack StringInput) URNOutput {
 	var parentPrefix StringInput
 	if parent != nil {
-		parentPrefix = parent.ToStringOutput().ApplyString(func(p string) string {
+		parentPrefix = ApplyString(parent.ToStringOutput(), func(p string) string {
 			return p[0:strings.LastIndex(p, "::")] + "$"
 		})
 	} else {
-		parentPrefix = All(stack, project).ApplyString(func(a []interface{}) string {
+		parentPrefix = ApplyString(All(stack, project), func(a []interface{}) string {
 			return "urn:pulumi:" + a[0].(string) + "::" + a[1].(string) + "::"
 		})
 
 	}
 
-	return All(parentPrefix, t, name).ApplyURN(func(a []interface{}) URN {
+	return ApplyURN(All(parentPrefix, t, name), func(a []interface{}) URN {
 		return URN(a[0].(string) + a[1].(string) + "::" + a[2].(string))
 	})
 }
@@ -103,7 +103,7 @@ func CreateURN(name, t, parent, project, stack StringInput) URNOutput {
 func inheritedChildAlias(childName, parentName, childType, project, stack string, parentURN URNOutput) URNOutput {
 	aliasName := StringInput(String(childName))
 	if strings.HasPrefix(childName, parentName) {
-		aliasName = parentURN.ApplyString(func(urn URN) string {
+		aliasName = ApplyString(parentURN, func(urn URN) string {
 			parentPrefix := urn[strings.LastIndex(string(urn), "::")+2:]
 			return string(parentPrefix) + childName[len(parentName):]
 		})

sdk/go/pulumi/stack_reference.go

@@ -23,7 +23,7 @@ func (s *StackReference) GetOutput(name StringInput) AnyOutput {
 
 // GetStringOutput returns a stack output keyed by the given name as an StringOutput
 func (s *StackReference) GetStringOutput(name StringInput) StringOutput {
-	return s.GetOutput(name).ApplyString(func(out interface{}) string {
+	return ApplyString(s.GetOutput(name), func(out interface{}) string {
 		var res string
 		if out != nil {
 			res = out.(string)
@@ -34,7 +34,7 @@ func (s *StackReference) GetStringOutput(name StringInput) StringOutput {
 
 // GetIDOutput returns a stack output keyed by the given name as an IDOutput
 func (s *StackReference) GetIDOutput(name StringInput) IDOutput {
-	return s.GetStringOutput(name).ApplyID(func(out string) ID {
+	return ApplyID(s.GetStringOutput(name), func(out string) ID {
 		return ID(out)
 	})
 }

sdk/go/pulumi/templates/types_builtins.go.template

@@ -22,12 +22,12 @@ import (
 
 {{range .Builtins}}
 // Apply{{.Name}} is like ApplyT, but returns a {{.Name}}Output.
-func (o *OutputState) Apply{{.Name}}(applier interface{}) {{.Name}}Output {
+func Apply{{.Name}}(o Output, applier interface{}) {{.Name}}Output {
 	return o.ApplyT(applier).({{.Name}}Output)
 }
 
 // Apply{{.Name}}WithContext is like ApplyTWithContext, but returns a {{.Name}}Output.
-func (o *OutputState) Apply{{.Name}}WithContext(ctx context.Context, applier interface{}) {{.Name}}Output {
+func Apply{{.Name}}WithContext(ctx context.Context, o Output, applier interface{}) {{.Name}}Output {
 	return o.ApplyTWithContext(ctx, applier).({{.Name}}Output)
 }
 {{end}}

sdk/go/pulumi/templates/types_builtins_test.go.template

@@ -133,12 +133,12 @@ func TestOutputApply(t *testing.T) {
 
 {{range .Builtins}}
 		t.Run("Apply{{.Name}}", func(t *testing.T) {
-			o2 := out.Apply{{.Name}}(func(v int) {{.ElementType}} { return *new({{.ElementType}}) })
+			o2 := Apply{{.Name}}(out, func(v int) {{.ElementType}} { return *new({{.ElementType}}) })
 			_, known, _, _, err := await(o2)
 			assert.True(t, known)
 			assert.NoError(t, err)
 
-			o2 = out.Apply{{.Name}}WithContext(context.Background(), func(_ context.Context, v int) {{.ElementType}} { return *new({{.ElementType}}) })
+			o2 = Apply{{.Name}}WithContext(context.Background(), out, func(_ context.Context, v int) {{.ElementType}} { return *new({{.ElementType}}) })
 			_, known, _, _, err = await(o2)
 			assert.True(t, known)
 			assert.NoError(t, err)

sdk/go/pulumi/types_builtins.go

@@ -21,752 +21,752 @@ import (
 )
 
 // ApplyArchive is like ApplyT, but returns a ArchiveOutput.
-func (o *OutputState) ApplyArchive(applier interface{}) ArchiveOutput {
+func ApplyArchive(o Output, applier interface{}) ArchiveOutput {
 	return o.ApplyT(applier).(ArchiveOutput)
 }
 
 // ApplyArchiveWithContext is like ApplyTWithContext, but returns a ArchiveOutput.
-func (o *OutputState) ApplyArchiveWithContext(ctx context.Context, applier interface{}) ArchiveOutput {
+func ApplyArchiveWithContext(ctx context.Context, o Output, applier interface{}) ArchiveOutput {
 	return o.ApplyTWithContext(ctx, applier).(ArchiveOutput)
 }
 
 // ApplyArchiveArray is like ApplyT, but returns a ArchiveArrayOutput.
-func (o *OutputState) ApplyArchiveArray(applier interface{}) ArchiveArrayOutput {
+func ApplyArchiveArray(o Output, applier interface{}) ArchiveArrayOutput {
 	return o.ApplyT(applier).(ArchiveArrayOutput)
 }
 
 // ApplyArchiveArrayWithContext is like ApplyTWithContext, but returns a ArchiveArrayOutput.
-func (o *OutputState) ApplyArchiveArrayWithContext(ctx context.Context, applier interface{}) ArchiveArrayOutput {
+func ApplyArchiveArrayWithContext(ctx context.Context, o Output, applier interface{}) ArchiveArrayOutput {
 	return o.ApplyTWithContext(ctx, applier).(ArchiveArrayOutput)
 }
 
 // ApplyArchiveMap is like ApplyT, but returns a ArchiveMapOutput.
-func (o *OutputState) ApplyArchiveMap(applier interface{}) ArchiveMapOutput {
+func ApplyArchiveMap(o Output, applier interface{}) ArchiveMapOutput {
 	return o.ApplyT(applier).(ArchiveMapOutput)
 }
 
 // ApplyArchiveMapWithContext is like ApplyTWithContext, but returns a ArchiveMapOutput.
-func (o *OutputState) ApplyArchiveMapWithContext(ctx context.Context, applier interface{}) ArchiveMapOutput {
+func ApplyArchiveMapWithContext(ctx context.Context, o Output, applier interface{}) ArchiveMapOutput {
 	return o.ApplyTWithContext(ctx, applier).(ArchiveMapOutput)
 }
 
 // ApplyArchiveArrayMap is like ApplyT, but returns a ArchiveArrayMapOutput.
-func (o *OutputState) ApplyArchiveArrayMap(applier interface{}) ArchiveArrayMapOutput {
+func ApplyArchiveArrayMap(o Output, applier interface{}) ArchiveArrayMapOutput {
 	return o.ApplyT(applier).(ArchiveArrayMapOutput)
 }
 
 // ApplyArchiveArrayMapWithContext is like ApplyTWithContext, but returns a ArchiveArrayMapOutput.
-func (o *OutputState) ApplyArchiveArrayMapWithContext(ctx context.Context, applier interface{}) ArchiveArrayMapOutput {
+func ApplyArchiveArrayMapWithContext(ctx context.Context, o Output, applier interface{}) ArchiveArrayMapOutput {
 	return o.ApplyTWithContext(ctx, applier).(ArchiveArrayMapOutput)
 }
 
 // ApplyArchiveMapArray is like ApplyT, but returns a ArchiveMapArrayOutput.
-func (o *OutputState) ApplyArchiveMapArray(applier interface{}) ArchiveMapArrayOutput {
+func ApplyArchiveMapArray(o Output, applier interface{}) ArchiveMapArrayOutput {
 	return o.ApplyT(applier).(ArchiveMapArrayOutput)
 }
 
 // ApplyArchiveMapArrayWithContext is like ApplyTWithContext, but returns a ArchiveMapArrayOutput.
-func (o *OutputState) ApplyArchiveMapArrayWithContext(ctx context.Context, applier interface{}) ArchiveMapArrayOutput {
+func ApplyArchiveMapArrayWithContext(ctx context.Context, o Output, applier interface{}) ArchiveMapArrayOutput {
 	return o.ApplyTWithContext(ctx, applier).(ArchiveMapArrayOutput)
 }
 
 // ApplyArchiveMapMap is like ApplyT, but returns a ArchiveMapMapOutput.
-func (o *OutputState) ApplyArchiveMapMap(applier interface{}) ArchiveMapMapOutput {
+func ApplyArchiveMapMap(o Output, applier interface{}) ArchiveMapMapOutput {
 	return o.ApplyT(applier).(ArchiveMapMapOutput)
 }
 
 // ApplyArchiveMapMapWithContext is like ApplyTWithContext, but returns a ArchiveMapMapOutput.
-func (o *OutputState) ApplyArchiveMapMapWithContext(ctx context.Context, applier interface{}) ArchiveMapMapOutput {
+func ApplyArchiveMapMapWithContext(ctx context.Context, o Output, applier interface{}) ArchiveMapMapOutput {
 	return o.ApplyTWithContext(ctx, applier).(ArchiveMapMapOutput)
 }
 
 // ApplyArchiveArrayArray is like ApplyT, but returns a ArchiveArrayArrayOutput.
-func (o *OutputState) ApplyArchiveArrayArray(applier interface{}) ArchiveArrayArrayOutput {
+func ApplyArchiveArrayArray(o Output, applier interface{}) ArchiveArrayArrayOutput {
 	return o.ApplyT(applier).(ArchiveArrayArrayOutput)
 }
 
 // ApplyArchiveArrayArrayWithContext is like ApplyTWithContext, but returns a ArchiveArrayArrayOutput.
-func (o *OutputState) ApplyArchiveArrayArrayWithContext(ctx context.Context, applier interface{}) ArchiveArrayArrayOutput {
+func ApplyArchiveArrayArrayWithContext(ctx context.Context, o Output, applier interface{}) ArchiveArrayArrayOutput {
 	return o.ApplyTWithContext(ctx, applier).(ArchiveArrayArrayOutput)
 }
 
 // ApplyAsset is like ApplyT, but returns a AssetOutput.
-func (o *OutputState) ApplyAsset(applier interface{}) AssetOutput {
+func ApplyAsset(o Output, applier interface{}) AssetOutput {
 	return o.ApplyT(applier).(AssetOutput)
 }
 
 // ApplyAssetWithContext is like ApplyTWithContext, but returns a AssetOutput.
-func (o *OutputState) ApplyAssetWithContext(ctx context.Context, applier interface{}) AssetOutput {
+func ApplyAssetWithContext(ctx context.Context, o Output, applier interface{}) AssetOutput {
 	return o.ApplyTWithContext(ctx, applier).(AssetOutput)
 }
 
 // ApplyAssetArray is like ApplyT, but returns a AssetArrayOutput.
-func (o *OutputState) ApplyAssetArray(applier interface{}) AssetArrayOutput {
+func ApplyAssetArray(o Output, applier interface{}) AssetArrayOutput {
 	return o.ApplyT(applier).(AssetArrayOutput)
 }
 
 // ApplyAssetArrayWithContext is like ApplyTWithContext, but returns a AssetArrayOutput.
-func (o *OutputState) ApplyAssetArrayWithContext(ctx context.Context, applier interface{}) AssetArrayOutput {
+func ApplyAssetArrayWithContext(ctx context.Context, o Output, applier interface{}) AssetArrayOutput {
 	return o.ApplyTWithContext(ctx, applier).(AssetArrayOutput)
 }
 
 // ApplyAssetMap is like ApplyT, but returns a AssetMapOutput.
-func (o *OutputState) ApplyAssetMap(applier interface{}) AssetMapOutput {
+func ApplyAssetMap(o Output, applier interface{}) AssetMapOutput {
 	return o.ApplyT(applier).(AssetMapOutput)
 }
 
 // ApplyAssetMapWithContext is like ApplyTWithContext, but returns a AssetMapOutput.
-func (o *OutputState) ApplyAssetMapWithContext(ctx context.Context, applier interface{}) AssetMapOutput {
+func ApplyAssetMapWithContext(ctx context.Context, o Output, applier interface{}) AssetMapOutput {
 	return o.ApplyTWithContext(ctx, applier).(AssetMapOutput)
 }
 
 // ApplyAssetArrayMap is like ApplyT, but returns a AssetArrayMapOutput.
-func (o *OutputState) ApplyAssetArrayMap(applier interface{}) AssetArrayMapOutput {
+func ApplyAssetArrayMap(o Output, applier interface{}) AssetArrayMapOutput {
 	return o.ApplyT(applier).(AssetArrayMapOutput)
 }
 
 // ApplyAssetArrayMapWithContext is like ApplyTWithContext, but returns a AssetArrayMapOutput.
-func (o *OutputState) ApplyAssetArrayMapWithContext(ctx context.Context, applier interface{}) AssetArrayMapOutput {
+func ApplyAssetArrayMapWithContext(ctx context.Context, o Output, applier interface{}) AssetArrayMapOutput {
 	return o.ApplyTWithContext(ctx, applier).(AssetArrayMapOutput)
 }
 
 // ApplyAssetMapArray is like ApplyT, but returns a AssetMapArrayOutput.
-func (o *OutputState) ApplyAssetMapArray(applier interface{}) AssetMapArrayOutput {
+func ApplyAssetMapArray(o Output, applier interface{}) AssetMapArrayOutput {
 	return o.ApplyT(applier).(AssetMapArrayOutput)
 }
 
 // ApplyAssetMapArrayWithContext is like ApplyTWithContext, but returns a AssetMapArrayOutput.
-func (o *OutputState) ApplyAssetMapArrayWithContext(ctx context.Context, applier interface{}) AssetMapArrayOutput {
+func ApplyAssetMapArrayWithContext(ctx context.Context, o Output, applier interface{}) AssetMapArrayOutput {
 	return o.ApplyTWithContext(ctx, applier).(AssetMapArrayOutput)
 }
 
 // ApplyAssetMapMap is like ApplyT, but returns a AssetMapMapOutput.
-func (o *OutputState) ApplyAssetMapMap(applier interface{}) AssetMapMapOutput {
+func ApplyAssetMapMap(o Output, applier interface{}) AssetMapMapOutput {
 	return o.ApplyT(applier).(AssetMapMapOutput)
 }
 
 // ApplyAssetMapMapWithContext is like ApplyTWithContext, but returns a AssetMapMapOutput.
-func (o *OutputState) ApplyAssetMapMapWithContext(ctx context.Context, applier interface{}) AssetMapMapOutput {
+func ApplyAssetMapMapWithContext(ctx context.Context, o Output, applier interface{}) AssetMapMapOutput {
 	return o.ApplyTWithContext(ctx, applier).(AssetMapMapOutput)
 }
 
 // ApplyAssetArrayArray is like ApplyT, but returns a AssetArrayArrayOutput.
-func (o *OutputState) ApplyAssetArrayArray(applier interface{}) AssetArrayArrayOutput {
+func ApplyAssetArrayArray(o Output, applier interface{}) AssetArrayArrayOutput {
 	return o.ApplyT(applier).(AssetArrayArrayOutput)
 }
 
 // ApplyAssetArrayArrayWithContext is like ApplyTWithContext, but returns a AssetArrayArrayOutput.
-func (o *OutputState) ApplyAssetArrayArrayWithContext(ctx context.Context, applier interface{}) AssetArrayArrayOutput {
+func ApplyAssetArrayArrayWithContext(ctx context.Context, o Output, applier interface{}) AssetArrayArrayOutput {
 	return o.ApplyTWithContext(ctx, applier).(AssetArrayArrayOutput)
 }
 
 // ApplyAssetOrArchive is like ApplyT, but returns a AssetOrArchiveOutput.
-func (o *OutputState) ApplyAssetOrArchive(applier interface{}) AssetOrArchiveOutput {
+func ApplyAssetOrArchive(o Output, applier interface{}) AssetOrArchiveOutput {
 	return o.ApplyT(applier).(AssetOrArchiveOutput)
 }
 
 // ApplyAssetOrArchiveWithContext is like ApplyTWithContext, but returns a AssetOrArchiveOutput.
-func (o *OutputState) ApplyAssetOrArchiveWithContext(ctx context.Context, applier interface{}) AssetOrArchiveOutput {
+func ApplyAssetOrArchiveWithContext(ctx context.Context, o Output, applier interface{}) AssetOrArchiveOutput {
 	return o.ApplyTWithContext(ctx, applier).(AssetOrArchiveOutput)
 }
 
 // ApplyAssetOrArchiveArray is like ApplyT, but returns a AssetOrArchiveArrayOutput.
-func (o *OutputState) ApplyAssetOrArchiveArray(applier interface{}) AssetOrArchiveArrayOutput {
+func ApplyAssetOrArchiveArray(o Output, applier interface{}) AssetOrArchiveArrayOutput {
 	return o.ApplyT(applier).(AssetOrArchiveArrayOutput)
 }
 
 // ApplyAssetOrArchiveArrayWithContext is like ApplyTWithContext, but returns a AssetOrArchiveArrayOutput.
-func (o *OutputState) ApplyAssetOrArchiveArrayWithContext(ctx context.Context, applier interface{}) AssetOrArchiveArrayOutput {
+func ApplyAssetOrArchiveArrayWithContext(ctx context.Context, o Output, applier interface{}) AssetOrArchiveArrayOutput {
 	return o.ApplyTWithContext(ctx, applier).(AssetOrArchiveArrayOutput)
 }
 
 // ApplyAssetOrArchiveMap is like ApplyT, but returns a AssetOrArchiveMapOutput.
-func (o *OutputState) ApplyAssetOrArchiveMap(applier interface{}) AssetOrArchiveMapOutput {
+func ApplyAssetOrArchiveMap(o Output, applier interface{}) AssetOrArchiveMapOutput {
 	return o.ApplyT(applier).(AssetOrArchiveMapOutput)
 }
 
 // ApplyAssetOrArchiveMapWithContext is like ApplyTWithContext, but returns a AssetOrArchiveMapOutput.
-func (o *OutputState) ApplyAssetOrArchiveMapWithContext(ctx context.Context, applier interface{}) AssetOrArchiveMapOutput {
+func ApplyAssetOrArchiveMapWithContext(ctx context.Context, o Output, applier interface{}) AssetOrArchiveMapOutput {
 	return o.ApplyTWithContext(ctx, applier).(AssetOrArchiveMapOutput)
 }
 
 // ApplyAssetOrArchiveArrayMap is like ApplyT, but returns a AssetOrArchiveArrayMapOutput.
-func (o *OutputState) ApplyAssetOrArchiveArrayMap(applier interface{}) AssetOrArchiveArrayMapOutput {
+func ApplyAssetOrArchiveArrayMap(o Output, applier interface{}) AssetOrArchiveArrayMapOutput {
 	return o.ApplyT(applier).(AssetOrArchiveArrayMapOutput)
 }
 
 // ApplyAssetOrArchiveArrayMapWithContext is like ApplyTWithContext, but returns a AssetOrArchiveArrayMapOutput.
-func (o *OutputState) ApplyAssetOrArchiveArrayMapWithContext(ctx context.Context, applier interface{}) AssetOrArchiveArrayMapOutput {
+func ApplyAssetOrArchiveArrayMapWithContext(ctx context.Context, o Output, applier interface{}) AssetOrArchiveArrayMapOutput {
 	return o.ApplyTWithContext(ctx, applier).(AssetOrArchiveArrayMapOutput)
 }
 
 // ApplyAssetOrArchiveMapArray is like ApplyT, but returns a AssetOrArchiveMapArrayOutput.
-func (o *OutputState) ApplyAssetOrArchiveMapArray(applier interface{}) AssetOrArchiveMapArrayOutput {
+func ApplyAssetOrArchiveMapArray(o Output, applier interface{}) AssetOrArchiveMapArrayOutput {
 	return o.ApplyT(applier).(AssetOrArchiveMapArrayOutput)
 }
 
 // ApplyAssetOrArchiveMapArrayWithContext is like ApplyTWithContext, but returns a AssetOrArchiveMapArrayOutput.
-func (o *OutputState) ApplyAssetOrArchiveMapArrayWithContext(ctx context.Context, applier interface{}) AssetOrArchiveMapArrayOutput {
+func ApplyAssetOrArchiveMapArrayWithContext(ctx context.Context, o Output, applier interface{}) AssetOrArchiveMapArrayOutput {
 	return o.ApplyTWithContext(ctx, applier).(AssetOrArchiveMapArrayOutput)
 }
 
 // ApplyAssetOrArchiveMapMap is like ApplyT, but returns a AssetOrArchiveMapMapOutput.
-func (o *OutputState) ApplyAssetOrArchiveMapMap(applier interface{}) AssetOrArchiveMapMapOutput {
+func ApplyAssetOrArchiveMapMap(o Output, applier interface{}) AssetOrArchiveMapMapOutput {
 	return o.ApplyT(applier).(AssetOrArchiveMapMapOutput)
 }
 
 // ApplyAssetOrArchiveMapMapWithContext is like ApplyTWithContext, but returns a AssetOrArchiveMapMapOutput.
-func (o *OutputState) ApplyAssetOrArchiveMapMapWithContext(ctx context.Context, applier interface{}) AssetOrArchiveMapMapOutput {
+func ApplyAssetOrArchiveMapMapWithContext(ctx context.Context, o Output, applier interface{}) AssetOrArchiveMapMapOutput {
 	return o.ApplyTWithContext(ctx, applier).(AssetOrArchiveMapMapOutput)
 }
 
 // ApplyAssetOrArchiveArrayArray is like ApplyT, but returns a AssetOrArchiveArrayArrayOutput.
-func (o *OutputState) ApplyAssetOrArchiveArrayArray(applier interface{}) AssetOrArchiveArrayArrayOutput {
+func ApplyAssetOrArchiveArrayArray(o Output, applier interface{}) AssetOrArchiveArrayArrayOutput {
 	return o.ApplyT(applier).(AssetOrArchiveArrayArrayOutput)
 }
 
 // ApplyAssetOrArchiveArrayArrayWithContext is like ApplyTWithContext, but returns a AssetOrArchiveArrayArrayOutput.
-func (o *OutputState) ApplyAssetOrArchiveArrayArrayWithContext(ctx context.Context, applier interface{}) AssetOrArchiveArrayArrayOutput {
+func ApplyAssetOrArchiveArrayArrayWithContext(ctx context.Context, o Output, applier interface{}) AssetOrArchiveArrayArrayOutput {
 	return o.ApplyTWithContext(ctx, applier).(AssetOrArchiveArrayArrayOutput)
 }
 
 // ApplyBool is like ApplyT, but returns a BoolOutput.
-func (o *OutputState) ApplyBool(applier interface{}) BoolOutput {
+func ApplyBool(o Output, applier interface{}) BoolOutput {
 	return o.ApplyT(applier).(BoolOutput)
 }
 
 // ApplyBoolWithContext is like ApplyTWithContext, but returns a BoolOutput.
-func (o *OutputState) ApplyBoolWithContext(ctx context.Context, applier interface{}) BoolOutput {
+func ApplyBoolWithContext(ctx context.Context, o Output, applier interface{}) BoolOutput {
 	return o.ApplyTWithContext(ctx, applier).(BoolOutput)
 }
 
 // ApplyBoolPtr is like ApplyT, but returns a BoolPtrOutput.
-func (o *OutputState) ApplyBoolPtr(applier interface{}) BoolPtrOutput {
+func ApplyBoolPtr(o Output, applier interface{}) BoolPtrOutput {
 	return o.ApplyT(applier).(BoolPtrOutput)
 }
 
 // ApplyBoolPtrWithContext is like ApplyTWithContext, but returns a BoolPtrOutput.
-func (o *OutputState) ApplyBoolPtrWithContext(ctx context.Context, applier interface{}) BoolPtrOutput {
+func ApplyBoolPtrWithContext(ctx context.Context, o Output, applier interface{}) BoolPtrOutput {
 	return o.ApplyTWithContext(ctx, applier).(BoolPtrOutput)
 }
 
 // ApplyBoolArray is like ApplyT, but returns a BoolArrayOutput.
-func (o *OutputState) ApplyBoolArray(applier interface{}) BoolArrayOutput {
+func ApplyBoolArray(o Output, applier interface{}) BoolArrayOutput {
 	return o.ApplyT(applier).(BoolArrayOutput)
 }
 
 // ApplyBoolArrayWithContext is like ApplyTWithContext, but returns a BoolArrayOutput.
-func (o *OutputState) ApplyBoolArrayWithContext(ctx context.Context, applier interface{}) BoolArrayOutput {
+func ApplyBoolArrayWithContext(ctx context.Context, o Output, applier interface{}) BoolArrayOutput {
 	return o.ApplyTWithContext(ctx, applier).(BoolArrayOutput)
 }
 
 // ApplyBoolMap is like ApplyT, but returns a BoolMapOutput.
-func (o *OutputState) ApplyBoolMap(applier interface{}) BoolMapOutput {
+func ApplyBoolMap(o Output, applier interface{}) BoolMapOutput {
 	return o.ApplyT(applier).(BoolMapOutput)
 }
 
 // ApplyBoolMapWithContext is like ApplyTWithContext, but returns a BoolMapOutput.
-func (o *OutputState) ApplyBoolMapWithContext(ctx context.Context, applier interface{}) BoolMapOutput {
+func ApplyBoolMapWithContext(ctx context.Context, o Output, applier interface{}) BoolMapOutput {
 	return o.ApplyTWithContext(ctx, applier).(BoolMapOutput)
 }
 
 // ApplyBoolArrayMap is like ApplyT, but returns a BoolArrayMapOutput.
-func (o *OutputState) ApplyBoolArrayMap(applier interface{}) BoolArrayMapOutput {
+func ApplyBoolArrayMap(o Output, applier interface{}) BoolArrayMapOutput {
 	return o.ApplyT(applier).(BoolArrayMapOutput)
 }
 
 // ApplyBoolArrayMapWithContext is like ApplyTWithContext, but returns a BoolArrayMapOutput.
-func (o *OutputState) ApplyBoolArrayMapWithContext(ctx context.Context, applier interface{}) BoolArrayMapOutput {
+func ApplyBoolArrayMapWithContext(ctx context.Context, o Output, applier interface{}) BoolArrayMapOutput {
 	return o.ApplyTWithContext(ctx, applier).(BoolArrayMapOutput)
 }
 
 // ApplyBoolMapArray is like ApplyT, but returns a BoolMapArrayOutput.
-func (o *OutputState) ApplyBoolMapArray(applier interface{}) BoolMapArrayOutput {
+func ApplyBoolMapArray(o Output, applier interface{}) BoolMapArrayOutput {
 	return o.ApplyT(applier).(BoolMapArrayOutput)
 }
 
 // ApplyBoolMapArrayWithContext is like ApplyTWithContext, but returns a BoolMapArrayOutput.
-func (o *OutputState) ApplyBoolMapArrayWithContext(ctx context.Context, applier interface{}) BoolMapArrayOutput {
+func ApplyBoolMapArrayWithContext(ctx context.Context, o Output, applier interface{}) BoolMapArrayOutput {
 	return o.ApplyTWithContext(ctx, applier).(BoolMapArrayOutput)
 }
 
 // ApplyBoolMapMap is like ApplyT, but returns a BoolMapMapOutput.
-func (o *OutputState) ApplyBoolMapMap(applier interface{}) BoolMapMapOutput {
+func ApplyBoolMapMap(o Output, applier interface{}) BoolMapMapOutput {
 	return o.ApplyT(applier).(BoolMapMapOutput)
 }
 
 // ApplyBoolMapMapWithContext is like ApplyTWithContext, but returns a BoolMapMapOutput.
-func (o *OutputState) ApplyBoolMapMapWithContext(ctx context.Context, applier interface{}) BoolMapMapOutput {
+func ApplyBoolMapMapWithContext(ctx context.Context, o Output, applier interface{}) BoolMapMapOutput {
 	return o.ApplyTWithContext(ctx, applier).(BoolMapMapOutput)
 }
 
 // ApplyBoolArrayArray is like ApplyT, but returns a BoolArrayArrayOutput.
-func (o *OutputState) ApplyBoolArrayArray(applier interface{}) BoolArrayArrayOutput {
+func ApplyBoolArrayArray(o Output, applier interface{}) BoolArrayArrayOutput {
 	return o.ApplyT(applier).(BoolArrayArrayOutput)
 }
 
 // ApplyBoolArrayArrayWithContext is like ApplyTWithContext, but returns a BoolArrayArrayOutput.
-func (o *OutputState) ApplyBoolArrayArrayWithContext(ctx context.Context, applier interface{}) BoolArrayArrayOutput {
+func ApplyBoolArrayArrayWithContext(ctx context.Context, o Output, applier interface{}) BoolArrayArrayOutput {
 	return o.ApplyTWithContext(ctx, applier).(BoolArrayArrayOutput)
 }
 
 // ApplyFloat64 is like ApplyT, but returns a Float64Output.
-func (o *OutputState) ApplyFloat64(applier interface{}) Float64Output {
+func ApplyFloat64(o Output, applier interface{}) Float64Output {
 	return o.ApplyT(applier).(Float64Output)
 }
 
 // ApplyFloat64WithContext is like ApplyTWithContext, but returns a Float64Output.
-func (o *OutputState) ApplyFloat64WithContext(ctx context.Context, applier interface{}) Float64Output {
+func ApplyFloat64WithContext(ctx context.Context, o Output, applier interface{}) Float64Output {
 	return o.ApplyTWithContext(ctx, applier).(Float64Output)
 }
 
 // ApplyFloat64Ptr is like ApplyT, but returns a Float64PtrOutput.
-func (o *OutputState) ApplyFloat64Ptr(applier interface{}) Float64PtrOutput {
+func ApplyFloat64Ptr(o Output, applier interface{}) Float64PtrOutput {
 	return o.ApplyT(applier).(Float64PtrOutput)
 }
 
 // ApplyFloat64PtrWithContext is like ApplyTWithContext, but returns a Float64PtrOutput.
-func (o *OutputState) ApplyFloat64PtrWithContext(ctx context.Context, applier interface{}) Float64PtrOutput {
+func ApplyFloat64PtrWithContext(ctx context.Context, o Output, applier interface{}) Float64PtrOutput {
 	return o.ApplyTWithContext(ctx, applier).(Float64PtrOutput)
 }
 
 // ApplyFloat64Array is like ApplyT, but returns a Float64ArrayOutput.
-func (o *OutputState) ApplyFloat64Array(applier interface{}) Float64ArrayOutput {
+func ApplyFloat64Array(o Output, applier interface{}) Float64ArrayOutput {
 	return o.ApplyT(applier).(Float64ArrayOutput)
 }
 
 // ApplyFloat64ArrayWithContext is like ApplyTWithContext, but returns a Float64ArrayOutput.
-func (o *OutputState) ApplyFloat64ArrayWithContext(ctx context.Context, applier interface{}) Float64ArrayOutput {
+func ApplyFloat64ArrayWithContext(ctx context.Context, o Output, applier interface{}) Float64ArrayOutput {
 	return o.ApplyTWithContext(ctx, applier).(Float64ArrayOutput)
 }
 
 // ApplyFloat64Map is like ApplyT, but returns a Float64MapOutput.
-func (o *OutputState) ApplyFloat64Map(applier interface{}) Float64MapOutput {
+func ApplyFloat64Map(o Output, applier interface{}) Float64MapOutput {
 	return o.ApplyT(applier).(Float64MapOutput)
 }
 
 // ApplyFloat64MapWithContext is like ApplyTWithContext, but returns a Float64MapOutput.
-func (o *OutputState) ApplyFloat64MapWithContext(ctx context.Context, applier interface{}) Float64MapOutput {
+func ApplyFloat64MapWithContext(ctx context.Context, o Output, applier interface{}) Float64MapOutput {
 	return o.ApplyTWithContext(ctx, applier).(Float64MapOutput)
 }
 
 // ApplyFloat64ArrayMap is like ApplyT, but returns a Float64ArrayMapOutput.
-func (o *OutputState) ApplyFloat64ArrayMap(applier interface{}) Float64ArrayMapOutput {
+func ApplyFloat64ArrayMap(o Output, applier interface{}) Float64ArrayMapOutput {
 	return o.ApplyT(applier).(Float64ArrayMapOutput)
 }
 
 // ApplyFloat64ArrayMapWithContext is like ApplyTWithContext, but returns a Float64ArrayMapOutput.
-func (o *OutputState) ApplyFloat64ArrayMapWithContext(ctx context.Context, applier interface{}) Float64ArrayMapOutput {
+func ApplyFloat64ArrayMapWithContext(ctx context.Context, o Output, applier interface{}) Float64ArrayMapOutput {
 	return o.ApplyTWithContext(ctx, applier).(Float64ArrayMapOutput)
 }
 
 // ApplyFloat64MapArray is like ApplyT, but returns a Float64MapArrayOutput.
-func (o *OutputState) ApplyFloat64MapArray(applier interface{}) Float64MapArrayOutput {
+func ApplyFloat64MapArray(o Output, applier interface{}) Float64MapArrayOutput {
 	return o.ApplyT(applier).(Float64MapArrayOutput)
 }
 
 // ApplyFloat64MapArrayWithContext is like ApplyTWithContext, but returns a Float64MapArrayOutput.
-func (o *OutputState) ApplyFloat64MapArrayWithContext(ctx context.Context, applier interface{}) Float64MapArrayOutput {
+func ApplyFloat64MapArrayWithContext(ctx context.Context, o Output, applier interface{}) Float64MapArrayOutput {
 	return o.ApplyTWithContext(ctx, applier).(Float64MapArrayOutput)
 }
 
 // ApplyFloat64MapMap is like ApplyT, but returns a Float64MapMapOutput.
-func (o *OutputState) ApplyFloat64MapMap(applier interface{}) Float64MapMapOutput {
+func ApplyFloat64MapMap(o Output, applier interface{}) Float64MapMapOutput {
 	return o.ApplyT(applier).(Float64MapMapOutput)
 }
 
 // ApplyFloat64MapMapWithContext is like ApplyTWithContext, but returns a Float64MapMapOutput.
-func (o *OutputState) ApplyFloat64MapMapWithContext(ctx context.Context, applier interface{}) Float64MapMapOutput {
+func ApplyFloat64MapMapWithContext(ctx context.Context, o Output, applier interface{}) Float64MapMapOutput {
 	return o.ApplyTWithContext(ctx, applier).(Float64MapMapOutput)
 }
 
 // ApplyFloat64ArrayArray is like ApplyT, but returns a Float64ArrayArrayOutput.
-func (o *OutputState) ApplyFloat64ArrayArray(applier interface{}) Float64ArrayArrayOutput {
+func ApplyFloat64ArrayArray(o Output, applier interface{}) Float64ArrayArrayOutput {
 	return o.ApplyT(applier).(Float64ArrayArrayOutput)
 }
 
 // ApplyFloat64ArrayArrayWithContext is like ApplyTWithContext, but returns a Float64ArrayArrayOutput.
-func (o *OutputState) ApplyFloat64ArrayArrayWithContext(ctx context.Context, applier interface{}) Float64ArrayArrayOutput {
+func ApplyFloat64ArrayArrayWithContext(ctx context.Context, o Output, applier interface{}) Float64ArrayArrayOutput {
 	return o.ApplyTWithContext(ctx, applier).(Float64ArrayArrayOutput)
 }
 
 // ApplyID is like ApplyT, but returns a IDOutput.
-func (o *OutputState) ApplyID(applier interface{}) IDOutput {
+func ApplyID(o Output, applier interface{}) IDOutput {
 	return o.ApplyT(applier).(IDOutput)
 }
 
 // ApplyIDWithContext is like ApplyTWithContext, but returns a IDOutput.
-func (o *OutputState) ApplyIDWithContext(ctx context.Context, applier interface{}) IDOutput {
+func ApplyIDWithContext(ctx context.Context, o Output, applier interface{}) IDOutput {
 	return o.ApplyTWithContext(ctx, applier).(IDOutput)
 }
 
 // ApplyIDPtr is like ApplyT, but returns a IDPtrOutput.
-func (o *OutputState) ApplyIDPtr(applier interface{}) IDPtrOutput {
+func ApplyIDPtr(o Output, applier interface{}) IDPtrOutput {
 	return o.ApplyT(applier).(IDPtrOutput)
 }
 
 // ApplyIDPtrWithContext is like ApplyTWithContext, but returns a IDPtrOutput.
-func (o *OutputState) ApplyIDPtrWithContext(ctx context.Context, applier interface{}) IDPtrOutput {
+func ApplyIDPtrWithContext(ctx context.Context, o Output, applier interface{}) IDPtrOutput {
 	return o.ApplyTWithContext(ctx, applier).(IDPtrOutput)
 }
 
 // ApplyIDArray is like ApplyT, but returns a IDArrayOutput.
-func (o *OutputState) ApplyIDArray(applier interface{}) IDArrayOutput {
+func ApplyIDArray(o Output, applier interface{}) IDArrayOutput {
 	return o.ApplyT(applier).(IDArrayOutput)
 }
 
 // ApplyIDArrayWithContext is like ApplyTWithContext, but returns a IDArrayOutput.
-func (o *OutputState) ApplyIDArrayWithContext(ctx context.Context, applier interface{}) IDArrayOutput {
+func ApplyIDArrayWithContext(ctx context.Context, o Output, applier interface{}) IDArrayOutput {
 	return o.ApplyTWithContext(ctx, applier).(IDArrayOutput)
 }
 
 // ApplyIDMap is like ApplyT, but returns a IDMapOutput.
-func (o *OutputState) ApplyIDMap(applier interface{}) IDMapOutput {
+func ApplyIDMap(o Output, applier interface{}) IDMapOutput {
 	return o.ApplyT(applier).(IDMapOutput)
 }
 
 // ApplyIDMapWithContext is like ApplyTWithContext, but returns a IDMapOutput.
-func (o *OutputState) ApplyIDMapWithContext(ctx context.Context, applier interface{}) IDMapOutput {
+func ApplyIDMapWithContext(ctx context.Context, o Output, applier interface{}) IDMapOutput {
 	return o.ApplyTWithContext(ctx, applier).(IDMapOutput)
 }
 
 // ApplyIDArrayMap is like ApplyT, but returns a IDArrayMapOutput.
-func (o *OutputState) ApplyIDArrayMap(applier interface{}) IDArrayMapOutput {
+func ApplyIDArrayMap(o Output, applier interface{}) IDArrayMapOutput {
 	return o.ApplyT(applier).(IDArrayMapOutput)
 }
 
 // ApplyIDArrayMapWithContext is like ApplyTWithContext, but returns a IDArrayMapOutput.
-func (o *OutputState) ApplyIDArrayMapWithContext(ctx context.Context, applier interface{}) IDArrayMapOutput {
+func ApplyIDArrayMapWithContext(ctx context.Context, o Output, applier interface{}) IDArrayMapOutput {
 	return o.ApplyTWithContext(ctx, applier).(IDArrayMapOutput)
 }
 
 // ApplyIDMapArray is like ApplyT, but returns a IDMapArrayOutput.
-func (o *OutputState) ApplyIDMapArray(applier interface{}) IDMapArrayOutput {
+func ApplyIDMapArray(o Output, applier interface{}) IDMapArrayOutput {
 	return o.ApplyT(applier).(IDMapArrayOutput)
 }
 
 // ApplyIDMapArrayWithContext is like ApplyTWithContext, but returns a IDMapArrayOutput.
-func (o *OutputState) ApplyIDMapArrayWithContext(ctx context.Context, applier interface{}) IDMapArrayOutput {
+func ApplyIDMapArrayWithContext(ctx context.Context, o Output, applier interface{}) IDMapArrayOutput {
 	return o.ApplyTWithContext(ctx, applier).(IDMapArrayOutput)
 }
 
 // ApplyIDMapMap is like ApplyT, but returns a IDMapMapOutput.
-func (o *OutputState) ApplyIDMapMap(applier interface{}) IDMapMapOutput {
+func ApplyIDMapMap(o Output, applier interface{}) IDMapMapOutput {
 	return o.ApplyT(applier).(IDMapMapOutput)
 }
 
 // ApplyIDMapMapWithContext is like ApplyTWithContext, but returns a IDMapMapOutput.
-func (o *OutputState) ApplyIDMapMapWithContext(ctx context.Context, applier interface{}) IDMapMapOutput {
+func ApplyIDMapMapWithContext(ctx context.Context, o Output, applier interface{}) IDMapMapOutput {
 	return o.ApplyTWithContext(ctx, applier).(IDMapMapOutput)
 }
 
 // ApplyIDArrayArray is like ApplyT, but returns a IDArrayArrayOutput.
-func (o *OutputState) ApplyIDArrayArray(applier interface{}) IDArrayArrayOutput {
+func ApplyIDArrayArray(o Output, applier interface{}) IDArrayArrayOutput {
 	return o.ApplyT(applier).(IDArrayArrayOutput)
 }
 
 // ApplyIDArrayArrayWithContext is like ApplyTWithContext, but returns a IDArrayArrayOutput.
-func (o *OutputState) ApplyIDArrayArrayWithContext(ctx context.Context, applier interface{}) IDArrayArrayOutput {
+func ApplyIDArrayArrayWithContext(ctx context.Context, o Output, applier interface{}) IDArrayArrayOutput {
 	return o.ApplyTWithContext(ctx, applier).(IDArrayArrayOutput)
 }
 
 // ApplyArray is like ApplyT, but returns a ArrayOutput.
-func (o *OutputState) ApplyArray(applier interface{}) ArrayOutput {
+func ApplyArray(o Output, applier interface{}) ArrayOutput {
 	return o.ApplyT(applier).(ArrayOutput)
 }
 
 // ApplyArrayWithContext is like ApplyTWithContext, but returns a ArrayOutput.
-func (o *OutputState) ApplyArrayWithContext(ctx context.Context, applier interface{}) ArrayOutput {
+func ApplyArrayWithContext(ctx context.Context, o Output, applier interface{}) ArrayOutput {
 	return o.ApplyTWithContext(ctx, applier).(ArrayOutput)
 }
 
 // ApplyMap is like ApplyT, but returns a MapOutput.
-func (o *OutputState) ApplyMap(applier interface{}) MapOutput {
+func ApplyMap(o Output, applier interface{}) MapOutput {
 	return o.ApplyT(applier).(MapOutput)
 }
 
 // ApplyMapWithContext is like ApplyTWithContext, but returns a MapOutput.
-func (o *OutputState) ApplyMapWithContext(ctx context.Context, applier interface{}) MapOutput {
+func ApplyMapWithContext(ctx context.Context, o Output, applier interface{}) MapOutput {
 	return o.ApplyTWithContext(ctx, applier).(MapOutput)
 }
 
 // ApplyArrayMap is like ApplyT, but returns a ArrayMapOutput.
-func (o *OutputState) ApplyArrayMap(applier interface{}) ArrayMapOutput {
+func ApplyArrayMap(o Output, applier interface{}) ArrayMapOutput {
 	return o.ApplyT(applier).(ArrayMapOutput)
 }
 
 // ApplyArrayMapWithContext is like ApplyTWithContext, but returns a ArrayMapOutput.
-func (o *OutputState) ApplyArrayMapWithContext(ctx context.Context, applier interface{}) ArrayMapOutput {
+func ApplyArrayMapWithContext(ctx context.Context, o Output, applier interface{}) ArrayMapOutput {
 	return o.ApplyTWithContext(ctx, applier).(ArrayMapOutput)
 }
 
 // ApplyMapArray is like ApplyT, but returns a MapArrayOutput.
-func (o *OutputState) ApplyMapArray(applier interface{}) MapArrayOutput {
+func ApplyMapArray(o Output, applier interface{}) MapArrayOutput {
 	return o.ApplyT(applier).(MapArrayOutput)
 }
 
 // ApplyMapArrayWithContext is like ApplyTWithContext, but returns a MapArrayOutput.
-func (o *OutputState) ApplyMapArrayWithContext(ctx context.Context, applier interface{}) MapArrayOutput {
+func ApplyMapArrayWithContext(ctx context.Context, o Output, applier interface{}) MapArrayOutput {
 	return o.ApplyTWithContext(ctx, applier).(MapArrayOutput)
 }
 
 // ApplyMapMap is like ApplyT, but returns a MapMapOutput.
-func (o *OutputState) ApplyMapMap(applier interface{}) MapMapOutput {
+func ApplyMapMap(o Output, applier interface{}) MapMapOutput {
 	return o.ApplyT(applier).(MapMapOutput)
 }
 
 // ApplyMapMapWithContext is like ApplyTWithContext, but returns a MapMapOutput.
-func (o *OutputState) ApplyMapMapWithContext(ctx context.Context, applier interface{}) MapMapOutput {
+func ApplyMapMapWithContext(ctx context.Context, o Output, applier interface{}) MapMapOutput {
 	return o.ApplyTWithContext(ctx, applier).(MapMapOutput)
 }
 
 // ApplyArrayArray is like ApplyT, but returns a ArrayArrayOutput.
-func (o *OutputState) ApplyArrayArray(applier interface{}) ArrayArrayOutput {
+func ApplyArrayArray(o Output, applier interface{}) ArrayArrayOutput {
 	return o.ApplyT(applier).(ArrayArrayOutput)
 }
 
 // ApplyArrayArrayWithContext is like ApplyTWithContext, but returns a ArrayArrayOutput.
-func (o *OutputState) ApplyArrayArrayWithContext(ctx context.Context, applier interface{}) ArrayArrayOutput {
+func ApplyArrayArrayWithContext(ctx context.Context, o Output, applier interface{}) ArrayArrayOutput {
 	return o.ApplyTWithContext(ctx, applier).(ArrayArrayOutput)
 }
 
 // ApplyInt is like ApplyT, but returns a IntOutput.
-func (o *OutputState) ApplyInt(applier interface{}) IntOutput {
+func ApplyInt(o Output, applier interface{}) IntOutput {
 	return o.ApplyT(applier).(IntOutput)
 }
 
 // ApplyIntWithContext is like ApplyTWithContext, but returns a IntOutput.
-func (o *OutputState) ApplyIntWithContext(ctx context.Context, applier interface{}) IntOutput {
+func ApplyIntWithContext(ctx context.Context, o Output, applier interface{}) IntOutput {
 	return o.ApplyTWithContext(ctx, applier).(IntOutput)
 }
 
 // ApplyIntPtr is like ApplyT, but returns a IntPtrOutput.
-func (o *OutputState) ApplyIntPtr(applier interface{}) IntPtrOutput {
+func ApplyIntPtr(o Output, applier interface{}) IntPtrOutput {
 	return o.ApplyT(applier).(IntPtrOutput)
 }
 
 // ApplyIntPtrWithContext is like ApplyTWithContext, but returns a IntPtrOutput.
-func (o *OutputState) ApplyIntPtrWithContext(ctx context.Context, applier interface{}) IntPtrOutput {
+func ApplyIntPtrWithContext(ctx context.Context, o Output, applier interface{}) IntPtrOutput {
 	return o.ApplyTWithContext(ctx, applier).(IntPtrOutput)
 }
 
 // ApplyIntArray is like ApplyT, but returns a IntArrayOutput.
-func (o *OutputState) ApplyIntArray(applier interface{}) IntArrayOutput {
+func ApplyIntArray(o Output, applier interface{}) IntArrayOutput {
 	return o.ApplyT(applier).(IntArrayOutput)
 }
 
 // ApplyIntArrayWithContext is like ApplyTWithContext, but returns a IntArrayOutput.
-func (o *OutputState) ApplyIntArrayWithContext(ctx context.Context, applier interface{}) IntArrayOutput {
+func ApplyIntArrayWithContext(ctx context.Context, o Output, applier interface{}) IntArrayOutput {
 	return o.ApplyTWithContext(ctx, applier).(IntArrayOutput)
 }
 
 // ApplyIntMap is like ApplyT, but returns a IntMapOutput.
-func (o *OutputState) ApplyIntMap(applier interface{}) IntMapOutput {
+func ApplyIntMap(o Output, applier interface{}) IntMapOutput {
 	return o.ApplyT(applier).(IntMapOutput)
 }
 
 // ApplyIntMapWithContext is like ApplyTWithContext, but returns a IntMapOutput.
-func (o *OutputState) ApplyIntMapWithContext(ctx context.Context, applier interface{}) IntMapOutput {
+func ApplyIntMapWithContext(ctx context.Context, o Output, applier interface{}) IntMapOutput {
 	return o.ApplyTWithContext(ctx, applier).(IntMapOutput)
 }
 
 // ApplyIntArrayMap is like ApplyT, but returns a IntArrayMapOutput.
-func (o *OutputState) ApplyIntArrayMap(applier interface{}) IntArrayMapOutput {
+func ApplyIntArrayMap(o Output, applier interface{}) IntArrayMapOutput {
 	return o.ApplyT(applier).(IntArrayMapOutput)
 }
 
 // ApplyIntArrayMapWithContext is like ApplyTWithContext, but returns a IntArrayMapOutput.
-func (o *OutputState) ApplyIntArrayMapWithContext(ctx context.Context, applier interface{}) IntArrayMapOutput {
+func ApplyIntArrayMapWithContext(ctx context.Context, o Output, applier interface{}) IntArrayMapOutput {
 	return o.ApplyTWithContext(ctx, applier).(IntArrayMapOutput)
 }
 
 // ApplyIntMapArray is like ApplyT, but returns a IntMapArrayOutput.
-func (o *OutputState) ApplyIntMapArray(applier interface{}) IntMapArrayOutput {
+func ApplyIntMapArray(o Output, applier interface{}) IntMapArrayOutput {
 	return o.ApplyT(applier).(IntMapArrayOutput)
 }
 
 // ApplyIntMapArrayWithContext is like ApplyTWithContext, but returns a IntMapArrayOutput.
-func (o *OutputState) ApplyIntMapArrayWithContext(ctx context.Context, applier interface{}) IntMapArrayOutput {
+func ApplyIntMapArrayWithContext(ctx context.Context, o Output, applier interface{}) IntMapArrayOutput {
 	return o.ApplyTWithContext(ctx, applier).(IntMapArrayOutput)
 }
 
 // ApplyIntMapMap is like ApplyT, but returns a IntMapMapOutput.
-func (o *OutputState) ApplyIntMapMap(applier interface{}) IntMapMapOutput {
+func ApplyIntMapMap(o Output, applier interface{}) IntMapMapOutput {
 	return o.ApplyT(applier).(IntMapMapOutput)
 }
 
 // ApplyIntMapMapWithContext is like ApplyTWithContext, but returns a IntMapMapOutput.
-func (o *OutputState) ApplyIntMapMapWithContext(ctx context.Context, applier interface{}) IntMapMapOutput {
+func ApplyIntMapMapWithContext(ctx context.Context, o Output, applier interface{}) IntMapMapOutput {
 	return o.ApplyTWithContext(ctx, applier).(IntMapMapOutput)
 }
 
 // ApplyIntArrayArray is like ApplyT, but returns a IntArrayArrayOutput.
-func (o *OutputState) ApplyIntArrayArray(applier interface{}) IntArrayArrayOutput {
+func ApplyIntArrayArray(o Output, applier interface{}) IntArrayArrayOutput {
 	return o.ApplyT(applier).(IntArrayArrayOutput)
 }
 
 // ApplyIntArrayArrayWithContext is like ApplyTWithContext, but returns a IntArrayArrayOutput.
-func (o *OutputState) ApplyIntArrayArrayWithContext(ctx context.Context, applier interface{}) IntArrayArrayOutput {
+func ApplyIntArrayArrayWithContext(ctx context.Context, o Output, applier interface{}) IntArrayArrayOutput {
 	return o.ApplyTWithContext(ctx, applier).(IntArrayArrayOutput)
 }
 
 // ApplyString is like ApplyT, but returns a StringOutput.
-func (o *OutputState) ApplyString(applier interface{}) StringOutput {
+func ApplyString(o Output, applier interface{}) StringOutput {
 	return o.ApplyT(applier).(StringOutput)
 }
 
 // ApplyStringWithContext is like ApplyTWithContext, but returns a StringOutput.
-func (o *OutputState) ApplyStringWithContext(ctx context.Context, applier interface{}) StringOutput {
+func ApplyStringWithContext(ctx context.Context, o Output, applier interface{}) StringOutput {
 	return o.ApplyTWithContext(ctx, applier).(StringOutput)
 }
 
 // ApplyStringPtr is like ApplyT, but returns a StringPtrOutput.
-func (o *OutputState) ApplyStringPtr(applier interface{}) StringPtrOutput {
+func ApplyStringPtr(o Output, applier interface{}) StringPtrOutput {
 	return o.ApplyT(applier).(StringPtrOutput)
 }
 
 // ApplyStringPtrWithContext is like ApplyTWithContext, but returns a StringPtrOutput.
-func (o *OutputState) ApplyStringPtrWithContext(ctx context.Context, applier interface{}) StringPtrOutput {
+func ApplyStringPtrWithContext(ctx context.Context, o Output, applier interface{}) StringPtrOutput {
 	return o.ApplyTWithContext(ctx, applier).(StringPtrOutput)
 }
 
 // ApplyStringArray is like ApplyT, but returns a StringArrayOutput.
-func (o *OutputState) ApplyStringArray(applier interface{}) StringArrayOutput {
+func ApplyStringArray(o Output, applier interface{}) StringArrayOutput {
 	return o.ApplyT(applier).(StringArrayOutput)
 }
 
 // ApplyStringArrayWithContext is like ApplyTWithContext, but returns a StringArrayOutput.
-func (o *OutputState) ApplyStringArrayWithContext(ctx context.Context, applier interface{}) StringArrayOutput {
+func ApplyStringArrayWithContext(ctx context.Context, o Output, applier interface{}) StringArrayOutput {
 	return o.ApplyTWithContext(ctx, applier).(StringArrayOutput)
 }
 
 // ApplyStringMap is like ApplyT, but returns a StringMapOutput.
-func (o *OutputState) ApplyStringMap(applier interface{}) StringMapOutput {
+func ApplyStringMap(o Output, applier interface{}) StringMapOutput {
 	return o.ApplyT(applier).(StringMapOutput)
 }
 
 // ApplyStringMapWithContext is like ApplyTWithContext, but returns a StringMapOutput.
-func (o *OutputState) ApplyStringMapWithContext(ctx context.Context, applier interface{}) StringMapOutput {
+func ApplyStringMapWithContext(ctx context.Context, o Output, applier interface{}) StringMapOutput {
 	return o.ApplyTWithContext(ctx, applier).(StringMapOutput)
 }
 
 // ApplyStringArrayMap is like ApplyT, but returns a StringArrayMapOutput.
-func (o *OutputState) ApplyStringArrayMap(applier interface{}) StringArrayMapOutput {
+func ApplyStringArrayMap(o Output, applier interface{}) StringArrayMapOutput {
 	return o.ApplyT(applier).(StringArrayMapOutput)
 }
 
 // ApplyStringArrayMapWithContext is like ApplyTWithContext, but returns a StringArrayMapOutput.
-func (o *OutputState) ApplyStringArrayMapWithContext(ctx context.Context, applier interface{}) StringArrayMapOutput {
+func ApplyStringArrayMapWithContext(ctx context.Context, o Output, applier interface{}) StringArrayMapOutput {
 	return o.ApplyTWithContext(ctx, applier).(StringArrayMapOutput)
 }
 
 // ApplyStringMapArray is like ApplyT, but returns a StringMapArrayOutput.
-func (o *OutputState) ApplyStringMapArray(applier interface{}) StringMapArrayOutput {
+func ApplyStringMapArray(o Output, applier interface{}) StringMapArrayOutput {
 	return o.ApplyT(applier).(StringMapArrayOutput)
 }
 
 // ApplyStringMapArrayWithContext is like ApplyTWithContext, but returns a StringMapArrayOutput.
-func (o *OutputState) ApplyStringMapArrayWithContext(ctx context.Context, applier interface{}) StringMapArrayOutput {
+func ApplyStringMapArrayWithContext(ctx context.Context, o Output, applier interface{}) StringMapArrayOutput {
 	return o.ApplyTWithContext(ctx, applier).(StringMapArrayOutput)
 }
 
 // ApplyStringMapMap is like ApplyT, but returns a StringMapMapOutput.
-func (o *OutputState) ApplyStringMapMap(applier interface{}) StringMapMapOutput {
+func ApplyStringMapMap(o Output, applier interface{}) StringMapMapOutput {
 	return o.ApplyT(applier).(StringMapMapOutput)
 }
 
 // ApplyStringMapMapWithContext is like ApplyTWithContext, but returns a StringMapMapOutput.
-func (o *OutputState) ApplyStringMapMapWithContext(ctx context.Context, applier interface{}) StringMapMapOutput {
+func ApplyStringMapMapWithContext(ctx context.Context, o Output, applier interface{}) StringMapMapOutput {
 	return o.ApplyTWithContext(ctx, applier).(StringMapMapOutput)
 }
 
 // ApplyStringArrayArray is like ApplyT, but returns a StringArrayArrayOutput.
-func (o *OutputState) ApplyStringArrayArray(applier interface{}) StringArrayArrayOutput {
+func ApplyStringArrayArray(o Output, applier interface{}) StringArrayArrayOutput {
 	return o.ApplyT(applier).(StringArrayArrayOutput)
 }
 
 // ApplyStringArrayArrayWithContext is like ApplyTWithContext, but returns a StringArrayArrayOutput.
-func (o *OutputState) ApplyStringArrayArrayWithContext(ctx context.Context, applier interface{}) StringArrayArrayOutput {
+func ApplyStringArrayArrayWithContext(ctx context.Context, o Output, applier interface{}) StringArrayArrayOutput {
 	return o.ApplyTWithContext(ctx, applier).(StringArrayArrayOutput)
 }
 
 // ApplyURN is like ApplyT, but returns a URNOutput.
-func (o *OutputState) ApplyURN(applier interface{}) URNOutput {
+func ApplyURN(o Output, applier interface{}) URNOutput {
 	return o.ApplyT(applier).(URNOutput)
 }
 
 // ApplyURNWithContext is like ApplyTWithContext, but returns a URNOutput.
-func (o *OutputState) ApplyURNWithContext(ctx context.Context, applier interface{}) URNOutput {
+func ApplyURNWithContext(ctx context.Context, o Output, applier interface{}) URNOutput {
 	return o.ApplyTWithContext(ctx, applier).(URNOutput)
 }
 
 // ApplyURNPtr is like ApplyT, but returns a URNPtrOutput.
-func (o *OutputState) ApplyURNPtr(applier interface{}) URNPtrOutput {
+func ApplyURNPtr(o Output, applier interface{}) URNPtrOutput {
 	return o.ApplyT(applier).(URNPtrOutput)
 }
 
 // ApplyURNPtrWithContext is like ApplyTWithContext, but returns a URNPtrOutput.
-func (o *OutputState) ApplyURNPtrWithContext(ctx context.Context, applier interface{}) URNPtrOutput {
+func ApplyURNPtrWithContext(ctx context.Context, o Output, applier interface{}) URNPtrOutput {
 	return o.ApplyTWithContext(ctx, applier).(URNPtrOutput)
 }
 
 // ApplyURNArray is like ApplyT, but returns a URNArrayOutput.
-func (o *OutputState) ApplyURNArray(applier interface{}) URNArrayOutput {
+func ApplyURNArray(o Output, applier interface{}) URNArrayOutput {
 	return o.ApplyT(applier).(URNArrayOutput)
 }
 
 // ApplyURNArrayWithContext is like ApplyTWithContext, but returns a URNArrayOutput.
-func (o *OutputState) ApplyURNArrayWithContext(ctx context.Context, applier interface{}) URNArrayOutput {
+func ApplyURNArrayWithContext(ctx context.Context, o Output, applier interface{}) URNArrayOutput {
 	return o.ApplyTWithContext(ctx, applier).(URNArrayOutput)
 }
 
 // ApplyURNMap is like ApplyT, but returns a URNMapOutput.
-func (o *OutputState) ApplyURNMap(applier interface{}) URNMapOutput {
+func ApplyURNMap(o Output, applier interface{}) URNMapOutput {
 	return o.ApplyT(applier).(URNMapOutput)
 }
 
 // ApplyURNMapWithContext is like ApplyTWithContext, but returns a URNMapOutput.
-func (o *OutputState) ApplyURNMapWithContext(ctx context.Context, applier interface{}) URNMapOutput {
+func ApplyURNMapWithContext(ctx context.Context, o Output, applier interface{}) URNMapOutput {
 	return o.ApplyTWithContext(ctx, applier).(URNMapOutput)
 }
 
 // ApplyURNArrayMap is like ApplyT, but returns a URNArrayMapOutput.
-func (o *OutputState) ApplyURNArrayMap(applier interface{}) URNArrayMapOutput {
+func ApplyURNArrayMap(o Output, applier interface{}) URNArrayMapOutput {
 	return o.ApplyT(applier).(URNArrayMapOutput)
 }
 
 // ApplyURNArrayMapWithContext is like ApplyTWithContext, but returns a URNArrayMapOutput.
-func (o *OutputState) ApplyURNArrayMapWithContext(ctx context.Context, applier interface{}) URNArrayMapOutput {
+func ApplyURNArrayMapWithContext(ctx context.Context, o Output, applier interface{}) URNArrayMapOutput {
 	return o.ApplyTWithContext(ctx, applier).(URNArrayMapOutput)
 }
 
 // ApplyURNMapArray is like ApplyT, but returns a URNMapArrayOutput.
-func (o *OutputState) ApplyURNMapArray(applier interface{}) URNMapArrayOutput {
+func ApplyURNMapArray(o Output, applier interface{}) URNMapArrayOutput {
 	return o.ApplyT(applier).(URNMapArrayOutput)
 }
 
 // ApplyURNMapArrayWithContext is like ApplyTWithContext, but returns a URNMapArrayOutput.
-func (o *OutputState) ApplyURNMapArrayWithContext(ctx context.Context, applier interface{}) URNMapArrayOutput {
+func ApplyURNMapArrayWithContext(ctx context.Context, o Output, applier interface{}) URNMapArrayOutput {
 	return o.ApplyTWithContext(ctx, applier).(URNMapArrayOutput)
 }
 
 // ApplyURNMapMap is like ApplyT, but returns a URNMapMapOutput.
-func (o *OutputState) ApplyURNMapMap(applier interface{}) URNMapMapOutput {
+func ApplyURNMapMap(o Output, applier interface{}) URNMapMapOutput {
 	return o.ApplyT(applier).(URNMapMapOutput)
 }
 
 // ApplyURNMapMapWithContext is like ApplyTWithContext, but returns a URNMapMapOutput.
-func (o *OutputState) ApplyURNMapMapWithContext(ctx context.Context, applier interface{}) URNMapMapOutput {
+func ApplyURNMapMapWithContext(ctx context.Context, o Output, applier interface{}) URNMapMapOutput {
 	return o.ApplyTWithContext(ctx, applier).(URNMapMapOutput)
 }
 
 // ApplyURNArrayArray is like ApplyT, but returns a URNArrayArrayOutput.
-func (o *OutputState) ApplyURNArrayArray(applier interface{}) URNArrayArrayOutput {
+func ApplyURNArrayArray(o Output, applier interface{}) URNArrayArrayOutput {
 	return o.ApplyT(applier).(URNArrayArrayOutput)
 }
 
 // ApplyURNArrayArrayWithContext is like ApplyTWithContext, but returns a URNArrayArrayOutput.
-func (o *OutputState) ApplyURNArrayArrayWithContext(ctx context.Context, applier interface{}) URNArrayArrayOutput {
+func ApplyURNArrayArrayWithContext(ctx context.Context, o Output, applier interface{}) URNArrayArrayOutput {
 	return o.ApplyTWithContext(ctx, applier).(URNArrayArrayOutput)
 }
 

sdk/go/pulumi/types_test.go

@@ -556,7 +556,7 @@ func TestNil(t *testing.T) {
 	assert.NoError(t, err)
 	assert.Equal(t, nil, v)
 
-	bo := ao.ApplyBool(func(x interface{}) bool {
+	bo := ApplyBool(ao, func(x interface{}) bool {
 		return x == nil
 	})
 	v, known, secret, deps, err = await(bo)