package yandex

import (
	"context"
	"reflect"

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

type ComputeSnapshot struct {
	pulumi.CustomResourceState

	CreatedAt pulumi.StringOutput `pulumi:"createdAt"`

	Description pulumi.StringPtrOutput `pulumi:"description"`

	DiskSize pulumi.IntOutput `pulumi:"diskSize"`

	FolderId pulumi.StringOutput `pulumi:"folderId"`

	Labels pulumi.StringMapOutput `pulumi:"labels"`

	Name pulumi.StringOutput `pulumi:"name"`

	SourceDiskId pulumi.StringOutput `pulumi:"sourceDiskId"`

	StorageSize pulumi.IntOutput `pulumi:"storageSize"`
}

func NewComputeSnapshot(ctx *pulumi.Context,
	name string, args *ComputeSnapshotArgs, opts ...pulumi.ResourceOption) (*ComputeSnapshot, error) {
	if args == nil {
		return nil, errors.New("missing one or more required arguments")
	}

	if args.SourceDiskId == nil {
		return nil, errors.New("invalid value for required argument 'SourceDiskId'")
	}
	var resource ComputeSnapshot
	err := ctx.RegisterResource("yandex:index/computeSnapshot:ComputeSnapshot", name, args, &resource, opts...)
	if err != nil {
		return nil, err
	}
	return &resource, nil
}

func GetComputeSnapshot(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ComputeSnapshotState, opts ...pulumi.ResourceOption) (*ComputeSnapshot, error) {
	var resource ComputeSnapshot
	err := ctx.ReadResource("yandex:index/computeSnapshot:ComputeSnapshot", name, id, state, &resource, opts...)
	if err != nil {
		return nil, err
	}
	return &resource, nil
}

type computeSnapshotState struct {

	CreatedAt *string `pulumi:"createdAt"`

	Description *string `pulumi:"description"`

	DiskSize *int `pulumi:"diskSize"`

	FolderId *string `pulumi:"folderId"`

	Labels map[string]string `pulumi:"labels"`

	Name *string `pulumi:"name"`

	SourceDiskId *string `pulumi:"sourceDiskId"`

	StorageSize *int `pulumi:"storageSize"`
}

type ComputeSnapshotState struct {

	CreatedAt pulumi.StringPtrInput

	Description pulumi.StringPtrInput

	DiskSize pulumi.IntPtrInput

	FolderId pulumi.StringPtrInput

	Labels pulumi.StringMapInput

	Name pulumi.StringPtrInput

	SourceDiskId pulumi.StringPtrInput

	StorageSize pulumi.IntPtrInput
}

func (ComputeSnapshotState) ElementType() reflect.Type {
	return reflect.TypeOf((*computeSnapshotState)(nil)).Elem()
}

type computeSnapshotArgs struct {

	Description *string `pulumi:"description"`

	FolderId *string `pulumi:"folderId"`

	Labels map[string]string `pulumi:"labels"`

	Name *string `pulumi:"name"`

	SourceDiskId string `pulumi:"sourceDiskId"`
}

type ComputeSnapshotArgs struct {

	Description pulumi.StringPtrInput

	FolderId pulumi.StringPtrInput

	Labels pulumi.StringMapInput

	Name pulumi.StringPtrInput

	SourceDiskId pulumi.StringInput
}

func (ComputeSnapshotArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*computeSnapshotArgs)(nil)).Elem()
}

type ComputeSnapshotInput interface {
	pulumi.Input

	ToComputeSnapshotOutput() ComputeSnapshotOutput
	ToComputeSnapshotOutputWithContext(ctx context.Context) ComputeSnapshotOutput
}

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

func (i *ComputeSnapshot) ToComputeSnapshotOutput() ComputeSnapshotOutput {
	return i.ToComputeSnapshotOutputWithContext(context.Background())
}

func (i *ComputeSnapshot) ToComputeSnapshotOutputWithContext(ctx context.Context) ComputeSnapshotOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ComputeSnapshotOutput)
}

