# coding=utf-8
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

import builtins
import copy
import warnings
import sys
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
if sys.version_info >= (3, 11):
    from typing import NotRequired, TypedDict, TypeAlias
else:
    from typing_extensions import NotRequired, TypedDict, TypeAlias
from .. import _utilities
from . import outputs

__all__ = [
    'GetPricesPriceResult',
    'GetPricesPriceModuleDetailResult',
    'GetPricesPricePromotionDetailResult',
    'GetProductsProductResult',
    'GetResourceTypesTypeResult',
    'GetResourceTypesTypeHandlersResult',
    'GetResourceTypesTypeHandlersCreateResult',
    'GetResourceTypesTypeHandlersDeleteResult',
    'GetResourceTypesTypeHandlersGetResult',
    'GetResourceTypesTypeHandlersListResult',
    'GetResourceTypesTypeHandlersUpdateResult',
    'GetResourceTypesTypeInfoResult',
]

@pulumi.output_type
class GetPricesPriceResult(dict):
    def __init__(__self__, *,
                 currency: builtins.str,
                 discount_price: builtins.float,
                 module_details: Sequence['outputs.GetPricesPriceModuleDetailResult'],
                 original_price: builtins.float,
                 promotion_details: Sequence['outputs.GetPricesPricePromotionDetailResult'],
                 trade_price: builtins.float):
        """
        :param builtins.str currency: Currency. Value range: CNY: RMB. USD: USD. JPY: Japanese yen.
        :param builtins.float discount_price: Discount
        :param Sequence['GetPricesPriceModuleDetailArgs'] module_details: Pricing Module Price Details
        :param builtins.float original_price: Original Price
        :param Sequence['GetPricesPricePromotionDetailArgs'] promotion_details: Offer Details
        :param builtins.float trade_price: Preferential price
        """
        pulumi.set(__self__, "currency", currency)
        pulumi.set(__self__, "discount_price", discount_price)
        pulumi.set(__self__, "module_details", module_details)
        pulumi.set(__self__, "original_price", original_price)
        pulumi.set(__self__, "promotion_details", promotion_details)
        pulumi.set(__self__, "trade_price", trade_price)

    @property
    @pulumi.getter
    def currency(self) -> builtins.str:
        """
        Currency. Value range: CNY: RMB. USD: USD. JPY: Japanese yen.
        """
        return pulumi.get(self, "currency")

    @property
    @pulumi.getter(name="discountPrice")
    def discount_price(self) -> builtins.float:
        """
        Discount
        """
        return pulumi.get(self, "discount_price")

    @property
    @pulumi.getter(name="moduleDetails")
    def module_details(self) -> Sequence['outputs.GetPricesPriceModuleDetailResult']:
        """
        Pricing Module Price Details
        """
        return pulumi.get(self, "module_details")

    @property
    @pulumi.getter(name="originalPrice")
    def original_price(self) -> builtins.float:
        """
        Original Price
        """
        return pulumi.get(self, "original_price")

    @property
    @pulumi.getter(name="promotionDetails")
    def promotion_details(self) -> Sequence['outputs.GetPricesPricePromotionDetailResult']:
        """
        Offer Details
        """
        return pulumi.get(self, "promotion_details")

    @property
    @pulumi.getter(name="tradePrice")
    def trade_price(self) -> builtins.float:
        """
        Preferential price
        """
        return pulumi.get(self, "trade_price")


