sharedDirectoryAccepter.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 directoryservice

import (
	"context"
	"reflect"

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

// Accepts a shared directory in a consumer account.
//
// > **NOTE:** Destroying this resource removes the shared directory from the consumer account only.
//
// ## Example Usage
//
// ```go
// package main
//
// import (
//
//	"github.com/pulumi/pulumi-aws/sdk/v5/go/aws/directoryservice"
//	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
//
// )
//
//	func main() {
//		pulumi.Run(func(ctx *pulumi.Context) error {
//			exampleSharedDirectory, err := directoryservice.NewSharedDirectory(ctx, "exampleSharedDirectory", &directoryservice.SharedDirectoryArgs{
//				DirectoryId: pulumi.Any(aws_directory_service_directory.Example.Id),
//				Notes:       pulumi.String("example"),
//				Target: &directoryservice.SharedDirectoryTargetArgs{
//					Id: pulumi.Any(data.Aws_caller_identity.Receiver.Account_id),
//				},
//			})
//			if err != nil {
//				return err
//			}
//			_, err = directoryservice.NewSharedDirectoryAccepter(ctx, "exampleSharedDirectoryAccepter", &directoryservice.SharedDirectoryAccepterArgs{
//				SharedDirectoryId: exampleSharedDirectory.SharedDirectoryId,
//			}, pulumi.Provider("awsalternate"))
//			if err != nil {
//				return err
//			}
//			return nil
//		})
//	}
//
// ```
//
// ## Import
//
// Directory Service Shared Directories can be imported using the shared directory ID, e.g.,
//
// ```sh
//
//	$ pulumi import aws:directoryservice/sharedDirectoryAccepter:SharedDirectoryAccepter example d-9267633ece
//
// ```
type SharedDirectoryAccepter struct {
	pulumi.CustomResourceState

	// Method used when sharing a directory (i.e., `ORGANIZATIONS` or `HANDSHAKE`).
	Method pulumi.StringOutput `pulumi:"method"`
	// Message sent by the directory owner to the directory consumer to help the directory consumer administrator determine whether to approve or reject the share invitation.
	Notes pulumi.StringOutput `pulumi:"notes"`
	// Account identifier of the directory owner.
	OwnerAccountId pulumi.StringOutput `pulumi:"ownerAccountId"`
	// Identifier of the Managed Microsoft AD directory from the perspective of the directory owner.
	OwnerDirectoryId pulumi.StringOutput `pulumi:"ownerDirectoryId"`
	// Identifier of the directory that is stored in the directory consumer account that corresponds to the shared directory in the owner account.
	SharedDirectoryId pulumi.StringOutput `pulumi:"sharedDirectoryId"`
}

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

	if args.SharedDirectoryId == nil {
		return nil, errors.New("invalid value for required argument 'SharedDirectoryId'")
	}
	var resource SharedDirectoryAccepter
	err := ctx.RegisterResource("aws:directoryservice/sharedDirectoryAccepter:SharedDirectoryAccepter", name, args, &resource, opts...)
	if err != nil {
		return nil, err
	}
	return &resource, nil
}

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

// Input properties used for looking up and filtering SharedDirectoryAccepter resources.
type sharedDirectoryAccepterState struct {
	// Method used when sharing a directory (i.e., `ORGANIZATIONS` or `HANDSHAKE`).
	Method *string `pulumi:"method"`
	// Message sent by the directory owner to the directory consumer to help the directory consumer administrator determine whether to approve or reject the share invitation.
	Notes *string `pulumi:"notes"`
	// Account identifier of the directory owner.
	OwnerAccountId *string `pulumi:"ownerAccountId"`
	// Identifier of the Managed Microsoft AD directory from the perspective of the directory owner.
	OwnerDirectoryId *string `pulumi:"ownerDirectoryId"`
	// Identifier of the directory that is stored in the directory consumer account that corresponds to the shared directory in the owner account.
	SharedDirectoryId *string `pulumi:"sharedDirectoryId"`
}