func (i *ComputeSnapshot) ToComputeSnapshotPtrOutput() ComputeSnapshotPtrOutput {
	return i.ToComputeSnapshotPtrOutputWithContext(context.Background())
}

func (i *ComputeSnapshot) ToComputeSnapshotPtrOutputWithContext(ctx context.Context) ComputeSnapshotPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ComputeSnapshotPtrOutput)
}

type ComputeSnapshotPtrInput interface {
	pulumi.Input

	ToComputeSnapshotPtrOutput() ComputeSnapshotPtrOutput
	ToComputeSnapshotPtrOutputWithContext(ctx context.Context) ComputeSnapshotPtrOutput
}

type computeSnapshotPtrType ComputeSnapshotArgs

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

func (i *computeSnapshotPtrType) ToComputeSnapshotPtrOutput() ComputeSnapshotPtrOutput {
	return i.ToComputeSnapshotPtrOutputWithContext(context.Background())
}

func (i *computeSnapshotPtrType) ToComputeSnapshotPtrOutputWithContext(ctx context.Context) ComputeSnapshotPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ComputeSnapshotPtrOutput)
}

type ComputeSnapshotArrayInput interface {
	pulumi.Input

	ToComputeSnapshotArrayOutput() ComputeSnapshotArrayOutput
	ToComputeSnapshotArrayOutputWithContext(context.Context) ComputeSnapshotArrayOutput
}

type ComputeSnapshotArray []ComputeSnapshotInput

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

func (i ComputeSnapshotArray) ToComputeSnapshotArrayOutput() ComputeSnapshotArrayOutput {
	return i.ToComputeSnapshotArrayOutputWithContext(context.Background())
}

func (i ComputeSnapshotArray) ToComputeSnapshotArrayOutputWithContext(ctx context.Context) ComputeSnapshotArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ComputeSnapshotArrayOutput)
}

type ComputeSnapshotMapInput interface {
	pulumi.Input

	ToComputeSnapshotMapOutput() ComputeSnapshotMapOutput
	ToComputeSnapshotMapOutputWithContext(context.Context) ComputeSnapshotMapOutput
}

type ComputeSnapshotMap map[string]ComputeSnapshotInput

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

func (i ComputeSnapshotMap) ToComputeSnapshotMapOutput() ComputeSnapshotMapOutput {
	return i.ToComputeSnapshotMapOutputWithContext(context.Background())
}

func (i ComputeSnapshotMap) ToComputeSnapshotMapOutputWithContext(ctx context.Context) ComputeSnapshotMapOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ComputeSnapshotMapOutput)
}

type ComputeSnapshotOutput struct{ *pulumi.OutputState }

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

func (o ComputeSnapshotOutput) ToComputeSnapshotOutput() ComputeSnapshotOutput {
	return o
}

func (o ComputeSnapshotOutput) ToComputeSnapshotOutputWithContext(ctx context.Context) ComputeSnapshotOutput {
	return o
}

func (o ComputeSnapshotOutput) ToComputeSnapshotPtrOutput() ComputeSnapshotPtrOutput {
	return o.ToComputeSnapshotPtrOutputWithContext(context.Background())
}

func (o ComputeSnapshotOutput) ToComputeSnapshotPtrOutputWithContext(ctx context.Context) ComputeSnapshotPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ComputeSnapshot) *ComputeSnapshot {
		return &v
	}).(ComputeSnapshotPtrOutput)
}

type ComputeSnapshotPtrOutput struct{ *pulumi.OutputState }

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

func (o ComputeSnapshotPtrOutput) ToComputeSnapshotPtrOutput() ComputeSnapshotPtrOutput {
	return o
}

func (o ComputeSnapshotPtrOutput) ToComputeSnapshotPtrOutputWithContext(ctx context.Context) ComputeSnapshotPtrOutput {
	return o
}

func (o ComputeSnapshotPtrOutput) Elem() ComputeSnapshotOutput {
	return o.ApplyT(func(v *ComputeSnapshot) ComputeSnapshot {
		if v != nil {
			return *v
		}
		var ret ComputeSnapshot
		return ret
	}).(ComputeSnapshotOutput)
}

