confluentEnvironment.go

// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
// *** Do not edit by hand unless you're certain you know what you are doing! ***

package confluent

import (
	"context"
	"reflect"

	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

type ConfluentEnvironment struct {
	pulumi.CustomResourceState

	// The name of the environment
	Name pulumi.StringOutput `pulumi:"name"`
}

// NewConfluentEnvironment registers a new resource with the given unique name, arguments, and options.
func NewConfluentEnvironment(ctx *pulumi.Context,
	name string, args *ConfluentEnvironmentArgs, opts ...pulumi.ResourceOption) (*ConfluentEnvironment, error) {
	if args == nil {
		args = &ConfluentEnvironmentArgs{}
	}

	var resource ConfluentEnvironment
	err := ctx.RegisterResource("confluent:index/confluentEnvironment:ConfluentEnvironment", name, args, &resource, opts...)
	if err != nil {
		return nil, err
	}
	return &resource, nil
}

// GetConfluentEnvironment gets an existing ConfluentEnvironment resource's state with the given name, ID, and optional
// state properties that are used to uniquely qualify the lookup (nil if not required).
func GetConfluentEnvironment(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ConfluentEnvironmentState, opts ...pulumi.ResourceOption) (*ConfluentEnvironment, error) {
	var resource ConfluentEnvironment
	err := ctx.ReadResource("confluent:index/confluentEnvironment:ConfluentEnvironment", name, id, state, &resource, opts...)
	if err != nil {
		return nil, err
	}
	return &resource, nil
}

// Input properties used for looking up and filtering ConfluentEnvironment resources.
type confluentEnvironmentState struct {
	// The name of the environment
	Name *string `pulumi:"name"`
}

type ConfluentEnvironmentState struct {
	// The name of the environment
	Name pulumi.StringPtrInput
}

func (ConfluentEnvironmentState) ElementType() reflect.Type {
	return reflect.TypeOf((*confluentEnvironmentState)(nil)).Elem()
}

type confluentEnvironmentArgs struct {
	// The name of the environment
	Name *string `pulumi:"name"`
}

// The set of arguments for constructing a ConfluentEnvironment resource.
type ConfluentEnvironmentArgs struct {
	// The name of the environment
	Name pulumi.StringPtrInput
}

func (ConfluentEnvironmentArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*confluentEnvironmentArgs)(nil)).Elem()
}

type ConfluentEnvironmentInput interface {
	pulumi.Input

	ToConfluentEnvironmentOutput() ConfluentEnvironmentOutput
	ToConfluentEnvironmentOutputWithContext(ctx context.Context) ConfluentEnvironmentOutput
}

func (*ConfluentEnvironment) ElementType() reflect.Type {
	return reflect.TypeOf((*ConfluentEnvironment)(nil))
}

func (i *ConfluentEnvironment) ToConfluentEnvironmentOutput() ConfluentEnvironmentOutput {
	return i.ToConfluentEnvironmentOutputWithContext(context.Background())
}

func (i *ConfluentEnvironment) ToConfluentEnvironmentOutputWithContext(ctx context.Context) ConfluentEnvironmentOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ConfluentEnvironmentOutput)
}

func (i *ConfluentEnvironment) ToConfluentEnvironmentPtrOutput() ConfluentEnvironmentPtrOutput {
	return i.ToConfluentEnvironmentPtrOutputWithContext(context.Background())
}

func (i *ConfluentEnvironment) ToConfluentEnvironmentPtrOutputWithContext(ctx context.Context) ConfluentEnvironmentPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ConfluentEnvironmentPtrOutput)
}

type ConfluentEnvironmentPtrInput interface {
	pulumi.Input

	ToConfluentEnvironmentPtrOutput() ConfluentEnvironmentPtrOutput
	ToConfluentEnvironmentPtrOutputWithContext(ctx context.Context) ConfluentEnvironmentPtrOutput
}

type confluentEnvironmentPtrType ConfluentEnvironmentArgs

func (*confluentEnvironmentPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ConfluentEnvironment)(nil))
}

func (i *confluentEnvironmentPtrType) ToConfluentEnvironmentPtrOutput() ConfluentEnvironmentPtrOutput {
	return i.ToConfluentEnvironmentPtrOutputWithContext(context.Background())
}

func (i *confluentEnvironmentPtrType) ToConfluentEnvironmentPtrOutputWithContext(ctx context.Context) ConfluentEnvironmentPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ConfluentEnvironmentPtrOutput)
}

// ConfluentEnvironmentArrayInput is an input type that accepts ConfluentEnvironmentArray and ConfluentEnvironmentArrayOutput values.
// You can construct a concrete instance of `ConfluentEnvironmentArrayInput` via:
//
//          ConfluentEnvironmentArray{ ConfluentEnvironmentArgs{...} }
type ConfluentEnvironmentArrayInput interface {
	pulumi.Input

	ToConfluentEnvironmentArrayOutput() ConfluentEnvironmentArrayOutput
	ToConfluentEnvironmentArrayOutputWithContext(context.Context) ConfluentEnvironmentArrayOutput
}

type ConfluentEnvironmentArray []ConfluentEnvironmentInput

func (ConfluentEnvironmentArray) ElementType() reflect.Type {
	return reflect.TypeOf((*[]*ConfluentEnvironment)(nil)).Elem()
}

func (i ConfluentEnvironmentArray) ToConfluentEnvironmentArrayOutput() ConfluentEnvironmentArrayOutput {
	return i.ToConfluentEnvironmentArrayOutputWithContext(context.Background())
}

func (i ConfluentEnvironmentArray) ToConfluentEnvironmentArrayOutputWithContext(ctx context.Context) ConfluentEnvironmentArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ConfluentEnvironmentArrayOutput)
}