type SharedDirectoryAccepterState struct {
	// Method used when sharing a directory (i.e., `ORGANIZATIONS` or `HANDSHAKE`).
	Method pulumi.StringPtrInput
	// Message sent by the directory owner to the directory consumer to help the directory consumer administrator determine whether to approve or reject the share invitation.
	Notes pulumi.StringPtrInput
	// Account identifier of the directory owner.
	OwnerAccountId pulumi.StringPtrInput
	// Identifier of the Managed Microsoft AD directory from the perspective of the directory owner.
	OwnerDirectoryId pulumi.StringPtrInput
	// Identifier of the directory that is stored in the directory consumer account that corresponds to the shared directory in the owner account.
	SharedDirectoryId pulumi.StringPtrInput
}

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

type sharedDirectoryAccepterArgs struct {
	// Identifier of the directory that is stored in the directory consumer account that corresponds to the shared directory in the owner account.
	SharedDirectoryId string `pulumi:"sharedDirectoryId"`
}

// The set of arguments for constructing a SharedDirectoryAccepter resource.
type SharedDirectoryAccepterArgs struct {
	// Identifier of the directory that is stored in the directory consumer account that corresponds to the shared directory in the owner account.
	SharedDirectoryId pulumi.StringInput
}

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

type SharedDirectoryAccepterInput interface {
	pulumi.Input

	ToSharedDirectoryAccepterOutput() SharedDirectoryAccepterOutput
	ToSharedDirectoryAccepterOutputWithContext(ctx context.Context) SharedDirectoryAccepterOutput
}

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

func (i *SharedDirectoryAccepter) ToSharedDirectoryAccepterOutput() SharedDirectoryAccepterOutput {
	return i.ToSharedDirectoryAccepterOutputWithContext(context.Background())
}

func (i *SharedDirectoryAccepter) ToSharedDirectoryAccepterOutputWithContext(ctx context.Context) SharedDirectoryAccepterOutput {
	return pulumi.ToOutputWithContext(ctx, i).(SharedDirectoryAccepterOutput)
}

// SharedDirectoryAccepterArrayInput is an input type that accepts SharedDirectoryAccepterArray and SharedDirectoryAccepterArrayOutput values.
// You can construct a concrete instance of `SharedDirectoryAccepterArrayInput` via:
//
//	SharedDirectoryAccepterArray{ SharedDirectoryAccepterArgs{...} }
type SharedDirectoryAccepterArrayInput interface {
	pulumi.Input

	ToSharedDirectoryAccepterArrayOutput() SharedDirectoryAccepterArrayOutput
	ToSharedDirectoryAccepterArrayOutputWithContext(context.Context) SharedDirectoryAccepterArrayOutput
}

type SharedDirectoryAccepterArray []SharedDirectoryAccepterInput

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

func (i SharedDirectoryAccepterArray) ToSharedDirectoryAccepterArrayOutput() SharedDirectoryAccepterArrayOutput {
	return i.ToSharedDirectoryAccepterArrayOutputWithContext(context.Background())
}

func (i SharedDirectoryAccepterArray) ToSharedDirectoryAccepterArrayOutputWithContext(ctx context.Context) SharedDirectoryAccepterArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(SharedDirectoryAccepterArrayOutput)
}

// SharedDirectoryAccepterMapInput is an input type that accepts SharedDirectoryAccepterMap and SharedDirectoryAccepterMapOutput values.
// You can construct a concrete instance of `SharedDirectoryAccepterMapInput` via:
//
//	SharedDirectoryAccepterMap{ "key": SharedDirectoryAccepterArgs{...} }
type SharedDirectoryAccepterMapInput interface {
	pulumi.Input

	ToSharedDirectoryAccepterMapOutput() SharedDirectoryAccepterMapOutput
	ToSharedDirectoryAccepterMapOutputWithContext(context.Context) SharedDirectoryAccepterMapOutput
}

type SharedDirectoryAccepterMap map[string]SharedDirectoryAccepterInput

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

func (i SharedDirectoryAccepterMap) ToSharedDirectoryAccepterMapOutput() SharedDirectoryAccepterMapOutput {
	return i.ToSharedDirectoryAccepterMapOutputWithContext(context.Background())
}

func (i SharedDirectoryAccepterMap) ToSharedDirectoryAccepterMapOutputWithContext(ctx context.Context) SharedDirectoryAccepterMapOutput {
	return pulumi.ToOutputWithContext(ctx, i).(SharedDirectoryAccepterMapOutput)
}

