mongoRoleDefinition.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 cosmosdb

import (
	"context"
	"reflect"

	"errors"
	"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/internal"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

// Manages a Cosmos DB Mongo Role Definition.
//
// ## Example Usage
//
// ```go
// package main
//
// import (
//
//	"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/core"
//	"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/cosmosdb"
//	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
//
// )
//
//	func main() {
//		pulumi.Run(func(ctx *pulumi.Context) error {
//			example, err := core.NewResourceGroup(ctx, "example", &core.ResourceGroupArgs{
//				Name:     pulumi.String("example-resources"),
//				Location: pulumi.String("West Europe"),
//			})
//			if err != nil {
//				return err
//			}
//			exampleAccount, err := cosmosdb.NewAccount(ctx, "example", &cosmosdb.AccountArgs{
//				Name:              pulumi.String("example-ca"),
//				Location:          example.Location,
//				ResourceGroupName: example.Name,
//				OfferType:         pulumi.String("Standard"),
//				Kind:              pulumi.String("MongoDB"),
//				Capabilities: cosmosdb.AccountCapabilityArray{
//					&cosmosdb.AccountCapabilityArgs{
//						Name: pulumi.String("EnableMongo"),
//					},
//					&cosmosdb.AccountCapabilityArgs{
//						Name: pulumi.String("EnableMongoRoleBasedAccessControl"),
//					},
//				},
//				ConsistencyPolicy: &cosmosdb.AccountConsistencyPolicyArgs{
//					ConsistencyLevel: pulumi.String("Strong"),
//				},
//				GeoLocations: cosmosdb.AccountGeoLocationArray{
//					&cosmosdb.AccountGeoLocationArgs{
//						Location:         example.Location,
//						FailoverPriority: pulumi.Int(0),
//					},
//				},
//			})
//			if err != nil {
//				return err
//			}
//			exampleMongoDatabase, err := cosmosdb.NewMongoDatabase(ctx, "example", &cosmosdb.MongoDatabaseArgs{
//				Name:              pulumi.String("example-mongodb"),
//				ResourceGroupName: exampleAccount.ResourceGroupName,
//				AccountName:       exampleAccount.Name,
//			})
//			if err != nil {
//				return err
//			}
//			_, err = cosmosdb.NewMongoRoleDefinition(ctx, "example", &cosmosdb.MongoRoleDefinitionArgs{
//				CosmosMongoDatabaseId: exampleMongoDatabase.ID(),
//				RoleName:              pulumi.String("example-roledefinition"),
//			})
//			if err != nil {
//				return err
//			}
//			return nil
//		})
//	}
//
// ```
//
// ## Import
//
// Cosmos DB Mongo Role Definitions can be imported using the `resource id`, e.g.
//
// ```sh
// $ pulumi import azure:cosmosdb/mongoRoleDefinition:MongoRoleDefinition example /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.DocumentDB/databaseAccounts/account1/mongodbRoleDefinitions/dbname1.rolename1
// ```
type MongoRoleDefinition struct {
	pulumi.CustomResourceState

	// The resource ID of the Mongo DB. Changing this forces a new resource to be created.
	CosmosMongoDatabaseId pulumi.StringOutput `pulumi:"cosmosMongoDatabaseId"`
	// A list of Mongo Roles which are inherited to the Mongo Role Definition.
	//
	// > **Note:** The role that needs to be inherited should exist in the Mongo DB of `cosmosMongoDatabaseId`.
	InheritedRoleNames pulumi.StringArrayOutput `pulumi:"inheritedRoleNames"`
	// A `privilege` block as defined below.
	Privileges MongoRoleDefinitionPrivilegeArrayOutput `pulumi:"privileges"`
	// The user-friendly name for the Mongo Role Definition. It must be unique for the database account. Changing this forces a new resource to be created.
	RoleName pulumi.StringOutput `pulumi:"roleName"`
}

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

	if args.CosmosMongoDatabaseId == nil {
		return nil, errors.New("invalid value for required argument 'CosmosMongoDatabaseId'")
	}
	if args.RoleName == nil {
		return nil, errors.New("invalid value for required argument 'RoleName'")
	}
	opts = internal.PkgResourceDefaultOpts(opts)
	var resource MongoRoleDefinition
	err := ctx.RegisterResource("azure:cosmosdb/mongoRoleDefinition:MongoRoleDefinition", name, args, &resource, opts...)
	if err != nil {
		return nil, err
	}
	return &resource, nil
}

// GetMongoRoleDefinition gets an existing MongoRoleDefinition 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 GetMongoRoleDefinition(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *MongoRoleDefinitionState, opts ...pulumi.ResourceOption) (*MongoRoleDefinition, error) {
	var resource MongoRoleDefinition
	err := ctx.ReadResource("azure:cosmosdb/mongoRoleDefinition:MongoRoleDefinition", name, id, state, &resource, opts...)
	if err != nil {
		return nil, err
	}
	return &resource, nil
}

