pulumiEnums.go

// Code generated by pulumi-language-go DO NOT EDIT.
// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! ***

package glue

import (
	"context"
	"reflect"

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

// Compatibility setting for the schema.
type SchemaCompatibility string

const (
	SchemaCompatibilityNone        = SchemaCompatibility("NONE")
	SchemaCompatibilityDisabled    = SchemaCompatibility("DISABLED")
	SchemaCompatibilityBackward    = SchemaCompatibility("BACKWARD")
	SchemaCompatibilityBackwardAll = SchemaCompatibility("BACKWARD_ALL")
	SchemaCompatibilityForward     = SchemaCompatibility("FORWARD")
	SchemaCompatibilityForwardAll  = SchemaCompatibility("FORWARD_ALL")
	SchemaCompatibilityFull        = SchemaCompatibility("FULL")
	SchemaCompatibilityFullAll     = SchemaCompatibility("FULL_ALL")
)

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

func (e SchemaCompatibility) ToSchemaCompatibilityOutput() SchemaCompatibilityOutput {
	return pulumi.ToOutput(e).(SchemaCompatibilityOutput)
}

func (e SchemaCompatibility) ToSchemaCompatibilityOutputWithContext(ctx context.Context) SchemaCompatibilityOutput {
	return pulumi.ToOutputWithContext(ctx, e).(SchemaCompatibilityOutput)
}

func (e SchemaCompatibility) ToSchemaCompatibilityPtrOutput() SchemaCompatibilityPtrOutput {
	return e.ToSchemaCompatibilityPtrOutputWithContext(context.Background())
}

func (e SchemaCompatibility) ToSchemaCompatibilityPtrOutputWithContext(ctx context.Context) SchemaCompatibilityPtrOutput {
	return SchemaCompatibility(e).ToSchemaCompatibilityOutputWithContext(ctx).ToSchemaCompatibilityPtrOutputWithContext(ctx)
}

func (e SchemaCompatibility) ToStringOutput() pulumi.StringOutput {
	return pulumi.ToOutput(pulumi.String(e)).(pulumi.StringOutput)
}

func (e SchemaCompatibility) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput {
	return pulumi.ToOutputWithContext(ctx, pulumi.String(e)).(pulumi.StringOutput)
}

func (e SchemaCompatibility) ToStringPtrOutput() pulumi.StringPtrOutput {
	return pulumi.String(e).ToStringPtrOutputWithContext(context.Background())
}

func (e SchemaCompatibility) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput {
	return pulumi.String(e).ToStringOutputWithContext(ctx).ToStringPtrOutputWithContext(ctx)
}

type SchemaCompatibilityOutput struct{ *pulumi.OutputState }

func (SchemaCompatibilityOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*SchemaCompatibility)(nil)).Elem()
}

func (o SchemaCompatibilityOutput) ToSchemaCompatibilityOutput() SchemaCompatibilityOutput {
	return o
}

func (o SchemaCompatibilityOutput) ToSchemaCompatibilityOutputWithContext(ctx context.Context) SchemaCompatibilityOutput {
	return o
}

func (o SchemaCompatibilityOutput) ToSchemaCompatibilityPtrOutput() SchemaCompatibilityPtrOutput {
	return o.ToSchemaCompatibilityPtrOutputWithContext(context.Background())
}

func (o SchemaCompatibilityOutput) ToSchemaCompatibilityPtrOutputWithContext(ctx context.Context) SchemaCompatibilityPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v SchemaCompatibility) *SchemaCompatibility {
		return &v
	}).(SchemaCompatibilityPtrOutput)
}

func (o SchemaCompatibilityOutput) ToStringOutput() pulumi.StringOutput {
	return o.ToStringOutputWithContext(context.Background())
}

func (o SchemaCompatibilityOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, e SchemaCompatibility) string {
		return string(e)
	}).(pulumi.StringOutput)
}

func (o SchemaCompatibilityOutput) ToStringPtrOutput() pulumi.StringPtrOutput {
	return o.ToStringPtrOutputWithContext(context.Background())
}

func (o SchemaCompatibilityOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, e SchemaCompatibility) *string {
		v := string(e)
		return &v
	}).(pulumi.StringPtrOutput)
}

type SchemaCompatibilityPtrOutput struct{ *pulumi.OutputState }

func (SchemaCompatibilityPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**SchemaCompatibility)(nil)).Elem()
}

func (o SchemaCompatibilityPtrOutput) ToSchemaCompatibilityPtrOutput() SchemaCompatibilityPtrOutput {
	return o
}

func (o SchemaCompatibilityPtrOutput) ToSchemaCompatibilityPtrOutputWithContext(ctx context.Context) SchemaCompatibilityPtrOutput {
	return o
}

func (o SchemaCompatibilityPtrOutput) Elem() SchemaCompatibilityOutput {
	return o.ApplyT(func(v *SchemaCompatibility) SchemaCompatibility {
		if v != nil {
			return *v
		}
		var ret SchemaCompatibility
		return ret
	}).(SchemaCompatibilityOutput)
}

