github.com/pulumi/pulumi-aws/sdk/v6@v6.32.0/go/aws/glue/classifier.go

// Code generated by the Pulumi Terraform Bridge (tfgen) Tool 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-aws/sdk/v6/go/aws/internal"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

// Provides a Glue Classifier resource.
//
// > **NOTE:** It is only valid to create one type of classifier (csv, grok, JSON, or XML). Changing classifier types will recreate the classifier.
//
// ## Example Usage
//
// ### Csv Classifier
//
// <!--Start PulumiCodeChooser -->
// ```go
// package main
//
// import (
//
//	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/glue"
//	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
//
// )
//
//	func main() {
//		pulumi.Run(func(ctx *pulumi.Context) error {
//			_, err := glue.NewClassifier(ctx, "example", &glue.ClassifierArgs{
//				Name: pulumi.String("example"),
//				CsvClassifier: &glue.ClassifierCsvClassifierArgs{
//					AllowSingleColumn:    pulumi.Bool(false),
//					ContainsHeader:       pulumi.String("PRESENT"),
//					Delimiter:            pulumi.String(","),
//					DisableValueTrimming: pulumi.Bool(false),
//					Headers: pulumi.StringArray{
//						pulumi.String("example1"),
//						pulumi.String("example2"),
//					},
//					QuoteSymbol: pulumi.String("'"),
//				},
//			})
//			if err != nil {
//				return err
//			}
//			return nil
//		})
//	}
//
// ```
// <!--End PulumiCodeChooser -->
//
// ### Grok Classifier
//
// <!--Start PulumiCodeChooser -->
// ```go
// package main
//
// import (
//
//	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/glue"
//	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
//
// )
//
//	func main() {
//		pulumi.Run(func(ctx *pulumi.Context) error {
//			_, err := glue.NewClassifier(ctx, "example", &glue.ClassifierArgs{
//				Name: pulumi.String("example"),
//				GrokClassifier: &glue.ClassifierGrokClassifierArgs{
//					Classification: pulumi.String("example"),
//					GrokPattern:    pulumi.String("example"),
//				},
//			})
//			if err != nil {
//				return err
//			}
//			return nil
//		})
//	}
//
// ```
// <!--End PulumiCodeChooser -->
//
// ### JSON Classifier
//
// <!--Start PulumiCodeChooser -->
// ```go
// package main
//
// import (
//
//	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/glue"
//	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
//
// )
//
//	func main() {
//		pulumi.Run(func(ctx *pulumi.Context) error {
//			_, err := glue.NewClassifier(ctx, "example", &glue.ClassifierArgs{
//				Name: pulumi.String("example"),
//				JsonClassifier: &glue.ClassifierJsonClassifierArgs{
//					JsonPath: pulumi.String("example"),
//				},
//			})
//			if err != nil {
//				return err
//			}
//			return nil
//		})
//	}
//
// ```
// <!--End PulumiCodeChooser -->
//
// ### XML Classifier
//
// <!--Start PulumiCodeChooser -->
// ```go
// package main
//
// import (
//
//	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/glue"
//	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
//
// )
//
//	func main() {
//		pulumi.Run(func(ctx *pulumi.Context) error {
//			_, err := glue.NewClassifier(ctx, "example", &glue.ClassifierArgs{
//				Name: pulumi.String("example"),
//				XmlClassifier: &glue.ClassifierXmlClassifierArgs{
//					Classification: pulumi.String("example"),
//					RowTag:         pulumi.String("example"),
//				},
//			})
//			if err != nil {
//				return err
//			}
//			return nil
//		})
//	}
//
// ```
// <!--End PulumiCodeChooser -->
//
// ## Import
//
// Using `pulumi import`, import Glue Classifiers using their name. For example:
//
// ```sh
// $ pulumi import aws:glue/classifier:Classifier MyClassifier MyClassifier
// ```
type Classifier struct {
	pulumi.CustomResourceState

	// A classifier for Csv content. Defined below.
	CsvClassifier ClassifierCsvClassifierPtrOutput `pulumi:"csvClassifier"`
	// A classifier that uses grok patterns. Defined below.
	GrokClassifier ClassifierGrokClassifierPtrOutput `pulumi:"grokClassifier"`
	// A classifier for JSON content. Defined below.
	JsonClassifier ClassifierJsonClassifierPtrOutput `pulumi:"jsonClassifier"`
	// The name of the classifier.
	Name pulumi.StringOutput `pulumi:"name"`
	// A classifier for XML content. Defined below.
	XmlClassifier ClassifierXmlClassifierPtrOutput `pulumi:"xmlClassifier"`
}

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

	opts = internal.PkgResourceDefaultOpts(opts)
	var resource Classifier
	err := ctx.RegisterResource("aws:glue/classifier:Classifier", name, args, &resource, opts...)
	if err != nil {
		return nil, err
	}
	return &resource, nil
}

