addonsConfig.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 apigee

import (
	"context"
	"reflect"

	"errors"
	"github.com/pulumi/pulumi-gcp/sdk/v6/go/gcp/internal"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumix"
)

// Configures the add-ons for the Apigee organization. The existing add-on configuration will be fully replaced.
//
// To get more information about AddonsConfig, see:
//
// * [API documentation](https://cloud.google.com/apigee/docs/reference/apis/apigee/rest/v1/organizations#setaddons)
// * How-to Guides
//   - [Creating an API organization](https://cloud.google.com/apigee/docs/api-platform/get-started/create-org)
//
// ## Example Usage
// ### Apigee Addons Basic
//
// ```go
// package main
//
// import (
//
//	"github.com/pulumi/pulumi-gcp/sdk/v6/go/gcp/apigee"
//	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
//
// )
//
//	func main() {
//		pulumi.Run(func(ctx *pulumi.Context) error {
//			_, err := apigee.NewAddonsConfig(ctx, "testOrganization", &apigee.AddonsConfigArgs{
//				AddonsConfig: &apigee.AddonsConfigAddonsConfigArgs{
//					ApiSecurityConfig: &apigee.AddonsConfigAddonsConfigApiSecurityConfigArgs{
//						Enabled: pulumi.Bool(true),
//					},
//					MonetizationConfig: &apigee.AddonsConfigAddonsConfigMonetizationConfigArgs{
//						Enabled: pulumi.Bool(true),
//					},
//				},
//				Org: pulumi.String("test_organization"),
//			})
//			if err != nil {
//				return err
//			}
//			return nil
//		})
//	}
//
// ```
// ### Apigee Addons Full
//
// ```go
// package main
//
// import (
//
//	"github.com/pulumi/pulumi-gcp/sdk/v6/go/gcp/apigee"
//	"github.com/pulumi/pulumi-gcp/sdk/v6/go/gcp/compute"
//	"github.com/pulumi/pulumi-gcp/sdk/v6/go/gcp/organizations"
//	"github.com/pulumi/pulumi-gcp/sdk/v6/go/gcp/projects"
//	"github.com/pulumi/pulumi-gcp/sdk/v6/go/gcp/servicenetworking"
//	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
//
// )
//
//	func main() {
//		pulumi.Run(func(ctx *pulumi.Context) error {
//			current, err := organizations.GetClientConfig(ctx, nil, nil)
//			if err != nil {
//				return err
//			}
//			apigee, err := projects.NewService(ctx, "apigee", &projects.ServiceArgs{
//				Project: *pulumi.String(current.Project),
//				Service: pulumi.String("apigee.googleapis.com"),
//			})
//			if err != nil {
//				return err
//			}
//			compute, err := projects.NewService(ctx, "compute", &projects.ServiceArgs{
//				Project: *pulumi.String(current.Project),
//				Service: pulumi.String("compute.googleapis.com"),
//			})
//			if err != nil {
//				return err
//			}
//			_, err = projects.NewService(ctx, "servicenetworking", &projects.ServiceArgs{
//				Project: *pulumi.String(current.Project),
//				Service: pulumi.String("servicenetworking.googleapis.com"),
//			})
//			if err != nil {
//				return err
//			}
//			apigeeNetwork, err := compute.NewNetwork(ctx, "apigeeNetwork", &compute.NetworkArgs{
//				Project: *pulumi.String(current.Project),
//			}, pulumi.DependsOn([]pulumi.Resource{
//				compute,
//			}))
//			if err != nil {
//				return err
//			}
//			apigeeRange, err := compute.NewGlobalAddress(ctx, "apigeeRange", &compute.GlobalAddressArgs{
//				Purpose:      pulumi.String("VPC_PEERING"),
//				AddressType:  pulumi.String("INTERNAL"),
//				PrefixLength: pulumi.Int(16),
//				Network:      apigeeNetwork.ID(),
//				Project:      *pulumi.String(current.Project),
//			})
//			if err != nil {
//				return err
//			}
//			apigeeVpcConnection, err := servicenetworking.NewConnection(ctx, "apigeeVpcConnection", &servicenetworking.ConnectionArgs{
//				Network: apigeeNetwork.ID(),
//				Service: pulumi.String("servicenetworking.googleapis.com"),
//				ReservedPeeringRanges: pulumi.StringArray{
//					apigeeRange.Name,
//				},
//			})
//			if err != nil {
//				return err
//			}
//			org, err := apigee.NewOrganization(ctx, "org", &apigee.OrganizationArgs{
//				AnalyticsRegion:   pulumi.String("us-central1"),
//				ProjectId:         *pulumi.String(current.Project),
//				AuthorizedNetwork: apigeeNetwork.ID(),
//				BillingType:       pulumi.String("EVALUATION"),
//			}, pulumi.DependsOn([]pulumi.Resource{
//				apigeeVpcConnection,
//				apigee,
//			}))
//			if err != nil {
//				return err
//			}
//			_, err = apigee.NewAddonsConfig(ctx, "testOrganization", &apigee.AddonsConfigArgs{
//				Org: org.Name,
//				AddonsConfig: &apigee.AddonsConfigAddonsConfigArgs{
//					IntegrationConfig: &apigee.AddonsConfigAddonsConfigIntegrationConfigArgs{
//						Enabled: pulumi.Bool(true),
//					},
//					ApiSecurityConfig: &apigee.AddonsConfigAddonsConfigApiSecurityConfigArgs{
//						Enabled: pulumi.Bool(true),
//					},
//					ConnectorsPlatformConfig: &apigee.AddonsConfigAddonsConfigConnectorsPlatformConfigArgs{
//						Enabled: pulumi.Bool(true),
//					},
//					MonetizationConfig: &apigee.AddonsConfigAddonsConfigMonetizationConfigArgs{
//						Enabled: pulumi.Bool(true),
//					},
//					AdvancedApiOpsConfig: &apigee.AddonsConfigAddonsConfigAdvancedApiOpsConfigArgs{
//						Enabled: pulumi.Bool(true),
//					},
//				},
//			})
//			if err != nil {
//				return err
//			}
//			return nil
//		})
//	}
//
// ```
//
// ## Import
//
// # AddonsConfig can be imported using any of these accepted formats
//
// ```sh
//
//	$ pulumi import gcp:apigee/addonsConfig:AddonsConfig default organizations/{{name}}
//
// ```
//
// ```sh
//
//	$ pulumi import gcp:apigee/addonsConfig:AddonsConfig default {{name}}
//
// ```
type AddonsConfig struct {
	pulumi.CustomResourceState

	// Addon configurations of the Apigee organization.
	// Structure is documented below.
	AddonsConfig AddonsConfigAddonsConfigPtrOutput `pulumi:"addonsConfig"`
	// Name of the Apigee organization.
	//
	// ***
	Org pulumi.StringOutput `pulumi:"org"`
}

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

	if args.Org == nil {
		return nil, errors.New("invalid value for required argument 'Org'")
	}
	opts = internal.PkgResourceDefaultOpts(opts)
	var resource AddonsConfig
	err := ctx.RegisterResource("gcp:apigee/addonsConfig:AddonsConfig", name, args, &resource, opts...)
	if err != nil {
		return nil, err
	}
	return &resource, nil
}

