pulumix

package
v3.113.0 Latest Latest
Warning

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

 Go to latest Published: Apr 15, 2024 License: Apache-2.0 Imports: 5 Imported by: 402

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func Cast 

func Cast[O OutputOf[T], T any](i Input[T]) O

Cast turns any Input[T] into a concrete Output type O.

O must meet the following requirements:

  • implement ElementType() returning a type compatible with T
  • embed *OutputState as a field

The above is true for all output types generated by the Pulumi SDK.

As an example, you can use Cast to convert interchangeably between Output[[]string], ArrayOutput[string], and StringArrayOutput. 

var o pulumix.Output[[]string] = // ...
ao := pulumix.Cast[pulumix.ArrayOutput[string]](o)
sao := pulumix.Cast[pulumi.StringArrayOutput](o)

func InputElementType 

func InputElementType(t reflect.Type) (e reflect.Type, ok bool)

InputElementType returns the element type of an Input[T] or false if the type is not a Input[T].

Types

type Array 

type Array[T any] []Input[T]

Array is a list of input values of the same type. It may be used as an Input[[]T].

func (Array[T]) AsAny 

func (a Array[T]) AsAny() Output[any]

AsAny turns the array into an Output[any].

func (Array[T]) ElementType 

func (Array[T]) ElementType() reflect.Type

ElementType returns the reflected type of []T.

func (Array[T]) ToOutput 

func (a Array[T]) ToOutput(ctx context.Context) Output[[]T]

ToOutput builds an Output from the values in the array.

type ArrayOutput 

type ArrayOutput[T any] struct{ *internal.OutputState }

ArrayOutput is an Output value holding a slice of type T. It may be used as an Input[[]T].

func (ArrayOutput[T]) ElementType 

func (o ArrayOutput[T]) ElementType() reflect.Type

ElementType returns the reflected type of []T.

func (ArrayOutput[T]) Index 

func (o ArrayOutput[T]) Index(idx Input[int]) Output[T]

Index returns an Output holding the value inside the slice at the given index.

If the index is out of bounds, the returned Output holds the zero value of T.

func (ArrayOutput[T]) ToOutput 

func (o ArrayOutput[T]) ToOutput(ctx context.Context) Output[[]T]

ToOutput converts the ArrayOutput to an Output.

func (ArrayOutput[T]) Untyped 

func (o ArrayOutput[T]) Untyped() internal.Output

Untyped converts a ArrayOutput to a pulumi.Output.

See Output.Untyped for more details.

type GArrayOutput 

type GArrayOutput[T any, O OutputOf[T]] struct{ *internal.OutputState }

GArrayOutput is an Output value holding a slice of type T. It may be used as an Input[[]T].

O is the kind of Output value that this GArrayOutput unwraps to.

func (GArrayOutput[T, O]) ElementType 

func (o GArrayOutput[T, O]) ElementType() reflect.Type

ElementType returns the reflected type of []T.

func (GArrayOutput[T, O]) Index 

func (o GArrayOutput[T, O]) Index(idx Input[int]) O

Index returns an Output holding the value inside the slice at the given index.

If the index is out of bounds, the returned Output holds the zero value of T.

func (GArrayOutput[T, O]) ToOutput 

func (o GArrayOutput[T, O]) ToOutput(ctx context.Context) Output[[]T]

ToOutput converts the GArrayOutput to an Output.

func (GArrayOutput[T, O]) Untyped 

func (o GArrayOutput[T, O]) Untyped() internal.Output

Untyped converts a GArrayOutput to a pulumi.Output.

See Output.Untyped for more details.

type GMapOutput 

type GMapOutput[T any, O OutputOf[T]] struct{ *internal.OutputState }

GMapOutput is an Output value holding a map[string]T. It may be used as an Input[map[string]T].

O is the kind of Output value that this GMapOutput unwraps to.

func (GMapOutput[T, O]) ElementType 

func (o GMapOutput[T, O]) ElementType() reflect.Type

ElementType returns the reflected type of map[string]T.

func (GMapOutput[T, O]) MapIndex 

func (o GMapOutput[T, O]) MapIndex(key Input[string]) O

MapIndex returns an Output holding the value inside the map with the given key.

If there is no value with the given key, the returned Output holds the zero value of T.

func (GMapOutput[T, O]) ToOutput 