// ConfluentEnvironmentMapInput is an input type that accepts ConfluentEnvironmentMap and ConfluentEnvironmentMapOutput values.
// You can construct a concrete instance of `ConfluentEnvironmentMapInput` via:
//
//          ConfluentEnvironmentMap{ "key": ConfluentEnvironmentArgs{...} }
type ConfluentEnvironmentMapInput interface {
	pulumi.Input

	ToConfluentEnvironmentMapOutput() ConfluentEnvironmentMapOutput
	ToConfluentEnvironmentMapOutputWithContext(context.Context) ConfluentEnvironmentMapOutput
}

type ConfluentEnvironmentMap map[string]ConfluentEnvironmentInput

func (ConfluentEnvironmentMap) ElementType() reflect.Type {
	return reflect.TypeOf((*map[string]*ConfluentEnvironment)(nil)).Elem()
}

func (i ConfluentEnvironmentMap) ToConfluentEnvironmentMapOutput() ConfluentEnvironmentMapOutput {
	return i.ToConfluentEnvironmentMapOutputWithContext(context.Background())
}

func (i ConfluentEnvironmentMap) ToConfluentEnvironmentMapOutputWithContext(ctx context.Context) ConfluentEnvironmentMapOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ConfluentEnvironmentMapOutput)
}

type ConfluentEnvironmentOutput struct{ *pulumi.OutputState }

func (ConfluentEnvironmentOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ConfluentEnvironment)(nil))
}

func (o ConfluentEnvironmentOutput) ToConfluentEnvironmentOutput() ConfluentEnvironmentOutput {
	return o
}

func (o ConfluentEnvironmentOutput) ToConfluentEnvironmentOutputWithContext(ctx context.Context) ConfluentEnvironmentOutput {
	return o
}

func (o ConfluentEnvironmentOutput) ToConfluentEnvironmentPtrOutput() ConfluentEnvironmentPtrOutput {
	return o.ToConfluentEnvironmentPtrOutputWithContext(context.Background())
}

func (o ConfluentEnvironmentOutput) ToConfluentEnvironmentPtrOutputWithContext(ctx context.Context) ConfluentEnvironmentPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ConfluentEnvironment) *ConfluentEnvironment {
		return &v
	}).(ConfluentEnvironmentPtrOutput)
}

type ConfluentEnvironmentPtrOutput struct{ *pulumi.OutputState }

func (ConfluentEnvironmentPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ConfluentEnvironment)(nil))
}

func (o ConfluentEnvironmentPtrOutput) ToConfluentEnvironmentPtrOutput() ConfluentEnvironmentPtrOutput {
	return o
}

func (o ConfluentEnvironmentPtrOutput) ToConfluentEnvironmentPtrOutputWithContext(ctx context.Context) ConfluentEnvironmentPtrOutput {
	return o
}

func (o ConfluentEnvironmentPtrOutput) Elem() ConfluentEnvironmentOutput {
	return o.ApplyT(func(v *ConfluentEnvironment) ConfluentEnvironment {
		if v != nil {
			return *v
		}
		var ret ConfluentEnvironment
		return ret
	}).(ConfluentEnvironmentOutput)
}

type ConfluentEnvironmentArrayOutput struct{ *pulumi.OutputState }

func (ConfluentEnvironmentArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]ConfluentEnvironment)(nil))
}

func (o ConfluentEnvironmentArrayOutput) ToConfluentEnvironmentArrayOutput() ConfluentEnvironmentArrayOutput {
	return o
}

func (o ConfluentEnvironmentArrayOutput) ToConfluentEnvironmentArrayOutputWithContext(ctx context.Context) ConfluentEnvironmentArrayOutput {
	return o
}

func (o ConfluentEnvironmentArrayOutput) Index(i pulumi.IntInput) ConfluentEnvironmentOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) ConfluentEnvironment {
		return vs[0].([]ConfluentEnvironment)[vs[1].(int)]
	}).(ConfluentEnvironmentOutput)
}

type ConfluentEnvironmentMapOutput struct{ *pulumi.OutputState }

func (ConfluentEnvironmentMapOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*map[string]ConfluentEnvironment)(nil))
}

func (o ConfluentEnvironmentMapOutput) ToConfluentEnvironmentMapOutput() ConfluentEnvironmentMapOutput {
	return o
}

func (o ConfluentEnvironmentMapOutput) ToConfluentEnvironmentMapOutputWithContext(ctx context.Context) ConfluentEnvironmentMapOutput {
	return o
}

func (o ConfluentEnvironmentMapOutput) MapIndex(k pulumi.StringInput) ConfluentEnvironmentOutput {
	return pulumi.All(o, k).ApplyT(func(vs []interface{}) ConfluentEnvironment {
		return vs[0].(map[string]ConfluentEnvironment)[vs[1].(string)]
	}).(ConfluentEnvironmentOutput)
}

func init() {
	pulumi.RegisterInputType(reflect.TypeOf((*ConfluentEnvironmentInput)(nil)).Elem(), &ConfluentEnvironment{})
	pulumi.RegisterInputType(reflect.TypeOf((*ConfluentEnvironmentPtrInput)(nil)).Elem(), &ConfluentEnvironment{})
	pulumi.RegisterInputType(reflect.TypeOf((*ConfluentEnvironmentArrayInput)(nil)).Elem(), ConfluentEnvironmentArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*ConfluentEnvironmentMapInput)(nil)).Elem(), ConfluentEnvironmentMap{})
	pulumi.RegisterOutputType(ConfluentEnvironmentOutput{})
	pulumi.RegisterOutputType(ConfluentEnvironmentPtrOutput{})
	pulumi.RegisterOutputType(ConfluentEnvironmentArrayOutput{})
	pulumi.RegisterOutputType(ConfluentEnvironmentMapOutput{})
}