type ComputeSnapshotArrayOutput struct{ *pulumi.OutputState }

func (ComputeSnapshotArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]ComputeSnapshot)(nil))
}

func (o ComputeSnapshotArrayOutput) ToComputeSnapshotArrayOutput() ComputeSnapshotArrayOutput {
	return o
}

func (o ComputeSnapshotArrayOutput) ToComputeSnapshotArrayOutputWithContext(ctx context.Context) ComputeSnapshotArrayOutput {
	return o
}

func (o ComputeSnapshotArrayOutput) Index(i pulumi.IntInput) ComputeSnapshotOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) ComputeSnapshot {
		return vs[0].([]ComputeSnapshot)[vs[1].(int)]
	}).(ComputeSnapshotOutput)
}

type ComputeSnapshotMapOutput struct{ *pulumi.OutputState }

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

func (o ComputeSnapshotMapOutput) ToComputeSnapshotMapOutput() ComputeSnapshotMapOutput {
	return o
}

func (o ComputeSnapshotMapOutput) ToComputeSnapshotMapOutputWithContext(ctx context.Context) ComputeSnapshotMapOutput {
	return o
}

func (o ComputeSnapshotMapOutput) MapIndex(k pulumi.StringInput) ComputeSnapshotOutput {
	return pulumi.All(o, k).ApplyT(func(vs []interface{}) ComputeSnapshot {
		return vs[0].(map[string]ComputeSnapshot)[vs[1].(string)]
	}).(ComputeSnapshotOutput)
}

func init() {
	pulumi.RegisterInputType(reflect.TypeOf((*ComputeSnapshotInput)(nil)).Elem(), &ComputeSnapshot{})
	pulumi.RegisterInputType(reflect.TypeOf((*ComputeSnapshotPtrInput)(nil)).Elem(), &ComputeSnapshot{})
	pulumi.RegisterInputType(reflect.TypeOf((*ComputeSnapshotArrayInput)(nil)).Elem(), ComputeSnapshotArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*ComputeSnapshotMapInput)(nil)).Elem(), ComputeSnapshotMap{})
	pulumi.RegisterOutputType(ComputeSnapshotOutput{})
	pulumi.RegisterOutputType(ComputeSnapshotPtrOutput{})
	pulumi.RegisterOutputType(ComputeSnapshotArrayOutput{})
	pulumi.RegisterOutputType(ComputeSnapshotMapOutput{})
}
// *** 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 yandex

import (
	"context"
	"reflect"

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

// Creates a new snapshot of a disk. For more information, see
// [the official documentation](https://cloud.yandex.com/docs/compute/concepts/snapshot).
//
// ## Example Usage
//
// ```go
// package main
//
// import (
// 	"github.com/pulumi/pulumi-yandex/sdk/go/yandex"
// 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
// )
//
// func main() {
// 	pulumi.Run(func(ctx *pulumi.Context) error {
// 		_, err := yandex.NewComputeSnapshot(ctx, "_default", &yandex.ComputeSnapshotArgs{
// 			Labels: pulumi.StringMap{
// 				"my-label": pulumi.String("my-label-value"),
// 			},
// 			SourceDiskId: pulumi.String("test_disk_id"),
// 		})
// 		if err != nil {
// 			return err
// 		}
// 		return nil
// 	})
// }
// ```
//
// ## Import
//
// A snapshot can be imported using the `id` of the resource, e.g.
//
// ```sh
//  $ pulumi import yandex:index/computeSnapshot:ComputeSnapshot disk-snapshot shapshot_id
// ```
type ComputeSnapshot struct {
	pulumi.CustomResourceState

	// Creation timestamp of the snapshot.
	CreatedAt pulumi.StringOutput `pulumi:"createdAt"`
	// Description of the resource.
	Description pulumi.StringPtrOutput `pulumi:"description"`
	// Size of the disk when the snapshot was created, specified in GB.
	DiskSize pulumi.IntOutput `pulumi:"diskSize"`
	// The ID of the folder that the resource belongs to. If it
	// is not provided, the default provider folder is used.
	FolderId pulumi.StringOutput `pulumi:"folderId"`
	// A set of key/value label pairs to assign to the snapshot.
	Labels pulumi.StringMapOutput `pulumi:"labels"`
	// A name for the resource.
	Name pulumi.StringOutput `pulumi:"name"`
	// ID of the disk to create a snapshot from.
	SourceDiskId pulumi.StringOutput `pulumi:"sourceDiskId"`
	// Size of the snapshot, specified in GB.
	StorageSize pulumi.IntOutput `pulumi:"storageSize"`
}

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

	if args.SourceDiskId == nil {
		return nil, errors.New("invalid value for required argument 'SourceDiskId'")
	}
	var resource ComputeSnapshot
	err := ctx.RegisterResource("yandex:index/computeSnapshot:ComputeSnapshot", name, args, &resource, opts...)
	if err != nil {
		return nil, err
	}
	return &resource, nil
}

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