@pulumi.output_type
class GetPricesPriceModuleDetailResult(dict):
    def __init__(__self__, *,
                 cost_after_discount: builtins.float,
                 invoice_discount: builtins.float,
                 module_code: builtins.str,
                 module_name: builtins.str,
                 original_cost: builtins.float,
                 price_type: builtins.str):
        """
        :param builtins.float cost_after_discount: Preferential price.
        :param builtins.float invoice_discount: Discount.
        :param builtins.str module_code: Valuation Module Identification.
        :param builtins.str module_name: Pricing Module Name.
        :param builtins.float original_cost: Original Price.
        :param builtins.str price_type: Price Type.
        """
        pulumi.set(__self__, "cost_after_discount", cost_after_discount)
        pulumi.set(__self__, "invoice_discount", invoice_discount)
        pulumi.set(__self__, "module_code", module_code)
        pulumi.set(__self__, "module_name", module_name)
        pulumi.set(__self__, "original_cost", original_cost)
        pulumi.set(__self__, "price_type", price_type)

    @property
    @pulumi.getter(name="costAfterDiscount")
    def cost_after_discount(self) -> builtins.float:
        """
        Preferential price.
        """
        return pulumi.get(self, "cost_after_discount")

    @property
    @pulumi.getter(name="invoiceDiscount")
    def invoice_discount(self) -> builtins.float:
        """
        Discount.
        """
        return pulumi.get(self, "invoice_discount")

    @property
    @pulumi.getter(name="moduleCode")
    def module_code(self) -> builtins.str:
        """
        Valuation Module Identification.
        """
        return pulumi.get(self, "module_code")

    @property
    @pulumi.getter(name="moduleName")
    def module_name(self) -> builtins.str:
        """
        Pricing Module Name.
        """
        return pulumi.get(self, "module_name")

    @property
    @pulumi.getter(name="originalCost")
    def original_cost(self) -> builtins.float:
        """
        Original Price.
        """
        return pulumi.get(self, "original_cost")

    @property
    @pulumi.getter(name="priceType")
    def price_type(self) -> builtins.str:
        """
        Price Type.
        """
        return pulumi.get(self, "price_type")


@pulumi.output_type
class GetPricesPricePromotionDetailResult(dict):
    def __init__(__self__, *,
                 promotion_desc: builtins.str,
                 promotion_id: builtins.int,
                 promotion_name: builtins.str):
        """
        :param builtins.str promotion_desc: Offer Description.
        :param builtins.int promotion_id: Offer logo.
        :param builtins.str promotion_name: Offer Name.
        """
        pulumi.set(__self__, "promotion_desc", promotion_desc)
        pulumi.set(__self__, "promotion_id", promotion_id)
        pulumi.set(__self__, "promotion_name", promotion_name)

    @property
    @pulumi.getter(name="promotionDesc")
    def promotion_desc(self) -> builtins.str:
        """
        Offer Description.
        """
        return pulumi.get(self, "promotion_desc")

    @property
    @pulumi.getter(name="promotionId")
    def promotion_id(self) -> builtins.int:
        """
        Offer logo.
        """
        return pulumi.get(self, "promotion_id")

    @property
    @pulumi.getter(name="promotionName")
    def promotion_name(self) -> builtins.str:
        """
        Offer Name.
        """
        return pulumi.get(self, "promotion_name")