func (o GMapOutput[T, O]) ToOutput(ctx context.Context) Output[map[string]T]

ToOutput converts the GMapOutput to an Output.

func (GMapOutput[T, O]) Untyped 

func (o GMapOutput[T, O]) Untyped() internal.Output

Untyped converts a GMapOutput to a pulumi.Output.

See Output.Untyped for more details.

type GPtrOutput 

type GPtrOutput[T any, O OutputOf[T]] struct{ *internal.OutputState }

GPtrOutput is an Output value holding a pointer of type T. It may be used as an Input[*T].

O is the kind of Output value that this GPtrOutput unwraps to.

func (GPtrOutput[T, O]) Elem 

func (o GPtrOutput[T, O]) Elem() O

Elem dereferences the pointer, returning the underlying value in an Output. If the pointer is nil, the returned Output holds the zero value of T.

func (GPtrOutput[T, O]) ElementType 

func (o GPtrOutput[T, O]) ElementType() reflect.Type

ElementType returns the reflected type of *T.

func (GPtrOutput[T, O]) ToOutput 

func (o GPtrOutput[T, O]) ToOutput(ctx context.Context) Output[*T]

ToOutput converts the GPtrOutput to an Output.

func (GPtrOutput[T, O]) Untyped 

func (o GPtrOutput[T, O]) Untyped() internal.Output

Untyped converts a GPtrOutput[T] to a pulumi.Output.

See Output.Untyped for more details.

type Input 

type Input[T any] interface {
	internal.Input

	// ToOutput converts this input to an Output[T].
	ToOutput(context.Context) Output[T]
}

Input is a generic input for a Pulumi resource or function.

All Input values are convertible to Output values, allowing them to be composed together with other inputs and resource outputs.

type Map 

type Map[T any] map[string]Input[T]

Map is a map from strings to input values of the same type. It may be used as an Input[map[string]T].

func (Map[T]) AsAny 

func (m Map[T]) AsAny() Output[any]

AsAny turns the map into an Output[any].

func (Map[T]) ElementType 

func (Map[T]) ElementType() reflect.Type

ElementType returns the reflected type of map[string]T.

func (Map[T]) ToOutput 

func (m Map[T]) ToOutput(ctx context.Context) Output[map[string]T]

ToOutput builds an Output from the values in the map.

type MapOutput 

type MapOutput[T any] struct{ *internal.OutputState }

MapOutput is an Output value holding a map[string]T. It may be used as an Input[map[string]T].

func (MapOutput[T]) ElementType 

func (o MapOutput[T]) ElementType() reflect.Type

ElementType returns the reflected type of map[string]T.

func (MapOutput[T]) MapIndex 

func (o MapOutput[T]) MapIndex(key Input[string]) Output[T]

MapIndex returns an Output holding the value inside the map with the given key.

If there is no value with the given key, the returned Output holds the zero value of T.

func (MapOutput[T]) ToOutput 

func (o MapOutput[T]) ToOutput(ctx context.Context) Output[map[string]T]

ToOutput converts the MapOutput to an Output.

func (MapOutput[T]) Untyped 

func (o MapOutput[T]) Untyped() internal.Output

Untyped converts a MapOutput to a pulumi.Output.

See Output.Untyped for more details.

type Output 

type Output[T any] struct{ *internal.OutputState }

Output is a promise of a value of type T. It encodes the relationship between resources in a Pulumi application. The value may be unknown, a secret, and may have dependencies.

Output[T] implements pulumix.Input[T], as well as pulumi.Input.

func All 

func All(args ...Input[any]) Output[[]any]

All combines multiple inputs into a single output that produces a list of all the input values.

func Apply 

func Apply[A1, B any](
	i1 Input[A1],
	fn func(A1) B,
) Output[B]

Apply applies a function to an input, returning an Output holding the result of the function.

This is a variant of ApplyContextErr that does not allow the function to return an error, and uses the background context.

func Apply2 

func Apply2[A1, A2, B any](
	i1 Input[A1], i2 Input[A2],
	fn func(A1, A2) B,
) Output[B]

Apply2 applies a function to 2 inputs, returning an Output holding the result of the function.

This is a variant of Apply2ContextErr that does not allow the function to return an error, and uses the background context.

func Apply2Context 