func (o SchemaCompatibilityPtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput {
	return o.ToStringPtrOutputWithContext(context.Background())
}

func (o SchemaCompatibilityPtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, e *SchemaCompatibility) *string {
		if e == nil {
			return nil
		}
		v := string(*e)
		return &v
	}).(pulumi.StringPtrOutput)
}

// SchemaCompatibilityInput is an input type that accepts values of the SchemaCompatibility enum
// A concrete instance of `SchemaCompatibilityInput` can be one of the following:
//
//	SchemaCompatibilityNone
//	SchemaCompatibilityDisabled
//	SchemaCompatibilityBackward
//	SchemaCompatibilityBackwardAll
//	SchemaCompatibilityForward
//	SchemaCompatibilityForwardAll
//	SchemaCompatibilityFull
//	SchemaCompatibilityFullAll
type SchemaCompatibilityInput interface {
	pulumi.Input

	ToSchemaCompatibilityOutput() SchemaCompatibilityOutput
	ToSchemaCompatibilityOutputWithContext(context.Context) SchemaCompatibilityOutput
}

var schemaCompatibilityPtrType = reflect.TypeOf((**SchemaCompatibility)(nil)).Elem()

type SchemaCompatibilityPtrInput interface {
	pulumi.Input

	ToSchemaCompatibilityPtrOutput() SchemaCompatibilityPtrOutput
	ToSchemaCompatibilityPtrOutputWithContext(context.Context) SchemaCompatibilityPtrOutput
}

type schemaCompatibilityPtr string

func SchemaCompatibilityPtr(v string) SchemaCompatibilityPtrInput {
	return (*schemaCompatibilityPtr)(&v)
}

func (*schemaCompatibilityPtr) ElementType() reflect.Type {
	return schemaCompatibilityPtrType
}

func (in *schemaCompatibilityPtr) ToSchemaCompatibilityPtrOutput() SchemaCompatibilityPtrOutput {
	return pulumi.ToOutput(in).(SchemaCompatibilityPtrOutput)
}

func (in *schemaCompatibilityPtr) ToSchemaCompatibilityPtrOutputWithContext(ctx context.Context) SchemaCompatibilityPtrOutput {
	return pulumi.ToOutputWithContext(ctx, in).(SchemaCompatibilityPtrOutput)
}

// Data format name to use for the schema. Accepted values: 'AVRO', 'JSON', 'PROTOBUF'
type SchemaDataFormat string

const (
	SchemaDataFormatAvro     = SchemaDataFormat("AVRO")
	SchemaDataFormatJson     = SchemaDataFormat("JSON")
	SchemaDataFormatProtobuf = SchemaDataFormat("PROTOBUF")
)

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

func (e SchemaDataFormat) ToSchemaDataFormatOutput() SchemaDataFormatOutput {
	return pulumi.ToOutput(e).(SchemaDataFormatOutput)
}

func (e SchemaDataFormat) ToSchemaDataFormatOutputWithContext(ctx context.Context) SchemaDataFormatOutput {
	return pulumi.ToOutputWithContext(ctx, e).(SchemaDataFormatOutput)
}

func (e SchemaDataFormat) ToSchemaDataFormatPtrOutput() SchemaDataFormatPtrOutput {
	return e.ToSchemaDataFormatPtrOutputWithContext(context.Background())
}

func (e SchemaDataFormat) ToSchemaDataFormatPtrOutputWithContext(ctx context.Context) SchemaDataFormatPtrOutput {
	return SchemaDataFormat(e).ToSchemaDataFormatOutputWithContext(ctx).ToSchemaDataFormatPtrOutputWithContext(ctx)
}

func (e SchemaDataFormat) ToStringOutput() pulumi.StringOutput {
	return pulumi.ToOutput(pulumi.String(e)).(pulumi.StringOutput)
}

func (e SchemaDataFormat) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput {
	return pulumi.ToOutputWithContext(ctx, pulumi.String(e)).(pulumi.StringOutput)
}

func (e SchemaDataFormat) ToStringPtrOutput() pulumi.StringPtrOutput {
	return pulumi.String(e).ToStringPtrOutputWithContext(context.Background())
}

func (e SchemaDataFormat) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput {
	return pulumi.String(e).ToStringOutputWithContext(ctx).ToStringPtrOutputWithContext(ctx)
}

type SchemaDataFormatOutput struct{ *pulumi.OutputState }

func (SchemaDataFormatOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*SchemaDataFormat)(nil)).Elem()
}

func (o SchemaDataFormatOutput) ToSchemaDataFormatOutput() SchemaDataFormatOutput {
	return o
}

func (o SchemaDataFormatOutput) ToSchemaDataFormatOutputWithContext(ctx context.Context) SchemaDataFormatOutput {
	return o
}