// GetClassifier gets an existing Classifier 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 GetClassifier(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ClassifierState, opts ...pulumi.ResourceOption) (*Classifier, error) {
	var resource Classifier
	err := ctx.ReadResource("aws:glue/classifier:Classifier", name, id, state, &resource, opts...)
	if err != nil {
		return nil, err
	}
	return &resource, nil
}

// Input properties used for looking up and filtering Classifier resources.
type classifierState struct {
	// A classifier for Csv content. Defined below.
	CsvClassifier *ClassifierCsvClassifier `pulumi:"csvClassifier"`
	// A classifier that uses grok patterns. Defined below.
	GrokClassifier *ClassifierGrokClassifier `pulumi:"grokClassifier"`
	// A classifier for JSON content. Defined below.
	JsonClassifier *ClassifierJsonClassifier `pulumi:"jsonClassifier"`
	// The name of the classifier.
	Name *string `pulumi:"name"`
	// A classifier for XML content. Defined below.
	XmlClassifier *ClassifierXmlClassifier `pulumi:"xmlClassifier"`
}

type ClassifierState struct {
	// A classifier for Csv content. Defined below.
	CsvClassifier ClassifierCsvClassifierPtrInput
	// A classifier that uses grok patterns. Defined below.
	GrokClassifier ClassifierGrokClassifierPtrInput
	// A classifier for JSON content. Defined below.
	JsonClassifier ClassifierJsonClassifierPtrInput
	// The name of the classifier.
	Name pulumi.StringPtrInput
	// A classifier for XML content. Defined below.
	XmlClassifier ClassifierXmlClassifierPtrInput
}

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

type classifierArgs struct {
	// A classifier for Csv content. Defined below.
	CsvClassifier *ClassifierCsvClassifier `pulumi:"csvClassifier"`
	// A classifier that uses grok patterns. Defined below.
	GrokClassifier *ClassifierGrokClassifier `pulumi:"grokClassifier"`
	// A classifier for JSON content. Defined below.
	JsonClassifier *ClassifierJsonClassifier `pulumi:"jsonClassifier"`
	// The name of the classifier.
	Name *string `pulumi:"name"`
	// A classifier for XML content. Defined below.
	XmlClassifier *ClassifierXmlClassifier `pulumi:"xmlClassifier"`
}

// The set of arguments for constructing a Classifier resource.
type ClassifierArgs struct {
	// A classifier for Csv content. Defined below.
	CsvClassifier ClassifierCsvClassifierPtrInput
	// A classifier that uses grok patterns. Defined below.
	GrokClassifier ClassifierGrokClassifierPtrInput
	// A classifier for JSON content. Defined below.
	JsonClassifier ClassifierJsonClassifierPtrInput
	// The name of the classifier.
	Name pulumi.StringPtrInput
	// A classifier for XML content. Defined below.
	XmlClassifier ClassifierXmlClassifierPtrInput
}

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

type ClassifierInput interface {
	pulumi.Input

	ToClassifierOutput() ClassifierOutput
	ToClassifierOutputWithContext(ctx context.Context) ClassifierOutput
}

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

func (i *Classifier) ToClassifierOutput() ClassifierOutput {
	return i.ToClassifierOutputWithContext(context.Background())
}

func (i *Classifier) ToClassifierOutputWithContext(ctx context.Context) ClassifierOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ClassifierOutput)
}

// ClassifierArrayInput is an input type that accepts ClassifierArray and ClassifierArrayOutput values.
// You can construct a concrete instance of `ClassifierArrayInput` via:
//
//	ClassifierArray{ ClassifierArgs{...} }
type ClassifierArrayInput interface {
	pulumi.Input

	ToClassifierArrayOutput() ClassifierArrayOutput
	ToClassifierArrayOutputWithContext(context.Context) ClassifierArrayOutput
}

type ClassifierArray []ClassifierInput

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

func (i ClassifierArray) ToClassifierArrayOutput() ClassifierArrayOutput {
	return i.ToClassifierArrayOutputWithContext(context.Background())
}