// Input properties used for looking up and filtering ComputeSnapshot resources.
type computeSnapshotState struct {
	// Creation timestamp of the snapshot.
	CreatedAt *string `pulumi:"createdAt"`
	// Description of the resource.
	Description *string `pulumi:"description"`
	// Size of the disk when the snapshot was created, specified in GB.
	DiskSize *int `pulumi:"diskSize"`
	// The ID of the folder that the resource belongs to. If it
	// is not provided, the default provider folder is used.
	FolderId *string `pulumi:"folderId"`
	// A set of key/value label pairs to assign to the snapshot.
	Labels map[string]string `pulumi:"labels"`
	// A name for the resource.
	Name *string `pulumi:"name"`
	// ID of the disk to create a snapshot from.
	SourceDiskId *string `pulumi:"sourceDiskId"`
	// Size of the snapshot, specified in GB.
	StorageSize *int `pulumi:"storageSize"`
}

type ComputeSnapshotState struct {
	// Creation timestamp of the snapshot.
	CreatedAt pulumi.StringPtrInput
	// Description of the resource.
	Description pulumi.StringPtrInput
	// Size of the disk when the snapshot was created, specified in GB.
	DiskSize pulumi.IntPtrInput
	// The ID of the folder that the resource belongs to. If it
	// is not provided, the default provider folder is used.
	FolderId pulumi.StringPtrInput
	// A set of key/value label pairs to assign to the snapshot.
	Labels pulumi.StringMapInput
	// A name for the resource.
	Name pulumi.StringPtrInput
	// ID of the disk to create a snapshot from.
	SourceDiskId pulumi.StringPtrInput
	// Size of the snapshot, specified in GB.
	StorageSize pulumi.IntPtrInput
}

func (ComputeSnapshotState) ElementType() reflect.Type {
	return reflect.TypeOf((*computeSnapshotState)(nil)).Elem()
}

type computeSnapshotArgs struct {
	// Description of the resource.
	Description *string `pulumi:"description"`
	// The ID of the folder that the resource belongs to. If it
	// is not provided, the default provider folder is used.
	FolderId *string `pulumi:"folderId"`
	// A set of key/value label pairs to assign to the snapshot.
	Labels map[string]string `pulumi:"labels"`
	// A name for the resource.
	Name *string `pulumi:"name"`
	// ID of the disk to create a snapshot from.
	SourceDiskId string `pulumi:"sourceDiskId"`
}

// The set of arguments for constructing a ComputeSnapshot resource.
type ComputeSnapshotArgs struct {
	// Description of the resource.
	Description pulumi.StringPtrInput
	// The ID of the folder that the resource belongs to. If it
	// is not provided, the default provider folder is used.
	FolderId pulumi.StringPtrInput
	// A set of key/value label pairs to assign to the snapshot.
	Labels pulumi.StringMapInput
	// A name for the resource.
	Name pulumi.StringPtrInput
	// ID of the disk to create a snapshot from.
	SourceDiskId pulumi.StringInput
}