// Input properties used for looking up and filtering MongoRoleDefinition resources.
type mongoRoleDefinitionState struct {
	// The resource ID of the Mongo DB. Changing this forces a new resource to be created.
	CosmosMongoDatabaseId *string `pulumi:"cosmosMongoDatabaseId"`
	// A list of Mongo Roles which are inherited to the Mongo Role Definition.
	//
	// > **Note:** The role that needs to be inherited should exist in the Mongo DB of `cosmosMongoDatabaseId`.
	InheritedRoleNames []string `pulumi:"inheritedRoleNames"`
	// A `privilege` block as defined below.
	Privileges []MongoRoleDefinitionPrivilege `pulumi:"privileges"`
	// The user-friendly name for the Mongo Role Definition. It must be unique for the database account. Changing this forces a new resource to be created.
	RoleName *string `pulumi:"roleName"`
}

type MongoRoleDefinitionState struct {
	// The resource ID of the Mongo DB. Changing this forces a new resource to be created.
	CosmosMongoDatabaseId pulumi.StringPtrInput
	// A list of Mongo Roles which are inherited to the Mongo Role Definition.
	//
	// > **Note:** The role that needs to be inherited should exist in the Mongo DB of `cosmosMongoDatabaseId`.
	InheritedRoleNames pulumi.StringArrayInput
	// A `privilege` block as defined below.
	Privileges MongoRoleDefinitionPrivilegeArrayInput
	// The user-friendly name for the Mongo Role Definition. It must be unique for the database account. Changing this forces a new resource to be created.
	RoleName pulumi.StringPtrInput
}

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

type mongoRoleDefinitionArgs struct {
	// The resource ID of the Mongo DB. Changing this forces a new resource to be created.
	CosmosMongoDatabaseId string `pulumi:"cosmosMongoDatabaseId"`
	// A list of Mongo Roles which are inherited to the Mongo Role Definition.
	//
	// > **Note:** The role that needs to be inherited should exist in the Mongo DB of `cosmosMongoDatabaseId`.
	InheritedRoleNames []string `pulumi:"inheritedRoleNames"`
	// A `privilege` block as defined below.
	Privileges []MongoRoleDefinitionPrivilege `pulumi:"privileges"`
	// The user-friendly name for the Mongo Role Definition. It must be unique for the database account. Changing this forces a new resource to be created.
	RoleName string `pulumi:"roleName"`
}

// The set of arguments for constructing a MongoRoleDefinition resource.
type MongoRoleDefinitionArgs struct {
	// The resource ID of the Mongo DB. Changing this forces a new resource to be created.
	CosmosMongoDatabaseId pulumi.StringInput
	// A list of Mongo Roles which are inherited to the Mongo Role Definition.
	//
	// > **Note:** The role that needs to be inherited should exist in the Mongo DB of `cosmosMongoDatabaseId`.
	InheritedRoleNames pulumi.StringArrayInput
	// A `privilege` block as defined below.
	Privileges MongoRoleDefinitionPrivilegeArrayInput
	// The user-friendly name for the Mongo Role Definition. It must be unique for the database account. Changing this forces a new resource to be created.
	RoleName pulumi.StringInput
}

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

type MongoRoleDefinitionInput interface {
	pulumi.Input

	ToMongoRoleDefinitionOutput() MongoRoleDefinitionOutput
	ToMongoRoleDefinitionOutputWithContext(ctx context.Context) MongoRoleDefinitionOutput
}

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

func (i *MongoRoleDefinition) ToMongoRoleDefinitionOutput() MongoRoleDefinitionOutput {
	return i.ToMongoRoleDefinitionOutputWithContext(context.Background())
}

func (i *MongoRoleDefinition) ToMongoRoleDefinitionOutputWithContext(ctx context.Context) MongoRoleDefinitionOutput {
	return pulumi.ToOutputWithContext(ctx, i).(MongoRoleDefinitionOutput)
}

// MongoRoleDefinitionArrayInput is an input type that accepts MongoRoleDefinitionArray and MongoRoleDefinitionArrayOutput values.
// You can construct a concrete instance of `MongoRoleDefinitionArrayInput` via:
//
//	MongoRoleDefinitionArray{ MongoRoleDefinitionArgs{...} }
type MongoRoleDefinitionArrayInput interface {
	pulumi.Input

	ToMongoRoleDefinitionArrayOutput() MongoRoleDefinitionArrayOutput
	ToMongoRoleDefinitionArrayOutputWithContext(context.Context) MongoRoleDefinitionArrayOutput
}

type MongoRoleDefinitionArray []MongoRoleDefinitionInput

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

func (i MongoRoleDefinitionArray) ToMongoRoleDefinitionArrayOutput() MongoRoleDefinitionArrayOutput {
	return i.ToMongoRoleDefinitionArrayOutputWithContext(context.Background())
}

func (i MongoRoleDefinitionArray) ToMongoRoleDefinitionArrayOutputWithContext(ctx context.Context) MongoRoleDefinitionArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(MongoRoleDefinitionArrayOutput)
}

