2559 lines
109 KiB
Go
2559 lines
109 KiB
Go
// *** WARNING: this file was generated by test. ***
|
|
// *** Do not edit by hand unless you're certain you know what you are doing! ***
|
|
|
|
package myedgeorder
|
|
|
|
import (
|
|
"context"
|
|
"reflect"
|
|
|
|
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
|
|
)
|
|
|
|
// Availability information of a product system.
|
|
type AvailabilityInformationResponse struct {
|
|
// Current availability stage of the product. Availability stage
|
|
AvailabilityStage string `pulumi:"availabilityStage"`
|
|
// Reason why the product is disabled.
|
|
DisabledReason string `pulumi:"disabledReason"`
|
|
// Message for why the product is disabled.
|
|
DisabledReasonMessage string `pulumi:"disabledReasonMessage"`
|
|
}
|
|
|
|
// AvailabilityInformationResponseInput is an input type that accepts AvailabilityInformationResponseArgs and AvailabilityInformationResponseOutput values.
|
|
// You can construct a concrete instance of `AvailabilityInformationResponseInput` via:
|
|
//
|
|
// AvailabilityInformationResponseArgs{...}
|
|
type AvailabilityInformationResponseInput interface {
|
|
pulumi.Input
|
|
|
|
ToAvailabilityInformationResponseOutput() AvailabilityInformationResponseOutput
|
|
ToAvailabilityInformationResponseOutputWithContext(context.Context) AvailabilityInformationResponseOutput
|
|
}
|
|
|
|
// Availability information of a product system.
|
|
type AvailabilityInformationResponseArgs struct {
|
|
// Current availability stage of the product. Availability stage
|
|
AvailabilityStage pulumi.StringInput `pulumi:"availabilityStage"`
|
|
// Reason why the product is disabled.
|
|
DisabledReason pulumi.StringInput `pulumi:"disabledReason"`
|
|
// Message for why the product is disabled.
|
|
DisabledReasonMessage pulumi.StringInput `pulumi:"disabledReasonMessage"`
|
|
}
|
|
|
|
func (AvailabilityInformationResponseArgs) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*AvailabilityInformationResponse)(nil)).Elem()
|
|
}
|
|
|
|
func (i AvailabilityInformationResponseArgs) ToAvailabilityInformationResponseOutput() AvailabilityInformationResponseOutput {
|
|
return i.ToAvailabilityInformationResponseOutputWithContext(context.Background())
|
|
}
|
|
|
|
func (i AvailabilityInformationResponseArgs) ToAvailabilityInformationResponseOutputWithContext(ctx context.Context) AvailabilityInformationResponseOutput {
|
|
return pulumi.ToOutputWithContext(ctx, i).(AvailabilityInformationResponseOutput)
|
|
}
|
|
|
|
// Availability information of a product system.
|
|
type AvailabilityInformationResponseOutput struct{ *pulumi.OutputState }
|
|
|
|
func (AvailabilityInformationResponseOutput) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*AvailabilityInformationResponse)(nil)).Elem()
|
|
}
|
|
|
|
func (o AvailabilityInformationResponseOutput) ToAvailabilityInformationResponseOutput() AvailabilityInformationResponseOutput {
|
|
return o
|
|
}
|
|
|
|
func (o AvailabilityInformationResponseOutput) ToAvailabilityInformationResponseOutputWithContext(ctx context.Context) AvailabilityInformationResponseOutput {
|
|
return o
|
|
}
|
|
|
|
// Current availability stage of the product. Availability stage
|
|
func (o AvailabilityInformationResponseOutput) AvailabilityStage() pulumi.StringOutput {
|
|
return o.ApplyT(func(v AvailabilityInformationResponse) string { return v.AvailabilityStage }).(pulumi.StringOutput)
|
|
}
|
|
|
|
// Reason why the product is disabled.
|
|
func (o AvailabilityInformationResponseOutput) DisabledReason() pulumi.StringOutput {
|
|
return o.ApplyT(func(v AvailabilityInformationResponse) string { return v.DisabledReason }).(pulumi.StringOutput)
|
|
}
|
|
|
|
// Message for why the product is disabled.
|
|
func (o AvailabilityInformationResponseOutput) DisabledReasonMessage() pulumi.StringOutput {
|
|
return o.ApplyT(func(v AvailabilityInformationResponse) string { return v.DisabledReasonMessage }).(pulumi.StringOutput)
|
|
}
|
|
|
|
// Holds billing meter details for each type of billing
|
|
type BillingMeterDetailsResponse struct {
|
|
// Frequency of recurrence
|
|
Frequency string `pulumi:"frequency"`
|
|
// Represents MeterDetails
|
|
MeterDetails interface{} `pulumi:"meterDetails"`
|
|
// Represents Metering type (eg one-time or recurrent)
|
|
MeteringType string `pulumi:"meteringType"`
|
|
// Represents Billing type name
|
|
Name string `pulumi:"name"`
|
|
}
|
|
|
|
// BillingMeterDetailsResponseInput is an input type that accepts BillingMeterDetailsResponseArgs and BillingMeterDetailsResponseOutput values.
|
|
// You can construct a concrete instance of `BillingMeterDetailsResponseInput` via:
|
|
//
|
|
// BillingMeterDetailsResponseArgs{...}
|
|
type BillingMeterDetailsResponseInput interface {
|
|
pulumi.Input
|
|
|
|
ToBillingMeterDetailsResponseOutput() BillingMeterDetailsResponseOutput
|
|
ToBillingMeterDetailsResponseOutputWithContext(context.Context) BillingMeterDetailsResponseOutput
|
|
}
|
|
|
|
// Holds billing meter details for each type of billing
|
|
type BillingMeterDetailsResponseArgs struct {
|
|
// Frequency of recurrence
|
|
Frequency pulumi.StringInput `pulumi:"frequency"`
|
|
// Represents MeterDetails
|
|
MeterDetails pulumi.Input `pulumi:"meterDetails"`
|
|
// Represents Metering type (eg one-time or recurrent)
|
|
MeteringType pulumi.StringInput `pulumi:"meteringType"`
|
|
// Represents Billing type name
|
|
Name pulumi.StringInput `pulumi:"name"`
|
|
}
|
|
|
|
func (BillingMeterDetailsResponseArgs) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*BillingMeterDetailsResponse)(nil)).Elem()
|
|
}
|
|
|
|
func (i BillingMeterDetailsResponseArgs) ToBillingMeterDetailsResponseOutput() BillingMeterDetailsResponseOutput {
|
|
return i.ToBillingMeterDetailsResponseOutputWithContext(context.Background())
|
|
}
|
|
|
|
func (i BillingMeterDetailsResponseArgs) ToBillingMeterDetailsResponseOutputWithContext(ctx context.Context) BillingMeterDetailsResponseOutput {
|
|
return pulumi.ToOutputWithContext(ctx, i).(BillingMeterDetailsResponseOutput)
|
|
}
|
|
|
|
// BillingMeterDetailsResponseArrayInput is an input type that accepts BillingMeterDetailsResponseArray and BillingMeterDetailsResponseArrayOutput values.
|
|
// You can construct a concrete instance of `BillingMeterDetailsResponseArrayInput` via:
|
|
//
|
|
// BillingMeterDetailsResponseArray{ BillingMeterDetailsResponseArgs{...} }
|
|
type BillingMeterDetailsResponseArrayInput interface {
|
|
pulumi.Input
|
|
|
|
ToBillingMeterDetailsResponseArrayOutput() BillingMeterDetailsResponseArrayOutput
|
|
ToBillingMeterDetailsResponseArrayOutputWithContext(context.Context) BillingMeterDetailsResponseArrayOutput
|
|
}
|
|
|
|
type BillingMeterDetailsResponseArray []BillingMeterDetailsResponseInput
|
|
|
|
func (BillingMeterDetailsResponseArray) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*[]BillingMeterDetailsResponse)(nil)).Elem()
|
|
}
|
|
|
|
func (i BillingMeterDetailsResponseArray) ToBillingMeterDetailsResponseArrayOutput() BillingMeterDetailsResponseArrayOutput {
|
|
return i.ToBillingMeterDetailsResponseArrayOutputWithContext(context.Background())
|
|
}
|
|
|
|
func (i BillingMeterDetailsResponseArray) ToBillingMeterDetailsResponseArrayOutputWithContext(ctx context.Context) BillingMeterDetailsResponseArrayOutput {
|
|
return pulumi.ToOutputWithContext(ctx, i).(BillingMeterDetailsResponseArrayOutput)
|
|
}
|
|
|
|
// Holds billing meter details for each type of billing
|
|
type BillingMeterDetailsResponseOutput struct{ *pulumi.OutputState }
|
|
|
|
func (BillingMeterDetailsResponseOutput) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*BillingMeterDetailsResponse)(nil)).Elem()
|
|
}
|
|
|
|
func (o BillingMeterDetailsResponseOutput) ToBillingMeterDetailsResponseOutput() BillingMeterDetailsResponseOutput {
|
|
return o
|
|
}
|
|
|
|
func (o BillingMeterDetailsResponseOutput) ToBillingMeterDetailsResponseOutputWithContext(ctx context.Context) BillingMeterDetailsResponseOutput {
|
|
return o
|
|
}
|
|
|
|
// Frequency of recurrence
|
|
func (o BillingMeterDetailsResponseOutput) Frequency() pulumi.StringOutput {
|
|
return o.ApplyT(func(v BillingMeterDetailsResponse) string { return v.Frequency }).(pulumi.StringOutput)
|
|
}
|
|
|
|
// Represents MeterDetails
|
|
func (o BillingMeterDetailsResponseOutput) MeterDetails() pulumi.AnyOutput {
|
|
return o.ApplyT(func(v BillingMeterDetailsResponse) interface{} { return v.MeterDetails }).(pulumi.AnyOutput)
|
|
}
|
|
|
|
// Represents Metering type (eg one-time or recurrent)
|
|
func (o BillingMeterDetailsResponseOutput) MeteringType() pulumi.StringOutput {
|
|
return o.ApplyT(func(v BillingMeterDetailsResponse) string { return v.MeteringType }).(pulumi.StringOutput)
|
|
}
|
|
|
|
// Represents Billing type name
|
|
func (o BillingMeterDetailsResponseOutput) Name() pulumi.StringOutput {
|
|
return o.ApplyT(func(v BillingMeterDetailsResponse) string { return v.Name }).(pulumi.StringOutput)
|
|
}
|
|
|
|
type BillingMeterDetailsResponseArrayOutput struct{ *pulumi.OutputState }
|
|
|
|
func (BillingMeterDetailsResponseArrayOutput) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*[]BillingMeterDetailsResponse)(nil)).Elem()
|
|
}
|
|
|
|
func (o BillingMeterDetailsResponseArrayOutput) ToBillingMeterDetailsResponseArrayOutput() BillingMeterDetailsResponseArrayOutput {
|
|
return o
|
|
}
|
|
|
|
func (o BillingMeterDetailsResponseArrayOutput) ToBillingMeterDetailsResponseArrayOutputWithContext(ctx context.Context) BillingMeterDetailsResponseArrayOutput {
|
|
return o
|
|
}
|
|
|
|
func (o BillingMeterDetailsResponseArrayOutput) Index(i pulumi.IntInput) BillingMeterDetailsResponseOutput {
|
|
return pulumi.All(o, i).ApplyT(func(vs []interface{}) BillingMeterDetailsResponse {
|
|
return vs[0].([]BillingMeterDetailsResponse)[vs[1].(int)]
|
|
}).(BillingMeterDetailsResponseOutput)
|
|
}
|
|
|
|
// Configuration filters
|
|
type ConfigurationFilters struct {
|
|
// Filters specific to product
|
|
FilterableProperty []FilterableProperty `pulumi:"filterableProperty"`
|
|
// Product hierarchy information
|
|
HierarchyInformation HierarchyInformation `pulumi:"hierarchyInformation"`
|
|
}
|
|
|
|
// ConfigurationFiltersInput is an input type that accepts ConfigurationFiltersArgs and ConfigurationFiltersOutput values.
|
|
// You can construct a concrete instance of `ConfigurationFiltersInput` via:
|
|
//
|
|
// ConfigurationFiltersArgs{...}
|
|
type ConfigurationFiltersInput interface {
|
|
pulumi.Input
|
|
|
|
ToConfigurationFiltersOutput() ConfigurationFiltersOutput
|
|
ToConfigurationFiltersOutputWithContext(context.Context) ConfigurationFiltersOutput
|
|
}
|
|
|
|
// Configuration filters
|
|
type ConfigurationFiltersArgs struct {
|
|
// Filters specific to product
|
|
FilterableProperty FilterablePropertyArrayInput `pulumi:"filterableProperty"`
|
|
// Product hierarchy information
|
|
HierarchyInformation HierarchyInformationInput `pulumi:"hierarchyInformation"`
|
|
}
|
|
|
|
func (ConfigurationFiltersArgs) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*ConfigurationFilters)(nil)).Elem()
|
|
}
|
|
|
|
func (i ConfigurationFiltersArgs) ToConfigurationFiltersOutput() ConfigurationFiltersOutput {
|
|
return i.ToConfigurationFiltersOutputWithContext(context.Background())
|
|
}
|
|
|
|
func (i ConfigurationFiltersArgs) ToConfigurationFiltersOutputWithContext(ctx context.Context) ConfigurationFiltersOutput {
|
|
return pulumi.ToOutputWithContext(ctx, i).(ConfigurationFiltersOutput)
|
|
}
|
|
|
|
// ConfigurationFiltersArrayInput is an input type that accepts ConfigurationFiltersArray and ConfigurationFiltersArrayOutput values.
|
|
// You can construct a concrete instance of `ConfigurationFiltersArrayInput` via:
|
|
//
|
|
// ConfigurationFiltersArray{ ConfigurationFiltersArgs{...} }
|
|
type ConfigurationFiltersArrayInput interface {
|
|
pulumi.Input
|
|
|
|
ToConfigurationFiltersArrayOutput() ConfigurationFiltersArrayOutput
|
|
ToConfigurationFiltersArrayOutputWithContext(context.Context) ConfigurationFiltersArrayOutput
|
|
}
|
|
|
|
type ConfigurationFiltersArray []ConfigurationFiltersInput
|
|
|
|
func (ConfigurationFiltersArray) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*[]ConfigurationFilters)(nil)).Elem()
|
|
}
|
|
|
|
func (i ConfigurationFiltersArray) ToConfigurationFiltersArrayOutput() ConfigurationFiltersArrayOutput {
|
|
return i.ToConfigurationFiltersArrayOutputWithContext(context.Background())
|
|
}
|
|
|
|
func (i ConfigurationFiltersArray) ToConfigurationFiltersArrayOutputWithContext(ctx context.Context) ConfigurationFiltersArrayOutput {
|
|
return pulumi.ToOutputWithContext(ctx, i).(ConfigurationFiltersArrayOutput)
|
|
}
|
|
|
|
// Configuration filters
|
|
type ConfigurationFiltersOutput struct{ *pulumi.OutputState }
|
|
|
|
func (ConfigurationFiltersOutput) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*ConfigurationFilters)(nil)).Elem()
|
|
}
|
|
|
|
func (o ConfigurationFiltersOutput) ToConfigurationFiltersOutput() ConfigurationFiltersOutput {
|
|
return o
|
|
}
|
|
|
|
func (o ConfigurationFiltersOutput) ToConfigurationFiltersOutputWithContext(ctx context.Context) ConfigurationFiltersOutput {
|
|
return o
|
|
}
|
|
|
|
// Filters specific to product
|
|
func (o ConfigurationFiltersOutput) FilterableProperty() FilterablePropertyArrayOutput {
|
|
return o.ApplyT(func(v ConfigurationFilters) []FilterableProperty { return v.FilterableProperty }).(FilterablePropertyArrayOutput)
|
|
}
|
|
|
|
// Product hierarchy information
|
|
func (o ConfigurationFiltersOutput) HierarchyInformation() HierarchyInformationOutput {
|
|
return o.ApplyT(func(v ConfigurationFilters) HierarchyInformation { return v.HierarchyInformation }).(HierarchyInformationOutput)
|
|
}
|
|
|
|
type ConfigurationFiltersArrayOutput struct{ *pulumi.OutputState }
|
|
|
|
func (ConfigurationFiltersArrayOutput) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*[]ConfigurationFilters)(nil)).Elem()
|
|
}
|
|
|
|
func (o ConfigurationFiltersArrayOutput) ToConfigurationFiltersArrayOutput() ConfigurationFiltersArrayOutput {
|
|
return o
|
|
}
|
|
|
|
func (o ConfigurationFiltersArrayOutput) ToConfigurationFiltersArrayOutputWithContext(ctx context.Context) ConfigurationFiltersArrayOutput {
|
|
return o
|
|
}
|
|
|
|
func (o ConfigurationFiltersArrayOutput) Index(i pulumi.IntInput) ConfigurationFiltersOutput {
|
|
return pulumi.All(o, i).ApplyT(func(vs []interface{}) ConfigurationFilters {
|
|
return vs[0].([]ConfigurationFilters)[vs[1].(int)]
|
|
}).(ConfigurationFiltersOutput)
|
|
}
|
|
|
|
// Configuration object.
|
|
type ConfigurationResponse struct {
|
|
// Availability information of the product system.
|
|
AvailabilityInformation AvailabilityInformationResponse `pulumi:"availabilityInformation"`
|
|
// Cost information for the product system.
|
|
CostInformation CostInformationResponse `pulumi:"costInformation"`
|
|
// Description related to the product system.
|
|
Description DescriptionResponse `pulumi:"description"`
|
|
// Dimensions of the configuration
|
|
Dimensions DimensionsResponse `pulumi:"dimensions"`
|
|
// Display Name for the product system.
|
|
DisplayName string `pulumi:"displayName"`
|
|
// list of filters supported for a product
|
|
FilterableProperties []FilterablePropertyResponse `pulumi:"filterableProperties"`
|
|
// Hierarchy information of a product.
|
|
HierarchyInformation HierarchyInformationResponse `pulumi:"hierarchyInformation"`
|
|
// Image information for the product system.
|
|
ImageInformation []ImageInformationResponse `pulumi:"imageInformation"`
|
|
// Specifications of the configuration
|
|
Specifications []SpecificationResponse `pulumi:"specifications"`
|
|
}
|
|
|
|
// ConfigurationResponseInput is an input type that accepts ConfigurationResponseArgs and ConfigurationResponseOutput values.
|
|
// You can construct a concrete instance of `ConfigurationResponseInput` via:
|
|
//
|
|
// ConfigurationResponseArgs{...}
|
|
type ConfigurationResponseInput interface {
|
|
pulumi.Input
|
|
|
|
ToConfigurationResponseOutput() ConfigurationResponseOutput
|
|
ToConfigurationResponseOutputWithContext(context.Context) ConfigurationResponseOutput
|
|
}
|
|
|
|
// Configuration object.
|
|
type ConfigurationResponseArgs struct {
|
|
// Availability information of the product system.
|
|
AvailabilityInformation AvailabilityInformationResponseInput `pulumi:"availabilityInformation"`
|
|
// Cost information for the product system.
|
|
CostInformation CostInformationResponseInput `pulumi:"costInformation"`
|
|
// Description related to the product system.
|
|
Description DescriptionResponseInput `pulumi:"description"`
|
|
// Dimensions of the configuration
|
|
Dimensions DimensionsResponseInput `pulumi:"dimensions"`
|
|
// Display Name for the product system.
|
|
DisplayName pulumi.StringInput `pulumi:"displayName"`
|
|
// list of filters supported for a product
|
|
FilterableProperties FilterablePropertyResponseArrayInput `pulumi:"filterableProperties"`
|
|
// Hierarchy information of a product.
|
|
HierarchyInformation HierarchyInformationResponseInput `pulumi:"hierarchyInformation"`
|
|
// Image information for the product system.
|
|
ImageInformation ImageInformationResponseArrayInput `pulumi:"imageInformation"`
|
|
// Specifications of the configuration
|
|
Specifications SpecificationResponseArrayInput `pulumi:"specifications"`
|
|
}
|
|
|
|
func (ConfigurationResponseArgs) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*ConfigurationResponse)(nil)).Elem()
|
|
}
|
|
|
|
func (i ConfigurationResponseArgs) ToConfigurationResponseOutput() ConfigurationResponseOutput {
|
|
return i.ToConfigurationResponseOutputWithContext(context.Background())
|
|
}
|
|
|
|
func (i ConfigurationResponseArgs) ToConfigurationResponseOutputWithContext(ctx context.Context) ConfigurationResponseOutput {
|
|
return pulumi.ToOutputWithContext(ctx, i).(ConfigurationResponseOutput)
|
|
}
|
|
|
|
// ConfigurationResponseArrayInput is an input type that accepts ConfigurationResponseArray and ConfigurationResponseArrayOutput values.
|
|
// You can construct a concrete instance of `ConfigurationResponseArrayInput` via:
|
|
//
|
|
// ConfigurationResponseArray{ ConfigurationResponseArgs{...} }
|
|
type ConfigurationResponseArrayInput interface {
|
|
pulumi.Input
|
|
|
|
ToConfigurationResponseArrayOutput() ConfigurationResponseArrayOutput
|
|
ToConfigurationResponseArrayOutputWithContext(context.Context) ConfigurationResponseArrayOutput
|
|
}
|
|
|
|
type ConfigurationResponseArray []ConfigurationResponseInput
|
|
|
|
func (ConfigurationResponseArray) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*[]ConfigurationResponse)(nil)).Elem()
|
|
}
|
|
|
|
func (i ConfigurationResponseArray) ToConfigurationResponseArrayOutput() ConfigurationResponseArrayOutput {
|
|
return i.ToConfigurationResponseArrayOutputWithContext(context.Background())
|
|
}
|
|
|
|
func (i ConfigurationResponseArray) ToConfigurationResponseArrayOutputWithContext(ctx context.Context) ConfigurationResponseArrayOutput {
|
|
return pulumi.ToOutputWithContext(ctx, i).(ConfigurationResponseArrayOutput)
|
|
}
|
|
|
|
// Configuration object.
|
|
type ConfigurationResponseOutput struct{ *pulumi.OutputState }
|
|
|
|
func (ConfigurationResponseOutput) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*ConfigurationResponse)(nil)).Elem()
|
|
}
|
|
|
|
func (o ConfigurationResponseOutput) ToConfigurationResponseOutput() ConfigurationResponseOutput {
|
|
return o
|
|
}
|
|
|
|
func (o ConfigurationResponseOutput) ToConfigurationResponseOutputWithContext(ctx context.Context) ConfigurationResponseOutput {
|
|
return o
|
|
}
|
|
|
|
// Availability information of the product system.
|
|
func (o ConfigurationResponseOutput) AvailabilityInformation() AvailabilityInformationResponseOutput {
|
|
return o.ApplyT(func(v ConfigurationResponse) AvailabilityInformationResponse { return v.AvailabilityInformation }).(AvailabilityInformationResponseOutput)
|
|
}
|
|
|
|
// Cost information for the product system.
|
|
func (o ConfigurationResponseOutput) CostInformation() CostInformationResponseOutput {
|
|
return o.ApplyT(func(v ConfigurationResponse) CostInformationResponse { return v.CostInformation }).(CostInformationResponseOutput)
|
|
}
|
|
|
|
// Description related to the product system.
|
|
func (o ConfigurationResponseOutput) Description() DescriptionResponseOutput {
|
|
return o.ApplyT(func(v ConfigurationResponse) DescriptionResponse { return v.Description }).(DescriptionResponseOutput)
|
|
}
|
|
|
|
// Dimensions of the configuration
|
|
func (o ConfigurationResponseOutput) Dimensions() DimensionsResponseOutput {
|
|
return o.ApplyT(func(v ConfigurationResponse) DimensionsResponse { return v.Dimensions }).(DimensionsResponseOutput)
|
|
}
|
|
|
|
// Display Name for the product system.
|
|
func (o ConfigurationResponseOutput) DisplayName() pulumi.StringOutput {
|
|
return o.ApplyT(func(v ConfigurationResponse) string { return v.DisplayName }).(pulumi.StringOutput)
|
|
}
|
|
|
|
// list of filters supported for a product
|
|
func (o ConfigurationResponseOutput) FilterableProperties() FilterablePropertyResponseArrayOutput {
|
|
return o.ApplyT(func(v ConfigurationResponse) []FilterablePropertyResponse { return v.FilterableProperties }).(FilterablePropertyResponseArrayOutput)
|
|
}
|
|
|
|
// Hierarchy information of a product.
|
|
func (o ConfigurationResponseOutput) HierarchyInformation() HierarchyInformationResponseOutput {
|
|
return o.ApplyT(func(v ConfigurationResponse) HierarchyInformationResponse { return v.HierarchyInformation }).(HierarchyInformationResponseOutput)
|
|
}
|
|
|
|
// Image information for the product system.
|
|
func (o ConfigurationResponseOutput) ImageInformation() ImageInformationResponseArrayOutput {
|
|
return o.ApplyT(func(v ConfigurationResponse) []ImageInformationResponse { return v.ImageInformation }).(ImageInformationResponseArrayOutput)
|
|
}
|
|
|
|
// Specifications of the configuration
|
|
func (o ConfigurationResponseOutput) Specifications() SpecificationResponseArrayOutput {
|
|
return o.ApplyT(func(v ConfigurationResponse) []SpecificationResponse { return v.Specifications }).(SpecificationResponseArrayOutput)
|
|
}
|
|
|
|
type ConfigurationResponseArrayOutput struct{ *pulumi.OutputState }
|
|
|
|
func (ConfigurationResponseArrayOutput) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*[]ConfigurationResponse)(nil)).Elem()
|
|
}
|
|
|
|
func (o ConfigurationResponseArrayOutput) ToConfigurationResponseArrayOutput() ConfigurationResponseArrayOutput {
|
|
return o
|
|
}
|
|
|
|
func (o ConfigurationResponseArrayOutput) ToConfigurationResponseArrayOutputWithContext(ctx context.Context) ConfigurationResponseArrayOutput {
|
|
return o
|
|
}
|
|
|
|
func (o ConfigurationResponseArrayOutput) Index(i pulumi.IntInput) ConfigurationResponseOutput {
|
|
return pulumi.All(o, i).ApplyT(func(vs []interface{}) ConfigurationResponse {
|
|
return vs[0].([]ConfigurationResponse)[vs[1].(int)]
|
|
}).(ConfigurationResponseOutput)
|
|
}
|
|
|
|
// Cost information for the product system
|
|
type CostInformationResponse struct {
|
|
// Default url to display billing information
|
|
BillingInfoUrl string `pulumi:"billingInfoUrl"`
|
|
// Details on the various billing aspects for the product system.
|
|
BillingMeterDetails []BillingMeterDetailsResponse `pulumi:"billingMeterDetails"`
|
|
}
|
|
|
|
// CostInformationResponseInput is an input type that accepts CostInformationResponseArgs and CostInformationResponseOutput values.
|
|
// You can construct a concrete instance of `CostInformationResponseInput` via:
|
|
//
|
|
// CostInformationResponseArgs{...}
|
|
type CostInformationResponseInput interface {
|
|
pulumi.Input
|
|
|
|
ToCostInformationResponseOutput() CostInformationResponseOutput
|
|
ToCostInformationResponseOutputWithContext(context.Context) CostInformationResponseOutput
|
|
}
|
|
|
|
// Cost information for the product system
|
|
type CostInformationResponseArgs struct {
|
|
// Default url to display billing information
|
|
BillingInfoUrl pulumi.StringInput `pulumi:"billingInfoUrl"`
|
|
// Details on the various billing aspects for the product system.
|
|
BillingMeterDetails BillingMeterDetailsResponseArrayInput `pulumi:"billingMeterDetails"`
|
|
}
|
|
|
|
func (CostInformationResponseArgs) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*CostInformationResponse)(nil)).Elem()
|
|
}
|
|
|
|
func (i CostInformationResponseArgs) ToCostInformationResponseOutput() CostInformationResponseOutput {
|
|
return i.ToCostInformationResponseOutputWithContext(context.Background())
|
|
}
|
|
|
|
func (i CostInformationResponseArgs) ToCostInformationResponseOutputWithContext(ctx context.Context) CostInformationResponseOutput {
|
|
return pulumi.ToOutputWithContext(ctx, i).(CostInformationResponseOutput)
|
|
}
|
|
|
|
// Cost information for the product system
|
|
type CostInformationResponseOutput struct{ *pulumi.OutputState }
|
|
|
|
func (CostInformationResponseOutput) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*CostInformationResponse)(nil)).Elem()
|
|
}
|
|
|
|
func (o CostInformationResponseOutput) ToCostInformationResponseOutput() CostInformationResponseOutput {
|
|
return o
|
|
}
|
|
|
|
func (o CostInformationResponseOutput) ToCostInformationResponseOutputWithContext(ctx context.Context) CostInformationResponseOutput {
|
|
return o
|
|
}
|
|
|
|
// Default url to display billing information
|
|
func (o CostInformationResponseOutput) BillingInfoUrl() pulumi.StringOutput {
|
|
return o.ApplyT(func(v CostInformationResponse) string { return v.BillingInfoUrl }).(pulumi.StringOutput)
|
|
}
|
|
|
|
// Details on the various billing aspects for the product system.
|
|
func (o CostInformationResponseOutput) BillingMeterDetails() BillingMeterDetailsResponseArrayOutput {
|
|
return o.ApplyT(func(v CostInformationResponse) []BillingMeterDetailsResponse { return v.BillingMeterDetails }).(BillingMeterDetailsResponseArrayOutput)
|
|
}
|
|
|
|
// Holds Customer subscription details. Clients can display available products to unregistered customers by explicitly passing subscription details
|
|
type CustomerSubscriptionDetails struct {
|
|
// Location placement Id of a subscription
|
|
LocationPlacementId *string `pulumi:"locationPlacementId"`
|
|
// Quota ID of a subscription
|
|
QuotaId string `pulumi:"quotaId"`
|
|
// List of registered feature flags for subscription
|
|
RegisteredFeatures []CustomerSubscriptionRegisteredFeatures `pulumi:"registeredFeatures"`
|
|
}
|
|
|
|
// CustomerSubscriptionDetailsInput is an input type that accepts CustomerSubscriptionDetailsArgs and CustomerSubscriptionDetailsOutput values.
|
|
// You can construct a concrete instance of `CustomerSubscriptionDetailsInput` via:
|
|
//
|
|
// CustomerSubscriptionDetailsArgs{...}
|
|
type CustomerSubscriptionDetailsInput interface {
|
|
pulumi.Input
|
|
|
|
ToCustomerSubscriptionDetailsOutput() CustomerSubscriptionDetailsOutput
|
|
ToCustomerSubscriptionDetailsOutputWithContext(context.Context) CustomerSubscriptionDetailsOutput
|
|
}
|
|
|
|
// Holds Customer subscription details. Clients can display available products to unregistered customers by explicitly passing subscription details
|
|
type CustomerSubscriptionDetailsArgs struct {
|
|
// Location placement Id of a subscription
|
|
LocationPlacementId pulumi.StringPtrInput `pulumi:"locationPlacementId"`
|
|
// Quota ID of a subscription
|
|
QuotaId pulumi.StringInput `pulumi:"quotaId"`
|
|
// List of registered feature flags for subscription
|
|
RegisteredFeatures CustomerSubscriptionRegisteredFeaturesArrayInput `pulumi:"registeredFeatures"`
|
|
}
|
|
|
|
func (CustomerSubscriptionDetailsArgs) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*CustomerSubscriptionDetails)(nil)).Elem()
|
|
}
|
|
|
|
func (i CustomerSubscriptionDetailsArgs) ToCustomerSubscriptionDetailsOutput() CustomerSubscriptionDetailsOutput {
|
|
return i.ToCustomerSubscriptionDetailsOutputWithContext(context.Background())
|
|
}
|
|
|
|
func (i CustomerSubscriptionDetailsArgs) ToCustomerSubscriptionDetailsOutputWithContext(ctx context.Context) CustomerSubscriptionDetailsOutput {
|
|
return pulumi.ToOutputWithContext(ctx, i).(CustomerSubscriptionDetailsOutput)
|
|
}
|
|
|
|
func (i CustomerSubscriptionDetailsArgs) ToCustomerSubscriptionDetailsPtrOutput() CustomerSubscriptionDetailsPtrOutput {
|
|
return i.ToCustomerSubscriptionDetailsPtrOutputWithContext(context.Background())
|
|
}
|
|
|
|
func (i CustomerSubscriptionDetailsArgs) ToCustomerSubscriptionDetailsPtrOutputWithContext(ctx context.Context) CustomerSubscriptionDetailsPtrOutput {
|
|
return pulumi.ToOutputWithContext(ctx, i).(CustomerSubscriptionDetailsOutput).ToCustomerSubscriptionDetailsPtrOutputWithContext(ctx)
|
|
}
|
|
|
|
// CustomerSubscriptionDetailsPtrInput is an input type that accepts CustomerSubscriptionDetailsArgs, CustomerSubscriptionDetailsPtr and CustomerSubscriptionDetailsPtrOutput values.
|
|
// You can construct a concrete instance of `CustomerSubscriptionDetailsPtrInput` via:
|
|
//
|
|
// CustomerSubscriptionDetailsArgs{...}
|
|
//
|
|
// or:
|
|
//
|
|
// nil
|
|
type CustomerSubscriptionDetailsPtrInput interface {
|
|
pulumi.Input
|
|
|
|
ToCustomerSubscriptionDetailsPtrOutput() CustomerSubscriptionDetailsPtrOutput
|
|
ToCustomerSubscriptionDetailsPtrOutputWithContext(context.Context) CustomerSubscriptionDetailsPtrOutput
|
|
}
|
|
|
|
type customerSubscriptionDetailsPtrType CustomerSubscriptionDetailsArgs
|
|
|
|
func CustomerSubscriptionDetailsPtr(v *CustomerSubscriptionDetailsArgs) CustomerSubscriptionDetailsPtrInput {
|
|
return (*customerSubscriptionDetailsPtrType)(v)
|
|
}
|
|
|
|
func (*customerSubscriptionDetailsPtrType) ElementType() reflect.Type {
|
|
return reflect.TypeOf((**CustomerSubscriptionDetails)(nil)).Elem()
|
|
}
|
|
|
|
func (i *customerSubscriptionDetailsPtrType) ToCustomerSubscriptionDetailsPtrOutput() CustomerSubscriptionDetailsPtrOutput {
|
|
return i.ToCustomerSubscriptionDetailsPtrOutputWithContext(context.Background())
|
|
}
|
|
|
|
func (i *customerSubscriptionDetailsPtrType) ToCustomerSubscriptionDetailsPtrOutputWithContext(ctx context.Context) CustomerSubscriptionDetailsPtrOutput {
|
|
return pulumi.ToOutputWithContext(ctx, i).(CustomerSubscriptionDetailsPtrOutput)
|
|
}
|
|
|
|
// Holds Customer subscription details. Clients can display available products to unregistered customers by explicitly passing subscription details
|
|
type CustomerSubscriptionDetailsOutput struct{ *pulumi.OutputState }
|
|
|
|
func (CustomerSubscriptionDetailsOutput) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*CustomerSubscriptionDetails)(nil)).Elem()
|
|
}
|
|
|
|
func (o CustomerSubscriptionDetailsOutput) ToCustomerSubscriptionDetailsOutput() CustomerSubscriptionDetailsOutput {
|
|
return o
|
|
}
|
|
|
|
func (o CustomerSubscriptionDetailsOutput) ToCustomerSubscriptionDetailsOutputWithContext(ctx context.Context) CustomerSubscriptionDetailsOutput {
|
|
return o
|
|
}
|
|
|
|
func (o CustomerSubscriptionDetailsOutput) ToCustomerSubscriptionDetailsPtrOutput() CustomerSubscriptionDetailsPtrOutput {
|
|
return o.ToCustomerSubscriptionDetailsPtrOutputWithContext(context.Background())
|
|
}
|
|
|
|
func (o CustomerSubscriptionDetailsOutput) ToCustomerSubscriptionDetailsPtrOutputWithContext(ctx context.Context) CustomerSubscriptionDetailsPtrOutput {
|
|
return o.ApplyTWithContext(ctx, func(_ context.Context, v CustomerSubscriptionDetails) *CustomerSubscriptionDetails {
|
|
return &v
|
|
}).(CustomerSubscriptionDetailsPtrOutput)
|
|
}
|
|
|
|
// Location placement Id of a subscription
|
|
func (o CustomerSubscriptionDetailsOutput) LocationPlacementId() pulumi.StringPtrOutput {
|
|
return o.ApplyT(func(v CustomerSubscriptionDetails) *string { return v.LocationPlacementId }).(pulumi.StringPtrOutput)
|
|
}
|
|
|
|
// Quota ID of a subscription
|
|
func (o CustomerSubscriptionDetailsOutput) QuotaId() pulumi.StringOutput {
|
|
return o.ApplyT(func(v CustomerSubscriptionDetails) string { return v.QuotaId }).(pulumi.StringOutput)
|
|
}
|
|
|
|
// List of registered feature flags for subscription
|
|
func (o CustomerSubscriptionDetailsOutput) RegisteredFeatures() CustomerSubscriptionRegisteredFeaturesArrayOutput {
|
|
return o.ApplyT(func(v CustomerSubscriptionDetails) []CustomerSubscriptionRegisteredFeatures {
|
|
return v.RegisteredFeatures
|
|
}).(CustomerSubscriptionRegisteredFeaturesArrayOutput)
|
|
}
|
|
|
|
type CustomerSubscriptionDetailsPtrOutput struct{ *pulumi.OutputState }
|
|
|
|
func (CustomerSubscriptionDetailsPtrOutput) ElementType() reflect.Type {
|
|
return reflect.TypeOf((**CustomerSubscriptionDetails)(nil)).Elem()
|
|
}
|
|
|
|
func (o CustomerSubscriptionDetailsPtrOutput) ToCustomerSubscriptionDetailsPtrOutput() CustomerSubscriptionDetailsPtrOutput {
|
|
return o
|
|
}
|
|
|
|
func (o CustomerSubscriptionDetailsPtrOutput) ToCustomerSubscriptionDetailsPtrOutputWithContext(ctx context.Context) CustomerSubscriptionDetailsPtrOutput {
|
|
return o
|
|
}
|
|
|
|
func (o CustomerSubscriptionDetailsPtrOutput) Elem() CustomerSubscriptionDetailsOutput {
|
|
return o.ApplyT(func(v *CustomerSubscriptionDetails) CustomerSubscriptionDetails {
|
|
if v != nil {
|
|
return *v
|
|
}
|
|
var ret CustomerSubscriptionDetails
|
|
return ret
|
|
}).(CustomerSubscriptionDetailsOutput)
|
|
}
|
|
|
|
// Location placement Id of a subscription
|
|
func (o CustomerSubscriptionDetailsPtrOutput) LocationPlacementId() pulumi.StringPtrOutput {
|
|
return o.ApplyT(func(v *CustomerSubscriptionDetails) *string {
|
|
if v == nil {
|
|
return nil
|
|
}
|
|
return v.LocationPlacementId
|
|
}).(pulumi.StringPtrOutput)
|
|
}
|
|
|
|
// Quota ID of a subscription
|
|
func (o CustomerSubscriptionDetailsPtrOutput) QuotaId() pulumi.StringPtrOutput {
|
|
return o.ApplyT(func(v *CustomerSubscriptionDetails) *string {
|
|
if v == nil {
|
|
return nil
|
|
}
|
|
return &v.QuotaId
|
|
}).(pulumi.StringPtrOutput)
|
|
}
|
|
|
|
// List of registered feature flags for subscription
|
|
func (o CustomerSubscriptionDetailsPtrOutput) RegisteredFeatures() CustomerSubscriptionRegisteredFeaturesArrayOutput {
|
|
return o.ApplyT(func(v *CustomerSubscriptionDetails) []CustomerSubscriptionRegisteredFeatures {
|
|
if v == nil {
|
|
return nil
|
|
}
|
|
return v.RegisteredFeatures
|
|
}).(CustomerSubscriptionRegisteredFeaturesArrayOutput)
|
|
}
|
|
|
|
// Represents subscription registered features
|
|
type CustomerSubscriptionRegisteredFeatures struct {
|
|
// Name of subscription registered feature
|
|
Name *string `pulumi:"name"`
|
|
// State of subscription registered feature
|
|
State *string `pulumi:"state"`
|
|
}
|
|
|
|
// CustomerSubscriptionRegisteredFeaturesInput is an input type that accepts CustomerSubscriptionRegisteredFeaturesArgs and CustomerSubscriptionRegisteredFeaturesOutput values.
|
|
// You can construct a concrete instance of `CustomerSubscriptionRegisteredFeaturesInput` via:
|
|
//
|
|
// CustomerSubscriptionRegisteredFeaturesArgs{...}
|
|
type CustomerSubscriptionRegisteredFeaturesInput interface {
|
|
pulumi.Input
|
|
|
|
ToCustomerSubscriptionRegisteredFeaturesOutput() CustomerSubscriptionRegisteredFeaturesOutput
|
|
ToCustomerSubscriptionRegisteredFeaturesOutputWithContext(context.Context) CustomerSubscriptionRegisteredFeaturesOutput
|
|
}
|
|
|
|
// Represents subscription registered features
|
|
type CustomerSubscriptionRegisteredFeaturesArgs struct {
|
|
// Name of subscription registered feature
|
|
Name pulumi.StringPtrInput `pulumi:"name"`
|
|
// State of subscription registered feature
|
|
State pulumi.StringPtrInput `pulumi:"state"`
|
|
}
|
|
|
|
func (CustomerSubscriptionRegisteredFeaturesArgs) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*CustomerSubscriptionRegisteredFeatures)(nil)).Elem()
|
|
}
|
|
|
|
func (i CustomerSubscriptionRegisteredFeaturesArgs) ToCustomerSubscriptionRegisteredFeaturesOutput() CustomerSubscriptionRegisteredFeaturesOutput {
|
|
return i.ToCustomerSubscriptionRegisteredFeaturesOutputWithContext(context.Background())
|
|
}
|
|
|
|
func (i CustomerSubscriptionRegisteredFeaturesArgs) ToCustomerSubscriptionRegisteredFeaturesOutputWithContext(ctx context.Context) CustomerSubscriptionRegisteredFeaturesOutput {
|
|
return pulumi.ToOutputWithContext(ctx, i).(CustomerSubscriptionRegisteredFeaturesOutput)
|
|
}
|
|
|
|
// CustomerSubscriptionRegisteredFeaturesArrayInput is an input type that accepts CustomerSubscriptionRegisteredFeaturesArray and CustomerSubscriptionRegisteredFeaturesArrayOutput values.
|
|
// You can construct a concrete instance of `CustomerSubscriptionRegisteredFeaturesArrayInput` via:
|
|
//
|
|
// CustomerSubscriptionRegisteredFeaturesArray{ CustomerSubscriptionRegisteredFeaturesArgs{...} }
|
|
type CustomerSubscriptionRegisteredFeaturesArrayInput interface {
|
|
pulumi.Input
|
|
|
|
ToCustomerSubscriptionRegisteredFeaturesArrayOutput() CustomerSubscriptionRegisteredFeaturesArrayOutput
|
|
ToCustomerSubscriptionRegisteredFeaturesArrayOutputWithContext(context.Context) CustomerSubscriptionRegisteredFeaturesArrayOutput
|
|
}
|
|
|
|
type CustomerSubscriptionRegisteredFeaturesArray []CustomerSubscriptionRegisteredFeaturesInput
|
|
|
|
func (CustomerSubscriptionRegisteredFeaturesArray) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*[]CustomerSubscriptionRegisteredFeatures)(nil)).Elem()
|
|
}
|
|
|
|
func (i CustomerSubscriptionRegisteredFeaturesArray) ToCustomerSubscriptionRegisteredFeaturesArrayOutput() CustomerSubscriptionRegisteredFeaturesArrayOutput {
|
|
return i.ToCustomerSubscriptionRegisteredFeaturesArrayOutputWithContext(context.Background())
|
|
}
|
|
|
|
func (i CustomerSubscriptionRegisteredFeaturesArray) ToCustomerSubscriptionRegisteredFeaturesArrayOutputWithContext(ctx context.Context) CustomerSubscriptionRegisteredFeaturesArrayOutput {
|
|
return pulumi.ToOutputWithContext(ctx, i).(CustomerSubscriptionRegisteredFeaturesArrayOutput)
|
|
}
|
|
|
|
// Represents subscription registered features
|
|
type CustomerSubscriptionRegisteredFeaturesOutput struct{ *pulumi.OutputState }
|
|
|
|
func (CustomerSubscriptionRegisteredFeaturesOutput) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*CustomerSubscriptionRegisteredFeatures)(nil)).Elem()
|
|
}
|
|
|
|
func (o CustomerSubscriptionRegisteredFeaturesOutput) ToCustomerSubscriptionRegisteredFeaturesOutput() CustomerSubscriptionRegisteredFeaturesOutput {
|
|
return o
|
|
}
|
|
|
|
func (o CustomerSubscriptionRegisteredFeaturesOutput) ToCustomerSubscriptionRegisteredFeaturesOutputWithContext(ctx context.Context) CustomerSubscriptionRegisteredFeaturesOutput {
|
|
return o
|
|
}
|
|
|
|
// Name of subscription registered feature
|
|
func (o CustomerSubscriptionRegisteredFeaturesOutput) Name() pulumi.StringPtrOutput {
|
|
return o.ApplyT(func(v CustomerSubscriptionRegisteredFeatures) *string { return v.Name }).(pulumi.StringPtrOutput)
|
|
}
|
|
|
|
// State of subscription registered feature
|
|
func (o CustomerSubscriptionRegisteredFeaturesOutput) State() pulumi.StringPtrOutput {
|
|
return o.ApplyT(func(v CustomerSubscriptionRegisteredFeatures) *string { return v.State }).(pulumi.StringPtrOutput)
|
|
}
|
|
|
|
type CustomerSubscriptionRegisteredFeaturesArrayOutput struct{ *pulumi.OutputState }
|
|
|
|
func (CustomerSubscriptionRegisteredFeaturesArrayOutput) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*[]CustomerSubscriptionRegisteredFeatures)(nil)).Elem()
|
|
}
|
|
|
|
func (o CustomerSubscriptionRegisteredFeaturesArrayOutput) ToCustomerSubscriptionRegisteredFeaturesArrayOutput() CustomerSubscriptionRegisteredFeaturesArrayOutput {
|
|
return o
|
|
}
|
|
|
|
func (o CustomerSubscriptionRegisteredFeaturesArrayOutput) ToCustomerSubscriptionRegisteredFeaturesArrayOutputWithContext(ctx context.Context) CustomerSubscriptionRegisteredFeaturesArrayOutput {
|
|
return o
|
|
}
|
|
|
|
func (o CustomerSubscriptionRegisteredFeaturesArrayOutput) Index(i pulumi.IntInput) CustomerSubscriptionRegisteredFeaturesOutput {
|
|
return pulumi.All(o, i).ApplyT(func(vs []interface{}) CustomerSubscriptionRegisteredFeatures {
|
|
return vs[0].([]CustomerSubscriptionRegisteredFeatures)[vs[1].(int)]
|
|
}).(CustomerSubscriptionRegisteredFeaturesOutput)
|
|
}
|
|
|
|
// Description related properties of a product system.
|
|
type DescriptionResponse struct {
|
|
// Attributes for the product system.
|
|
Attributes []string `pulumi:"attributes"`
|
|
// Type of description.
|
|
DescriptionType string `pulumi:"descriptionType"`
|
|
// Keywords for the product system.
|
|
Keywords []string `pulumi:"keywords"`
|
|
// Links for the product system.
|
|
Links []LinkResponse `pulumi:"links"`
|
|
// Long description of the product system.
|
|
LongDescription string `pulumi:"longDescription"`
|
|
// Short description of the product system.
|
|
ShortDescription string `pulumi:"shortDescription"`
|
|
}
|
|
|
|
// DescriptionResponseInput is an input type that accepts DescriptionResponseArgs and DescriptionResponseOutput values.
|
|
// You can construct a concrete instance of `DescriptionResponseInput` via:
|
|
//
|
|
// DescriptionResponseArgs{...}
|
|
type DescriptionResponseInput interface {
|
|
pulumi.Input
|
|
|
|
ToDescriptionResponseOutput() DescriptionResponseOutput
|
|
ToDescriptionResponseOutputWithContext(context.Context) DescriptionResponseOutput
|
|
}
|
|
|
|
// Description related properties of a product system.
|
|
type DescriptionResponseArgs struct {
|
|
// Attributes for the product system.
|
|
Attributes pulumi.StringArrayInput `pulumi:"attributes"`
|
|
// Type of description.
|
|
DescriptionType pulumi.StringInput `pulumi:"descriptionType"`
|
|
// Keywords for the product system.
|
|
Keywords pulumi.StringArrayInput `pulumi:"keywords"`
|
|
// Links for the product system.
|
|
Links LinkResponseArrayInput `pulumi:"links"`
|
|
// Long description of the product system.
|
|
LongDescription pulumi.StringInput `pulumi:"longDescription"`
|
|
// Short description of the product system.
|
|
ShortDescription pulumi.StringInput `pulumi:"shortDescription"`
|
|
}
|
|
|
|
func (DescriptionResponseArgs) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*DescriptionResponse)(nil)).Elem()
|
|
}
|
|
|
|
func (i DescriptionResponseArgs) ToDescriptionResponseOutput() DescriptionResponseOutput {
|
|
return i.ToDescriptionResponseOutputWithContext(context.Background())
|
|
}
|
|
|
|
func (i DescriptionResponseArgs) ToDescriptionResponseOutputWithContext(ctx context.Context) DescriptionResponseOutput {
|
|
return pulumi.ToOutputWithContext(ctx, i).(DescriptionResponseOutput)
|
|
}
|
|
|
|
// Description related properties of a product system.
|
|
type DescriptionResponseOutput struct{ *pulumi.OutputState }
|
|
|
|
func (DescriptionResponseOutput) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*DescriptionResponse)(nil)).Elem()
|
|
}
|
|
|
|
func (o DescriptionResponseOutput) ToDescriptionResponseOutput() DescriptionResponseOutput {
|
|
return o
|
|
}
|
|
|
|
func (o DescriptionResponseOutput) ToDescriptionResponseOutputWithContext(ctx context.Context) DescriptionResponseOutput {
|
|
return o
|
|
}
|
|
|
|
// Attributes for the product system.
|
|
func (o DescriptionResponseOutput) Attributes() pulumi.StringArrayOutput {
|
|
return o.ApplyT(func(v DescriptionResponse) []string { return v.Attributes }).(pulumi.StringArrayOutput)
|
|
}
|
|
|
|
// Type of description.
|
|
func (o DescriptionResponseOutput) DescriptionType() pulumi.StringOutput {
|
|
return o.ApplyT(func(v DescriptionResponse) string { return v.DescriptionType }).(pulumi.StringOutput)
|
|
}
|
|
|
|
// Keywords for the product system.
|
|
func (o DescriptionResponseOutput) Keywords() pulumi.StringArrayOutput {
|
|
return o.ApplyT(func(v DescriptionResponse) []string { return v.Keywords }).(pulumi.StringArrayOutput)
|
|
}
|
|
|
|
// Links for the product system.
|
|
func (o DescriptionResponseOutput) Links() LinkResponseArrayOutput {
|
|
return o.ApplyT(func(v DescriptionResponse) []LinkResponse { return v.Links }).(LinkResponseArrayOutput)
|
|
}
|
|
|
|
// Long description of the product system.
|
|
func (o DescriptionResponseOutput) LongDescription() pulumi.StringOutput {
|
|
return o.ApplyT(func(v DescriptionResponse) string { return v.LongDescription }).(pulumi.StringOutput)
|
|
}
|
|
|
|
// Short description of the product system.
|
|
func (o DescriptionResponseOutput) ShortDescription() pulumi.StringOutput {
|
|
return o.ApplyT(func(v DescriptionResponse) string { return v.ShortDescription }).(pulumi.StringOutput)
|
|
}
|
|
|
|
// Dimensions of a configuration.
|
|
type DimensionsResponse struct {
|
|
// Depth of the device.
|
|
Depth float64 `pulumi:"depth"`
|
|
// Height of the device.
|
|
Height float64 `pulumi:"height"`
|
|
// Length of the device.
|
|
Length float64 `pulumi:"length"`
|
|
// Unit for the dimensions of length, height and width.
|
|
LengthHeightUnit string `pulumi:"lengthHeightUnit"`
|
|
// Weight of the device.
|
|
Weight float64 `pulumi:"weight"`
|
|
// Unit for the dimensions of weight.
|
|
WeightUnit string `pulumi:"weightUnit"`
|
|
// Width of the device.
|
|
Width float64 `pulumi:"width"`
|
|
}
|
|
|
|
// DimensionsResponseInput is an input type that accepts DimensionsResponseArgs and DimensionsResponseOutput values.
|
|
// You can construct a concrete instance of `DimensionsResponseInput` via:
|
|
//
|
|
// DimensionsResponseArgs{...}
|
|
type DimensionsResponseInput interface {
|
|
pulumi.Input
|
|
|
|
ToDimensionsResponseOutput() DimensionsResponseOutput
|
|
ToDimensionsResponseOutputWithContext(context.Context) DimensionsResponseOutput
|
|
}
|
|
|
|
// Dimensions of a configuration.
|
|
type DimensionsResponseArgs struct {
|
|
// Depth of the device.
|
|
Depth pulumi.Float64Input `pulumi:"depth"`
|
|
// Height of the device.
|
|
Height pulumi.Float64Input `pulumi:"height"`
|
|
// Length of the device.
|
|
Length pulumi.Float64Input `pulumi:"length"`
|
|
// Unit for the dimensions of length, height and width.
|
|
LengthHeightUnit pulumi.StringInput `pulumi:"lengthHeightUnit"`
|
|
// Weight of the device.
|
|
Weight pulumi.Float64Input `pulumi:"weight"`
|
|
// Unit for the dimensions of weight.
|
|
WeightUnit pulumi.StringInput `pulumi:"weightUnit"`
|
|
// Width of the device.
|
|
Width pulumi.Float64Input `pulumi:"width"`
|
|
}
|
|
|
|
func (DimensionsResponseArgs) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*DimensionsResponse)(nil)).Elem()
|
|
}
|
|
|
|
func (i DimensionsResponseArgs) ToDimensionsResponseOutput() DimensionsResponseOutput {
|
|
return i.ToDimensionsResponseOutputWithContext(context.Background())
|
|
}
|
|
|
|
func (i DimensionsResponseArgs) ToDimensionsResponseOutputWithContext(ctx context.Context) DimensionsResponseOutput {
|
|
return pulumi.ToOutputWithContext(ctx, i).(DimensionsResponseOutput)
|
|
}
|
|
|
|
// Dimensions of a configuration.
|
|
type DimensionsResponseOutput struct{ *pulumi.OutputState }
|
|
|
|
func (DimensionsResponseOutput) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*DimensionsResponse)(nil)).Elem()
|
|
}
|
|
|
|
func (o DimensionsResponseOutput) ToDimensionsResponseOutput() DimensionsResponseOutput {
|
|
return o
|
|
}
|
|
|
|
func (o DimensionsResponseOutput) ToDimensionsResponseOutputWithContext(ctx context.Context) DimensionsResponseOutput {
|
|
return o
|
|
}
|
|
|
|
// Depth of the device.
|
|
func (o DimensionsResponseOutput) Depth() pulumi.Float64Output {
|
|
return o.ApplyT(func(v DimensionsResponse) float64 { return v.Depth }).(pulumi.Float64Output)
|
|
}
|
|
|
|
// Height of the device.
|
|
func (o DimensionsResponseOutput) Height() pulumi.Float64Output {
|
|
return o.ApplyT(func(v DimensionsResponse) float64 { return v.Height }).(pulumi.Float64Output)
|
|
}
|
|
|
|
// Length of the device.
|
|
func (o DimensionsResponseOutput) Length() pulumi.Float64Output {
|
|
return o.ApplyT(func(v DimensionsResponse) float64 { return v.Length }).(pulumi.Float64Output)
|
|
}
|
|
|
|
// Unit for the dimensions of length, height and width.
|
|
func (o DimensionsResponseOutput) LengthHeightUnit() pulumi.StringOutput {
|
|
return o.ApplyT(func(v DimensionsResponse) string { return v.LengthHeightUnit }).(pulumi.StringOutput)
|
|
}
|
|
|
|
// Weight of the device.
|
|
func (o DimensionsResponseOutput) Weight() pulumi.Float64Output {
|
|
return o.ApplyT(func(v DimensionsResponse) float64 { return v.Weight }).(pulumi.Float64Output)
|
|
}
|
|
|
|
// Unit for the dimensions of weight.
|
|
func (o DimensionsResponseOutput) WeightUnit() pulumi.StringOutput {
|
|
return o.ApplyT(func(v DimensionsResponse) string { return v.WeightUnit }).(pulumi.StringOutput)
|
|
}
|
|
|
|
// Width of the device.
|
|
func (o DimensionsResponseOutput) Width() pulumi.Float64Output {
|
|
return o.ApplyT(func(v DimensionsResponse) float64 { return v.Width }).(pulumi.Float64Output)
|
|
}
|
|
|
|
// Different types of filters supported and its values.
|
|
type FilterableProperty struct {
|
|
// Values to be filtered.
|
|
SupportedValues []string `pulumi:"supportedValues"`
|
|
// Type of product filter.
|
|
Type string `pulumi:"type"`
|
|
}
|
|
|
|
// FilterablePropertyInput is an input type that accepts FilterablePropertyArgs and FilterablePropertyOutput values.
|
|
// You can construct a concrete instance of `FilterablePropertyInput` via:
|
|
//
|
|
// FilterablePropertyArgs{...}
|
|
type FilterablePropertyInput interface {
|
|
pulumi.Input
|
|
|
|
ToFilterablePropertyOutput() FilterablePropertyOutput
|
|
ToFilterablePropertyOutputWithContext(context.Context) FilterablePropertyOutput
|
|
}
|
|
|
|
// Different types of filters supported and its values.
|
|
type FilterablePropertyArgs struct {
|
|
// Values to be filtered.
|
|
SupportedValues pulumi.StringArrayInput `pulumi:"supportedValues"`
|
|
// Type of product filter.
|
|
Type pulumi.StringInput `pulumi:"type"`
|
|
}
|
|
|
|
func (FilterablePropertyArgs) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*FilterableProperty)(nil)).Elem()
|
|
}
|
|
|
|
func (i FilterablePropertyArgs) ToFilterablePropertyOutput() FilterablePropertyOutput {
|
|
return i.ToFilterablePropertyOutputWithContext(context.Background())
|
|
}
|
|
|
|
func (i FilterablePropertyArgs) ToFilterablePropertyOutputWithContext(ctx context.Context) FilterablePropertyOutput {
|
|
return pulumi.ToOutputWithContext(ctx, i).(FilterablePropertyOutput)
|
|
}
|
|
|
|
// FilterablePropertyArrayInput is an input type that accepts FilterablePropertyArray and FilterablePropertyArrayOutput values.
|
|
// You can construct a concrete instance of `FilterablePropertyArrayInput` via:
|
|
//
|
|
// FilterablePropertyArray{ FilterablePropertyArgs{...} }
|
|
type FilterablePropertyArrayInput interface {
|
|
pulumi.Input
|
|
|
|
ToFilterablePropertyArrayOutput() FilterablePropertyArrayOutput
|
|
ToFilterablePropertyArrayOutputWithContext(context.Context) FilterablePropertyArrayOutput
|
|
}
|
|
|
|
type FilterablePropertyArray []FilterablePropertyInput
|
|
|
|
func (FilterablePropertyArray) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*[]FilterableProperty)(nil)).Elem()
|
|
}
|
|
|
|
func (i FilterablePropertyArray) ToFilterablePropertyArrayOutput() FilterablePropertyArrayOutput {
|
|
return i.ToFilterablePropertyArrayOutputWithContext(context.Background())
|
|
}
|
|
|
|
func (i FilterablePropertyArray) ToFilterablePropertyArrayOutputWithContext(ctx context.Context) FilterablePropertyArrayOutput {
|
|
return pulumi.ToOutputWithContext(ctx, i).(FilterablePropertyArrayOutput)
|
|
}
|
|
|
|
// Different types of filters supported and its values.
|
|
type FilterablePropertyOutput struct{ *pulumi.OutputState }
|
|
|
|
func (FilterablePropertyOutput) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*FilterableProperty)(nil)).Elem()
|
|
}
|
|
|
|
func (o FilterablePropertyOutput) ToFilterablePropertyOutput() FilterablePropertyOutput {
|
|
return o
|
|
}
|
|
|
|
func (o FilterablePropertyOutput) ToFilterablePropertyOutputWithContext(ctx context.Context) FilterablePropertyOutput {
|
|
return o
|
|
}
|
|
|
|
// Values to be filtered.
|
|
func (o FilterablePropertyOutput) SupportedValues() pulumi.StringArrayOutput {
|
|
return o.ApplyT(func(v FilterableProperty) []string { return v.SupportedValues }).(pulumi.StringArrayOutput)
|
|
}
|
|
|
|
// Type of product filter.
|
|
func (o FilterablePropertyOutput) Type() pulumi.StringOutput {
|
|
return o.ApplyT(func(v FilterableProperty) string { return v.Type }).(pulumi.StringOutput)
|
|
}
|
|
|
|
type FilterablePropertyArrayOutput struct{ *pulumi.OutputState }
|
|
|
|
func (FilterablePropertyArrayOutput) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*[]FilterableProperty)(nil)).Elem()
|
|
}
|
|
|
|
func (o FilterablePropertyArrayOutput) ToFilterablePropertyArrayOutput() FilterablePropertyArrayOutput {
|
|
return o
|
|
}
|
|
|
|
func (o FilterablePropertyArrayOutput) ToFilterablePropertyArrayOutputWithContext(ctx context.Context) FilterablePropertyArrayOutput {
|
|
return o
|
|
}
|
|
|
|
func (o FilterablePropertyArrayOutput) Index(i pulumi.IntInput) FilterablePropertyOutput {
|
|
return pulumi.All(o, i).ApplyT(func(vs []interface{}) FilterableProperty {
|
|
return vs[0].([]FilterableProperty)[vs[1].(int)]
|
|
}).(FilterablePropertyOutput)
|
|
}
|
|
|
|
// Different types of filters supported and its values.
|
|
type FilterablePropertyResponse struct {
|
|
// Values to be filtered.
|
|
SupportedValues []string `pulumi:"supportedValues"`
|
|
// Type of product filter.
|
|
Type string `pulumi:"type"`
|
|
}
|
|
|
|
// FilterablePropertyResponseInput is an input type that accepts FilterablePropertyResponseArgs and FilterablePropertyResponseOutput values.
|
|
// You can construct a concrete instance of `FilterablePropertyResponseInput` via:
|
|
//
|
|
// FilterablePropertyResponseArgs{...}
|
|
type FilterablePropertyResponseInput interface {
|
|
pulumi.Input
|
|
|
|
ToFilterablePropertyResponseOutput() FilterablePropertyResponseOutput
|
|
ToFilterablePropertyResponseOutputWithContext(context.Context) FilterablePropertyResponseOutput
|
|
}
|
|
|
|
// Different types of filters supported and its values.
|
|
type FilterablePropertyResponseArgs struct {
|
|
// Values to be filtered.
|
|
SupportedValues pulumi.StringArrayInput `pulumi:"supportedValues"`
|
|
// Type of product filter.
|
|
Type pulumi.StringInput `pulumi:"type"`
|
|
}
|
|
|
|
func (FilterablePropertyResponseArgs) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*FilterablePropertyResponse)(nil)).Elem()
|
|
}
|
|
|
|
func (i FilterablePropertyResponseArgs) ToFilterablePropertyResponseOutput() FilterablePropertyResponseOutput {
|
|
return i.ToFilterablePropertyResponseOutputWithContext(context.Background())
|
|
}
|
|
|
|
func (i FilterablePropertyResponseArgs) ToFilterablePropertyResponseOutputWithContext(ctx context.Context) FilterablePropertyResponseOutput {
|
|
return pulumi.ToOutputWithContext(ctx, i).(FilterablePropertyResponseOutput)
|
|
}
|
|
|
|
// FilterablePropertyResponseArrayInput is an input type that accepts FilterablePropertyResponseArray and FilterablePropertyResponseArrayOutput values.
|
|
// You can construct a concrete instance of `FilterablePropertyResponseArrayInput` via:
|
|
//
|
|
// FilterablePropertyResponseArray{ FilterablePropertyResponseArgs{...} }
|
|
type FilterablePropertyResponseArrayInput interface {
|
|
pulumi.Input
|
|
|
|
ToFilterablePropertyResponseArrayOutput() FilterablePropertyResponseArrayOutput
|
|
ToFilterablePropertyResponseArrayOutputWithContext(context.Context) FilterablePropertyResponseArrayOutput
|
|
}
|
|
|
|
type FilterablePropertyResponseArray []FilterablePropertyResponseInput
|
|
|
|
func (FilterablePropertyResponseArray) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*[]FilterablePropertyResponse)(nil)).Elem()
|
|
}
|
|
|
|
func (i FilterablePropertyResponseArray) ToFilterablePropertyResponseArrayOutput() FilterablePropertyResponseArrayOutput {
|
|
return i.ToFilterablePropertyResponseArrayOutputWithContext(context.Background())
|
|
}
|
|
|
|
func (i FilterablePropertyResponseArray) ToFilterablePropertyResponseArrayOutputWithContext(ctx context.Context) FilterablePropertyResponseArrayOutput {
|
|
return pulumi.ToOutputWithContext(ctx, i).(FilterablePropertyResponseArrayOutput)
|
|
}
|
|
|
|
// Different types of filters supported and its values.
|
|
type FilterablePropertyResponseOutput struct{ *pulumi.OutputState }
|
|
|
|
func (FilterablePropertyResponseOutput) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*FilterablePropertyResponse)(nil)).Elem()
|
|
}
|
|
|
|
func (o FilterablePropertyResponseOutput) ToFilterablePropertyResponseOutput() FilterablePropertyResponseOutput {
|
|
return o
|
|
}
|
|
|
|
func (o FilterablePropertyResponseOutput) ToFilterablePropertyResponseOutputWithContext(ctx context.Context) FilterablePropertyResponseOutput {
|
|
return o
|
|
}
|
|
|
|
// Values to be filtered.
|
|
func (o FilterablePropertyResponseOutput) SupportedValues() pulumi.StringArrayOutput {
|
|
return o.ApplyT(func(v FilterablePropertyResponse) []string { return v.SupportedValues }).(pulumi.StringArrayOutput)
|
|
}
|
|
|
|
// Type of product filter.
|
|
func (o FilterablePropertyResponseOutput) Type() pulumi.StringOutput {
|
|
return o.ApplyT(func(v FilterablePropertyResponse) string { return v.Type }).(pulumi.StringOutput)
|
|
}
|
|
|
|
type FilterablePropertyResponseArrayOutput struct{ *pulumi.OutputState }
|
|
|
|
func (FilterablePropertyResponseArrayOutput) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*[]FilterablePropertyResponse)(nil)).Elem()
|
|
}
|
|
|
|
func (o FilterablePropertyResponseArrayOutput) ToFilterablePropertyResponseArrayOutput() FilterablePropertyResponseArrayOutput {
|
|
return o
|
|
}
|
|
|
|
func (o FilterablePropertyResponseArrayOutput) ToFilterablePropertyResponseArrayOutputWithContext(ctx context.Context) FilterablePropertyResponseArrayOutput {
|
|
return o
|
|
}
|
|
|
|
func (o FilterablePropertyResponseArrayOutput) Index(i pulumi.IntInput) FilterablePropertyResponseOutput {
|
|
return pulumi.All(o, i).ApplyT(func(vs []interface{}) FilterablePropertyResponse {
|
|
return vs[0].([]FilterablePropertyResponse)[vs[1].(int)]
|
|
}).(FilterablePropertyResponseOutput)
|
|
}
|
|
|
|
// Holds details about product hierarchy information
|
|
type HierarchyInformation struct {
|
|
// Represents configuration name that uniquely identifies configuration
|
|
ConfigurationName *string `pulumi:"configurationName"`
|
|
// Represents product family name that uniquely identifies product family
|
|
ProductFamilyName *string `pulumi:"productFamilyName"`
|
|
// Represents product line name that uniquely identifies product line
|
|
ProductLineName *string `pulumi:"productLineName"`
|
|
// Represents product name that uniquely identifies product
|
|
ProductName *string `pulumi:"productName"`
|
|
}
|
|
|
|
// HierarchyInformationInput is an input type that accepts HierarchyInformationArgs and HierarchyInformationOutput values.
|
|
// You can construct a concrete instance of `HierarchyInformationInput` via:
|
|
//
|
|
// HierarchyInformationArgs{...}
|
|
type HierarchyInformationInput interface {
|
|
pulumi.Input
|
|
|
|
ToHierarchyInformationOutput() HierarchyInformationOutput
|
|
ToHierarchyInformationOutputWithContext(context.Context) HierarchyInformationOutput
|
|
}
|
|
|
|
// Holds details about product hierarchy information
|
|
type HierarchyInformationArgs struct {
|
|
// Represents configuration name that uniquely identifies configuration
|
|
ConfigurationName pulumi.StringPtrInput `pulumi:"configurationName"`
|
|
// Represents product family name that uniquely identifies product family
|
|
ProductFamilyName pulumi.StringPtrInput `pulumi:"productFamilyName"`
|
|
// Represents product line name that uniquely identifies product line
|
|
ProductLineName pulumi.StringPtrInput `pulumi:"productLineName"`
|
|
// Represents product name that uniquely identifies product
|
|
ProductName pulumi.StringPtrInput `pulumi:"productName"`
|
|
}
|
|
|
|
func (HierarchyInformationArgs) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*HierarchyInformation)(nil)).Elem()
|
|
}
|
|
|
|
func (i HierarchyInformationArgs) ToHierarchyInformationOutput() HierarchyInformationOutput {
|
|
return i.ToHierarchyInformationOutputWithContext(context.Background())
|
|
}
|
|
|
|
func (i HierarchyInformationArgs) ToHierarchyInformationOutputWithContext(ctx context.Context) HierarchyInformationOutput {
|
|
return pulumi.ToOutputWithContext(ctx, i).(HierarchyInformationOutput)
|
|
}
|
|
|
|
// Holds details about product hierarchy information
|
|
type HierarchyInformationOutput struct{ *pulumi.OutputState }
|
|
|
|
func (HierarchyInformationOutput) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*HierarchyInformation)(nil)).Elem()
|
|
}
|
|
|
|
func (o HierarchyInformationOutput) ToHierarchyInformationOutput() HierarchyInformationOutput {
|
|
return o
|
|
}
|
|
|
|
func (o HierarchyInformationOutput) ToHierarchyInformationOutputWithContext(ctx context.Context) HierarchyInformationOutput {
|
|
return o
|
|
}
|
|
|
|
// Represents configuration name that uniquely identifies configuration
|
|
func (o HierarchyInformationOutput) ConfigurationName() pulumi.StringPtrOutput {
|
|
return o.ApplyT(func(v HierarchyInformation) *string { return v.ConfigurationName }).(pulumi.StringPtrOutput)
|
|
}
|
|
|
|
// Represents product family name that uniquely identifies product family
|
|
func (o HierarchyInformationOutput) ProductFamilyName() pulumi.StringPtrOutput {
|
|
return o.ApplyT(func(v HierarchyInformation) *string { return v.ProductFamilyName }).(pulumi.StringPtrOutput)
|
|
}
|
|
|
|
// Represents product line name that uniquely identifies product line
|
|
func (o HierarchyInformationOutput) ProductLineName() pulumi.StringPtrOutput {
|
|
return o.ApplyT(func(v HierarchyInformation) *string { return v.ProductLineName }).(pulumi.StringPtrOutput)
|
|
}
|
|
|
|
// Represents product name that uniquely identifies product
|
|
func (o HierarchyInformationOutput) ProductName() pulumi.StringPtrOutput {
|
|
return o.ApplyT(func(v HierarchyInformation) *string { return v.ProductName }).(pulumi.StringPtrOutput)
|
|
}
|
|
|
|
// Holds details about product hierarchy information
|
|
type HierarchyInformationResponse struct {
|
|
// Represents configuration name that uniquely identifies configuration
|
|
ConfigurationName *string `pulumi:"configurationName"`
|
|
// Represents product family name that uniquely identifies product family
|
|
ProductFamilyName *string `pulumi:"productFamilyName"`
|
|
// Represents product line name that uniquely identifies product line
|
|
ProductLineName *string `pulumi:"productLineName"`
|
|
// Represents product name that uniquely identifies product
|
|
ProductName *string `pulumi:"productName"`
|
|
}
|
|
|
|
// HierarchyInformationResponseInput is an input type that accepts HierarchyInformationResponseArgs and HierarchyInformationResponseOutput values.
|
|
// You can construct a concrete instance of `HierarchyInformationResponseInput` via:
|
|
//
|
|
// HierarchyInformationResponseArgs{...}
|
|
type HierarchyInformationResponseInput interface {
|
|
pulumi.Input
|
|
|
|
ToHierarchyInformationResponseOutput() HierarchyInformationResponseOutput
|
|
ToHierarchyInformationResponseOutputWithContext(context.Context) HierarchyInformationResponseOutput
|
|
}
|
|
|
|
// Holds details about product hierarchy information
|
|
type HierarchyInformationResponseArgs struct {
|
|
// Represents configuration name that uniquely identifies configuration
|
|
ConfigurationName pulumi.StringPtrInput `pulumi:"configurationName"`
|
|
// Represents product family name that uniquely identifies product family
|
|
ProductFamilyName pulumi.StringPtrInput `pulumi:"productFamilyName"`
|
|
// Represents product line name that uniquely identifies product line
|
|
ProductLineName pulumi.StringPtrInput `pulumi:"productLineName"`
|
|
// Represents product name that uniquely identifies product
|
|
ProductName pulumi.StringPtrInput `pulumi:"productName"`
|
|
}
|
|
|
|
func (HierarchyInformationResponseArgs) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*HierarchyInformationResponse)(nil)).Elem()
|
|
}
|
|
|
|
func (i HierarchyInformationResponseArgs) ToHierarchyInformationResponseOutput() HierarchyInformationResponseOutput {
|
|
return i.ToHierarchyInformationResponseOutputWithContext(context.Background())
|
|
}
|
|
|
|
func (i HierarchyInformationResponseArgs) ToHierarchyInformationResponseOutputWithContext(ctx context.Context) HierarchyInformationResponseOutput {
|
|
return pulumi.ToOutputWithContext(ctx, i).(HierarchyInformationResponseOutput)
|
|
}
|
|
|
|
// Holds details about product hierarchy information
|
|
type HierarchyInformationResponseOutput struct{ *pulumi.OutputState }
|
|
|
|
func (HierarchyInformationResponseOutput) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*HierarchyInformationResponse)(nil)).Elem()
|
|
}
|
|
|
|
func (o HierarchyInformationResponseOutput) ToHierarchyInformationResponseOutput() HierarchyInformationResponseOutput {
|
|
return o
|
|
}
|
|
|
|
func (o HierarchyInformationResponseOutput) ToHierarchyInformationResponseOutputWithContext(ctx context.Context) HierarchyInformationResponseOutput {
|
|
return o
|
|
}
|
|
|
|
// Represents configuration name that uniquely identifies configuration
|
|
func (o HierarchyInformationResponseOutput) ConfigurationName() pulumi.StringPtrOutput {
|
|
return o.ApplyT(func(v HierarchyInformationResponse) *string { return v.ConfigurationName }).(pulumi.StringPtrOutput)
|
|
}
|
|
|
|
// Represents product family name that uniquely identifies product family
|
|
func (o HierarchyInformationResponseOutput) ProductFamilyName() pulumi.StringPtrOutput {
|
|
return o.ApplyT(func(v HierarchyInformationResponse) *string { return v.ProductFamilyName }).(pulumi.StringPtrOutput)
|
|
}
|
|
|
|
// Represents product line name that uniquely identifies product line
|
|
func (o HierarchyInformationResponseOutput) ProductLineName() pulumi.StringPtrOutput {
|
|
return o.ApplyT(func(v HierarchyInformationResponse) *string { return v.ProductLineName }).(pulumi.StringPtrOutput)
|
|
}
|
|
|
|
// Represents product name that uniquely identifies product
|
|
func (o HierarchyInformationResponseOutput) ProductName() pulumi.StringPtrOutput {
|
|
return o.ApplyT(func(v HierarchyInformationResponse) *string { return v.ProductName }).(pulumi.StringPtrOutput)
|
|
}
|
|
|
|
// Image for the product
|
|
type ImageInformationResponse struct {
|
|
// Type of the image
|
|
ImageType string `pulumi:"imageType"`
|
|
// Url of the image
|
|
ImageUrl string `pulumi:"imageUrl"`
|
|
}
|
|
|
|
// ImageInformationResponseInput is an input type that accepts ImageInformationResponseArgs and ImageInformationResponseOutput values.
|
|
// You can construct a concrete instance of `ImageInformationResponseInput` via:
|
|
//
|
|
// ImageInformationResponseArgs{...}
|
|
type ImageInformationResponseInput interface {
|
|
pulumi.Input
|
|
|
|
ToImageInformationResponseOutput() ImageInformationResponseOutput
|
|
ToImageInformationResponseOutputWithContext(context.Context) ImageInformationResponseOutput
|
|
}
|
|
|
|
// Image for the product
|
|
type ImageInformationResponseArgs struct {
|
|
// Type of the image
|
|
ImageType pulumi.StringInput `pulumi:"imageType"`
|
|
// Url of the image
|
|
ImageUrl pulumi.StringInput `pulumi:"imageUrl"`
|
|
}
|
|
|
|
func (ImageInformationResponseArgs) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*ImageInformationResponse)(nil)).Elem()
|
|
}
|
|
|
|
func (i ImageInformationResponseArgs) ToImageInformationResponseOutput() ImageInformationResponseOutput {
|
|
return i.ToImageInformationResponseOutputWithContext(context.Background())
|
|
}
|
|
|
|
func (i ImageInformationResponseArgs) ToImageInformationResponseOutputWithContext(ctx context.Context) ImageInformationResponseOutput {
|
|
return pulumi.ToOutputWithContext(ctx, i).(ImageInformationResponseOutput)
|
|
}
|
|
|
|
// ImageInformationResponseArrayInput is an input type that accepts ImageInformationResponseArray and ImageInformationResponseArrayOutput values.
|
|
// You can construct a concrete instance of `ImageInformationResponseArrayInput` via:
|
|
//
|
|
// ImageInformationResponseArray{ ImageInformationResponseArgs{...} }
|
|
type ImageInformationResponseArrayInput interface {
|
|
pulumi.Input
|
|
|
|
ToImageInformationResponseArrayOutput() ImageInformationResponseArrayOutput
|
|
ToImageInformationResponseArrayOutputWithContext(context.Context) ImageInformationResponseArrayOutput
|
|
}
|
|
|
|
type ImageInformationResponseArray []ImageInformationResponseInput
|
|
|
|
func (ImageInformationResponseArray) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*[]ImageInformationResponse)(nil)).Elem()
|
|
}
|
|
|
|
func (i ImageInformationResponseArray) ToImageInformationResponseArrayOutput() ImageInformationResponseArrayOutput {
|
|
return i.ToImageInformationResponseArrayOutputWithContext(context.Background())
|
|
}
|
|
|
|
func (i ImageInformationResponseArray) ToImageInformationResponseArrayOutputWithContext(ctx context.Context) ImageInformationResponseArrayOutput {
|
|
return pulumi.ToOutputWithContext(ctx, i).(ImageInformationResponseArrayOutput)
|
|
}
|
|
|
|
// Image for the product
|
|
type ImageInformationResponseOutput struct{ *pulumi.OutputState }
|
|
|
|
func (ImageInformationResponseOutput) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*ImageInformationResponse)(nil)).Elem()
|
|
}
|
|
|
|
func (o ImageInformationResponseOutput) ToImageInformationResponseOutput() ImageInformationResponseOutput {
|
|
return o
|
|
}
|
|
|
|
func (o ImageInformationResponseOutput) ToImageInformationResponseOutputWithContext(ctx context.Context) ImageInformationResponseOutput {
|
|
return o
|
|
}
|
|
|
|
// Type of the image
|
|
func (o ImageInformationResponseOutput) ImageType() pulumi.StringOutput {
|
|
return o.ApplyT(func(v ImageInformationResponse) string { return v.ImageType }).(pulumi.StringOutput)
|
|
}
|
|
|
|
// Url of the image
|
|
func (o ImageInformationResponseOutput) ImageUrl() pulumi.StringOutput {
|
|
return o.ApplyT(func(v ImageInformationResponse) string { return v.ImageUrl }).(pulumi.StringOutput)
|
|
}
|
|
|
|
type ImageInformationResponseArrayOutput struct{ *pulumi.OutputState }
|
|
|
|
func (ImageInformationResponseArrayOutput) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*[]ImageInformationResponse)(nil)).Elem()
|
|
}
|
|
|
|
func (o ImageInformationResponseArrayOutput) ToImageInformationResponseArrayOutput() ImageInformationResponseArrayOutput {
|
|
return o
|
|
}
|
|
|
|
func (o ImageInformationResponseArrayOutput) ToImageInformationResponseArrayOutputWithContext(ctx context.Context) ImageInformationResponseArrayOutput {
|
|
return o
|
|
}
|
|
|
|
func (o ImageInformationResponseArrayOutput) Index(i pulumi.IntInput) ImageInformationResponseOutput {
|
|
return pulumi.All(o, i).ApplyT(func(vs []interface{}) ImageInformationResponse {
|
|
return vs[0].([]ImageInformationResponse)[vs[1].(int)]
|
|
}).(ImageInformationResponseOutput)
|
|
}
|
|
|
|
// Returns link related to the product
|
|
type LinkResponse struct {
|
|
// Type of link
|
|
LinkType string `pulumi:"linkType"`
|
|
// Url of the link
|
|
LinkUrl string `pulumi:"linkUrl"`
|
|
}
|
|
|
|
// LinkResponseInput is an input type that accepts LinkResponseArgs and LinkResponseOutput values.
|
|
// You can construct a concrete instance of `LinkResponseInput` via:
|
|
//
|
|
// LinkResponseArgs{...}
|
|
type LinkResponseInput interface {
|
|
pulumi.Input
|
|
|
|
ToLinkResponseOutput() LinkResponseOutput
|
|
ToLinkResponseOutputWithContext(context.Context) LinkResponseOutput
|
|
}
|
|
|
|
// Returns link related to the product
|
|
type LinkResponseArgs struct {
|
|
// Type of link
|
|
LinkType pulumi.StringInput `pulumi:"linkType"`
|
|
// Url of the link
|
|
LinkUrl pulumi.StringInput `pulumi:"linkUrl"`
|
|
}
|
|
|
|
func (LinkResponseArgs) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*LinkResponse)(nil)).Elem()
|
|
}
|
|
|
|
func (i LinkResponseArgs) ToLinkResponseOutput() LinkResponseOutput {
|
|
return i.ToLinkResponseOutputWithContext(context.Background())
|
|
}
|
|
|
|
func (i LinkResponseArgs) ToLinkResponseOutputWithContext(ctx context.Context) LinkResponseOutput {
|
|
return pulumi.ToOutputWithContext(ctx, i).(LinkResponseOutput)
|
|
}
|
|
|
|
// LinkResponseArrayInput is an input type that accepts LinkResponseArray and LinkResponseArrayOutput values.
|
|
// You can construct a concrete instance of `LinkResponseArrayInput` via:
|
|
//
|
|
// LinkResponseArray{ LinkResponseArgs{...} }
|
|
type LinkResponseArrayInput interface {
|
|
pulumi.Input
|
|
|
|
ToLinkResponseArrayOutput() LinkResponseArrayOutput
|
|
ToLinkResponseArrayOutputWithContext(context.Context) LinkResponseArrayOutput
|
|
}
|
|
|
|
type LinkResponseArray []LinkResponseInput
|
|
|
|
func (LinkResponseArray) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*[]LinkResponse)(nil)).Elem()
|
|
}
|
|
|
|
func (i LinkResponseArray) ToLinkResponseArrayOutput() LinkResponseArrayOutput {
|
|
return i.ToLinkResponseArrayOutputWithContext(context.Background())
|
|
}
|
|
|
|
func (i LinkResponseArray) ToLinkResponseArrayOutputWithContext(ctx context.Context) LinkResponseArrayOutput {
|
|
return pulumi.ToOutputWithContext(ctx, i).(LinkResponseArrayOutput)
|
|
}
|
|
|
|
// Returns link related to the product
|
|
type LinkResponseOutput struct{ *pulumi.OutputState }
|
|
|
|
func (LinkResponseOutput) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*LinkResponse)(nil)).Elem()
|
|
}
|
|
|
|
func (o LinkResponseOutput) ToLinkResponseOutput() LinkResponseOutput {
|
|
return o
|
|
}
|
|
|
|
func (o LinkResponseOutput) ToLinkResponseOutputWithContext(ctx context.Context) LinkResponseOutput {
|
|
return o
|
|
}
|
|
|
|
// Type of link
|
|
func (o LinkResponseOutput) LinkType() pulumi.StringOutput {
|
|
return o.ApplyT(func(v LinkResponse) string { return v.LinkType }).(pulumi.StringOutput)
|
|
}
|
|
|
|
// Url of the link
|
|
func (o LinkResponseOutput) LinkUrl() pulumi.StringOutput {
|
|
return o.ApplyT(func(v LinkResponse) string { return v.LinkUrl }).(pulumi.StringOutput)
|
|
}
|
|
|
|
type LinkResponseArrayOutput struct{ *pulumi.OutputState }
|
|
|
|
func (LinkResponseArrayOutput) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*[]LinkResponse)(nil)).Elem()
|
|
}
|
|
|
|
func (o LinkResponseArrayOutput) ToLinkResponseArrayOutput() LinkResponseArrayOutput {
|
|
return o
|
|
}
|
|
|
|
func (o LinkResponseArrayOutput) ToLinkResponseArrayOutputWithContext(ctx context.Context) LinkResponseArrayOutput {
|
|
return o
|
|
}
|
|
|
|
func (o LinkResponseArrayOutput) Index(i pulumi.IntInput) LinkResponseOutput {
|
|
return pulumi.All(o, i).ApplyT(func(vs []interface{}) LinkResponse {
|
|
return vs[0].([]LinkResponse)[vs[1].(int)]
|
|
}).(LinkResponseOutput)
|
|
}
|
|
|
|
// Billing type PAV2 meter details
|
|
type Pav2MeterDetailsResponse struct {
|
|
// Represents billing type.
|
|
// Expected value is 'Pav2'.
|
|
BillingType *string `pulumi:"billingType"`
|
|
// Charging type.
|
|
ChargingType string `pulumi:"chargingType"`
|
|
// Validation status of requested data center and transport.
|
|
MeterGuid string `pulumi:"meterGuid"`
|
|
// Billing unit applicable for Pav2 billing
|
|
Multiplier float64 `pulumi:"multiplier"`
|
|
}
|
|
|
|
// Pav2MeterDetailsResponseInput is an input type that accepts Pav2MeterDetailsResponseArgs and Pav2MeterDetailsResponseOutput values.
|
|
// You can construct a concrete instance of `Pav2MeterDetailsResponseInput` via:
|
|
//
|
|
// Pav2MeterDetailsResponseArgs{...}
|
|
type Pav2MeterDetailsResponseInput interface {
|
|
pulumi.Input
|
|
|
|
ToPav2MeterDetailsResponseOutput() Pav2MeterDetailsResponseOutput
|
|
ToPav2MeterDetailsResponseOutputWithContext(context.Context) Pav2MeterDetailsResponseOutput
|
|
}
|
|
|
|
// Billing type PAV2 meter details
|
|
type Pav2MeterDetailsResponseArgs struct {
|
|
// Represents billing type.
|
|
// Expected value is 'Pav2'.
|
|
BillingType pulumi.StringPtrInput `pulumi:"billingType"`
|
|
// Charging type.
|
|
ChargingType pulumi.StringInput `pulumi:"chargingType"`
|
|
// Validation status of requested data center and transport.
|
|
MeterGuid pulumi.StringInput `pulumi:"meterGuid"`
|
|
// Billing unit applicable for Pav2 billing
|
|
Multiplier pulumi.Float64Input `pulumi:"multiplier"`
|
|
}
|
|
|
|
func (Pav2MeterDetailsResponseArgs) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*Pav2MeterDetailsResponse)(nil)).Elem()
|
|
}
|
|
|
|
func (i Pav2MeterDetailsResponseArgs) ToPav2MeterDetailsResponseOutput() Pav2MeterDetailsResponseOutput {
|
|
return i.ToPav2MeterDetailsResponseOutputWithContext(context.Background())
|
|
}
|
|
|
|
func (i Pav2MeterDetailsResponseArgs) ToPav2MeterDetailsResponseOutputWithContext(ctx context.Context) Pav2MeterDetailsResponseOutput {
|
|
return pulumi.ToOutputWithContext(ctx, i).(Pav2MeterDetailsResponseOutput)
|
|
}
|
|
|
|
// Billing type PAV2 meter details
|
|
type Pav2MeterDetailsResponseOutput struct{ *pulumi.OutputState }
|
|
|
|
func (Pav2MeterDetailsResponseOutput) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*Pav2MeterDetailsResponse)(nil)).Elem()
|
|
}
|
|
|
|
func (o Pav2MeterDetailsResponseOutput) ToPav2MeterDetailsResponseOutput() Pav2MeterDetailsResponseOutput {
|
|
return o
|
|
}
|
|
|
|
func (o Pav2MeterDetailsResponseOutput) ToPav2MeterDetailsResponseOutputWithContext(ctx context.Context) Pav2MeterDetailsResponseOutput {
|
|
return o
|
|
}
|
|
|
|
// Represents billing type.
|
|
// Expected value is 'Pav2'.
|
|
func (o Pav2MeterDetailsResponseOutput) BillingType() pulumi.StringPtrOutput {
|
|
return o.ApplyT(func(v Pav2MeterDetailsResponse) *string { return v.BillingType }).(pulumi.StringPtrOutput)
|
|
}
|
|
|
|
// Charging type.
|
|
func (o Pav2MeterDetailsResponseOutput) ChargingType() pulumi.StringOutput {
|
|
return o.ApplyT(func(v Pav2MeterDetailsResponse) string { return v.ChargingType }).(pulumi.StringOutput)
|
|
}
|
|
|
|
// Validation status of requested data center and transport.
|
|
func (o Pav2MeterDetailsResponseOutput) MeterGuid() pulumi.StringOutput {
|
|
return o.ApplyT(func(v Pav2MeterDetailsResponse) string { return v.MeterGuid }).(pulumi.StringOutput)
|
|
}
|
|
|
|
// Billing unit applicable for Pav2 billing
|
|
func (o Pav2MeterDetailsResponseOutput) Multiplier() pulumi.Float64Output {
|
|
return o.ApplyT(func(v Pav2MeterDetailsResponse) float64 { return v.Multiplier }).(pulumi.Float64Output)
|
|
}
|
|
|
|
// Product Family
|
|
type ProductFamilyResponse struct {
|
|
// Availability information of the product system.
|
|
AvailabilityInformation AvailabilityInformationResponse `pulumi:"availabilityInformation"`
|
|
// Cost information for the product system.
|
|
CostInformation CostInformationResponse `pulumi:"costInformation"`
|
|
// Description related to the product system.
|
|
Description DescriptionResponse `pulumi:"description"`
|
|
// Display Name for the product system.
|
|
DisplayName string `pulumi:"displayName"`
|
|
// list of filters supported for a product
|
|
FilterableProperties []FilterablePropertyResponse `pulumi:"filterableProperties"`
|
|
// Hierarchy information of a product.
|
|
HierarchyInformation HierarchyInformationResponse `pulumi:"hierarchyInformation"`
|
|
// Image information for the product system.
|
|
ImageInformation []ImageInformationResponse `pulumi:"imageInformation"`
|
|
// List of product lines supported in the product family
|
|
ProductLines []ProductLineResponse `pulumi:"productLines"`
|
|
}
|
|
|
|
// ProductFamilyResponseInput is an input type that accepts ProductFamilyResponseArgs and ProductFamilyResponseOutput values.
|
|
// You can construct a concrete instance of `ProductFamilyResponseInput` via:
|
|
//
|
|
// ProductFamilyResponseArgs{...}
|
|
type ProductFamilyResponseInput interface {
|
|
pulumi.Input
|
|
|
|
ToProductFamilyResponseOutput() ProductFamilyResponseOutput
|
|
ToProductFamilyResponseOutputWithContext(context.Context) ProductFamilyResponseOutput
|
|
}
|
|
|
|
// Product Family
|
|
type ProductFamilyResponseArgs struct {
|
|
// Availability information of the product system.
|
|
AvailabilityInformation AvailabilityInformationResponseInput `pulumi:"availabilityInformation"`
|
|
// Cost information for the product system.
|
|
CostInformation CostInformationResponseInput `pulumi:"costInformation"`
|
|
// Description related to the product system.
|
|
Description DescriptionResponseInput `pulumi:"description"`
|
|
// Display Name for the product system.
|
|
DisplayName pulumi.StringInput `pulumi:"displayName"`
|
|
// list of filters supported for a product
|
|
FilterableProperties FilterablePropertyResponseArrayInput `pulumi:"filterableProperties"`
|
|
// Hierarchy information of a product.
|
|
HierarchyInformation HierarchyInformationResponseInput `pulumi:"hierarchyInformation"`
|
|
// Image information for the product system.
|
|
ImageInformation ImageInformationResponseArrayInput `pulumi:"imageInformation"`
|
|
// List of product lines supported in the product family
|
|
ProductLines ProductLineResponseArrayInput `pulumi:"productLines"`
|
|
}
|
|
|
|
func (ProductFamilyResponseArgs) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*ProductFamilyResponse)(nil)).Elem()
|
|
}
|
|
|
|
func (i ProductFamilyResponseArgs) ToProductFamilyResponseOutput() ProductFamilyResponseOutput {
|
|
return i.ToProductFamilyResponseOutputWithContext(context.Background())
|
|
}
|
|
|
|
func (i ProductFamilyResponseArgs) ToProductFamilyResponseOutputWithContext(ctx context.Context) ProductFamilyResponseOutput {
|
|
return pulumi.ToOutputWithContext(ctx, i).(ProductFamilyResponseOutput)
|
|
}
|
|
|
|
// ProductFamilyResponseArrayInput is an input type that accepts ProductFamilyResponseArray and ProductFamilyResponseArrayOutput values.
|
|
// You can construct a concrete instance of `ProductFamilyResponseArrayInput` via:
|
|
//
|
|
// ProductFamilyResponseArray{ ProductFamilyResponseArgs{...} }
|
|
type ProductFamilyResponseArrayInput interface {
|
|
pulumi.Input
|
|
|
|
ToProductFamilyResponseArrayOutput() ProductFamilyResponseArrayOutput
|
|
ToProductFamilyResponseArrayOutputWithContext(context.Context) ProductFamilyResponseArrayOutput
|
|
}
|
|
|
|
type ProductFamilyResponseArray []ProductFamilyResponseInput
|
|
|
|
func (ProductFamilyResponseArray) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*[]ProductFamilyResponse)(nil)).Elem()
|
|
}
|
|
|
|
func (i ProductFamilyResponseArray) ToProductFamilyResponseArrayOutput() ProductFamilyResponseArrayOutput {
|
|
return i.ToProductFamilyResponseArrayOutputWithContext(context.Background())
|
|
}
|
|
|
|
func (i ProductFamilyResponseArray) ToProductFamilyResponseArrayOutputWithContext(ctx context.Context) ProductFamilyResponseArrayOutput {
|
|
return pulumi.ToOutputWithContext(ctx, i).(ProductFamilyResponseArrayOutput)
|
|
}
|
|
|
|
// Product Family
|
|
type ProductFamilyResponseOutput struct{ *pulumi.OutputState }
|
|
|
|
func (ProductFamilyResponseOutput) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*ProductFamilyResponse)(nil)).Elem()
|
|
}
|
|
|
|
func (o ProductFamilyResponseOutput) ToProductFamilyResponseOutput() ProductFamilyResponseOutput {
|
|
return o
|
|
}
|
|
|
|
func (o ProductFamilyResponseOutput) ToProductFamilyResponseOutputWithContext(ctx context.Context) ProductFamilyResponseOutput {
|
|
return o
|
|
}
|
|
|
|
// Availability information of the product system.
|
|
func (o ProductFamilyResponseOutput) AvailabilityInformation() AvailabilityInformationResponseOutput {
|
|
return o.ApplyT(func(v ProductFamilyResponse) AvailabilityInformationResponse { return v.AvailabilityInformation }).(AvailabilityInformationResponseOutput)
|
|
}
|
|
|
|
// Cost information for the product system.
|
|
func (o ProductFamilyResponseOutput) CostInformation() CostInformationResponseOutput {
|
|
return o.ApplyT(func(v ProductFamilyResponse) CostInformationResponse { return v.CostInformation }).(CostInformationResponseOutput)
|
|
}
|
|
|
|
// Description related to the product system.
|
|
func (o ProductFamilyResponseOutput) Description() DescriptionResponseOutput {
|
|
return o.ApplyT(func(v ProductFamilyResponse) DescriptionResponse { return v.Description }).(DescriptionResponseOutput)
|
|
}
|
|
|
|
// Display Name for the product system.
|
|
func (o ProductFamilyResponseOutput) DisplayName() pulumi.StringOutput {
|
|
return o.ApplyT(func(v ProductFamilyResponse) string { return v.DisplayName }).(pulumi.StringOutput)
|
|
}
|
|
|
|
// list of filters supported for a product
|
|
func (o ProductFamilyResponseOutput) FilterableProperties() FilterablePropertyResponseArrayOutput {
|
|
return o.ApplyT(func(v ProductFamilyResponse) []FilterablePropertyResponse { return v.FilterableProperties }).(FilterablePropertyResponseArrayOutput)
|
|
}
|
|
|
|
// Hierarchy information of a product.
|
|
func (o ProductFamilyResponseOutput) HierarchyInformation() HierarchyInformationResponseOutput {
|
|
return o.ApplyT(func(v ProductFamilyResponse) HierarchyInformationResponse { return v.HierarchyInformation }).(HierarchyInformationResponseOutput)
|
|
}
|
|
|
|
// Image information for the product system.
|
|
func (o ProductFamilyResponseOutput) ImageInformation() ImageInformationResponseArrayOutput {
|
|
return o.ApplyT(func(v ProductFamilyResponse) []ImageInformationResponse { return v.ImageInformation }).(ImageInformationResponseArrayOutput)
|
|
}
|
|
|
|
// List of product lines supported in the product family
|
|
func (o ProductFamilyResponseOutput) ProductLines() ProductLineResponseArrayOutput {
|
|
return o.ApplyT(func(v ProductFamilyResponse) []ProductLineResponse { return v.ProductLines }).(ProductLineResponseArrayOutput)
|
|
}
|
|
|
|
type ProductFamilyResponseArrayOutput struct{ *pulumi.OutputState }
|
|
|
|
func (ProductFamilyResponseArrayOutput) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*[]ProductFamilyResponse)(nil)).Elem()
|
|
}
|
|
|
|
func (o ProductFamilyResponseArrayOutput) ToProductFamilyResponseArrayOutput() ProductFamilyResponseArrayOutput {
|
|
return o
|
|
}
|
|
|
|
func (o ProductFamilyResponseArrayOutput) ToProductFamilyResponseArrayOutputWithContext(ctx context.Context) ProductFamilyResponseArrayOutput {
|
|
return o
|
|
}
|
|
|
|
func (o ProductFamilyResponseArrayOutput) Index(i pulumi.IntInput) ProductFamilyResponseOutput {
|
|
return pulumi.All(o, i).ApplyT(func(vs []interface{}) ProductFamilyResponse {
|
|
return vs[0].([]ProductFamilyResponse)[vs[1].(int)]
|
|
}).(ProductFamilyResponseOutput)
|
|
}
|
|
|
|
// Product line
|
|
type ProductLineResponse struct {
|
|
// Availability information of the product system.
|
|
AvailabilityInformation AvailabilityInformationResponse `pulumi:"availabilityInformation"`
|
|
// Cost information for the product system.
|
|
CostInformation CostInformationResponse `pulumi:"costInformation"`
|
|
// Description related to the product system.
|
|
Description DescriptionResponse `pulumi:"description"`
|
|
// Display Name for the product system.
|
|
DisplayName string `pulumi:"displayName"`
|
|
// list of filters supported for a product
|
|
FilterableProperties []FilterablePropertyResponse `pulumi:"filterableProperties"`
|
|
// Hierarchy information of a product.
|
|
HierarchyInformation HierarchyInformationResponse `pulumi:"hierarchyInformation"`
|
|
// Image information for the product system.
|
|
ImageInformation []ImageInformationResponse `pulumi:"imageInformation"`
|
|
// List of products in the product line
|
|
Products []ProductResponse `pulumi:"products"`
|
|
}
|
|
|
|
// ProductLineResponseInput is an input type that accepts ProductLineResponseArgs and ProductLineResponseOutput values.
|
|
// You can construct a concrete instance of `ProductLineResponseInput` via:
|
|
//
|
|
// ProductLineResponseArgs{...}
|
|
type ProductLineResponseInput interface {
|
|
pulumi.Input
|
|
|
|
ToProductLineResponseOutput() ProductLineResponseOutput
|
|
ToProductLineResponseOutputWithContext(context.Context) ProductLineResponseOutput
|
|
}
|
|
|
|
// Product line
|
|
type ProductLineResponseArgs struct {
|
|
// Availability information of the product system.
|
|
AvailabilityInformation AvailabilityInformationResponseInput `pulumi:"availabilityInformation"`
|
|
// Cost information for the product system.
|
|
CostInformation CostInformationResponseInput `pulumi:"costInformation"`
|
|
// Description related to the product system.
|
|
Description DescriptionResponseInput `pulumi:"description"`
|
|
// Display Name for the product system.
|
|
DisplayName pulumi.StringInput `pulumi:"displayName"`
|
|
// list of filters supported for a product
|
|
FilterableProperties FilterablePropertyResponseArrayInput `pulumi:"filterableProperties"`
|
|
// Hierarchy information of a product.
|
|
HierarchyInformation HierarchyInformationResponseInput `pulumi:"hierarchyInformation"`
|
|
// Image information for the product system.
|
|
ImageInformation ImageInformationResponseArrayInput `pulumi:"imageInformation"`
|
|
// List of products in the product line
|
|
Products ProductResponseArrayInput `pulumi:"products"`
|
|
}
|
|
|
|
func (ProductLineResponseArgs) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*ProductLineResponse)(nil)).Elem()
|
|
}
|
|
|
|
func (i ProductLineResponseArgs) ToProductLineResponseOutput() ProductLineResponseOutput {
|
|
return i.ToProductLineResponseOutputWithContext(context.Background())
|
|
}
|
|
|
|
func (i ProductLineResponseArgs) ToProductLineResponseOutputWithContext(ctx context.Context) ProductLineResponseOutput {
|
|
return pulumi.ToOutputWithContext(ctx, i).(ProductLineResponseOutput)
|
|
}
|
|
|
|
// ProductLineResponseArrayInput is an input type that accepts ProductLineResponseArray and ProductLineResponseArrayOutput values.
|
|
// You can construct a concrete instance of `ProductLineResponseArrayInput` via:
|
|
//
|
|
// ProductLineResponseArray{ ProductLineResponseArgs{...} }
|
|
type ProductLineResponseArrayInput interface {
|
|
pulumi.Input
|
|
|
|
ToProductLineResponseArrayOutput() ProductLineResponseArrayOutput
|
|
ToProductLineResponseArrayOutputWithContext(context.Context) ProductLineResponseArrayOutput
|
|
}
|
|
|
|
type ProductLineResponseArray []ProductLineResponseInput
|
|
|
|
func (ProductLineResponseArray) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*[]ProductLineResponse)(nil)).Elem()
|
|
}
|
|
|
|
func (i ProductLineResponseArray) ToProductLineResponseArrayOutput() ProductLineResponseArrayOutput {
|
|
return i.ToProductLineResponseArrayOutputWithContext(context.Background())
|
|
}
|
|
|
|
func (i ProductLineResponseArray) ToProductLineResponseArrayOutputWithContext(ctx context.Context) ProductLineResponseArrayOutput {
|
|
return pulumi.ToOutputWithContext(ctx, i).(ProductLineResponseArrayOutput)
|
|
}
|
|
|
|
// Product line
|
|
type ProductLineResponseOutput struct{ *pulumi.OutputState }
|
|
|
|
func (ProductLineResponseOutput) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*ProductLineResponse)(nil)).Elem()
|
|
}
|
|
|
|
func (o ProductLineResponseOutput) ToProductLineResponseOutput() ProductLineResponseOutput {
|
|
return o
|
|
}
|
|
|
|
func (o ProductLineResponseOutput) ToProductLineResponseOutputWithContext(ctx context.Context) ProductLineResponseOutput {
|
|
return o
|
|
}
|
|
|
|
// Availability information of the product system.
|
|
func (o ProductLineResponseOutput) AvailabilityInformation() AvailabilityInformationResponseOutput {
|
|
return o.ApplyT(func(v ProductLineResponse) AvailabilityInformationResponse { return v.AvailabilityInformation }).(AvailabilityInformationResponseOutput)
|
|
}
|
|
|
|
// Cost information for the product system.
|
|
func (o ProductLineResponseOutput) CostInformation() CostInformationResponseOutput {
|
|
return o.ApplyT(func(v ProductLineResponse) CostInformationResponse { return v.CostInformation }).(CostInformationResponseOutput)
|
|
}
|
|
|
|
// Description related to the product system.
|
|
func (o ProductLineResponseOutput) Description() DescriptionResponseOutput {
|
|
return o.ApplyT(func(v ProductLineResponse) DescriptionResponse { return v.Description }).(DescriptionResponseOutput)
|
|
}
|
|
|
|
// Display Name for the product system.
|
|
func (o ProductLineResponseOutput) DisplayName() pulumi.StringOutput {
|
|
return o.ApplyT(func(v ProductLineResponse) string { return v.DisplayName }).(pulumi.StringOutput)
|
|
}
|
|
|
|
// list of filters supported for a product
|
|
func (o ProductLineResponseOutput) FilterableProperties() FilterablePropertyResponseArrayOutput {
|
|
return o.ApplyT(func(v ProductLineResponse) []FilterablePropertyResponse { return v.FilterableProperties }).(FilterablePropertyResponseArrayOutput)
|
|
}
|
|
|
|
// Hierarchy information of a product.
|
|
func (o ProductLineResponseOutput) HierarchyInformation() HierarchyInformationResponseOutput {
|
|
return o.ApplyT(func(v ProductLineResponse) HierarchyInformationResponse { return v.HierarchyInformation }).(HierarchyInformationResponseOutput)
|
|
}
|
|
|
|
// Image information for the product system.
|
|
func (o ProductLineResponseOutput) ImageInformation() ImageInformationResponseArrayOutput {
|
|
return o.ApplyT(func(v ProductLineResponse) []ImageInformationResponse { return v.ImageInformation }).(ImageInformationResponseArrayOutput)
|
|
}
|
|
|
|
// List of products in the product line
|
|
func (o ProductLineResponseOutput) Products() ProductResponseArrayOutput {
|
|
return o.ApplyT(func(v ProductLineResponse) []ProductResponse { return v.Products }).(ProductResponseArrayOutput)
|
|
}
|
|
|
|
type ProductLineResponseArrayOutput struct{ *pulumi.OutputState }
|
|
|
|
func (ProductLineResponseArrayOutput) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*[]ProductLineResponse)(nil)).Elem()
|
|
}
|
|
|
|
func (o ProductLineResponseArrayOutput) ToProductLineResponseArrayOutput() ProductLineResponseArrayOutput {
|
|
return o
|
|
}
|
|
|
|
func (o ProductLineResponseArrayOutput) ToProductLineResponseArrayOutputWithContext(ctx context.Context) ProductLineResponseArrayOutput {
|
|
return o
|
|
}
|
|
|
|
func (o ProductLineResponseArrayOutput) Index(i pulumi.IntInput) ProductLineResponseOutput {
|
|
return pulumi.All(o, i).ApplyT(func(vs []interface{}) ProductLineResponse {
|
|
return vs[0].([]ProductLineResponse)[vs[1].(int)]
|
|
}).(ProductLineResponseOutput)
|
|
}
|
|
|
|
// List of Products
|
|
type ProductResponse struct {
|
|
// Availability information of the product system.
|
|
AvailabilityInformation AvailabilityInformationResponse `pulumi:"availabilityInformation"`
|
|
// List of configurations for the product
|
|
Configurations []ConfigurationResponse `pulumi:"configurations"`
|
|
// Cost information for the product system.
|
|
CostInformation CostInformationResponse `pulumi:"costInformation"`
|
|
// Description related to the product system.
|
|
Description DescriptionResponse `pulumi:"description"`
|
|
// Display Name for the product system.
|
|
DisplayName string `pulumi:"displayName"`
|
|
// list of filters supported for a product
|
|
FilterableProperties []FilterablePropertyResponse `pulumi:"filterableProperties"`
|
|
// Hierarchy information of a product.
|
|
HierarchyInformation HierarchyInformationResponse `pulumi:"hierarchyInformation"`
|
|
// Image information for the product system.
|
|
ImageInformation []ImageInformationResponse `pulumi:"imageInformation"`
|
|
}
|
|
|
|
// ProductResponseInput is an input type that accepts ProductResponseArgs and ProductResponseOutput values.
|
|
// You can construct a concrete instance of `ProductResponseInput` via:
|
|
//
|
|
// ProductResponseArgs{...}
|
|
type ProductResponseInput interface {
|
|
pulumi.Input
|
|
|
|
ToProductResponseOutput() ProductResponseOutput
|
|
ToProductResponseOutputWithContext(context.Context) ProductResponseOutput
|
|
}
|
|
|
|
// List of Products
|
|
type ProductResponseArgs struct {
|
|
// Availability information of the product system.
|
|
AvailabilityInformation AvailabilityInformationResponseInput `pulumi:"availabilityInformation"`
|
|
// List of configurations for the product
|
|
Configurations ConfigurationResponseArrayInput `pulumi:"configurations"`
|
|
// Cost information for the product system.
|
|
CostInformation CostInformationResponseInput `pulumi:"costInformation"`
|
|
// Description related to the product system.
|
|
Description DescriptionResponseInput `pulumi:"description"`
|
|
// Display Name for the product system.
|
|
DisplayName pulumi.StringInput `pulumi:"displayName"`
|
|
// list of filters supported for a product
|
|
FilterableProperties FilterablePropertyResponseArrayInput `pulumi:"filterableProperties"`
|
|
// Hierarchy information of a product.
|
|
HierarchyInformation HierarchyInformationResponseInput `pulumi:"hierarchyInformation"`
|
|
// Image information for the product system.
|
|
ImageInformation ImageInformationResponseArrayInput `pulumi:"imageInformation"`
|
|
}
|
|
|
|
func (ProductResponseArgs) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*ProductResponse)(nil)).Elem()
|
|
}
|
|
|
|
func (i ProductResponseArgs) ToProductResponseOutput() ProductResponseOutput {
|
|
return i.ToProductResponseOutputWithContext(context.Background())
|
|
}
|
|
|
|
func (i ProductResponseArgs) ToProductResponseOutputWithContext(ctx context.Context) ProductResponseOutput {
|
|
return pulumi.ToOutputWithContext(ctx, i).(ProductResponseOutput)
|
|
}
|
|
|
|
// ProductResponseArrayInput is an input type that accepts ProductResponseArray and ProductResponseArrayOutput values.
|
|
// You can construct a concrete instance of `ProductResponseArrayInput` via:
|
|
//
|
|
// ProductResponseArray{ ProductResponseArgs{...} }
|
|
type ProductResponseArrayInput interface {
|
|
pulumi.Input
|
|
|
|
ToProductResponseArrayOutput() ProductResponseArrayOutput
|
|
ToProductResponseArrayOutputWithContext(context.Context) ProductResponseArrayOutput
|
|
}
|
|
|
|
type ProductResponseArray []ProductResponseInput
|
|
|
|
func (ProductResponseArray) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*[]ProductResponse)(nil)).Elem()
|
|
}
|
|
|
|
func (i ProductResponseArray) ToProductResponseArrayOutput() ProductResponseArrayOutput {
|
|
return i.ToProductResponseArrayOutputWithContext(context.Background())
|
|
}
|
|
|
|
func (i ProductResponseArray) ToProductResponseArrayOutputWithContext(ctx context.Context) ProductResponseArrayOutput {
|
|
return pulumi.ToOutputWithContext(ctx, i).(ProductResponseArrayOutput)
|
|
}
|
|
|
|
// List of Products
|
|
type ProductResponseOutput struct{ *pulumi.OutputState }
|
|
|
|
func (ProductResponseOutput) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*ProductResponse)(nil)).Elem()
|
|
}
|
|
|
|
func (o ProductResponseOutput) ToProductResponseOutput() ProductResponseOutput {
|
|
return o
|
|
}
|
|
|
|
func (o ProductResponseOutput) ToProductResponseOutputWithContext(ctx context.Context) ProductResponseOutput {
|
|
return o
|
|
}
|
|
|
|
// Availability information of the product system.
|
|
func (o ProductResponseOutput) AvailabilityInformation() AvailabilityInformationResponseOutput {
|
|
return o.ApplyT(func(v ProductResponse) AvailabilityInformationResponse { return v.AvailabilityInformation }).(AvailabilityInformationResponseOutput)
|
|
}
|
|
|
|
// List of configurations for the product
|
|
func (o ProductResponseOutput) Configurations() ConfigurationResponseArrayOutput {
|
|
return o.ApplyT(func(v ProductResponse) []ConfigurationResponse { return v.Configurations }).(ConfigurationResponseArrayOutput)
|
|
}
|
|
|
|
// Cost information for the product system.
|
|
func (o ProductResponseOutput) CostInformation() CostInformationResponseOutput {
|
|
return o.ApplyT(func(v ProductResponse) CostInformationResponse { return v.CostInformation }).(CostInformationResponseOutput)
|
|
}
|
|
|
|
// Description related to the product system.
|
|
func (o ProductResponseOutput) Description() DescriptionResponseOutput {
|
|
return o.ApplyT(func(v ProductResponse) DescriptionResponse { return v.Description }).(DescriptionResponseOutput)
|
|
}
|
|
|
|
// Display Name for the product system.
|
|
func (o ProductResponseOutput) DisplayName() pulumi.StringOutput {
|
|
return o.ApplyT(func(v ProductResponse) string { return v.DisplayName }).(pulumi.StringOutput)
|
|
}
|
|
|
|
// list of filters supported for a product
|
|
func (o ProductResponseOutput) FilterableProperties() FilterablePropertyResponseArrayOutput {
|
|
return o.ApplyT(func(v ProductResponse) []FilterablePropertyResponse { return v.FilterableProperties }).(FilterablePropertyResponseArrayOutput)
|
|
}
|
|
|
|
// Hierarchy information of a product.
|
|
func (o ProductResponseOutput) HierarchyInformation() HierarchyInformationResponseOutput {
|
|
return o.ApplyT(func(v ProductResponse) HierarchyInformationResponse { return v.HierarchyInformation }).(HierarchyInformationResponseOutput)
|
|
}
|
|
|
|
// Image information for the product system.
|
|
func (o ProductResponseOutput) ImageInformation() ImageInformationResponseArrayOutput {
|
|
return o.ApplyT(func(v ProductResponse) []ImageInformationResponse { return v.ImageInformation }).(ImageInformationResponseArrayOutput)
|
|
}
|
|
|
|
type ProductResponseArrayOutput struct{ *pulumi.OutputState }
|
|
|
|
func (ProductResponseArrayOutput) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*[]ProductResponse)(nil)).Elem()
|
|
}
|
|
|
|
func (o ProductResponseArrayOutput) ToProductResponseArrayOutput() ProductResponseArrayOutput {
|
|
return o
|
|
}
|
|
|
|
func (o ProductResponseArrayOutput) ToProductResponseArrayOutputWithContext(ctx context.Context) ProductResponseArrayOutput {
|
|
return o
|
|
}
|
|
|
|
func (o ProductResponseArrayOutput) Index(i pulumi.IntInput) ProductResponseOutput {
|
|
return pulumi.All(o, i).ApplyT(func(vs []interface{}) ProductResponse {
|
|
return vs[0].([]ProductResponse)[vs[1].(int)]
|
|
}).(ProductResponseOutput)
|
|
}
|
|
|
|
// Billing type Purchase meter details
|
|
type PurchaseMeterDetailsResponse struct {
|
|
// Represents billing type.
|
|
// Expected value is 'Purchase'.
|
|
BillingType *string `pulumi:"billingType"`
|
|
// Charging type.
|
|
ChargingType string `pulumi:"chargingType"`
|
|
// Billing unit applicable for Pav2 billing
|
|
Multiplier float64 `pulumi:"multiplier"`
|
|
// Product Id
|
|
ProductId string `pulumi:"productId"`
|
|
// Sku Id
|
|
SkuId string `pulumi:"skuId"`
|
|
// Term Id
|
|
TermId string `pulumi:"termId"`
|
|
}
|
|
|
|
// PurchaseMeterDetailsResponseInput is an input type that accepts PurchaseMeterDetailsResponseArgs and PurchaseMeterDetailsResponseOutput values.
|
|
// You can construct a concrete instance of `PurchaseMeterDetailsResponseInput` via:
|
|
//
|
|
// PurchaseMeterDetailsResponseArgs{...}
|
|
type PurchaseMeterDetailsResponseInput interface {
|
|
pulumi.Input
|
|
|
|
ToPurchaseMeterDetailsResponseOutput() PurchaseMeterDetailsResponseOutput
|
|
ToPurchaseMeterDetailsResponseOutputWithContext(context.Context) PurchaseMeterDetailsResponseOutput
|
|
}
|
|
|
|
// Billing type Purchase meter details
|
|
type PurchaseMeterDetailsResponseArgs struct {
|
|
// Represents billing type.
|
|
// Expected value is 'Purchase'.
|
|
BillingType pulumi.StringPtrInput `pulumi:"billingType"`
|
|
// Charging type.
|
|
ChargingType pulumi.StringInput `pulumi:"chargingType"`
|
|
// Billing unit applicable for Pav2 billing
|
|
Multiplier pulumi.Float64Input `pulumi:"multiplier"`
|
|
// Product Id
|
|
ProductId pulumi.StringInput `pulumi:"productId"`
|
|
// Sku Id
|
|
SkuId pulumi.StringInput `pulumi:"skuId"`
|
|
// Term Id
|
|
TermId pulumi.StringInput `pulumi:"termId"`
|
|
}
|
|
|
|
func (PurchaseMeterDetailsResponseArgs) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*PurchaseMeterDetailsResponse)(nil)).Elem()
|
|
}
|
|
|
|
func (i PurchaseMeterDetailsResponseArgs) ToPurchaseMeterDetailsResponseOutput() PurchaseMeterDetailsResponseOutput {
|
|
return i.ToPurchaseMeterDetailsResponseOutputWithContext(context.Background())
|
|
}
|
|
|
|
func (i PurchaseMeterDetailsResponseArgs) ToPurchaseMeterDetailsResponseOutputWithContext(ctx context.Context) PurchaseMeterDetailsResponseOutput {
|
|
return pulumi.ToOutputWithContext(ctx, i).(PurchaseMeterDetailsResponseOutput)
|
|
}
|
|
|
|
// Billing type Purchase meter details
|
|
type PurchaseMeterDetailsResponseOutput struct{ *pulumi.OutputState }
|
|
|
|
func (PurchaseMeterDetailsResponseOutput) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*PurchaseMeterDetailsResponse)(nil)).Elem()
|
|
}
|
|
|
|
func (o PurchaseMeterDetailsResponseOutput) ToPurchaseMeterDetailsResponseOutput() PurchaseMeterDetailsResponseOutput {
|
|
return o
|
|
}
|
|
|
|
func (o PurchaseMeterDetailsResponseOutput) ToPurchaseMeterDetailsResponseOutputWithContext(ctx context.Context) PurchaseMeterDetailsResponseOutput {
|
|
return o
|
|
}
|
|
|
|
// Represents billing type.
|
|
// Expected value is 'Purchase'.
|
|
func (o PurchaseMeterDetailsResponseOutput) BillingType() pulumi.StringPtrOutput {
|
|
return o.ApplyT(func(v PurchaseMeterDetailsResponse) *string { return v.BillingType }).(pulumi.StringPtrOutput)
|
|
}
|
|
|
|
// Charging type.
|
|
func (o PurchaseMeterDetailsResponseOutput) ChargingType() pulumi.StringOutput {
|
|
return o.ApplyT(func(v PurchaseMeterDetailsResponse) string { return v.ChargingType }).(pulumi.StringOutput)
|
|
}
|
|
|
|
// Billing unit applicable for Pav2 billing
|
|
func (o PurchaseMeterDetailsResponseOutput) Multiplier() pulumi.Float64Output {
|
|
return o.ApplyT(func(v PurchaseMeterDetailsResponse) float64 { return v.Multiplier }).(pulumi.Float64Output)
|
|
}
|
|
|
|
// Product Id
|
|
func (o PurchaseMeterDetailsResponseOutput) ProductId() pulumi.StringOutput {
|
|
return o.ApplyT(func(v PurchaseMeterDetailsResponse) string { return v.ProductId }).(pulumi.StringOutput)
|
|
}
|
|
|
|
// Sku Id
|
|
func (o PurchaseMeterDetailsResponseOutput) SkuId() pulumi.StringOutput {
|
|
return o.ApplyT(func(v PurchaseMeterDetailsResponse) string { return v.SkuId }).(pulumi.StringOutput)
|
|
}
|
|
|
|
// Term Id
|
|
func (o PurchaseMeterDetailsResponseOutput) TermId() pulumi.StringOutput {
|
|
return o.ApplyT(func(v PurchaseMeterDetailsResponse) string { return v.TermId }).(pulumi.StringOutput)
|
|
}
|
|
|
|
// Specifications of the configurations
|
|
type SpecificationResponse struct {
|
|
// Name of the specification
|
|
Name string `pulumi:"name"`
|
|
// Value of the specification
|
|
Value string `pulumi:"value"`
|
|
}
|
|
|
|
// SpecificationResponseInput is an input type that accepts SpecificationResponseArgs and SpecificationResponseOutput values.
|
|
// You can construct a concrete instance of `SpecificationResponseInput` via:
|
|
//
|
|
// SpecificationResponseArgs{...}
|
|
type SpecificationResponseInput interface {
|
|
pulumi.Input
|
|
|
|
ToSpecificationResponseOutput() SpecificationResponseOutput
|
|
ToSpecificationResponseOutputWithContext(context.Context) SpecificationResponseOutput
|
|
}
|
|
|
|
// Specifications of the configurations
|
|
type SpecificationResponseArgs struct {
|
|
// Name of the specification
|
|
Name pulumi.StringInput `pulumi:"name"`
|
|
// Value of the specification
|
|
Value pulumi.StringInput `pulumi:"value"`
|
|
}
|
|
|
|
func (SpecificationResponseArgs) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*SpecificationResponse)(nil)).Elem()
|
|
}
|
|
|
|
func (i SpecificationResponseArgs) ToSpecificationResponseOutput() SpecificationResponseOutput {
|
|
return i.ToSpecificationResponseOutputWithContext(context.Background())
|
|
}
|
|
|
|
func (i SpecificationResponseArgs) ToSpecificationResponseOutputWithContext(ctx context.Context) SpecificationResponseOutput {
|
|
return pulumi.ToOutputWithContext(ctx, i).(SpecificationResponseOutput)
|
|
}
|
|
|
|
// SpecificationResponseArrayInput is an input type that accepts SpecificationResponseArray and SpecificationResponseArrayOutput values.
|
|
// You can construct a concrete instance of `SpecificationResponseArrayInput` via:
|
|
//
|
|
// SpecificationResponseArray{ SpecificationResponseArgs{...} }
|
|
type SpecificationResponseArrayInput interface {
|
|
pulumi.Input
|
|
|
|
ToSpecificationResponseArrayOutput() SpecificationResponseArrayOutput
|
|
ToSpecificationResponseArrayOutputWithContext(context.Context) SpecificationResponseArrayOutput
|
|
}
|
|
|
|
type SpecificationResponseArray []SpecificationResponseInput
|
|
|
|
func (SpecificationResponseArray) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*[]SpecificationResponse)(nil)).Elem()
|
|
}
|
|
|
|
func (i SpecificationResponseArray) ToSpecificationResponseArrayOutput() SpecificationResponseArrayOutput {
|
|
return i.ToSpecificationResponseArrayOutputWithContext(context.Background())
|
|
}
|
|
|
|
func (i SpecificationResponseArray) ToSpecificationResponseArrayOutputWithContext(ctx context.Context) SpecificationResponseArrayOutput {
|
|
return pulumi.ToOutputWithContext(ctx, i).(SpecificationResponseArrayOutput)
|
|
}
|
|
|
|
// Specifications of the configurations
|
|
type SpecificationResponseOutput struct{ *pulumi.OutputState }
|
|
|
|
func (SpecificationResponseOutput) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*SpecificationResponse)(nil)).Elem()
|
|
}
|
|
|
|
func (o SpecificationResponseOutput) ToSpecificationResponseOutput() SpecificationResponseOutput {
|
|
return o
|
|
}
|
|
|
|
func (o SpecificationResponseOutput) ToSpecificationResponseOutputWithContext(ctx context.Context) SpecificationResponseOutput {
|
|
return o
|
|
}
|
|
|
|
// Name of the specification
|
|
func (o SpecificationResponseOutput) Name() pulumi.StringOutput {
|
|
return o.ApplyT(func(v SpecificationResponse) string { return v.Name }).(pulumi.StringOutput)
|
|
}
|
|
|
|
// Value of the specification
|
|
func (o SpecificationResponseOutput) Value() pulumi.StringOutput {
|
|
return o.ApplyT(func(v SpecificationResponse) string { return v.Value }).(pulumi.StringOutput)
|
|
}
|
|
|
|
type SpecificationResponseArrayOutput struct{ *pulumi.OutputState }
|
|
|
|
func (SpecificationResponseArrayOutput) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*[]SpecificationResponse)(nil)).Elem()
|
|
}
|
|
|
|
func (o SpecificationResponseArrayOutput) ToSpecificationResponseArrayOutput() SpecificationResponseArrayOutput {
|
|
return o
|
|
}
|
|
|
|
func (o SpecificationResponseArrayOutput) ToSpecificationResponseArrayOutputWithContext(ctx context.Context) SpecificationResponseArrayOutput {
|
|
return o
|
|
}
|
|
|
|
func (o SpecificationResponseArrayOutput) Index(i pulumi.IntInput) SpecificationResponseOutput {
|
|
return pulumi.All(o, i).ApplyT(func(vs []interface{}) SpecificationResponse {
|
|
return vs[0].([]SpecificationResponse)[vs[1].(int)]
|
|
}).(SpecificationResponseOutput)
|
|
}
|
|
|
|
type FilterablePropertyArrayMap map[string]FilterablePropertyArrayInput
|
|
|
|
func (FilterablePropertyArrayMap) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*FilterablePropertyArray)(nil)).Elem()
|
|
}
|
|
|
|
func (i FilterablePropertyArrayMap) ToFilterablePropertyArrayMapOutput() FilterablePropertyArrayMapOutput {
|
|
return i.ToFilterablePropertyArrayMapOutputWithContext(context.Background())
|
|
}
|
|
|
|
func (i FilterablePropertyArrayMap) ToFilterablePropertyArrayMapOutputWithContext(ctx context.Context) FilterablePropertyArrayMapOutput {
|
|
return pulumi.ToOutputWithContext(ctx, i).(FilterablePropertyArrayMapOutput)
|
|
}
|
|
|
|
type FilterablePropertyArrayMapOutput struct{ *pulumi.OutputState }
|
|
|
|
func (FilterablePropertyArrayMapOutput) ElementType() reflect.Type {
|
|
return reflect.TypeOf((*map[string]FilterablePropertyArray)(nil)).Elem()
|
|
}
|
|
|
|
func (o FilterablePropertyArrayMapOutput) ToFilterablePropertyArrayMapOutput() FilterablePropertyArrayMapOutput {
|
|
return o
|
|
}
|
|
|
|
func (o FilterablePropertyArrayMapOutput) ToFilterablePropertyArrayMapOutputWithContext(ctx context.Context) FilterablePropertyArrayMapOutput {
|
|
return o
|
|
}
|
|
|
|
func (o FilterablePropertyArrayMapOutput) MapIndex(k pulumi.StringInput) FilterablePropertyArrayOutput {
|
|
return pulumi.All(o, k).ApplyT(func(vs []interface{}) FilterablePropertyArray {
|
|
return vs[0].(map[string]FilterablePropertyArray)[vs[1].(string)]
|
|
}).(FilterablePropertyArrayOutput)
|
|
}
|
|
|
|
// FilterablePropertyArrayMapInput is an input type that accepts FilterablePropertyArrayMap and FilterablePropertyArrayMapOutput values.
|
|
// You can construct a concrete instance of `FilterablePropertyArrayMapInput` via:
|
|
//
|
|
// FilterablePropertyArrayMap{ "key": FilterablePropertyArray{ FilterablePropertyArgs{...} } }
|
|
type FilterablePropertyArrayMapInput interface {
|
|
pulumi.Input
|
|
|
|
ToFilterablePropertyArrayMapOutput() FilterablePropertyArrayMapOutput
|
|
ToFilterablePropertyArrayMapOutputWithContext(context.Context) FilterablePropertyArrayMapOutput
|
|
}
|
|
|
|
func init() {
|
|
pulumi.RegisterInputType(reflect.TypeOf((*AvailabilityInformationResponseInput)(nil)).Elem(), AvailabilityInformationResponseArgs{})
|
|
pulumi.RegisterInputType(reflect.TypeOf((*BillingMeterDetailsResponseInput)(nil)).Elem(), BillingMeterDetailsResponseArgs{})
|
|
pulumi.RegisterInputType(reflect.TypeOf((*BillingMeterDetailsResponseArrayInput)(nil)).Elem(), BillingMeterDetailsResponseArray{})
|
|
pulumi.RegisterInputType(reflect.TypeOf((*ConfigurationFiltersInput)(nil)).Elem(), ConfigurationFiltersArgs{})
|
|
pulumi.RegisterInputType(reflect.TypeOf((*ConfigurationFiltersArrayInput)(nil)).Elem(), ConfigurationFiltersArray{})
|
|
pulumi.RegisterInputType(reflect.TypeOf((*ConfigurationResponseInput)(nil)).Elem(), ConfigurationResponseArgs{})
|
|
pulumi.RegisterInputType(reflect.TypeOf((*ConfigurationResponseArrayInput)(nil)).Elem(), ConfigurationResponseArray{})
|
|
pulumi.RegisterInputType(reflect.TypeOf((*CostInformationResponseInput)(nil)).Elem(), CostInformationResponseArgs{})
|
|
pulumi.RegisterInputType(reflect.TypeOf((*CustomerSubscriptionDetailsInput)(nil)).Elem(), CustomerSubscriptionDetailsArgs{})
|
|
pulumi.RegisterInputType(reflect.TypeOf((*CustomerSubscriptionDetailsPtrInput)(nil)).Elem(), CustomerSubscriptionDetailsArgs{})
|
|
pulumi.RegisterInputType(reflect.TypeOf((*CustomerSubscriptionRegisteredFeaturesInput)(nil)).Elem(), CustomerSubscriptionRegisteredFeaturesArgs{})
|
|
pulumi.RegisterInputType(reflect.TypeOf((*CustomerSubscriptionRegisteredFeaturesArrayInput)(nil)).Elem(), CustomerSubscriptionRegisteredFeaturesArray{})
|
|
pulumi.RegisterInputType(reflect.TypeOf((*DescriptionResponseInput)(nil)).Elem(), DescriptionResponseArgs{})
|
|
pulumi.RegisterInputType(reflect.TypeOf((*DimensionsResponseInput)(nil)).Elem(), DimensionsResponseArgs{})
|
|
pulumi.RegisterInputType(reflect.TypeOf((*FilterablePropertyInput)(nil)).Elem(), FilterablePropertyArgs{})
|
|
pulumi.RegisterInputType(reflect.TypeOf((*FilterablePropertyArrayInput)(nil)).Elem(), FilterablePropertyArray{})
|
|
pulumi.RegisterInputType(reflect.TypeOf((*FilterablePropertyResponseInput)(nil)).Elem(), FilterablePropertyResponseArgs{})
|
|
pulumi.RegisterInputType(reflect.TypeOf((*FilterablePropertyResponseArrayInput)(nil)).Elem(), FilterablePropertyResponseArray{})
|
|
pulumi.RegisterInputType(reflect.TypeOf((*HierarchyInformationInput)(nil)).Elem(), HierarchyInformationArgs{})
|
|
pulumi.RegisterInputType(reflect.TypeOf((*HierarchyInformationResponseInput)(nil)).Elem(), HierarchyInformationResponseArgs{})
|
|
pulumi.RegisterInputType(reflect.TypeOf((*ImageInformationResponseInput)(nil)).Elem(), ImageInformationResponseArgs{})
|
|
pulumi.RegisterInputType(reflect.TypeOf((*ImageInformationResponseArrayInput)(nil)).Elem(), ImageInformationResponseArray{})
|
|
pulumi.RegisterInputType(reflect.TypeOf((*LinkResponseInput)(nil)).Elem(), LinkResponseArgs{})
|
|
pulumi.RegisterInputType(reflect.TypeOf((*LinkResponseArrayInput)(nil)).Elem(), LinkResponseArray{})
|
|
pulumi.RegisterInputType(reflect.TypeOf((*Pav2MeterDetailsResponseInput)(nil)).Elem(), Pav2MeterDetailsResponseArgs{})
|
|
pulumi.RegisterInputType(reflect.TypeOf((*ProductFamilyResponseInput)(nil)).Elem(), ProductFamilyResponseArgs{})
|
|
pulumi.RegisterInputType(reflect.TypeOf((*ProductFamilyResponseArrayInput)(nil)).Elem(), ProductFamilyResponseArray{})
|
|
pulumi.RegisterInputType(reflect.TypeOf((*ProductLineResponseInput)(nil)).Elem(), ProductLineResponseArgs{})
|
|
pulumi.RegisterInputType(reflect.TypeOf((*ProductLineResponseArrayInput)(nil)).Elem(), ProductLineResponseArray{})
|
|
pulumi.RegisterInputType(reflect.TypeOf((*ProductResponseInput)(nil)).Elem(), ProductResponseArgs{})
|
|
pulumi.RegisterInputType(reflect.TypeOf((*ProductResponseArrayInput)(nil)).Elem(), ProductResponseArray{})
|
|
pulumi.RegisterInputType(reflect.TypeOf((*PurchaseMeterDetailsResponseInput)(nil)).Elem(), PurchaseMeterDetailsResponseArgs{})
|
|
pulumi.RegisterInputType(reflect.TypeOf((*SpecificationResponseInput)(nil)).Elem(), SpecificationResponseArgs{})
|
|
pulumi.RegisterInputType(reflect.TypeOf((*SpecificationResponseArrayInput)(nil)).Elem(), SpecificationResponseArray{})
|
|
pulumi.RegisterInputType(reflect.TypeOf((*FilterablePropertyArrayMapInput)(nil)).Elem(), FilterablePropertyArrayMap{})
|
|
pulumi.RegisterOutputType(AvailabilityInformationResponseOutput{})
|
|
pulumi.RegisterOutputType(BillingMeterDetailsResponseOutput{})
|
|
pulumi.RegisterOutputType(BillingMeterDetailsResponseArrayOutput{})
|
|
pulumi.RegisterOutputType(ConfigurationFiltersOutput{})
|
|
pulumi.RegisterOutputType(ConfigurationFiltersArrayOutput{})
|
|
pulumi.RegisterOutputType(ConfigurationResponseOutput{})
|
|
pulumi.RegisterOutputType(ConfigurationResponseArrayOutput{})
|
|
pulumi.RegisterOutputType(CostInformationResponseOutput{})
|
|
pulumi.RegisterOutputType(CustomerSubscriptionDetailsOutput{})
|
|
pulumi.RegisterOutputType(CustomerSubscriptionDetailsPtrOutput{})
|
|
pulumi.RegisterOutputType(CustomerSubscriptionRegisteredFeaturesOutput{})
|
|
pulumi.RegisterOutputType(CustomerSubscriptionRegisteredFeaturesArrayOutput{})
|
|
pulumi.RegisterOutputType(DescriptionResponseOutput{})
|
|
pulumi.RegisterOutputType(DimensionsResponseOutput{})
|
|
pulumi.RegisterOutputType(FilterablePropertyOutput{})
|
|
pulumi.RegisterOutputType(FilterablePropertyArrayOutput{})
|
|
pulumi.RegisterOutputType(FilterablePropertyResponseOutput{})
|
|
pulumi.RegisterOutputType(FilterablePropertyResponseArrayOutput{})
|
|
pulumi.RegisterOutputType(HierarchyInformationOutput{})
|
|
pulumi.RegisterOutputType(HierarchyInformationResponseOutput{})
|
|
pulumi.RegisterOutputType(ImageInformationResponseOutput{})
|
|
pulumi.RegisterOutputType(ImageInformationResponseArrayOutput{})
|
|
pulumi.RegisterOutputType(LinkResponseOutput{})
|
|
pulumi.RegisterOutputType(LinkResponseArrayOutput{})
|
|
pulumi.RegisterOutputType(Pav2MeterDetailsResponseOutput{})
|
|
pulumi.RegisterOutputType(ProductFamilyResponseOutput{})
|
|
pulumi.RegisterOutputType(ProductFamilyResponseArrayOutput{})
|
|
pulumi.RegisterOutputType(ProductLineResponseOutput{})
|
|
pulumi.RegisterOutputType(ProductLineResponseArrayOutput{})
|
|
pulumi.RegisterOutputType(ProductResponseOutput{})
|
|
pulumi.RegisterOutputType(ProductResponseArrayOutput{})
|
|
pulumi.RegisterOutputType(PurchaseMeterDetailsResponseOutput{})
|
|
pulumi.RegisterOutputType(SpecificationResponseOutput{})
|
|
pulumi.RegisterOutputType(SpecificationResponseArrayOutput{})
|
|
pulumi.RegisterOutputType(FilterablePropertyArrayMapOutput{})
|
|
}
|