func Apply2Context[A1, A2, B any](
	ctx context.Context,
	i1 Input[A1], i2 Input[A2],
	fn func(A1, A2) B,
) Output[B]

Apply2Context applies a function to 2 inputs, returning an Output holding the result of the function.

This is a variant of Apply2ContextErr that does not allow the function to return an error.

func Apply2ContextErr 

func Apply2ContextErr[A1, A2, B any](
	ctx context.Context,
	i1 Input[A1], i2 Input[A2],
	fn func(A1, A2) (B, error),
) Output[B]

Apply2ContextErr applies a function to 2 inputs, returning an Output holding the result of the function.

If the function returns an error, the Output will be in an error state.

func Apply2Err 

func Apply2Err[A1, A2, B any](
	i1 Input[A1], i2 Input[A2],
	fn func(A1, A2) (B, error),
) Output[B]

Apply2Err applies a function to 2 inputs, returning an Output holding the result of the function.

If the function returns an error, the Output will be in an error state.

This is a variant of Apply2ContextErr that uses the background context.

func Apply3 

func Apply3[A1, A2, A3, B any](
	i1 Input[A1], i2 Input[A2], i3 Input[A3],
	fn func(A1, A2, A3) B,
) Output[B]

Apply3 applies a function to 3 inputs, returning an Output holding the result of the function.

This is a variant of Apply3ContextErr that does not allow the function to return an error, and uses the background context.

func Apply3Context 

func Apply3Context[A1, A2, A3, B any](
	ctx context.Context,
	i1 Input[A1], i2 Input[A2], i3 Input[A3],
	fn func(A1, A2, A3) B,
) Output[B]

Apply3Context applies a function to 3 inputs, returning an Output holding the result of the function.

This is a variant of Apply3ContextErr that does not allow the function to return an error.

func Apply3ContextErr 

func Apply3ContextErr[A1, A2, A3, B any](
	ctx context.Context,
	i1 Input[A1], i2 Input[A2], i3 Input[A3],
	fn func(A1, A2, A3) (B, error),
) Output[B]

Apply3ContextErr applies a function to 3 inputs, returning an Output holding the result of the function.

If the function returns an error, the Output will be in an error state.

func Apply3Err 

func Apply3Err[A1, A2, A3, B any](
	i1 Input[A1], i2 Input[A2], i3 Input[A3],
	fn func(A1, A2, A3) (B, error),
) Output[B]

Apply3Err applies a function to 3 inputs, returning an Output holding the result of the function.

If the function returns an error, the Output will be in an error state.

This is a variant of Apply3ContextErr that uses the background context.

func Apply4 

func Apply4[A1, A2, A3, A4, B any](
	i1 Input[A1], i2 Input[A2], i3 Input[A3], i4 Input[A4],
	fn func(A1, A2, A3, A4) B,
) Output[B]

Apply4 applies a function to 4 inputs, returning an Output holding the result of the function.

This is a variant of Apply4ContextErr that does not allow the function to return an error, and uses the background context.

func Apply4Context 

func Apply4Context[A1, A2, A3, A4, B any](
	ctx context.Context,
	i1 Input[A1], i2 Input[A2], i3 Input[A3], i4 Input[A4],
	fn func(A1, A2, A3, A4) B,
) Output[B]

Apply4Context applies a function to 4 inputs, returning an Output holding the result of the function.

This is a variant of Apply4ContextErr that does not allow the function to return an error.

func Apply4ContextErr 

func Apply4ContextErr[A1, A2, A3, A4, B any](
	ctx context.Context,
	i1 Input[A1], i2 Input[A2], i3 Input[A3], i4 Input[A4],
	fn func(A1, A2, A3, A4) (B, error),
) Output[B]

Apply4ContextErr applies a function to 4 inputs, returning an Output holding the result of the function.

If the function returns an error, the Output will be in an error state.

func Apply4Err 

func Apply4Err[A1, A2, A3, A4, B any](
	i1 Input[A1], i2 Input[A2], i3 Input[A3], i4 Input[A4],
	fn func(A1, A2, A3, A4) (B, error),
) Output[B]

Apply4Err applies a function to 4 inputs, returning an Output holding the result of the function.

If the function returns an error, the Output will be in an error state.

This is a variant of Apply4ContextErr that uses the background context.

func Apply5 