type SharedDirectoryAccepterOutput struct{ *pulumi.OutputState }

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

func (o SharedDirectoryAccepterOutput) ToSharedDirectoryAccepterOutput() SharedDirectoryAccepterOutput {
	return o
}

func (o SharedDirectoryAccepterOutput) ToSharedDirectoryAccepterOutputWithContext(ctx context.Context) SharedDirectoryAccepterOutput {
	return o
}

// Method used when sharing a directory (i.e., `ORGANIZATIONS` or `HANDSHAKE`).
func (o SharedDirectoryAccepterOutput) Method() pulumi.StringOutput {
	return o.ApplyT(func(v *SharedDirectoryAccepter) pulumi.StringOutput { return v.Method }).(pulumi.StringOutput)
}

// Message sent by the directory owner to the directory consumer to help the directory consumer administrator determine whether to approve or reject the share invitation.
func (o SharedDirectoryAccepterOutput) Notes() pulumi.StringOutput {
	return o.ApplyT(func(v *SharedDirectoryAccepter) pulumi.StringOutput { return v.Notes }).(pulumi.StringOutput)
}

// Account identifier of the directory owner.
func (o SharedDirectoryAccepterOutput) OwnerAccountId() pulumi.StringOutput {
	return o.ApplyT(func(v *SharedDirectoryAccepter) pulumi.StringOutput { return v.OwnerAccountId }).(pulumi.StringOutput)
}

// Identifier of the Managed Microsoft AD directory from the perspective of the directory owner.
func (o SharedDirectoryAccepterOutput) OwnerDirectoryId() pulumi.StringOutput {
	return o.ApplyT(func(v *SharedDirectoryAccepter) pulumi.StringOutput { return v.OwnerDirectoryId }).(pulumi.StringOutput)
}

// Identifier of the directory that is stored in the directory consumer account that corresponds to the shared directory in the owner account.
func (o SharedDirectoryAccepterOutput) SharedDirectoryId() pulumi.StringOutput {
	return o.ApplyT(func(v *SharedDirectoryAccepter) pulumi.StringOutput { return v.SharedDirectoryId }).(pulumi.StringOutput)
}

type SharedDirectoryAccepterArrayOutput struct{ *pulumi.OutputState }

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

func (o SharedDirectoryAccepterArrayOutput) ToSharedDirectoryAccepterArrayOutput() SharedDirectoryAccepterArrayOutput {
	return o
}

func (o SharedDirectoryAccepterArrayOutput) ToSharedDirectoryAccepterArrayOutputWithContext(ctx context.Context) SharedDirectoryAccepterArrayOutput {
	return o
}

func (o SharedDirectoryAccepterArrayOutput) Index(i pulumi.IntInput) SharedDirectoryAccepterOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) *SharedDirectoryAccepter {
		return vs[0].([]*SharedDirectoryAccepter)[vs[1].(int)]
	}).(SharedDirectoryAccepterOutput)
}

type SharedDirectoryAccepterMapOutput struct{ *pulumi.OutputState }

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

func (o SharedDirectoryAccepterMapOutput) ToSharedDirectoryAccepterMapOutput() SharedDirectoryAccepterMapOutput {
	return o
}

func (o SharedDirectoryAccepterMapOutput) ToSharedDirectoryAccepterMapOutputWithContext(ctx context.Context) SharedDirectoryAccepterMapOutput {
	return o
}

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

func init() {
	pulumi.RegisterInputType(reflect.TypeOf((*SharedDirectoryAccepterInput)(nil)).Elem(), &SharedDirectoryAccepter{})
	pulumi.RegisterInputType(reflect.TypeOf((*SharedDirectoryAccepterArrayInput)(nil)).Elem(), SharedDirectoryAccepterArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*SharedDirectoryAccepterMapInput)(nil)).Elem(), SharedDirectoryAccepterMap{})
	pulumi.RegisterOutputType(SharedDirectoryAccepterOutput{})
	pulumi.RegisterOutputType(SharedDirectoryAccepterArrayOutput{})
	pulumi.RegisterOutputType(SharedDirectoryAccepterMapOutput{})
}