organizationConnections.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 auth0

import (
	"context"
	"reflect"

	"errors"
	"github.com/pulumi/pulumi-auth0/sdk/v2/go/auth0/internal"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumix"
)

// With this resource, you can manage enabled connections on an organization.
//
// !> This resource appends a connection to an organization. In contrast, the `OrganizationConnection` resource
// manages all the connections enabled for an organization. To avoid potential issues, it is recommended not to use this
// resource in conjunction with the `OrganizationConnection` resource when managing connections for the same
// organization id.
//
// ## Example Usage
//
// ```go
// package main
//
// import (
//
//	"github.com/pulumi/pulumi-auth0/sdk/v2/go/auth0"
//	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
//
// )
//
//	func main() {
//		pulumi.Run(func(ctx *pulumi.Context) error {
//			_, err := auth0.NewConnection(ctx, "myConnection-1", &auth0.ConnectionArgs{
//				Strategy: pulumi.String("auth0"),
//			})
//			if err != nil {
//				return err
//			}
//			_, err = auth0.NewConnection(ctx, "myConnection-2", &auth0.ConnectionArgs{
//				Strategy: pulumi.String("auth0"),
//			})
//			if err != nil {
//				return err
//			}
//			myOrganization, err := auth0.NewOrganization(ctx, "myOrganization", &auth0.OrganizationArgs{
//				DisplayName: pulumi.String("My Organization"),
//			})
//			if err != nil {
//				return err
//			}
//			_, err = auth0.NewOrganizationConnections(ctx, "one-to-many", &auth0.OrganizationConnectionsArgs{
//				OrganizationId: myOrganization.ID(),
//				EnabledConnections: auth0.OrganizationConnectionsEnabledConnectionArray{
//					&auth0.OrganizationConnectionsEnabledConnectionArgs{
//						ConnectionId:            myConnection_1.ID(),
//						AssignMembershipOnLogin: pulumi.Bool(true),
//					},
//					&auth0.OrganizationConnectionsEnabledConnectionArgs{
//						ConnectionId:            myConnection_2.ID(),
//						AssignMembershipOnLogin: pulumi.Bool(true),
//					},
//				},
//			})
//			if err != nil {
//				return err
//			}
//			return nil
//		})
//	}
//
// ```
//
// ## Import
//
// This resource can be imported by specifying the organization ID. # Example
//
// ```sh
//
//	$ pulumi import auth0:index/organizationConnections:OrganizationConnections my_org_conns org_XXXXX
//
// ```
type OrganizationConnections struct {
	pulumi.CustomResourceState

	// Connections that are enabled for the organization.
	EnabledConnections OrganizationConnectionsEnabledConnectionArrayOutput `pulumi:"enabledConnections"`
	// ID of the organization on which to enable the connections.
	OrganizationId pulumi.StringOutput `pulumi:"organizationId"`
}

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

	if args.EnabledConnections == nil {
		return nil, errors.New("invalid value for required argument 'EnabledConnections'")
	}
	if args.OrganizationId == nil {
		return nil, errors.New("invalid value for required argument 'OrganizationId'")
	}
	opts = internal.PkgResourceDefaultOpts(opts)
	var resource OrganizationConnections
	err := ctx.RegisterResource("auth0:index/organizationConnections:OrganizationConnections", name, args, &resource, opts...)
	if err != nil {
		return nil, err
	}
	return &resource, nil
}

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

// Input properties used for looking up and filtering OrganizationConnections resources.
type organizationConnectionsState struct {
	// Connections that are enabled for the organization.
	EnabledConnections []OrganizationConnectionsEnabledConnection `pulumi:"enabledConnections"`
	// ID of the organization on which to enable the connections.
	OrganizationId *string `pulumi:"organizationId"`
}

type OrganizationConnectionsState struct {
	// Connections that are enabled for the organization.
	EnabledConnections OrganizationConnectionsEnabledConnectionArrayInput
	// ID of the organization on which to enable the connections.
	OrganizationId pulumi.StringPtrInput
}

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