func (ComputeSnapshotArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*computeSnapshotArgs)(nil)).Elem()
}

type ComputeSnapshotInput interface {
	pulumi.Input

	ToComputeSnapshotOutput() ComputeSnapshotOutput
	ToComputeSnapshotOutputWithContext(ctx context.Context) ComputeSnapshotOutput
}

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

func (i *ComputeSnapshot) ToComputeSnapshotOutput() ComputeSnapshotOutput {
	return i.ToComputeSnapshotOutputWithContext(context.Background())
}

func (i *ComputeSnapshot) ToComputeSnapshotOutputWithContext(ctx context.Context) ComputeSnapshotOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ComputeSnapshotOutput)
}

func (i *ComputeSnapshot) ToComputeSnapshotPtrOutput() ComputeSnapshotPtrOutput {
	return i.ToComputeSnapshotPtrOutputWithContext(context.Background())
}

func (i *ComputeSnapshot) ToComputeSnapshotPtrOutputWithContext(ctx context.Context) ComputeSnapshotPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ComputeSnapshotPtrOutput)
}

type ComputeSnapshotPtrInput interface {
	pulumi.Input

	ToComputeSnapshotPtrOutput() ComputeSnapshotPtrOutput
	ToComputeSnapshotPtrOutputWithContext(ctx context.Context) ComputeSnapshotPtrOutput
}

type computeSnapshotPtrType ComputeSnapshotArgs

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

func (i *computeSnapshotPtrType) ToComputeSnapshotPtrOutput() ComputeSnapshotPtrOutput {
	return i.ToComputeSnapshotPtrOutputWithContext(context.Background())
}

func (i *computeSnapshotPtrType) ToComputeSnapshotPtrOutputWithContext(ctx context.Context) ComputeSnapshotPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ComputeSnapshotPtrOutput)
}

// ComputeSnapshotArrayInput is an input type that accepts ComputeSnapshotArray and ComputeSnapshotArrayOutput values.
// You can construct a concrete instance of `ComputeSnapshotArrayInput` via:
//
//          ComputeSnapshotArray{ ComputeSnapshotArgs{...} }
type ComputeSnapshotArrayInput interface {
	pulumi.Input

	ToComputeSnapshotArrayOutput() ComputeSnapshotArrayOutput
	ToComputeSnapshotArrayOutputWithContext(context.Context) ComputeSnapshotArrayOutput
}

type ComputeSnapshotArray []ComputeSnapshotInput

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

func (i ComputeSnapshotArray) ToComputeSnapshotArrayOutput() ComputeSnapshotArrayOutput {
	return i.ToComputeSnapshotArrayOutputWithContext(context.Background())
}

func (i ComputeSnapshotArray) ToComputeSnapshotArrayOutputWithContext(ctx context.Context) ComputeSnapshotArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ComputeSnapshotArrayOutput)
}

// ComputeSnapshotMapInput is an input type that accepts ComputeSnapshotMap and ComputeSnapshotMapOutput values.
// You can construct a concrete instance of `ComputeSnapshotMapInput` via:
//
//          ComputeSnapshotMap{ "key": ComputeSnapshotArgs{...} }
type ComputeSnapshotMapInput interface {
	pulumi.Input

	ToComputeSnapshotMapOutput() ComputeSnapshotMapOutput
	ToComputeSnapshotMapOutputWithContext(context.Context) ComputeSnapshotMapOutput
}

type ComputeSnapshotMap map[string]ComputeSnapshotInput

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

func (i ComputeSnapshotMap) ToComputeSnapshotMapOutput() ComputeSnapshotMapOutput {
	return i.ToComputeSnapshotMapOutputWithContext(context.Background())
}

func (i ComputeSnapshotMap) ToComputeSnapshotMapOutputWithContext(ctx context.Context) ComputeSnapshotMapOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ComputeSnapshotMapOutput)
}