@pulumi.output_type
class GetProductsProductResult(dict):
    def __init__(__self__, *,
                 id: builtins.str,
                 product_code: builtins.str,
                 product_name: builtins.str):
        """
        :param builtins.str id: The ID of the resource supplied above.
        :param builtins.str product_code: The first ID of the resource
        :param builtins.str product_name: The name of the resource
        """
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "product_code", product_code)
        pulumi.set(__self__, "product_name", product_name)

    @property
    @pulumi.getter
    def id(self) -> builtins.str:
        """
        The ID of the resource supplied above.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="productCode")
    def product_code(self) -> builtins.str:
        """
        The first ID of the resource
        """
        return pulumi.get(self, "product_code")

    @property
    @pulumi.getter(name="productName")
    def product_name(self) -> builtins.str:
        """
        The name of the resource
        """
        return pulumi.get(self, "product_name")


@pulumi.output_type
class GetResourceTypesTypeResult(dict):
    def __init__(__self__, *,
                 create_only_properties: Sequence[builtins.str],
                 delete_only_properties: Sequence[builtins.str],
                 filter_properties: Sequence[builtins.str],
                 get_only_properties: Sequence[builtins.str],
                 get_response_properties: Sequence[builtins.str],
                 handlers: 'outputs.GetResourceTypesTypeHandlersResult',
                 id: builtins.str,
                 infos: Sequence['outputs.GetResourceTypesTypeInfoResult'],
                 list_only_properties: Sequence[builtins.str],
                 list_response_properties: Sequence[builtins.str],
                 primary_identifier: builtins.str,
                 product: builtins.str,
                 properties: builtins.str,
                 public_properties: Sequence[builtins.str],
                 read_only_properties: Sequence[builtins.str],
                 requireds: Sequence[builtins.str],
                 resource_type: builtins.str,
                 sensitive_info_properties: Sequence[builtins.str],
                 update_only_properties: Sequence[builtins.str],
                 update_type_properties: Sequence[builtins.str]):
        """
        :param Sequence[builtins.str] create_only_properties: Create an operation private parameter collection. The attributes are not returned in the resource query operation, but the parameters are required in the creation operation.
        :param Sequence[builtins.str] delete_only_properties: Delete operation private parameter collection. The attribute is not returned in the resource query operation, but the parameter is required in the delete operation.
        :param Sequence[builtins.str] filter_properties: A collection of attributes that can be used as the filter parameter during the list operation.
        :param Sequence[builtins.str] get_only_properties: Query operation private parameter collection. The attribute is not returned in the resource query operation, but the input parameter is required in the query operation.
        :param Sequence[builtins.str] get_response_properties: The collection of properties returned by the query.
        :param 'GetResourceTypesTypeHandlersArgs' handlers: Supported resource operation information (including RAM permissions).
        :param builtins.str id: The ID of the resource supplied above.
        :param Sequence['GetResourceTypesTypeInfoArgs'] infos: Basic information about the resource type.
        :param Sequence[builtins.str] list_only_properties: Enumerate the operation private parameter collection. The attributes are not returned in the resource query operation, but the parameters that need to be passed in the enumeration operation.
        :param Sequence[builtins.str] list_response_properties: Enumerates the returned property collection.
        :param builtins.str primary_identifier: Resource ID
        :param builtins.str product: Product Code.
        :param builtins.str properties: Resource attribute definition, where key is the attribute name and value is the attribute details.
        :param Sequence[builtins.str] public_properties: A collection of public attributes, which are the basic attributes of the resource. Non-Operation private parameters.
        :param Sequence[builtins.str] read_only_properties: A set of read-only parameters. It is returned only in the list or get Operation. It is not used as an input parameter during creation and change.
        :param Sequence[builtins.str] requireds: Resource creation required parameter collection.
        :param builtins.str resource_type: The resource type.
        :param Sequence[builtins.str] sensitive_info_properties: A collection of sensitive attributes, such as passwords.
        :param Sequence[builtins.str] update_only_properties: Update operation private parameter collection. The attributes are not returned in the resource query operation, but the parameters are required in the update operation.
        :param Sequence[builtins.str] update_type_properties: A collection of properties that can be modified.
        """
        pulumi.set(__self__, "create_only_properties", create_only_properties)
        pulumi.set(__self__, "delete_only_properties", delete_only_properties)
        pulumi.set(__self__, "filter_properties", filter_properties)
        pulumi.set(__self__, "get_only_properties", get_only_properties)
        pulumi.set(__self__, "get_response_properties", get_response_properties)
        pulumi.set(__self__, "handlers", handlers)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "infos", infos)
        pulumi.set(__self__, "list_only_properties", list_only_properties)
        pulumi.set(__self__, "list_response_properties", list_response_properties)
        pulumi.set(__self__, "primary_identifier", primary_identifier)
        pulumi.set(__self__, "product", product)
        pulumi.set(__self__, "properties", properties)
        pulumi.set(__self__, "public_properties", public_properties)
        pulumi.set(__self__, "read_only_properties", read_only_properties)
        pulumi.set(__self__, "requireds", requireds)
        pulumi.set(__self__, "resource_type", resource_type)
        pulumi.set(__self__, "sensitive_info_properties", sensitive_info_properties)
        pulumi.set(__self__, "update_only_properties", update_only_properties)
        pulumi.set(__self__, "update_type_properties", update_type_properties)

    @property
    @pulumi.getter(name="createOnlyProperties")
    def create_only_properties(self) -> Sequence[builtins.str]:
        """
        Create an operation private parameter collection. The attributes are not returned in the resource query operation, but the parameters are required in the creation operation.
        """
        return pulumi.get(self, "create_only_properties")

    @property
    @pulumi.getter(name="deleteOnlyProperties")
    def delete_only_properties(self) -> Sequence[builtins.str]:
        """
        Delete operation private parameter collection. The attribute is not returned in the resource query operation, but the parameter is required in the delete operation.
        """
        return pulumi.get(self, "delete_only_properties")

    @property
    @pulumi.getter(name="filterProperties")
    def filter_properties(self) -> Sequence[builtins.str]:
        """
        A collection of attributes that can be used as the filter parameter during the list operation.
        """
        return pulumi.get(self, "filter_properties")

    @property
    @pulumi.getter(name="getOnlyProperties")
    def get_only_properties(self) -> Sequence[builtins.str]:
        """
        Query operation private parameter collection. The attribute is not returned in the resource query operation, but the input parameter is required in the query operation.
        """
        return pulumi.get(self, "get_only_properties")

    @property
    @pulumi.getter(name="getResponseProperties")
    def get_response_properties(self) -> Sequence[builtins.str]:
        """
        The collection of properties returned by the query.
        """
        return pulumi.get(self, "get_response_properties")

    @property
    @pulumi.getter
    def handlers(self) -> 'outputs.GetResourceTypesTypeHandlersResult':
        """
        Supported resource operation information (including RAM permissions).
        """
        return pulumi.get(self, "handlers")

    @property
    @pulumi.getter
    def id(self) -> builtins.str:
        """
        The ID of the resource supplied above.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter
    def infos(self) -> Sequence['outputs.GetResourceTypesTypeInfoResult']:
        """
        Basic information about the resource type.
        """
        return pulumi.get(self, "infos")

    @property
    @pulumi.getter(name="listOnlyProperties")
    def list_only_properties(self) -> Sequence[builtins.str]:
        """
        Enumerate the operation private parameter collection. The attributes are not returned in the resource query operation, but the parameters that need to be passed in the enumeration operation.
        """
        return pulumi.get(self, "list_only_properties")

    @property
    @pulumi.getter(name="listResponseProperties")
    def list_response_properties(self) -> Sequence[builtins.str]:
        """
        Enumerates the returned property collection.
        """
        return pulumi.get(self, "list_response_properties")

    @property
    @pulumi.getter(name="primaryIdentifier")
    def primary_identifier(self) -> builtins.str:
        """
        Resource ID
        """
        return pulumi.get(self, "primary_identifier")

    @property
    @pulumi.getter
    def product(self) -> builtins.str:
        """
        Product Code.
        """
        return pulumi.get(self, "product")

    @property
    @pulumi.getter
    def properties(self) -> builtins.str:
        """
        Resource attribute definition, where key is the attribute name and value is the attribute details.
        """
        return pulumi.get(self, "properties")

    @property
    @pulumi.getter(name="publicProperties")
    def public_properties(self) -> Sequence[builtins.str]:
        """
        A collection of public attributes, which are the basic attributes of the resource. Non-Operation private parameters.
        """
        return pulumi.get(self, "public_properties")

    @property
    @pulumi.getter(name="readOnlyProperties")
    def read_only_properties(self) -> Sequence[builtins.str]:
        """
        A set of read-only parameters. It is returned only in the list or get Operation. It is not used as an input parameter during creation and change.
        """
        return pulumi.get(self, "read_only_properties")

    @property
    @pulumi.getter
    def requireds(self) -> Sequence[builtins.str]:
        """
        Resource creation required parameter collection.
        """
        return pulumi.get(self, "requireds")

    @property
    @pulumi.getter(name="resourceType")
    def resource_type(self) -> builtins.str:
        """
        The resource type.
        """
        return pulumi.get(self, "resource_type")

    @property
    @pulumi.getter(name="sensitiveInfoProperties")
    def sensitive_info_properties(self) -> Sequence[builtins.str]:
        """
        A collection of sensitive attributes, such as passwords.
        """
        return pulumi.get(self, "sensitive_info_properties")

    @property
    @pulumi.getter(name="updateOnlyProperties")
    def update_only_properties(self) -> Sequence[builtins.str]:
        """
        Update operation private parameter collection. The attributes are not returned in the resource query operation, but the parameters are required in the update operation.
        """
        return pulumi.get(self, "update_only_properties")

    @property
    @pulumi.getter(name="updateTypeProperties")
    def update_type_properties(self) -> Sequence[builtins.str]:
        """
        A collection of properties that can be modified.
        """
        return pulumi.get(self, "update_type_properties")