func Apply5[A1, A2, A3, A4, A5, B any](
	i1 Input[A1], i2 Input[A2], i3 Input[A3], i4 Input[A4], i5 Input[A5],
	fn func(A1, A2, A3, A4, A5) B,
) Output[B]

Apply5 applies a function to 5 inputs, returning an Output holding the result of the function.

This is a variant of Apply5ContextErr that does not allow the function to return an error, and uses the background context.

func Apply5Context 

func Apply5Context[A1, A2, A3, A4, A5, B any](
	ctx context.Context,
	i1 Input[A1], i2 Input[A2], i3 Input[A3], i4 Input[A4], i5 Input[A5],
	fn func(A1, A2, A3, A4, A5) B,
) Output[B]

Apply5Context applies a function to 5 inputs, returning an Output holding the result of the function.

This is a variant of Apply5ContextErr that does not allow the function to return an error.

func Apply5ContextErr 

func Apply5ContextErr[A1, A2, A3, A4, A5, B any](
	ctx context.Context,
	i1 Input[A1], i2 Input[A2], i3 Input[A3], i4 Input[A4], i5 Input[A5],
	fn func(A1, A2, A3, A4, A5) (B, error),
) Output[B]

Apply5ContextErr applies a function to 5 inputs, returning an Output holding the result of the function.

If the function returns an error, the Output will be in an error state.

func Apply5Err 

func Apply5Err[A1, A2, A3, A4, A5, B any](
	i1 Input[A1], i2 Input[A2], i3 Input[A3], i4 Input[A4], i5 Input[A5],
	fn func(A1, A2, A3, A4, A5) (B, error),
) Output[B]

Apply5Err applies a function to 5 inputs, returning an Output holding the result of the function.

If the function returns an error, the Output will be in an error state.

This is a variant of Apply5ContextErr that uses the background context.

func Apply6 

func Apply6[A1, A2, A3, A4, A5, A6, B any](
	i1 Input[A1], i2 Input[A2], i3 Input[A3], i4 Input[A4], i5 Input[A5], i6 Input[A6],
	fn func(A1, A2, A3, A4, A5, A6) B,
) Output[B]

Apply6 applies a function to 6 inputs, returning an Output holding the result of the function.

This is a variant of Apply6ContextErr that does not allow the function to return an error, and uses the background context.

func Apply6Context 

func Apply6Context[A1, A2, A3, A4, A5, A6, B any](
	ctx context.Context,
	i1 Input[A1], i2 Input[A2], i3 Input[A3], i4 Input[A4], i5 Input[A5], i6 Input[A6],
	fn func(A1, A2, A3, A4, A5, A6) B,
) Output[B]

Apply6Context applies a function to 6 inputs, returning an Output holding the result of the function.

This is a variant of Apply6ContextErr that does not allow the function to return an error.

func Apply6ContextErr 

func Apply6ContextErr[A1, A2, A3, A4, A5, A6, B any](
	ctx context.Context,
	i1 Input[A1], i2 Input[A2], i3 Input[A3], i4 Input[A4], i5 Input[A5], i6 Input[A6],
	fn func(A1, A2, A3, A4, A5, A6) (B, error),
) Output[B]

Apply6ContextErr applies a function to 6 inputs, returning an Output holding the result of the function.

If the function returns an error, the Output will be in an error state.

func Apply6Err 

func Apply6Err[A1, A2, A3, A4, A5, A6, B any](
	i1 Input[A1], i2 Input[A2], i3 Input[A3], i4 Input[A4], i5 Input[A5], i6 Input[A6],
	fn func(A1, A2, A3, A4, A5, A6) (B, error),
) Output[B]

Apply6Err applies a function to 6 inputs, returning an Output holding the result of the function.

If the function returns an error, the Output will be in an error state.

This is a variant of Apply6ContextErr that uses the background context.

func Apply7 

func Apply7[A1, A2, A3, A4, A5, A6, A7, B any](
	i1 Input[A1], i2 Input[A2], i3 Input[A3], i4 Input[A4], i5 Input[A5], i6 Input[A6], i7 Input[A7],
	fn func(A1, A2, A3, A4, A5, A6, A7) B,
) Output[B]

Apply7 applies a function to 7 inputs, returning an Output holding the result of the function.

This is a variant of Apply7ContextErr that does not allow the function to return an error, and uses the background context.

