sequence.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 snowflake

import (
	"context"
	"reflect"

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

// ## Example Usage
//
// ```go
// package main
//
// import (
// 	"github.com/pulumi/pulumi-snowflake/sdk/go/snowflake"
// 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
// )
//
// func main() {
// 	pulumi.Run(func(ctx *pulumi.Context) error {
// 		_, err := snowflake.NewDatabase(ctx, "database", nil)
// 		if err != nil {
// 			return err
// 		}
// 		testSchema, err := snowflake.NewSchema(ctx, "testSchema", &snowflake.SchemaArgs{
// 			Database: pulumi.Any(snowflake_database.Test_database.Name),
// 		})
// 		if err != nil {
// 			return err
// 		}
// 		_, err = snowflake.NewSequence(ctx, "testSequence", &snowflake.SequenceArgs{
// 			Database: pulumi.Any(snowflake_database.Test_database.Name),
// 			Schema:   testSchema.Name,
// 		})
// 		if err != nil {
// 			return err
// 		}
// 		return nil
// 	})
// }
// ```
type Sequence struct {
	pulumi.CustomResourceState

	// Specifies a comment for the sequence.
	Comment pulumi.StringPtrOutput `pulumi:"comment"`
	// The database in which to create the sequence. Don't use the | character.
	Database pulumi.StringOutput `pulumi:"database"`
	// The fully qualified name of the sequence.
	FullyQualifiedName pulumi.StringOutput `pulumi:"fullyQualifiedName"`
	// The amount the sequence will increase by each time it is used
	Increment pulumi.IntPtrOutput `pulumi:"increment"`
	// Specifies the name for the sequence.
	Name pulumi.StringOutput `pulumi:"name"`
	// The next value the sequence will provide.
	NextValue pulumi.IntOutput `pulumi:"nextValue"`
	// The schema in which to create the sequence. Don't use the | character.
	Schema pulumi.StringOutput `pulumi:"schema"`
}

// NewSequence registers a new resource with the given unique name, arguments, and options.
func NewSequence(ctx *pulumi.Context,
	name string, args *SequenceArgs, opts ...pulumi.ResourceOption) (*Sequence, error) {
	if args == nil {
		return nil, errors.New("missing one or more required arguments")
	}

	if args.Database == nil {
		return nil, errors.New("invalid value for required argument 'Database'")
	}
	if args.Schema == nil {
		return nil, errors.New("invalid value for required argument 'Schema'")
	}
	var resource Sequence
	err := ctx.RegisterResource("snowflake:index/sequence:Sequence", name, args, &resource, opts...)
	if err != nil {
		return nil, err
	}
	return &resource, nil
}

// GetSequence gets an existing Sequence 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 GetSequence(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *SequenceState, opts ...pulumi.ResourceOption) (*Sequence, error) {
	var resource Sequence
	err := ctx.ReadResource("snowflake:index/sequence:Sequence", name, id, state, &resource, opts...)
	if err != nil {
		return nil, err
	}
	return &resource, nil
}

// Input properties used for looking up and filtering Sequence resources.
type sequenceState struct {
	// Specifies a comment for the sequence.
	Comment *string `pulumi:"comment"`
	// The database in which to create the sequence. Don't use the | character.
	Database *string `pulumi:"database"`
	// The fully qualified name of the sequence.
	FullyQualifiedName *string `pulumi:"fullyQualifiedName"`
	// The amount the sequence will increase by each time it is used
	Increment *int `pulumi:"increment"`
	// Specifies the name for the sequence.
	Name *string `pulumi:"name"`
	// The next value the sequence will provide.
	NextValue *int `pulumi:"nextValue"`
	// The schema in which to create the sequence. Don't use the | character.
	Schema *string `pulumi:"schema"`
}