@pulumi.output_type
class GetResourceTypesTypeHandlersResult(dict):
    def __init__(__self__, *,
                 creates: Sequence['outputs.GetResourceTypesTypeHandlersCreateResult'],
                 deletes: Sequence['outputs.GetResourceTypesTypeHandlersDeleteResult'],
                 gets: Sequence['outputs.GetResourceTypesTypeHandlersGetResult'],
                 lists: Sequence['outputs.GetResourceTypesTypeHandlersListResult'],
                 updates: Sequence['outputs.GetResourceTypesTypeHandlersUpdateResult']):
        """
        :param Sequence['GetResourceTypesTypeHandlersCreateArgs'] creates: Create operation association information.
        :param Sequence['GetResourceTypesTypeHandlersDeleteArgs'] deletes: Delete operation association information.
        :param Sequence['GetResourceTypesTypeHandlersGetArgs'] gets: Query operation association information.
        :param Sequence['GetResourceTypesTypeHandlersListArgs'] lists: List operation association information.
        :param Sequence['GetResourceTypesTypeHandlersUpdateArgs'] updates: Update operation association information.
        """
        pulumi.set(__self__, "creates", creates)
        pulumi.set(__self__, "deletes", deletes)
        pulumi.set(__self__, "gets", gets)
        pulumi.set(__self__, "lists", lists)
        pulumi.set(__self__, "updates", updates)

    @property
    @pulumi.getter
    def creates(self) -> Sequence['outputs.GetResourceTypesTypeHandlersCreateResult']:
        """
        Create operation association information.
        """
        return pulumi.get(self, "creates")

    @property
    @pulumi.getter
    def deletes(self) -> Sequence['outputs.GetResourceTypesTypeHandlersDeleteResult']:
        """
        Delete operation association information.
        """
        return pulumi.get(self, "deletes")

    @property
    @pulumi.getter
    def gets(self) -> Sequence['outputs.GetResourceTypesTypeHandlersGetResult']:
        """
        Query operation association information.
        """
        return pulumi.get(self, "gets")

    @property
    @pulumi.getter
    def lists(self) -> Sequence['outputs.GetResourceTypesTypeHandlersListResult']:
        """
        List operation association information.
        """
        return pulumi.get(self, "lists")

    @property
    @pulumi.getter
    def updates(self) -> Sequence['outputs.GetResourceTypesTypeHandlersUpdateResult']:
        """
        Update operation association information.
        """
        return pulumi.get(self, "updates")