// MongoRoleDefinitionMapInput is an input type that accepts MongoRoleDefinitionMap and MongoRoleDefinitionMapOutput values.
// You can construct a concrete instance of `MongoRoleDefinitionMapInput` via:
//
//	MongoRoleDefinitionMap{ "key": MongoRoleDefinitionArgs{...} }
type MongoRoleDefinitionMapInput interface {
	pulumi.Input

	ToMongoRoleDefinitionMapOutput() MongoRoleDefinitionMapOutput
	ToMongoRoleDefinitionMapOutputWithContext(context.Context) MongoRoleDefinitionMapOutput
}

type MongoRoleDefinitionMap map[string]MongoRoleDefinitionInput

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

func (i MongoRoleDefinitionMap) ToMongoRoleDefinitionMapOutput() MongoRoleDefinitionMapOutput {
	return i.ToMongoRoleDefinitionMapOutputWithContext(context.Background())
}

func (i MongoRoleDefinitionMap) ToMongoRoleDefinitionMapOutputWithContext(ctx context.Context) MongoRoleDefinitionMapOutput {
	return pulumi.ToOutputWithContext(ctx, i).(MongoRoleDefinitionMapOutput)
}

type MongoRoleDefinitionOutput struct{ *pulumi.OutputState }

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

func (o MongoRoleDefinitionOutput) ToMongoRoleDefinitionOutput() MongoRoleDefinitionOutput {
	return o
}

func (o MongoRoleDefinitionOutput) ToMongoRoleDefinitionOutputWithContext(ctx context.Context) MongoRoleDefinitionOutput {
	return o
}

// The resource ID of the Mongo DB. Changing this forces a new resource to be created.
func (o MongoRoleDefinitionOutput) CosmosMongoDatabaseId() pulumi.StringOutput {
	return o.ApplyT(func(v *MongoRoleDefinition) pulumi.StringOutput { return v.CosmosMongoDatabaseId }).(pulumi.StringOutput)
}

// A list of Mongo Roles which are inherited to the Mongo Role Definition.
//
// > **Note:** The role that needs to be inherited should exist in the Mongo DB of `cosmosMongoDatabaseId`.
func (o MongoRoleDefinitionOutput) InheritedRoleNames() pulumi.StringArrayOutput {
	return o.ApplyT(func(v *MongoRoleDefinition) pulumi.StringArrayOutput { return v.InheritedRoleNames }).(pulumi.StringArrayOutput)
}

// A `privilege` block as defined below.
func (o MongoRoleDefinitionOutput) Privileges() MongoRoleDefinitionPrivilegeArrayOutput {
	return o.ApplyT(func(v *MongoRoleDefinition) MongoRoleDefinitionPrivilegeArrayOutput { return v.Privileges }).(MongoRoleDefinitionPrivilegeArrayOutput)
}

// The user-friendly name for the Mongo Role Definition. It must be unique for the database account. Changing this forces a new resource to be created.
func (o MongoRoleDefinitionOutput) RoleName() pulumi.StringOutput {
	return o.ApplyT(func(v *MongoRoleDefinition) pulumi.StringOutput { return v.RoleName }).(pulumi.StringOutput)
}

type MongoRoleDefinitionArrayOutput struct{ *pulumi.OutputState }

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

func (o MongoRoleDefinitionArrayOutput) ToMongoRoleDefinitionArrayOutput() MongoRoleDefinitionArrayOutput {
	return o
}

func (o MongoRoleDefinitionArrayOutput) ToMongoRoleDefinitionArrayOutputWithContext(ctx context.Context) MongoRoleDefinitionArrayOutput {
	return o
}

func (o MongoRoleDefinitionArrayOutput) Index(i pulumi.IntInput) MongoRoleDefinitionOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) *MongoRoleDefinition {
		return vs[0].([]*MongoRoleDefinition)[vs[1].(int)]
	}).(MongoRoleDefinitionOutput)
}

type MongoRoleDefinitionMapOutput struct{ *pulumi.OutputState }

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

func (o MongoRoleDefinitionMapOutput) ToMongoRoleDefinitionMapOutput() MongoRoleDefinitionMapOutput {
	return o
}

func (o MongoRoleDefinitionMapOutput) ToMongoRoleDefinitionMapOutputWithContext(ctx context.Context) MongoRoleDefinitionMapOutput {
	return o
}

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

func init() {
	pulumi.RegisterInputType(reflect.TypeOf((*MongoRoleDefinitionInput)(nil)).Elem(), &MongoRoleDefinition{})
	pulumi.RegisterInputType(reflect.TypeOf((*MongoRoleDefinitionArrayInput)(nil)).Elem(), MongoRoleDefinitionArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*MongoRoleDefinitionMapInput)(nil)).Elem(), MongoRoleDefinitionMap{})
	pulumi.RegisterOutputType(MongoRoleDefinitionOutput{})
	pulumi.RegisterOutputType(MongoRoleDefinitionArrayOutput{})
	pulumi.RegisterOutputType(MongoRoleDefinitionMapOutput{})
}