type organizationConnectionsArgs struct {
	// Connections that are enabled for the organization.
	EnabledConnections []OrganizationConnectionsEnabledConnection `pulumi:"enabledConnections"`
	// ID of the organization on which to enable the connections.
	OrganizationId string `pulumi:"organizationId"`
}

// The set of arguments for constructing a OrganizationConnections resource.
type OrganizationConnectionsArgs struct {
	// Connections that are enabled for the organization.
	EnabledConnections OrganizationConnectionsEnabledConnectionArrayInput
	// ID of the organization on which to enable the connections.
	OrganizationId pulumi.StringInput
}

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

type OrganizationConnectionsInput interface {
	pulumi.Input

	ToOrganizationConnectionsOutput() OrganizationConnectionsOutput
	ToOrganizationConnectionsOutputWithContext(ctx context.Context) OrganizationConnectionsOutput
}

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

func (i *OrganizationConnections) ToOrganizationConnectionsOutput() OrganizationConnectionsOutput {
	return i.ToOrganizationConnectionsOutputWithContext(context.Background())
}

func (i *OrganizationConnections) ToOrganizationConnectionsOutputWithContext(ctx context.Context) OrganizationConnectionsOutput {
	return pulumi.ToOutputWithContext(ctx, i).(OrganizationConnectionsOutput)
}

func (i *OrganizationConnections) ToOutput(ctx context.Context) pulumix.Output[*OrganizationConnections] {
	return pulumix.Output[*OrganizationConnections]{
		OutputState: i.ToOrganizationConnectionsOutputWithContext(ctx).OutputState,
	}
}

// OrganizationConnectionsArrayInput is an input type that accepts OrganizationConnectionsArray and OrganizationConnectionsArrayOutput values.
// You can construct a concrete instance of `OrganizationConnectionsArrayInput` via:
//
//	OrganizationConnectionsArray{ OrganizationConnectionsArgs{...} }
type OrganizationConnectionsArrayInput interface {
	pulumi.Input

	ToOrganizationConnectionsArrayOutput() OrganizationConnectionsArrayOutput
	ToOrganizationConnectionsArrayOutputWithContext(context.Context) OrganizationConnectionsArrayOutput
}

type OrganizationConnectionsArray []OrganizationConnectionsInput

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

func (i OrganizationConnectionsArray) ToOrganizationConnectionsArrayOutput() OrganizationConnectionsArrayOutput {
	return i.ToOrganizationConnectionsArrayOutputWithContext(context.Background())
}

func (i OrganizationConnectionsArray) ToOrganizationConnectionsArrayOutputWithContext(ctx context.Context) OrganizationConnectionsArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(OrganizationConnectionsArrayOutput)
}

func (i OrganizationConnectionsArray) ToOutput(ctx context.Context) pulumix.Output[[]*OrganizationConnections] {
	return pulumix.Output[[]*OrganizationConnections]{
		OutputState: i.ToOrganizationConnectionsArrayOutputWithContext(ctx).OutputState,
	}
}

// OrganizationConnectionsMapInput is an input type that accepts OrganizationConnectionsMap and OrganizationConnectionsMapOutput values.
// You can construct a concrete instance of `OrganizationConnectionsMapInput` via:
//
//	OrganizationConnectionsMap{ "key": OrganizationConnectionsArgs{...} }
type OrganizationConnectionsMapInput interface {
	pulumi.Input

	ToOrganizationConnectionsMapOutput() OrganizationConnectionsMapOutput
	ToOrganizationConnectionsMapOutputWithContext(context.Context) OrganizationConnectionsMapOutput
}

type OrganizationConnectionsMap map[string]OrganizationConnectionsInput

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

func (i OrganizationConnectionsMap) ToOrganizationConnectionsMapOutput() OrganizationConnectionsMapOutput {
	return i.ToOrganizationConnectionsMapOutputWithContext(context.Background())
}