func (i ClassifierArray) ToClassifierArrayOutputWithContext(ctx context.Context) ClassifierArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ClassifierArrayOutput)
}

// ClassifierMapInput is an input type that accepts ClassifierMap and ClassifierMapOutput values.
// You can construct a concrete instance of `ClassifierMapInput` via:
//
//	ClassifierMap{ "key": ClassifierArgs{...} }
type ClassifierMapInput interface {
	pulumi.Input

	ToClassifierMapOutput() ClassifierMapOutput
	ToClassifierMapOutputWithContext(context.Context) ClassifierMapOutput
}

type ClassifierMap map[string]ClassifierInput

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

func (i ClassifierMap) ToClassifierMapOutput() ClassifierMapOutput {
	return i.ToClassifierMapOutputWithContext(context.Background())
}

func (i ClassifierMap) ToClassifierMapOutputWithContext(ctx context.Context) ClassifierMapOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ClassifierMapOutput)
}

type ClassifierOutput struct{ *pulumi.OutputState }

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

func (o ClassifierOutput) ToClassifierOutput() ClassifierOutput {
	return o
}

func (o ClassifierOutput) ToClassifierOutputWithContext(ctx context.Context) ClassifierOutput {
	return o
}

// A classifier for Csv content. Defined below.
func (o ClassifierOutput) CsvClassifier() ClassifierCsvClassifierPtrOutput {
	return o.ApplyT(func(v *Classifier) ClassifierCsvClassifierPtrOutput { return v.CsvClassifier }).(ClassifierCsvClassifierPtrOutput)
}

// A classifier that uses grok patterns. Defined below.
func (o ClassifierOutput) GrokClassifier() ClassifierGrokClassifierPtrOutput {
	return o.ApplyT(func(v *Classifier) ClassifierGrokClassifierPtrOutput { return v.GrokClassifier }).(ClassifierGrokClassifierPtrOutput)
}

// A classifier for JSON content. Defined below.
func (o ClassifierOutput) JsonClassifier() ClassifierJsonClassifierPtrOutput {
	return o.ApplyT(func(v *Classifier) ClassifierJsonClassifierPtrOutput { return v.JsonClassifier }).(ClassifierJsonClassifierPtrOutput)
}

// The name of the classifier.
func (o ClassifierOutput) Name() pulumi.StringOutput {
	return o.ApplyT(func(v *Classifier) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput)
}

// A classifier for XML content. Defined below.
func (o ClassifierOutput) XmlClassifier() ClassifierXmlClassifierPtrOutput {
	return o.ApplyT(func(v *Classifier) ClassifierXmlClassifierPtrOutput { return v.XmlClassifier }).(ClassifierXmlClassifierPtrOutput)
}

type ClassifierArrayOutput struct{ *pulumi.OutputState }

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

func (o ClassifierArrayOutput) ToClassifierArrayOutput() ClassifierArrayOutput {
	return o
}

func (o ClassifierArrayOutput) ToClassifierArrayOutputWithContext(ctx context.Context) ClassifierArrayOutput {
	return o
}

func (o ClassifierArrayOutput) Index(i pulumi.IntInput) ClassifierOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) *Classifier {
		return vs[0].([]*Classifier)[vs[1].(int)]
	}).(ClassifierOutput)
}

type ClassifierMapOutput struct{ *pulumi.OutputState }

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

func (o ClassifierMapOutput) ToClassifierMapOutput() ClassifierMapOutput {
	return o
}

func (o ClassifierMapOutput) ToClassifierMapOutputWithContext(ctx context.Context) ClassifierMapOutput {
	return o
}

func (o ClassifierMapOutput) MapIndex(k pulumi.StringInput) ClassifierOutput {
	return pulumi.All(o, k).ApplyT(func(vs []interface{}) *Classifier {
		return vs[0].(map[string]*Classifier)[vs[1].(string)]
	}).(ClassifierOutput)
}

func init() {
	pulumi.RegisterInputType(reflect.TypeOf((*ClassifierInput)(nil)).Elem(), &Classifier{})
	pulumi.RegisterInputType(reflect.TypeOf((*ClassifierArrayInput)(nil)).Elem(), ClassifierArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*ClassifierMapInput)(nil)).Elem(), ClassifierMap{})
	pulumi.RegisterOutputType(ClassifierOutput{})
	pulumi.RegisterOutputType(ClassifierArrayOutput{})
	pulumi.RegisterOutputType(ClassifierMapOutput{})
}