func (o SchemaDataFormatOutput) ToSchemaDataFormatPtrOutput() SchemaDataFormatPtrOutput {
	return o.ToSchemaDataFormatPtrOutputWithContext(context.Background())
}

func (o SchemaDataFormatOutput) ToSchemaDataFormatPtrOutputWithContext(ctx context.Context) SchemaDataFormatPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v SchemaDataFormat) *SchemaDataFormat {
		return &v
	}).(SchemaDataFormatPtrOutput)
}

func (o SchemaDataFormatOutput) ToStringOutput() pulumi.StringOutput {
	return o.ToStringOutputWithContext(context.Background())
}

func (o SchemaDataFormatOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, e SchemaDataFormat) string {
		return string(e)
	}).(pulumi.StringOutput)
}

func (o SchemaDataFormatOutput) ToStringPtrOutput() pulumi.StringPtrOutput {
	return o.ToStringPtrOutputWithContext(context.Background())
}

func (o SchemaDataFormatOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, e SchemaDataFormat) *string {
		v := string(e)
		return &v
	}).(pulumi.StringPtrOutput)
}

type SchemaDataFormatPtrOutput struct{ *pulumi.OutputState }

func (SchemaDataFormatPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**SchemaDataFormat)(nil)).Elem()
}

func (o SchemaDataFormatPtrOutput) ToSchemaDataFormatPtrOutput() SchemaDataFormatPtrOutput {
	return o
}

func (o SchemaDataFormatPtrOutput) ToSchemaDataFormatPtrOutputWithContext(ctx context.Context) SchemaDataFormatPtrOutput {
	return o
}

func (o SchemaDataFormatPtrOutput) Elem() SchemaDataFormatOutput {
	return o.ApplyT(func(v *SchemaDataFormat) SchemaDataFormat {
		if v != nil {
			return *v
		}
		var ret SchemaDataFormat
		return ret
	}).(SchemaDataFormatOutput)
}

func (o SchemaDataFormatPtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput {
	return o.ToStringPtrOutputWithContext(context.Background())
}

func (o SchemaDataFormatPtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, e *SchemaDataFormat) *string {
		if e == nil {
			return nil
		}
		v := string(*e)
		return &v
	}).(pulumi.StringPtrOutput)
}

// SchemaDataFormatInput is an input type that accepts values of the SchemaDataFormat enum
// A concrete instance of `SchemaDataFormatInput` can be one of the following:
//
//	SchemaDataFormatAvro
//	SchemaDataFormatJson
//	SchemaDataFormatProtobuf
type SchemaDataFormatInput interface {
	pulumi.Input

	ToSchemaDataFormatOutput() SchemaDataFormatOutput
	ToSchemaDataFormatOutputWithContext(context.Context) SchemaDataFormatOutput
}

var schemaDataFormatPtrType = reflect.TypeOf((**SchemaDataFormat)(nil)).Elem()

type SchemaDataFormatPtrInput interface {
	pulumi.Input

	ToSchemaDataFormatPtrOutput() SchemaDataFormatPtrOutput
	ToSchemaDataFormatPtrOutputWithContext(context.Context) SchemaDataFormatPtrOutput
}

type schemaDataFormatPtr string

func SchemaDataFormatPtr(v string) SchemaDataFormatPtrInput {
	return (*schemaDataFormatPtr)(&v)
}

func (*schemaDataFormatPtr) ElementType() reflect.Type {
	return schemaDataFormatPtrType
}

func (in *schemaDataFormatPtr) ToSchemaDataFormatPtrOutput() SchemaDataFormatPtrOutput {
	return pulumi.ToOutput(in).(SchemaDataFormatPtrOutput)
}

func (in *schemaDataFormatPtr) ToSchemaDataFormatPtrOutputWithContext(ctx context.Context) SchemaDataFormatPtrOutput {
	return pulumi.ToOutputWithContext(ctx, in).(SchemaDataFormatPtrOutput)
}

func init() {
	pulumi.RegisterInputType(reflect.TypeOf((*SchemaCompatibilityInput)(nil)).Elem(), SchemaCompatibility("NONE"))
	pulumi.RegisterInputType(reflect.TypeOf((*SchemaCompatibilityPtrInput)(nil)).Elem(), SchemaCompatibility("NONE"))
	pulumi.RegisterInputType(reflect.TypeOf((*SchemaDataFormatInput)(nil)).Elem(), SchemaDataFormat("AVRO"))
	pulumi.RegisterInputType(reflect.TypeOf((*SchemaDataFormatPtrInput)(nil)).Elem(), SchemaDataFormat("AVRO"))
	pulumi.RegisterOutputType(SchemaCompatibilityOutput{})
	pulumi.RegisterOutputType(SchemaCompatibilityPtrOutput{})
	pulumi.RegisterOutputType(SchemaDataFormatOutput{})
	pulumi.RegisterOutputType(SchemaDataFormatPtrOutput{})
}