func Apply7Context 

func Apply7Context[A1, A2, A3, A4, A5, A6, A7, B any](
	ctx context.Context,
	i1 Input[A1], i2 Input[A2], i3 Input[A3], i4 Input[A4], i5 Input[A5], i6 Input[A6], i7 Input[A7],
	fn func(A1, A2, A3, A4, A5, A6, A7) B,
) Output[B]

Apply7Context applies a function to 7 inputs, returning an Output holding the result of the function.

This is a variant of Apply7ContextErr that does not allow the function to return an error.

func Apply7ContextErr 

func Apply7ContextErr[A1, A2, A3, A4, A5, A6, A7, B any](
	ctx context.Context,
	i1 Input[A1], i2 Input[A2], i3 Input[A3], i4 Input[A4], i5 Input[A5], i6 Input[A6], i7 Input[A7],
	fn func(A1, A2, A3, A4, A5, A6, A7) (B, error),
) Output[B]

Apply7ContextErr applies a function to 7 inputs, returning an Output holding the result of the function.

If the function returns an error, the Output will be in an error state.

func Apply7Err 

func Apply7Err[A1, A2, A3, A4, A5, A6, A7, B any](
	i1 Input[A1], i2 Input[A2], i3 Input[A3], i4 Input[A4], i5 Input[A5], i6 Input[A6], i7 Input[A7],
	fn func(A1, A2, A3, A4, A5, A6, A7) (B, error),
) Output[B]

Apply7Err applies a function to 7 inputs, returning an Output holding the result of the function.

If the function returns an error, the Output will be in an error state.

This is a variant of Apply7ContextErr that uses the background context.

func Apply8 

func Apply8[A1, A2, A3, A4, A5, A6, A7, A8, B any](
	i1 Input[A1], i2 Input[A2], i3 Input[A3], i4 Input[A4], i5 Input[A5], i6 Input[A6], i7 Input[A7], i8 Input[A8],
	fn func(A1, A2, A3, A4, A5, A6, A7, A8) B,
) Output[B]

Apply8 applies a function to 8 inputs, returning an Output holding the result of the function.

This is a variant of Apply8ContextErr that does not allow the function to return an error, and uses the background context.

func Apply8Context 

func Apply8Context[A1, A2, A3, A4, A5, A6, A7, A8, B any](
	ctx context.Context,
	i1 Input[A1], i2 Input[A2], i3 Input[A3], i4 Input[A4], i5 Input[A5], i6 Input[A6], i7 Input[A7], i8 Input[A8],
	fn func(A1, A2, A3, A4, A5, A6, A7, A8) B,
) Output[B]

Apply8Context applies a function to 8 inputs, returning an Output holding the result of the function.

This is a variant of Apply8ContextErr that does not allow the function to return an error.

func Apply8ContextErr 

func Apply8ContextErr[A1, A2, A3, A4, A5, A6, A7, A8, B any](
	ctx context.Context,
	i1 Input[A1], i2 Input[A2], i3 Input[A3], i4 Input[A4], i5 Input[A5], i6 Input[A6], i7 Input[A7], i8 Input[A8],
	fn func(A1, A2, A3, A4, A5, A6, A7, A8) (B, error),
) Output[B]

Apply8ContextErr applies a function to 8 inputs, returning an Output holding the result of the function.

If the function returns an error, the Output will be in an error state.

func Apply8Err 

func Apply8Err[A1, A2, A3, A4, A5, A6, A7, A8, B any](
	i1 Input[A1], i2 Input[A2], i3 Input[A3], i4 Input[A4], i5 Input[A5], i6 Input[A6], i7 Input[A7], i8 Input[A8],
	fn func(A1, A2, A3, A4, A5, A6, A7, A8) (B, error),
) Output[B]

Apply8Err applies a function to 8 inputs, returning an Output holding the result of the function.

If the function returns an error, the Output will be in an error state.

This is a variant of Apply8ContextErr that uses the background context.

func ApplyContext 

func ApplyContext[A1, B any](
	ctx context.Context,
	i1 Input[A1],
	fn func(A1) B,
) Output[B]

ApplyContext applies a function to an input, returning an Output holding the result of the function.

This is a variant of ApplyContextErr that does not allow the function to return an error.

func ApplyContextErr 