@pulumi.output_type
class GetResourceTypesTypeHandlersCreateResult(dict):
    def __init__(__self__, *,
                 permissions: Sequence[builtins.str]):
        """
        :param Sequence[builtins.str] permissions: The collection of required RAM permission information.
        """
        pulumi.set(__self__, "permissions", permissions)

    @property
    @pulumi.getter
    def permissions(self) -> Sequence[builtins.str]:
        """
        The collection of required RAM permission information.
        """
        return pulumi.get(self, "permissions")


@pulumi.output_type
class GetResourceTypesTypeHandlersDeleteResult(dict):
    def __init__(__self__, *,
                 permissions: Sequence[builtins.str]):
        """
        :param Sequence[builtins.str] permissions: The collection of required RAM permission information.
        """
        pulumi.set(__self__, "permissions", permissions)

    @property
    @pulumi.getter
    def permissions(self) -> Sequence[builtins.str]:
        """
        The collection of required RAM permission information.
        """
        return pulumi.get(self, "permissions")


@pulumi.output_type
class GetResourceTypesTypeHandlersGetResult(dict):
    def __init__(__self__, *,
                 permissions: Sequence[builtins.str]):
        """
        :param Sequence[builtins.str] permissions: The collection of required RAM permission information.
        """
        pulumi.set(__self__, "permissions", permissions)

    @property
    @pulumi.getter
    def permissions(self) -> Sequence[builtins.str]:
        """
        The collection of required RAM permission information.
        """
        return pulumi.get(self, "permissions")


