2022-04-19 16:39:23 +00:00
|
|
|
// Code generated by test DO NOT EDIT.
|
|
|
|
// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! ***
|
2021-09-22 03:48:45 +00:00
|
|
|
|
|
|
|
package example
|
|
|
|
|
|
|
|
import (
|
|
|
|
"context"
|
|
|
|
"reflect"
|
|
|
|
|
|
|
|
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
|
2023-06-14 16:34:49 +00:00
|
|
|
"resource-args-python-case-insensitive/example/internal"
|
2021-09-22 03:48:45 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
type Person struct {
|
|
|
|
pulumi.CustomResourceState
|
|
|
|
|
|
|
|
Name pulumi.StringPtrOutput `pulumi:"name"`
|
|
|
|
Pets PetTypeArrayOutput `pulumi:"pets"`
|
|
|
|
}
|
|
|
|
|
|
|
|
// NewPerson registers a new resource with the given unique name, arguments, and options.
|
|
|
|
func NewPerson(ctx *pulumi.Context,
|
|
|
|
name string, args *PersonArgs, opts ...pulumi.ResourceOption) (*Person, error) {
|
|
|
|
if args == nil {
|
|
|
|
args = &PersonArgs{}
|
|
|
|
}
|
|
|
|
|
2023-06-14 16:34:49 +00:00
|
|
|
opts = internal.PkgResourceDefaultOpts(opts)
|
2021-09-22 03:48:45 +00:00
|
|
|
var resource Person
|
|
|
|
err := ctx.RegisterResource("example::Person", name, args, &resource, opts...)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
return &resource, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// GetPerson gets an existing Person 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 GetPerson(ctx *pulumi.Context,
|
|
|
|
name string, id pulumi.IDInput, state *PersonState, opts ...pulumi.ResourceOption) (*Person, error) {
|
|
|
|
var resource Person
|
|
|
|
err := ctx.ReadResource("example::Person", name, id, state, &resource, opts...)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
return &resource, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// Input properties used for looking up and filtering Person resources.
|
|
|
|
type personState struct {
|
|
|
|
}
|
|
|
|
|
|
|
|
type PersonState struct {
|
|
|
|
}
|
|
|
|
|
|
|
|
func (PersonState) ElementType() reflect.Type {
|
|
|
|
return reflect.TypeOf((*personState)(nil)).Elem()
|
|
|
|
}
|
|
|
|
|
|
|
|
type personArgs struct {
|
|
|
|
Name *string `pulumi:"name"`
|
|
|
|
Pets []PetType `pulumi:"pets"`
|
|
|
|
}
|
|
|
|
|
|
|
|
// The set of arguments for constructing a Person resource.
|
|
|
|
type PersonArgs struct {
|
|
|
|
Name pulumi.StringPtrInput
|
|
|
|
Pets PetTypeArrayInput
|
|
|
|
}
|
|
|
|
|
|
|
|
func (PersonArgs) ElementType() reflect.Type {
|
|
|
|
return reflect.TypeOf((*personArgs)(nil)).Elem()
|
|
|
|
}
|
|
|
|
|
|
|
|
type PersonInput interface {
|
|
|
|
pulumi.Input
|
|
|
|
|
|
|
|
ToPersonOutput() PersonOutput
|
|
|
|
ToPersonOutputWithContext(ctx context.Context) PersonOutput
|
|
|
|
}
|
|
|
|
|
|
|
|
func (*Person) ElementType() reflect.Type {
|
[codegen/go] Remove ResourcePtr input/output types (#8449)
These changes remove the `Ptr` variants of input/ouptut types for
resources. A `TPtr` input or output is normally generated for `T` if `T`
is present in an `optional(input(T))` or `optional(output(T))` and if
the Go representation for `T` is not nilable. The generation of `Ptr`
variants for resource types breaks the latter rule: the canonical
representation of a resource type named `Foo` is a pointer to a struct
type named `Foo` (i.e. `*Foo`). `Foo` itself is not a resource, as it
does not implement the Go `Resource` interface. Because this
representation already accommodates `nil` to indicate the lack of a
value, we need not generate `FooPtr{Input,Output}` types.
Besides being unnecessary, the implementation of `Ptr` types for
resources was incorrect. Rather than using `**Foo` as their element
type, these types use `*Foo`--identical to the element type used for
the normal input/output types. Furthermore, the generated code for
at least `FooOutput.ToFooPtrOutputWithContext` and `FooPtrOutput.Elem`
was incorrect, making these types virtually unusable in practice.
Finally, these `Ptr` types should never appear on input/output
properties in practice, as the logic we use to generate input and output
type references never generates them for `optional({input,output}(T)).
Instead, it generates references to the standard input/output types.
Though this is _technically_ a breaking change--it changes the set of
exported types for any package that defines resources--I believe that in
practice it will be invisible to users for the reasons stated above.
These types are not usable, and were never referenced.
This is preparatory work for #7943.
2021-11-23 18:24:56 +00:00
|
|
|
return reflect.TypeOf((**Person)(nil)).Elem()
|
2021-09-22 03:48:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func (i *Person) ToPersonOutput() PersonOutput {
|
|
|
|
return i.ToPersonOutputWithContext(context.Background())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (i *Person) ToPersonOutputWithContext(ctx context.Context) PersonOutput {
|
|
|
|
return pulumi.ToOutputWithContext(ctx, i).(PersonOutput)
|
|
|
|
}
|
|
|
|
|
|
|
|
// PersonArrayInput is an input type that accepts PersonArray and PersonArrayOutput values.
|
|
|
|
// You can construct a concrete instance of `PersonArrayInput` via:
|
|
|
|
//
|
2022-09-14 02:12:02 +00:00
|
|
|
// PersonArray{ PersonArgs{...} }
|
2021-09-22 03:48:45 +00:00
|
|
|
type PersonArrayInput interface {
|
|
|
|
pulumi.Input
|
|
|
|
|
|
|
|
ToPersonArrayOutput() PersonArrayOutput
|
|
|
|
ToPersonArrayOutputWithContext(context.Context) PersonArrayOutput
|
|
|
|
}
|
|
|
|
|
|
|
|
type PersonArray []PersonInput
|
|
|
|
|
|
|
|
func (PersonArray) ElementType() reflect.Type {
|
|
|
|
return reflect.TypeOf((*[]*Person)(nil)).Elem()
|
|
|
|
}
|
|
|
|
|
|
|
|
func (i PersonArray) ToPersonArrayOutput() PersonArrayOutput {
|
|
|
|
return i.ToPersonArrayOutputWithContext(context.Background())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (i PersonArray) ToPersonArrayOutputWithContext(ctx context.Context) PersonArrayOutput {
|
|
|
|
return pulumi.ToOutputWithContext(ctx, i).(PersonArrayOutput)
|
|
|
|
}
|
|
|
|
|
|
|
|
// PersonMapInput is an input type that accepts PersonMap and PersonMapOutput values.
|
|
|
|
// You can construct a concrete instance of `PersonMapInput` via:
|
|
|
|
//
|
2022-09-14 02:12:02 +00:00
|
|
|
// PersonMap{ "key": PersonArgs{...} }
|
2021-09-22 03:48:45 +00:00
|
|
|
type PersonMapInput interface {
|
|
|
|
pulumi.Input
|
|
|
|
|
|
|
|
ToPersonMapOutput() PersonMapOutput
|
|
|
|
ToPersonMapOutputWithContext(context.Context) PersonMapOutput
|
|
|
|
}
|
|
|
|
|
|
|
|
type PersonMap map[string]PersonInput
|
|
|
|
|
|
|
|
func (PersonMap) ElementType() reflect.Type {
|
|
|
|
return reflect.TypeOf((*map[string]*Person)(nil)).Elem()
|
|
|
|
}
|
|
|
|
|
|
|
|
func (i PersonMap) ToPersonMapOutput() PersonMapOutput {
|
|
|
|
return i.ToPersonMapOutputWithContext(context.Background())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (i PersonMap) ToPersonMapOutputWithContext(ctx context.Context) PersonMapOutput {
|
|
|
|
return pulumi.ToOutputWithContext(ctx, i).(PersonMapOutput)
|
|
|
|
}
|
|
|
|
|
|
|
|
type PersonOutput struct{ *pulumi.OutputState }
|
|
|
|
|
|
|
|
func (PersonOutput) ElementType() reflect.Type {
|
[codegen/go] Remove ResourcePtr input/output types (#8449)
These changes remove the `Ptr` variants of input/ouptut types for
resources. A `TPtr` input or output is normally generated for `T` if `T`
is present in an `optional(input(T))` or `optional(output(T))` and if
the Go representation for `T` is not nilable. The generation of `Ptr`
variants for resource types breaks the latter rule: the canonical
representation of a resource type named `Foo` is a pointer to a struct
type named `Foo` (i.e. `*Foo`). `Foo` itself is not a resource, as it
does not implement the Go `Resource` interface. Because this
representation already accommodates `nil` to indicate the lack of a
value, we need not generate `FooPtr{Input,Output}` types.
Besides being unnecessary, the implementation of `Ptr` types for
resources was incorrect. Rather than using `**Foo` as their element
type, these types use `*Foo`--identical to the element type used for
the normal input/output types. Furthermore, the generated code for
at least `FooOutput.ToFooPtrOutputWithContext` and `FooPtrOutput.Elem`
was incorrect, making these types virtually unusable in practice.
Finally, these `Ptr` types should never appear on input/output
properties in practice, as the logic we use to generate input and output
type references never generates them for `optional({input,output}(T)).
Instead, it generates references to the standard input/output types.
Though this is _technically_ a breaking change--it changes the set of
exported types for any package that defines resources--I believe that in
practice it will be invisible to users for the reasons stated above.
These types are not usable, and were never referenced.
This is preparatory work for #7943.
2021-11-23 18:24:56 +00:00
|
|
|
return reflect.TypeOf((**Person)(nil)).Elem()
|
2021-09-22 03:48:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func (o PersonOutput) ToPersonOutput() PersonOutput {
|
|
|
|
return o
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o PersonOutput) ToPersonOutputWithContext(ctx context.Context) PersonOutput {
|
|
|
|
return o
|
|
|
|
}
|
|
|
|
|
2022-05-03 18:36:57 +00:00
|
|
|
func (o PersonOutput) Name() pulumi.StringPtrOutput {
|
|
|
|
return o.ApplyT(func(v *Person) pulumi.StringPtrOutput { return v.Name }).(pulumi.StringPtrOutput)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o PersonOutput) Pets() PetTypeArrayOutput {
|
|
|
|
return o.ApplyT(func(v *Person) PetTypeArrayOutput { return v.Pets }).(PetTypeArrayOutput)
|
|
|
|
}
|
|
|
|
|
2021-09-22 03:48:45 +00:00
|
|
|
type PersonArrayOutput struct{ *pulumi.OutputState }
|
|
|
|
|
|
|
|
func (PersonArrayOutput) ElementType() reflect.Type {
|
[codegen/go] Remove ResourcePtr input/output types (#8449)
These changes remove the `Ptr` variants of input/ouptut types for
resources. A `TPtr` input or output is normally generated for `T` if `T`
is present in an `optional(input(T))` or `optional(output(T))` and if
the Go representation for `T` is not nilable. The generation of `Ptr`
variants for resource types breaks the latter rule: the canonical
representation of a resource type named `Foo` is a pointer to a struct
type named `Foo` (i.e. `*Foo`). `Foo` itself is not a resource, as it
does not implement the Go `Resource` interface. Because this
representation already accommodates `nil` to indicate the lack of a
value, we need not generate `FooPtr{Input,Output}` types.
Besides being unnecessary, the implementation of `Ptr` types for
resources was incorrect. Rather than using `**Foo` as their element
type, these types use `*Foo`--identical to the element type used for
the normal input/output types. Furthermore, the generated code for
at least `FooOutput.ToFooPtrOutputWithContext` and `FooPtrOutput.Elem`
was incorrect, making these types virtually unusable in practice.
Finally, these `Ptr` types should never appear on input/output
properties in practice, as the logic we use to generate input and output
type references never generates them for `optional({input,output}(T)).
Instead, it generates references to the standard input/output types.
Though this is _technically_ a breaking change--it changes the set of
exported types for any package that defines resources--I believe that in
practice it will be invisible to users for the reasons stated above.
These types are not usable, and were never referenced.
This is preparatory work for #7943.
2021-11-23 18:24:56 +00:00
|
|
|
return reflect.TypeOf((*[]*Person)(nil)).Elem()
|
2021-09-22 03:48:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func (o PersonArrayOutput) ToPersonArrayOutput() PersonArrayOutput {
|
|
|
|
return o
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o PersonArrayOutput) ToPersonArrayOutputWithContext(ctx context.Context) PersonArrayOutput {
|
|
|
|
return o
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o PersonArrayOutput) Index(i pulumi.IntInput) PersonOutput {
|
[codegen/go] Remove ResourcePtr input/output types (#8449)
These changes remove the `Ptr` variants of input/ouptut types for
resources. A `TPtr` input or output is normally generated for `T` if `T`
is present in an `optional(input(T))` or `optional(output(T))` and if
the Go representation for `T` is not nilable. The generation of `Ptr`
variants for resource types breaks the latter rule: the canonical
representation of a resource type named `Foo` is a pointer to a struct
type named `Foo` (i.e. `*Foo`). `Foo` itself is not a resource, as it
does not implement the Go `Resource` interface. Because this
representation already accommodates `nil` to indicate the lack of a
value, we need not generate `FooPtr{Input,Output}` types.
Besides being unnecessary, the implementation of `Ptr` types for
resources was incorrect. Rather than using `**Foo` as their element
type, these types use `*Foo`--identical to the element type used for
the normal input/output types. Furthermore, the generated code for
at least `FooOutput.ToFooPtrOutputWithContext` and `FooPtrOutput.Elem`
was incorrect, making these types virtually unusable in practice.
Finally, these `Ptr` types should never appear on input/output
properties in practice, as the logic we use to generate input and output
type references never generates them for `optional({input,output}(T)).
Instead, it generates references to the standard input/output types.
Though this is _technically_ a breaking change--it changes the set of
exported types for any package that defines resources--I believe that in
practice it will be invisible to users for the reasons stated above.
These types are not usable, and were never referenced.
This is preparatory work for #7943.
2021-11-23 18:24:56 +00:00
|
|
|
return pulumi.All(o, i).ApplyT(func(vs []interface{}) *Person {
|
|
|
|
return vs[0].([]*Person)[vs[1].(int)]
|
2021-09-22 03:48:45 +00:00
|
|
|
}).(PersonOutput)
|
|
|
|
}
|
|
|
|
|
|
|
|
type PersonMapOutput struct{ *pulumi.OutputState }
|
|
|
|
|
|
|
|
func (PersonMapOutput) ElementType() reflect.Type {
|
[codegen/go] Remove ResourcePtr input/output types (#8449)
These changes remove the `Ptr` variants of input/ouptut types for
resources. A `TPtr` input or output is normally generated for `T` if `T`
is present in an `optional(input(T))` or `optional(output(T))` and if
the Go representation for `T` is not nilable. The generation of `Ptr`
variants for resource types breaks the latter rule: the canonical
representation of a resource type named `Foo` is a pointer to a struct
type named `Foo` (i.e. `*Foo`). `Foo` itself is not a resource, as it
does not implement the Go `Resource` interface. Because this
representation already accommodates `nil` to indicate the lack of a
value, we need not generate `FooPtr{Input,Output}` types.
Besides being unnecessary, the implementation of `Ptr` types for
resources was incorrect. Rather than using `**Foo` as their element
type, these types use `*Foo`--identical to the element type used for
the normal input/output types. Furthermore, the generated code for
at least `FooOutput.ToFooPtrOutputWithContext` and `FooPtrOutput.Elem`
was incorrect, making these types virtually unusable in practice.
Finally, these `Ptr` types should never appear on input/output
properties in practice, as the logic we use to generate input and output
type references never generates them for `optional({input,output}(T)).
Instead, it generates references to the standard input/output types.
Though this is _technically_ a breaking change--it changes the set of
exported types for any package that defines resources--I believe that in
practice it will be invisible to users for the reasons stated above.
These types are not usable, and were never referenced.
This is preparatory work for #7943.
2021-11-23 18:24:56 +00:00
|
|
|
return reflect.TypeOf((*map[string]*Person)(nil)).Elem()
|
2021-09-22 03:48:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func (o PersonMapOutput) ToPersonMapOutput() PersonMapOutput {
|
|
|
|
return o
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o PersonMapOutput) ToPersonMapOutputWithContext(ctx context.Context) PersonMapOutput {
|
|
|
|
return o
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o PersonMapOutput) MapIndex(k pulumi.StringInput) PersonOutput {
|
[codegen/go] Remove ResourcePtr input/output types (#8449)
These changes remove the `Ptr` variants of input/ouptut types for
resources. A `TPtr` input or output is normally generated for `T` if `T`
is present in an `optional(input(T))` or `optional(output(T))` and if
the Go representation for `T` is not nilable. The generation of `Ptr`
variants for resource types breaks the latter rule: the canonical
representation of a resource type named `Foo` is a pointer to a struct
type named `Foo` (i.e. `*Foo`). `Foo` itself is not a resource, as it
does not implement the Go `Resource` interface. Because this
representation already accommodates `nil` to indicate the lack of a
value, we need not generate `FooPtr{Input,Output}` types.
Besides being unnecessary, the implementation of `Ptr` types for
resources was incorrect. Rather than using `**Foo` as their element
type, these types use `*Foo`--identical to the element type used for
the normal input/output types. Furthermore, the generated code for
at least `FooOutput.ToFooPtrOutputWithContext` and `FooPtrOutput.Elem`
was incorrect, making these types virtually unusable in practice.
Finally, these `Ptr` types should never appear on input/output
properties in practice, as the logic we use to generate input and output
type references never generates them for `optional({input,output}(T)).
Instead, it generates references to the standard input/output types.
Though this is _technically_ a breaking change--it changes the set of
exported types for any package that defines resources--I believe that in
practice it will be invisible to users for the reasons stated above.
These types are not usable, and were never referenced.
This is preparatory work for #7943.
2021-11-23 18:24:56 +00:00
|
|
|
return pulumi.All(o, k).ApplyT(func(vs []interface{}) *Person {
|
|
|
|
return vs[0].(map[string]*Person)[vs[1].(string)]
|
2021-09-22 03:48:45 +00:00
|
|
|
}).(PersonOutput)
|
|
|
|
}
|
|
|
|
|
|
|
|
func init() {
|
2021-10-14 17:41:40 +00:00
|
|
|
pulumi.RegisterInputType(reflect.TypeOf((*PersonInput)(nil)).Elem(), &Person{})
|
|
|
|
pulumi.RegisterInputType(reflect.TypeOf((*PersonArrayInput)(nil)).Elem(), PersonArray{})
|
|
|
|
pulumi.RegisterInputType(reflect.TypeOf((*PersonMapInput)(nil)).Elem(), PersonMap{})
|
2021-09-22 03:48:45 +00:00
|
|
|
pulumi.RegisterOutputType(PersonOutput{})
|
|
|
|
pulumi.RegisterOutputType(PersonArrayOutput{})
|
|
|
|
pulumi.RegisterOutputType(PersonMapOutput{})
|
|
|
|
}
|