github.com/pulumi/pulumi-aws/sdk/v6@v6.32.0/go/aws/lightsail/domain.go (about)

     1  // Code generated by the Pulumi Terraform Bridge (tfgen) Tool DO NOT EDIT.
     2  // *** WARNING: Do not edit by hand unless you're certain you know what you are doing! ***
     3  
     4  package lightsail
     5  
     6  import (
     7  	"context"
     8  	"reflect"
     9  
    10  	"errors"
    11  	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/internal"
    12  	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    13  )
    14  
    15  // Creates a domain resource for the specified domain (e.g., example.com).
    16  // You cannot register a new domain name using Lightsail. You must register
    17  // a domain name using Amazon Route 53 or another domain name registrar.
    18  // If you have already registered your domain, you can enter its name in
    19  // this parameter to manage the DNS records for that domain.
    20  //
    21  // > **Note:** Lightsail is currently only supported in a limited number of AWS Regions, please see ["Regions and Availability Zones in Amazon Lightsail"](https://lightsail.aws.amazon.com/ls/docs/overview/article/understanding-regions-and-availability-zones-in-amazon-lightsail) for more details
    22  //
    23  // ## Example Usage
    24  //
    25  // <!--Start PulumiCodeChooser -->
    26  // ```go
    27  // package main
    28  //
    29  // import (
    30  //
    31  //	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/lightsail"
    32  //	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    33  //
    34  // )
    35  //
    36  //	func main() {
    37  //		pulumi.Run(func(ctx *pulumi.Context) error {
    38  //			_, err := lightsail.NewDomain(ctx, "domain_test", &lightsail.DomainArgs{
    39  //				DomainName: pulumi.String("mydomain.com"),
    40  //			})
    41  //			if err != nil {
    42  //				return err
    43  //			}
    44  //			return nil
    45  //		})
    46  //	}
    47  //
    48  // ```
    49  // <!--End PulumiCodeChooser -->
    50  type Domain struct {
    51  	pulumi.CustomResourceState
    52  
    53  	// The ARN of the Lightsail domain
    54  	Arn pulumi.StringOutput `pulumi:"arn"`
    55  	// The name of the Lightsail domain to manage
    56  	DomainName pulumi.StringOutput `pulumi:"domainName"`
    57  }
    58  
    59  // NewDomain registers a new resource with the given unique name, arguments, and options.
    60  func NewDomain(ctx *pulumi.Context,
    61  	name string, args *DomainArgs, opts ...pulumi.ResourceOption) (*Domain, error) {
    62  	if args == nil {
    63  		return nil, errors.New("missing one or more required arguments")
    64  	}
    65  
    66  	if args.DomainName == nil {
    67  		return nil, errors.New("invalid value for required argument 'DomainName'")
    68  	}
    69  	opts = internal.PkgResourceDefaultOpts(opts)
    70  	var resource Domain
    71  	err := ctx.RegisterResource("aws:lightsail/domain:Domain", name, args, &resource, opts...)
    72  	if err != nil {
    73  		return nil, err
    74  	}
    75  	return &resource, nil
    76  }
    77  
    78  // GetDomain gets an existing Domain resource's state with the given name, ID, and optional
    79  // state properties that are used to uniquely qualify the lookup (nil if not required).
    80  func GetDomain(ctx *pulumi.Context,
    81  	name string, id pulumi.IDInput, state *DomainState, opts ...pulumi.ResourceOption) (*Domain, error) {
    82  	var resource Domain
    83  	err := ctx.ReadResource("aws:lightsail/domain:Domain", name, id, state, &resource, opts...)
    84  	if err != nil {
    85  		return nil, err
    86  	}
    87  	return &resource, nil
    88  }
    89  
    90  // Input properties used for looking up and filtering Domain resources.
    91  type domainState struct {
    92  	// The ARN of the Lightsail domain
    93  	Arn *string `pulumi:"arn"`
    94  	// The name of the Lightsail domain to manage
    95  	DomainName *string `pulumi:"domainName"`
    96  }
    97  
    98  type DomainState struct {
    99  	// The ARN of the Lightsail domain
   100  	Arn pulumi.StringPtrInput
   101  	// The name of the Lightsail domain to manage
   102  	DomainName pulumi.StringPtrInput
   103  }
   104  
   105  func (DomainState) ElementType() reflect.Type {
   106  	return reflect.TypeOf((*domainState)(nil)).Elem()
   107  }
   108  
   109  type domainArgs struct {
   110  	// The name of the Lightsail domain to manage
   111  	DomainName string `pulumi:"domainName"`
   112  }
   113  
   114  // The set of arguments for constructing a Domain resource.
   115  type DomainArgs struct {
   116  	// The name of the Lightsail domain to manage
   117  	DomainName pulumi.StringInput
   118  }
   119  
   120  func (DomainArgs) ElementType() reflect.Type {
   121  	return reflect.TypeOf((*domainArgs)(nil)).Elem()
   122  }
   123  
   124  type DomainInput interface {
   125  	pulumi.Input
   126  
   127  	ToDomainOutput() DomainOutput
   128  	ToDomainOutputWithContext(ctx context.Context) DomainOutput
   129  }
   130  
   131  func (*Domain) ElementType() reflect.Type {
   132  	return reflect.TypeOf((**Domain)(nil)).Elem()
   133  }
   134  
   135  func (i *Domain) ToDomainOutput() DomainOutput {
   136  	return i.ToDomainOutputWithContext(context.Background())
   137  }
   138  
   139  func (i *Domain) ToDomainOutputWithContext(ctx context.Context) DomainOutput {
   140  	return pulumi.ToOutputWithContext(ctx, i).(DomainOutput)
   141  }
   142  
   143  // DomainArrayInput is an input type that accepts DomainArray and DomainArrayOutput values.
   144  // You can construct a concrete instance of `DomainArrayInput` via:
   145  //
   146  //	DomainArray{ DomainArgs{...} }
   147  type DomainArrayInput interface {
   148  	pulumi.Input
   149  
   150  	ToDomainArrayOutput() DomainArrayOutput
   151  	ToDomainArrayOutputWithContext(context.Context) DomainArrayOutput
   152  }
   153  
   154  type DomainArray []DomainInput
   155  
   156  func (DomainArray) ElementType() reflect.Type {
   157  	return reflect.TypeOf((*[]*Domain)(nil)).Elem()
   158  }
   159  
   160  func (i DomainArray) ToDomainArrayOutput() DomainArrayOutput {
   161  	return i.ToDomainArrayOutputWithContext(context.Background())
   162  }
   163  
   164  func (i DomainArray) ToDomainArrayOutputWithContext(ctx context.Context) DomainArrayOutput {
   165  	return pulumi.ToOutputWithContext(ctx, i).(DomainArrayOutput)
   166  }
   167  
   168  // DomainMapInput is an input type that accepts DomainMap and DomainMapOutput values.
   169  // You can construct a concrete instance of `DomainMapInput` via:
   170  //
   171  //	DomainMap{ "key": DomainArgs{...} }
   172  type DomainMapInput interface {
   173  	pulumi.Input
   174  
   175  	ToDomainMapOutput() DomainMapOutput
   176  	ToDomainMapOutputWithContext(context.Context) DomainMapOutput
   177  }
   178  
   179  type DomainMap map[string]DomainInput
   180  
   181  func (DomainMap) ElementType() reflect.Type {
   182  	return reflect.TypeOf((*map[string]*Domain)(nil)).Elem()
   183  }
   184  
   185  func (i DomainMap) ToDomainMapOutput() DomainMapOutput {
   186  	return i.ToDomainMapOutputWithContext(context.Background())
   187  }
   188  
   189  func (i DomainMap) ToDomainMapOutputWithContext(ctx context.Context) DomainMapOutput {
   190  	return pulumi.ToOutputWithContext(ctx, i).(DomainMapOutput)
   191  }
   192  
   193  type DomainOutput struct{ *pulumi.OutputState }
   194  
   195  func (DomainOutput) ElementType() reflect.Type {
   196  	return reflect.TypeOf((**Domain)(nil)).Elem()
   197  }
   198  
   199  func (o DomainOutput) ToDomainOutput() DomainOutput {
   200  	return o
   201  }
   202  
   203  func (o DomainOutput) ToDomainOutputWithContext(ctx context.Context) DomainOutput {
   204  	return o
   205  }
   206  
   207  // The ARN of the Lightsail domain
   208  func (o DomainOutput) Arn() pulumi.StringOutput {
   209  	return o.ApplyT(func(v *Domain) pulumi.StringOutput { return v.Arn }).(pulumi.StringOutput)
   210  }
   211  
   212  // The name of the Lightsail domain to manage
   213  func (o DomainOutput) DomainName() pulumi.StringOutput {
   214  	return o.ApplyT(func(v *Domain) pulumi.StringOutput { return v.DomainName }).(pulumi.StringOutput)
   215  }
   216  
   217  type DomainArrayOutput struct{ *pulumi.OutputState }
   218  
   219  func (DomainArrayOutput) ElementType() reflect.Type {
   220  	return reflect.TypeOf((*[]*Domain)(nil)).Elem()
   221  }
   222  
   223  func (o DomainArrayOutput) ToDomainArrayOutput() DomainArrayOutput {
   224  	return o
   225  }
   226  
   227  func (o DomainArrayOutput) ToDomainArrayOutputWithContext(ctx context.Context) DomainArrayOutput {
   228  	return o
   229  }
   230  
   231  func (o DomainArrayOutput) Index(i pulumi.IntInput) DomainOutput {
   232  	return pulumi.All(o, i).ApplyT(func(vs []interface{}) *Domain {
   233  		return vs[0].([]*Domain)[vs[1].(int)]
   234  	}).(DomainOutput)
   235  }
   236  
   237  type DomainMapOutput struct{ *pulumi.OutputState }
   238  
   239  func (DomainMapOutput) ElementType() reflect.Type {
   240  	return reflect.TypeOf((*map[string]*Domain)(nil)).Elem()
   241  }
   242  
   243  func (o DomainMapOutput) ToDomainMapOutput() DomainMapOutput {
   244  	return o
   245  }
   246  
   247  func (o DomainMapOutput) ToDomainMapOutputWithContext(ctx context.Context) DomainMapOutput {
   248  	return o
   249  }
   250  
   251  func (o DomainMapOutput) MapIndex(k pulumi.StringInput) DomainOutput {
   252  	return pulumi.All(o, k).ApplyT(func(vs []interface{}) *Domain {
   253  		return vs[0].(map[string]*Domain)[vs[1].(string)]
   254  	}).(DomainOutput)
   255  }
   256  
   257  func init() {
   258  	pulumi.RegisterInputType(reflect.TypeOf((*DomainInput)(nil)).Elem(), &Domain{})
   259  	pulumi.RegisterInputType(reflect.TypeOf((*DomainArrayInput)(nil)).Elem(), DomainArray{})
   260  	pulumi.RegisterInputType(reflect.TypeOf((*DomainMapInput)(nil)).Elem(), DomainMap{})
   261  	pulumi.RegisterOutputType(DomainOutput{})
   262  	pulumi.RegisterOutputType(DomainArrayOutput{})
   263  	pulumi.RegisterOutputType(DomainMapOutput{})
   264  }