type SequenceState struct {
	// Specifies a comment for the sequence.
	Comment pulumi.StringPtrInput
	// The database in which to create the sequence. Don't use the | character.
	Database pulumi.StringPtrInput
	// The fully qualified name of the sequence.
	FullyQualifiedName pulumi.StringPtrInput
	// The amount the sequence will increase by each time it is used
	Increment pulumi.IntPtrInput
	// Specifies the name for the sequence.
	Name pulumi.StringPtrInput
	// The next value the sequence will provide.
	NextValue pulumi.IntPtrInput
	// The schema in which to create the sequence. Don't use the | character.
	Schema pulumi.StringPtrInput
}

func (SequenceState) ElementType() reflect.Type {
	return reflect.TypeOf((*sequenceState)(nil)).Elem()
}

type sequenceArgs struct {
	// Specifies a comment for the sequence.
	Comment *string `pulumi:"comment"`
	// The database in which to create the sequence. Don't use the | character.
	Database string `pulumi:"database"`
	// The amount the sequence will increase by each time it is used
	Increment *int `pulumi:"increment"`
	// Specifies the name for the sequence.
	Name *string `pulumi:"name"`
	// The schema in which to create the sequence. Don't use the | character.
	Schema string `pulumi:"schema"`
}

// The set of arguments for constructing a Sequence resource.
type SequenceArgs struct {
	// Specifies a comment for the sequence.
	Comment pulumi.StringPtrInput
	// The database in which to create the sequence. Don't use the | character.
	Database pulumi.StringInput
	// The amount the sequence will increase by each time it is used
	Increment pulumi.IntPtrInput
	// Specifies the name for the sequence.
	Name pulumi.StringPtrInput
	// The schema in which to create the sequence. Don't use the | character.
	Schema pulumi.StringInput
}

func (SequenceArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*sequenceArgs)(nil)).Elem()
}

type SequenceInput interface {
	pulumi.Input

	ToSequenceOutput() SequenceOutput
	ToSequenceOutputWithContext(ctx context.Context) SequenceOutput
}

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

func (i *Sequence) ToSequenceOutput() SequenceOutput {
	return i.ToSequenceOutputWithContext(context.Background())
}

func (i *Sequence) ToSequenceOutputWithContext(ctx context.Context) SequenceOutput {
	return pulumi.ToOutputWithContext(ctx, i).(SequenceOutput)
}

func (i *Sequence) ToSequencePtrOutput() SequencePtrOutput {
	return i.ToSequencePtrOutputWithContext(context.Background())
}

func (i *Sequence) ToSequencePtrOutputWithContext(ctx context.Context) SequencePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(SequencePtrOutput)
}

type SequencePtrInput interface {
	pulumi.Input

	ToSequencePtrOutput() SequencePtrOutput
	ToSequencePtrOutputWithContext(ctx context.Context) SequencePtrOutput
}

type sequencePtrType SequenceArgs

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

func (i *sequencePtrType) ToSequencePtrOutput() SequencePtrOutput {
	return i.ToSequencePtrOutputWithContext(context.Background())
}

func (i *sequencePtrType) ToSequencePtrOutputWithContext(ctx context.Context) SequencePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(SequencePtrOutput)
}

// SequenceArrayInput is an input type that accepts SequenceArray and SequenceArrayOutput values.
// You can construct a concrete instance of `SequenceArrayInput` via:
//
//          SequenceArray{ SequenceArgs{...} }
type SequenceArrayInput interface {
	pulumi.Input

	ToSequenceArrayOutput() SequenceArrayOutput
	ToSequenceArrayOutputWithContext(context.Context) SequenceArrayOutput
}

type SequenceArray []SequenceInput

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

func (i SequenceArray) ToSequenceArrayOutput() SequenceArrayOutput {
	return i.ToSequenceArrayOutputWithContext(context.Background())
}

func (i SequenceArray) ToSequenceArrayOutputWithContext(ctx context.Context) SequenceArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(SequenceArrayOutput)
}