// GetAddonsConfig gets an existing AddonsConfig 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 GetAddonsConfig(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *AddonsConfigState, opts ...pulumi.ResourceOption) (*AddonsConfig, error) {
	var resource AddonsConfig
	err := ctx.ReadResource("gcp:apigee/addonsConfig:AddonsConfig", name, id, state, &resource, opts...)
	if err != nil {
		return nil, err
	}
	return &resource, nil
}

// Input properties used for looking up and filtering AddonsConfig resources.
type addonsConfigState struct {
	// Addon configurations of the Apigee organization.
	// Structure is documented below.
	AddonsConfig *AddonsConfigAddonsConfig `pulumi:"addonsConfig"`
	// Name of the Apigee organization.
	//
	// ***
	Org *string `pulumi:"org"`
}

type AddonsConfigState struct {
	// Addon configurations of the Apigee organization.
	// Structure is documented below.
	AddonsConfig AddonsConfigAddonsConfigPtrInput
	// Name of the Apigee organization.
	//
	// ***
	Org pulumi.StringPtrInput
}

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

type addonsConfigArgs struct {
	// Addon configurations of the Apigee organization.
	// Structure is documented below.
	AddonsConfig *AddonsConfigAddonsConfig `pulumi:"addonsConfig"`
	// Name of the Apigee organization.
	//
	// ***
	Org string `pulumi:"org"`
}

// The set of arguments for constructing a AddonsConfig resource.
type AddonsConfigArgs struct {
	// Addon configurations of the Apigee organization.
	// Structure is documented below.
	AddonsConfig AddonsConfigAddonsConfigPtrInput
	// Name of the Apigee organization.
	//
	// ***
	Org pulumi.StringInput
}

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

type AddonsConfigInput interface {
	pulumi.Input

	ToAddonsConfigOutput() AddonsConfigOutput
	ToAddonsConfigOutputWithContext(ctx context.Context) AddonsConfigOutput
}

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

func (i *AddonsConfig) ToAddonsConfigOutput() AddonsConfigOutput {
	return i.ToAddonsConfigOutputWithContext(context.Background())
}

func (i *AddonsConfig) ToAddonsConfigOutputWithContext(ctx context.Context) AddonsConfigOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AddonsConfigOutput)
}

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