type ComputeSnapshotOutput struct{ *pulumi.OutputState }

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

func (o ComputeSnapshotOutput) ToComputeSnapshotOutput() ComputeSnapshotOutput {
	return o
}

func (o ComputeSnapshotOutput) ToComputeSnapshotOutputWithContext(ctx context.Context) ComputeSnapshotOutput {
	return o
}

func (o ComputeSnapshotOutput) ToComputeSnapshotPtrOutput() ComputeSnapshotPtrOutput {
	return o.ToComputeSnapshotPtrOutputWithContext(context.Background())
}

func (o ComputeSnapshotOutput) ToComputeSnapshotPtrOutputWithContext(ctx context.Context) ComputeSnapshotPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ComputeSnapshot) *ComputeSnapshot {
		return &v
	}).(ComputeSnapshotPtrOutput)
}

type ComputeSnapshotPtrOutput struct{ *pulumi.OutputState }

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

func (o ComputeSnapshotPtrOutput) ToComputeSnapshotPtrOutput() ComputeSnapshotPtrOutput {
	return o
}

func (o ComputeSnapshotPtrOutput) ToComputeSnapshotPtrOutputWithContext(ctx context.Context) ComputeSnapshotPtrOutput {
	return o
}

func (o ComputeSnapshotPtrOutput) Elem() ComputeSnapshotOutput {
	return o.ApplyT(func(v *ComputeSnapshot) ComputeSnapshot {
		if v != nil {
			return *v
		}
		var ret ComputeSnapshot
		return ret
	}).(ComputeSnapshotOutput)
}

type ComputeSnapshotArrayOutput struct{ *pulumi.OutputState }

func (ComputeSnapshotArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]ComputeSnapshot)(nil))
}

func (o ComputeSnapshotArrayOutput) ToComputeSnapshotArrayOutput() ComputeSnapshotArrayOutput {
	return o
}

func (o ComputeSnapshotArrayOutput) ToComputeSnapshotArrayOutputWithContext(ctx context.Context) ComputeSnapshotArrayOutput {
	return o
}

func (o ComputeSnapshotArrayOutput) Index(i pulumi.IntInput) ComputeSnapshotOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) ComputeSnapshot {
		return vs[0].([]ComputeSnapshot)[vs[1].(int)]
	}).(ComputeSnapshotOutput)
}

type ComputeSnapshotMapOutput struct{ *pulumi.OutputState }

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

func (o ComputeSnapshotMapOutput) ToComputeSnapshotMapOutput() ComputeSnapshotMapOutput {
	return o
}

func (o ComputeSnapshotMapOutput) ToComputeSnapshotMapOutputWithContext(ctx context.Context) ComputeSnapshotMapOutput {
	return o
}

func (o ComputeSnapshotMapOutput) MapIndex(k pulumi.StringInput) ComputeSnapshotOutput {
	return pulumi.All(o, k).ApplyT(func(vs []interface{}) ComputeSnapshot {
		return vs[0].(map[string]ComputeSnapshot)[vs[1].(string)]
	}).(ComputeSnapshotOutput)
}

func init() {
	pulumi.RegisterInputType(reflect.TypeOf((*ComputeSnapshotInput)(nil)).Elem(), &ComputeSnapshot{})
	pulumi.RegisterInputType(reflect.TypeOf((*ComputeSnapshotPtrInput)(nil)).Elem(), &ComputeSnapshot{})
	pulumi.RegisterInputType(reflect.TypeOf((*ComputeSnapshotArrayInput)(nil)).Elem(), ComputeSnapshotArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*ComputeSnapshotMapInput)(nil)).Elem(), ComputeSnapshotMap{})
	pulumi.RegisterOutputType(ComputeSnapshotOutput{})
	pulumi.RegisterOutputType(ComputeSnapshotPtrOutput{})
	pulumi.RegisterOutputType(ComputeSnapshotArrayOutput{})
	pulumi.RegisterOutputType(ComputeSnapshotMapOutput{})
}
