// *** 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.StringInput `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.StringOutput {
	return o.ApplyT(func(v Pav2MeterDetailsResponse) string { return v.BillingType }).(pulumi.StringOutput)
}

// 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.StringInput `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.StringOutput {
	return o.ApplyT(func(v PurchaseMeterDetailsResponse) string { return v.BillingType }).(pulumi.StringOutput)
}

// 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((*map[string][]FilterableProperty)(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)
}

// 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
}

type FilterablePropertyArrayMapOutput struct{ *pulumi.OutputState }

func (FilterablePropertyArrayMapOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*map[string][]FilterableProperty)(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{}) []FilterableProperty {
		return vs[0].(map[string][]FilterableProperty)[vs[1].(string)]
	}).(FilterablePropertyArrayOutput)
}

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{})
}