// AddonsConfigArrayInput is an input type that accepts AddonsConfigArray and AddonsConfigArrayOutput values.
// You can construct a concrete instance of `AddonsConfigArrayInput` via:
//
//	AddonsConfigArray{ AddonsConfigArgs{...} }
type AddonsConfigArrayInput interface {
	pulumi.Input

	ToAddonsConfigArrayOutput() AddonsConfigArrayOutput
	ToAddonsConfigArrayOutputWithContext(context.Context) AddonsConfigArrayOutput
}

type AddonsConfigArray []AddonsConfigInput

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

func (i AddonsConfigArray) ToAddonsConfigArrayOutput() AddonsConfigArrayOutput {
	return i.ToAddonsConfigArrayOutputWithContext(context.Background())
}

func (i AddonsConfigArray) ToAddonsConfigArrayOutputWithContext(ctx context.Context) AddonsConfigArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AddonsConfigArrayOutput)
}

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

// AddonsConfigMapInput is an input type that accepts AddonsConfigMap and AddonsConfigMapOutput values.
// You can construct a concrete instance of `AddonsConfigMapInput` via:
//
//	AddonsConfigMap{ "key": AddonsConfigArgs{...} }
type AddonsConfigMapInput interface {
	pulumi.Input

	ToAddonsConfigMapOutput() AddonsConfigMapOutput
	ToAddonsConfigMapOutputWithContext(context.Context) AddonsConfigMapOutput
}

type AddonsConfigMap map[string]AddonsConfigInput

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

func (i AddonsConfigMap) ToAddonsConfigMapOutput() AddonsConfigMapOutput {
	return i.ToAddonsConfigMapOutputWithContext(context.Background())
}

func (i AddonsConfigMap) ToAddonsConfigMapOutputWithContext(ctx context.Context) AddonsConfigMapOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AddonsConfigMapOutput)
}

func (i AddonsConfigMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*AddonsConfig] {
	return pulumix.Output[map[string]*AddonsConfig]{
		OutputState: i.ToAddonsConfigMapOutputWithContext(ctx).OutputState,
	}
}

type AddonsConfigOutput struct{ *pulumi.OutputState }

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

func (o AddonsConfigOutput) ToAddonsConfigOutput() AddonsConfigOutput {
	return o
}

func (o AddonsConfigOutput) ToAddonsConfigOutputWithContext(ctx context.Context) AddonsConfigOutput {
	return o
}

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

// Addon configurations of the Apigee organization.
// Structure is documented below.
func (o AddonsConfigOutput) AddonsConfig() AddonsConfigAddonsConfigPtrOutput {
	return o.ApplyT(func(v *AddonsConfig) AddonsConfigAddonsConfigPtrOutput { return v.AddonsConfig }).(AddonsConfigAddonsConfigPtrOutput)
}

// Name of the Apigee organization.
//
// ***
func (o AddonsConfigOutput) Org() pulumi.StringOutput {
	return o.ApplyT(func(v *AddonsConfig) pulumi.StringOutput { return v.Org }).(pulumi.StringOutput)
}

type AddonsConfigArrayOutput struct{ *pulumi.OutputState }

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

func (o AddonsConfigArrayOutput) ToAddonsConfigArrayOutput() AddonsConfigArrayOutput {
	return o
}

func (o AddonsConfigArrayOutput) ToAddonsConfigArrayOutputWithContext(ctx context.Context) AddonsConfigArrayOutput {
	return o
}

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

func (o AddonsConfigArrayOutput) Index(i pulumi.IntInput) AddonsConfigOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) *AddonsConfig {
		return vs[0].([]*AddonsConfig)[vs[1].(int)]
	}).(AddonsConfigOutput)
}

type AddonsConfigMapOutput struct{ *pulumi.OutputState }

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

func (o AddonsConfigMapOutput) ToAddonsConfigMapOutput() AddonsConfigMapOutput {
	return o
}

func (o AddonsConfigMapOutput) ToAddonsConfigMapOutputWithContext(ctx context.Context) AddonsConfigMapOutput {
	return o
}

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

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

func init() {
	pulumi.RegisterInputType(reflect.TypeOf((*AddonsConfigInput)(nil)).Elem(), &AddonsConfig{})
	pulumi.RegisterInputType(reflect.TypeOf((*AddonsConfigArrayInput)(nil)).Elem(), AddonsConfigArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*AddonsConfigMapInput)(nil)).Elem(), AddonsConfigMap{})
	pulumi.RegisterOutputType(AddonsConfigOutput{})
	pulumi.RegisterOutputType(AddonsConfigArrayOutput{})
	pulumi.RegisterOutputType(AddonsConfigMapOutput{})
}