func (i OrganizationConnectionsMap) ToOrganizationConnectionsMapOutputWithContext(ctx context.Context) OrganizationConnectionsMapOutput {
	return pulumi.ToOutputWithContext(ctx, i).(OrganizationConnectionsMapOutput)
}

func (i OrganizationConnectionsMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*OrganizationConnections] {
	return pulumix.Output[map[string]*OrganizationConnections]{
		OutputState: i.ToOrganizationConnectionsMapOutputWithContext(ctx).OutputState,
	}
}

type OrganizationConnectionsOutput struct{ *pulumi.OutputState }

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

func (o OrganizationConnectionsOutput) ToOrganizationConnectionsOutput() OrganizationConnectionsOutput {
	return o
}

func (o OrganizationConnectionsOutput) ToOrganizationConnectionsOutputWithContext(ctx context.Context) OrganizationConnectionsOutput {
	return o
}

func (o OrganizationConnectionsOutput) ToOutput(ctx context.Context) pulumix.Output[*OrganizationConnections] {
	return pulumix.Output[*OrganizationConnections]{
		OutputState: o.OutputState,
	}
}

// Connections that are enabled for the organization.
func (o OrganizationConnectionsOutput) EnabledConnections() OrganizationConnectionsEnabledConnectionArrayOutput {
	return o.ApplyT(func(v *OrganizationConnections) OrganizationConnectionsEnabledConnectionArrayOutput {
		return v.EnabledConnections
	}).(OrganizationConnectionsEnabledConnectionArrayOutput)
}

// ID of the organization on which to enable the connections.
func (o OrganizationConnectionsOutput) OrganizationId() pulumi.StringOutput {
	return o.ApplyT(func(v *OrganizationConnections) pulumi.StringOutput { return v.OrganizationId }).(pulumi.StringOutput)
}

type OrganizationConnectionsArrayOutput struct{ *pulumi.OutputState }

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

func (o OrganizationConnectionsArrayOutput) ToOrganizationConnectionsArrayOutput() OrganizationConnectionsArrayOutput {
	return o
}

func (o OrganizationConnectionsArrayOutput) ToOrganizationConnectionsArrayOutputWithContext(ctx context.Context) OrganizationConnectionsArrayOutput {
	return o
}

func (o OrganizationConnectionsArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*OrganizationConnections] {
	return pulumix.Output[[]*OrganizationConnections]{
		OutputState: o.OutputState,
	}
}

func (o OrganizationConnectionsArrayOutput) Index(i pulumi.IntInput) OrganizationConnectionsOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) *OrganizationConnections {
		return vs[0].([]*OrganizationConnections)[vs[1].(int)]
	}).(OrganizationConnectionsOutput)
}

type OrganizationConnectionsMapOutput struct{ *pulumi.OutputState }

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

func (o OrganizationConnectionsMapOutput) ToOrganizationConnectionsMapOutput() OrganizationConnectionsMapOutput {
	return o
}

func (o OrganizationConnectionsMapOutput) ToOrganizationConnectionsMapOutputWithContext(ctx context.Context) OrganizationConnectionsMapOutput {
	return o
}

func (o OrganizationConnectionsMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*OrganizationConnections] {
	return pulumix.Output[map[string]*OrganizationConnections]{
		OutputState: o.OutputState,
	}
}

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

func init() {
	pulumi.RegisterInputType(reflect.TypeOf((*OrganizationConnectionsInput)(nil)).Elem(), &OrganizationConnections{})
	pulumi.RegisterInputType(reflect.TypeOf((*OrganizationConnectionsArrayInput)(nil)).Elem(), OrganizationConnectionsArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*OrganizationConnectionsMapInput)(nil)).Elem(), OrganizationConnectionsMap{})
	pulumi.RegisterOutputType(OrganizationConnectionsOutput{})
	pulumi.RegisterOutputType(OrganizationConnectionsArrayOutput{})
	pulumi.RegisterOutputType(OrganizationConnectionsMapOutput{})
}