// SequenceMapInput is an input type that accepts SequenceMap and SequenceMapOutput values.
// You can construct a concrete instance of `SequenceMapInput` via:
//
//          SequenceMap{ "key": SequenceArgs{...} }
type SequenceMapInput interface {
	pulumi.Input

	ToSequenceMapOutput() SequenceMapOutput
	ToSequenceMapOutputWithContext(context.Context) SequenceMapOutput
}

type SequenceMap map[string]SequenceInput

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

func (i SequenceMap) ToSequenceMapOutput() SequenceMapOutput {
	return i.ToSequenceMapOutputWithContext(context.Background())
}

func (i SequenceMap) ToSequenceMapOutputWithContext(ctx context.Context) SequenceMapOutput {
	return pulumi.ToOutputWithContext(ctx, i).(SequenceMapOutput)
}

type SequenceOutput struct{ *pulumi.OutputState }

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

func (o SequenceOutput) ToSequenceOutput() SequenceOutput {
	return o
}

func (o SequenceOutput) ToSequenceOutputWithContext(ctx context.Context) SequenceOutput {
	return o
}

func (o SequenceOutput) ToSequencePtrOutput() SequencePtrOutput {
	return o.ToSequencePtrOutputWithContext(context.Background())
}

func (o SequenceOutput) ToSequencePtrOutputWithContext(ctx context.Context) SequencePtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v Sequence) *Sequence {
		return &v
	}).(SequencePtrOutput)
}

type SequencePtrOutput struct{ *pulumi.OutputState }

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

func (o SequencePtrOutput) ToSequencePtrOutput() SequencePtrOutput {
	return o
}

func (o SequencePtrOutput) ToSequencePtrOutputWithContext(ctx context.Context) SequencePtrOutput {
	return o
}

func (o SequencePtrOutput) Elem() SequenceOutput {
	return o.ApplyT(func(v *Sequence) Sequence {
		if v != nil {
			return *v
		}
		var ret Sequence
		return ret
	}).(SequenceOutput)
}

type SequenceArrayOutput struct{ *pulumi.OutputState }

func (SequenceArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]Sequence)(nil))
}

func (o SequenceArrayOutput) ToSequenceArrayOutput() SequenceArrayOutput {
	return o
}

func (o SequenceArrayOutput) ToSequenceArrayOutputWithContext(ctx context.Context) SequenceArrayOutput {
	return o
}

func (o SequenceArrayOutput) Index(i pulumi.IntInput) SequenceOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) Sequence {
		return vs[0].([]Sequence)[vs[1].(int)]
	}).(SequenceOutput)
}

type SequenceMapOutput struct{ *pulumi.OutputState }

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

func (o SequenceMapOutput) ToSequenceMapOutput() SequenceMapOutput {
	return o
}

func (o SequenceMapOutput) ToSequenceMapOutputWithContext(ctx context.Context) SequenceMapOutput {
	return o
}

func (o SequenceMapOutput) MapIndex(k pulumi.StringInput) SequenceOutput {
	return pulumi.All(o, k).ApplyT(func(vs []interface{}) Sequence {
		return vs[0].(map[string]Sequence)[vs[1].(string)]
	}).(SequenceOutput)
}

func init() {
	pulumi.RegisterInputType(reflect.TypeOf((*SequenceInput)(nil)).Elem(), &Sequence{})
	pulumi.RegisterInputType(reflect.TypeOf((*SequencePtrInput)(nil)).Elem(), &Sequence{})
	pulumi.RegisterInputType(reflect.TypeOf((*SequenceArrayInput)(nil)).Elem(), SequenceArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*SequenceMapInput)(nil)).Elem(), SequenceMap{})
	pulumi.RegisterOutputType(SequenceOutput{})
	pulumi.RegisterOutputType(SequencePtrOutput{})
	pulumi.RegisterOutputType(SequenceArrayOutput{})
	pulumi.RegisterOutputType(SequenceMapOutput{})
}