func ApplyContextErr[A1, B any](
	ctx context.Context,
	i1 Input[A1],
	fn func(A1) (B, error),
) Output[B]

ApplyContextErr applies a function to an input, returning an Output holding the result of the function.

If the function returns an error, the Output will be in an error state.

func ApplyErr 

func ApplyErr[A1, B any](
	i1 Input[A1],
	fn func(A1) (B, error),
) Output[B]

ApplyErr applies a function to an input, returning an Output holding the result of the function.

If the function returns an error, the Output will be in an error state.

This is a variant of ApplyContextErr that uses the background context.

func ConvertTyped 

func ConvertTyped[T any](o internal.Output) (Output[T], error)

ConvertTyped builds an Output with the given untyped pulumi.Output, which must produce a value assignable to type T.

Returns an error if o does not produce a compatible value.

func Flatten added in v3.81.0 

func Flatten[A any, I Input[A]](i Input[I]) Output[A]

Flatten unpacks the Output stored inside another input, returning an output containing the underlying value.

This is a variant of FlattenContext that uses the background context.

func FlattenContext added in v3.81.0 

func FlattenContext[A any, I Input[A]](ctx context.Context, i Input[I]) Output[A]

FlattenContext unpacks an Output stored inside another input, returning an output containing the underlying value.

func MustConvertTyped 

func MustConvertTyped[T any](o internal.Output) Output[T]

MustConvertTyped is a variant of ConvertTyped that panics if the type of value returned by o is not assignable to T.

func Val 

func Val[T any](v T) Output[T]

Val builds an Output holding the given value.

func (Output[T]) AsAny 

func (o Output[T]) AsAny() Output[any]

AsAny casts this Output[T] to an Output[any].

func (Output[T]) ElementType 

func (o Output[T]) ElementType() reflect.Type

ElementType reports the kind of value produced by this output.

This is the same as the type argument T.

func (Output[T]) ToOutput 

func (o Output[T]) ToOutput(ctx context.Context) Output[T]

ToOutput returns this value back.

This is necessary to implement Input[T].

func (Output[T]) Untyped 

func (o Output[T]) Untyped() internal.Output

Untyped converts an Output[T] to a pulumi.Output.

The concrete type of the returned value will be the most specific known implementation of pulumi.Output that matches the element type of the input, assuming it was registered with pulumi.RegisterOutputType.

Use this to call legacy APIs that expect a concrete pulumi.Output. For example, 

var o pulumix.Output[string] = // ...
legacyAPI(o.Untyped().(pulumi.StringOutput))

type OutputOf 

type OutputOf[T any] interface {
	Input[T]
	internal.Output
}

OutputOf[T] is a constraint satisfies by any output type that produces a value of type T. All such types MUST embed *pulumi.OutputState.

For example, OutputOf[int] is satisfied by pulumix.Output[int] as well as pulumi.IntOutput.

type PtrOutput 

type PtrOutput[T any] struct{ *internal.OutputState }

PtrOutput is an Output value holding a pointer of type T. It may be used as an Input[*T].

PtrOutput is a simpler variant of GPtrOutput that is not parameterized on the kind of Output value it unwraps to.

func Ptr 

func Ptr[T any](v T) PtrOutput[T]

Ptr builds an Output holding a pointer to the given value.

func PtrOf 

func PtrOf[T any, I Input[T]](i I) PtrOutput[T]

PtrOf returns an output holding a pointer to the value inside the given input.

For example, 

var s pulumi.StringOutput = ... // implements Input[string]
ps := PtrOf(s)                  // implements Input[*string]

func (PtrOutput[T]) Elem 

func (o PtrOutput[T]) Elem() Output[T]

Elem dereferences the pointer, returning the underlying value in an Output. If the pointer is nil, the returned Output holds the zero value of T.

func (PtrOutput[T]) ElementType 

func (o PtrOutput[T]) ElementType() reflect.Type

ElementType returns the reflected type of *T.

func (PtrOutput[T]) ToOutput 

func (o PtrOutput[T]) ToOutput(ctx context.Context) Output[*T]

ToOutput converts the PtrOutput to an Output.

func (PtrOutput[T]) Untyped 

func (o PtrOutput[T]) Untyped() internal.Output

Untyped converts a PtrOutput[T] to a pulumi.Output.

See Output.Untyped for more details.

Source Files

View all Source files

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.