@pulumi.output_type
class GetResourceTypesTypeHandlersListResult(dict):
    def __init__(__self__, *,
                 permissions: Sequence[builtins.str]):
        """
        :param Sequence[builtins.str] permissions: The collection of required RAM permission information.
        """
        pulumi.set(__self__, "permissions", permissions)

    @property
    @pulumi.getter
    def permissions(self) -> Sequence[builtins.str]:
        """
        The collection of required RAM permission information.
        """
        return pulumi.get(self, "permissions")


@pulumi.output_type
class GetResourceTypesTypeHandlersUpdateResult(dict):
    def __init__(__self__, *,
                 permissions: Sequence[builtins.str]):
        """
        :param Sequence[builtins.str] permissions: The collection of required RAM permission information.
        """
        pulumi.set(__self__, "permissions", permissions)

    @property
    @pulumi.getter
    def permissions(self) -> Sequence[builtins.str]:
        """
        The collection of required RAM permission information.
        """
        return pulumi.get(self, "permissions")


@pulumi.output_type
class GetResourceTypesTypeInfoResult(dict):
    def __init__(__self__, *,
                 charge_type: builtins.str,
                 delivery_scope: builtins.str,
                 description: builtins.str,
                 title: builtins.str):
        """
        :param builtins.str charge_type: Payment formpaid (paid)(free).
        :param builtins.str delivery_scope: Delivery Levelcenter (centralized deployment level)region (regional deployment level)zone (Availability zone deployment level).
        :param builtins.str description: Resource type description.
        :param builtins.str title: The resource type name.
        """
        pulumi.set(__self__, "charge_type", charge_type)
        pulumi.set(__self__, "delivery_scope", delivery_scope)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "title", title)

    @property
    @pulumi.getter(name="chargeType")
    def charge_type(self) -> builtins.str:
        """
        Payment formpaid (paid)(free).
        """
        return pulumi.get(self, "charge_type")

    @property
    @pulumi.getter(name="deliveryScope")
    def delivery_scope(self) -> builtins.str:
        """
        Delivery Levelcenter (centralized deployment level)region (regional deployment level)zone (Availability zone deployment level).
        """
        return pulumi.get(self, "delivery_scope")

    @property
    @pulumi.getter
    def description(self) -> builtins.str:
        """
        Resource type description.
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter
    def title(self) -> builtins.str:
        """
        The resource type name.
        """
        return pulumi.get(self, "title")


