import * as pulumi from "@pulumi/pulumi";
import * as inputs from "./types/input";
import * as outputs from "./types/output";
export declare class Price extends pulumi.CustomResource {
    /**
     * Get an existing Price resource's state with the given name, ID, and optional extra
     * properties used to qualify the lookup.
     *
     * @param name The _unique_ name of the resulting resource.
     * @param id The _unique_ provider ID of the resource to lookup.
     * @param state Any extra arguments used during the lookup.
     * @param opts Optional settings to control the behavior of the CustomResource.
     */
    static get(name: string, id: pulumi.Input<pulumi.ID>, state?: PriceState, opts?: pulumi.CustomResourceOptions): Price;
    /**
     * Returns true if the given object is an instance of Price.  This is designed to work even
     * when multiple copies of the Pulumi SDK have been loaded into the same process.
     */
    static isInstance(obj: any): obj is Price;
    /**
     * Whether the price can be used for new purchases. Defaults to true.
     */
    readonly active: pulumi.Output<boolean | undefined>;
    /**
     * Describes how to compute the price per period. Either perUnit or tiered. perUnit indicates that the fixed amount
     * (specified in unitAmount or unit_amount_decimal) will be charged per unit in quantity (for prices with
     * usage_type=licensed), or per unit of total usage (for prices with usage_type=metered). tiered indicates that the unit
     * pricing will be computed using a tiering strategy as defined using the tiers and tiersMode attributes.
     */
    readonly billingScheme: pulumi.Output<string>;
    /**
     * Three-letter ISO currency code, in lowercase.
     */
    readonly currency: pulumi.Output<string>;
    /**
     * Prices defined in each available currency option. Each key must be a three-letter ISO currency code and a supported
     * currency
     */
    readonly currencyOptions: pulumi.Output<outputs.PriceCurrencyOption[] | undefined>;
    /**
     * When set, provides configuration for the amount to be adjusted by the customer during Checkout Sessions and Payment
     * Links
     */
    readonly customUnitAmount: pulumi.Output<outputs.PriceCustomUnitAmount | undefined>;
    /**
     * A lookup key used to retrieve prices dynamically from a static string.
     */
    readonly lookupKey: pulumi.Output<string | undefined>;
    /**
     * Set of key-value pairs that you can attach to an object. This can be useful for storing additional information about the
     * object in a structured format.
     */
    readonly metadata: pulumi.Output<{
        [key: string]: string;
    } | undefined>;
    /**
     * A brief description of the price, hidden from customers.
     */
    readonly nickname: pulumi.Output<string | undefined>;
    /**
     * The ID of the product that this price will belong to.
     */
    readonly product: pulumi.Output<string>;
    /**
     * The recurring components of a price such as interval and usage_type.
     */
    readonly recurring: pulumi.Output<outputs.PriceRecurring | undefined>;
    /**
     * Specifies whether the price is considered inclusive of taxes or exclusive of taxes. One of inclusive, exclusive, or
     * unspecified. Once specified as either inclusive or exclusive, it cannot be changed.
     */
    readonly taxBehavior: pulumi.Output<string | undefined>;
    /**
     * Each element represents a pricing tier. This parameter requires billingScheme to be set to tiered. See also the
     * documentation for billing_scheme.
     */
    readonly tiers: pulumi.Output<outputs.PriceTier[] | undefined>;
    /**
     * Defines if the tiering price should be graduated or volume based. In volume-based tiering, the maximum quantity within a
     * period determines the per unit price, in graduated tiering pricing can successively change as the quantity grows.
     */
    readonly tiersMode: pulumi.Output<string | undefined>;
    /**
     * If set to true, will atomically remove the lookup key from the existing price, and assign it to this price.
     */
    readonly transferLookupKey: pulumi.Output<boolean | undefined>;
    /**
     * Apply a transformation to the reported usage or set quantity before computing the billed price. Cannot be combined with
     * tiers
     */
    readonly transformQuantity: pulumi.Output<outputs.PriceTransformQuantity | undefined>;
    /**
     * One of oneTime or recurring depending on whether the price is for a one-time purchase or a recurring (subscription)
     * purchase
     */
    readonly type: pulumi.Output<string>;
    /**
     * A positive integer in cents (or -1 for a free price) representing how much to charge.
     */
    readonly unitAmount: pulumi.Output<number>;
    /**
     * Same as unit_amount, but accepts a decimal value in cents with at most 12 decimal places. Only one of unitAmount and
     * unitAmountDecimal can be set
     */
    readonly unitAmountDecimal: pulumi.Output<number>;
    /**
     * Create a Price resource with the given unique name, arguments, and options.
     *
     * @param name The _unique_ name of the resource.
     * @param args The arguments to use to populate this resource's properties.
     * @param opts A bag of options that control this resource's behavior.
     */
    constructor(name: string, args: PriceArgs, opts?: pulumi.CustomResourceOptions);
}
/**
 * Input properties used for looking up and filtering Price resources.
 */
export interface PriceState {
    /**
     * Whether the price can be used for new purchases. Defaults to true.
     */
    active?: pulumi.Input<boolean>;
    /**
     * Describes how to compute the price per period. Either perUnit or tiered. perUnit indicates that the fixed amount
     * (specified in unitAmount or unit_amount_decimal) will be charged per unit in quantity (for prices with
     * usage_type=licensed), or per unit of total usage (for prices with usage_type=metered). tiered indicates that the unit
     * pricing will be computed using a tiering strategy as defined using the tiers and tiersMode attributes.
     */
    billingScheme?: pulumi.Input<string>;
    /**
     * Three-letter ISO currency code, in lowercase.
     */
    currency?: pulumi.Input<string>;
    /**
     * Prices defined in each available currency option. Each key must be a three-letter ISO currency code and a supported
     * currency
     */
    currencyOptions?: pulumi.Input<pulumi.Input<inputs.PriceCurrencyOption>[]>;
    /**
     * When set, provides configuration for the amount to be adjusted by the customer during Checkout Sessions and Payment
     * Links
     */
    customUnitAmount?: pulumi.Input<inputs.PriceCustomUnitAmount>;
    /**
     * A lookup key used to retrieve prices dynamically from a static string.
     */
    lookupKey?: pulumi.Input<string>;
    /**
     * Set of key-value pairs that you can attach to an object. This can be useful for storing additional information about the
     * object in a structured format.
     */
    metadata?: pulumi.Input<{
        [key: string]: pulumi.Input<string>;
    }>;
    /**
     * A brief description of the price, hidden from customers.
     */
    nickname?: pulumi.Input<string>;
    /**
     * The ID of the product that this price will belong to.
     */
    product?: pulumi.Input<string>;
    /**
     * The recurring components of a price such as interval and usage_type.
     */
    recurring?: pulumi.Input<inputs.PriceRecurring>;
    /**
     * Specifies whether the price is considered inclusive of taxes or exclusive of taxes. One of inclusive, exclusive, or
     * unspecified. Once specified as either inclusive or exclusive, it cannot be changed.
     */
    taxBehavior?: pulumi.Input<string>;
    /**
     * Each element represents a pricing tier. This parameter requires billingScheme to be set to tiered. See also the
     * documentation for billing_scheme.
     */
    tiers?: pulumi.Input<pulumi.Input<inputs.PriceTier>[]>;
    /**
     * Defines if the tiering price should be graduated or volume based. In volume-based tiering, the maximum quantity within a
     * period determines the per unit price, in graduated tiering pricing can successively change as the quantity grows.
     */
    tiersMode?: pulumi.Input<string>;
    /**
     * If set to true, will atomically remove the lookup key from the existing price, and assign it to this price.
     */
    transferLookupKey?: pulumi.Input<boolean>;
    /**
     * Apply a transformation to the reported usage or set quantity before computing the billed price. Cannot be combined with
     * tiers
     */
    transformQuantity?: pulumi.Input<inputs.PriceTransformQuantity>;
    /**
     * One of oneTime or recurring depending on whether the price is for a one-time purchase or a recurring (subscription)
     * purchase
     */
    type?: pulumi.Input<string>;
    /**
     * A positive integer in cents (or -1 for a free price) representing how much to charge.
     */
    unitAmount?: pulumi.Input<number>;
    /**
     * Same as unit_amount, but accepts a decimal value in cents with at most 12 decimal places. Only one of unitAmount and
     * unitAmountDecimal can be set
     */
    unitAmountDecimal?: pulumi.Input<number>;
}
/**
 * The set of arguments for constructing a Price resource.
 */
export interface PriceArgs {
    /**
     * Whether the price can be used for new purchases. Defaults to true.
     */
    active?: pulumi.Input<boolean>;
    /**
     * Describes how to compute the price per period. Either perUnit or tiered. perUnit indicates that the fixed amount
     * (specified in unitAmount or unit_amount_decimal) will be charged per unit in quantity (for prices with
     * usage_type=licensed), or per unit of total usage (for prices with usage_type=metered). tiered indicates that the unit
     * pricing will be computed using a tiering strategy as defined using the tiers and tiersMode attributes.
     */
    billingScheme?: pulumi.Input<string>;
    /**
     * Three-letter ISO currency code, in lowercase.
     */
    currency: pulumi.Input<string>;
    /**
     * Prices defined in each available currency option. Each key must be a three-letter ISO currency code and a supported
     * currency
     */
    currencyOptions?: pulumi.Input<pulumi.Input<inputs.PriceCurrencyOption>[]>;
    /**
     * When set, provides configuration for the amount to be adjusted by the customer during Checkout Sessions and Payment
     * Links
     */
    customUnitAmount?: pulumi.Input<inputs.PriceCustomUnitAmount>;
    /**
     * A lookup key used to retrieve prices dynamically from a static string.
     */
    lookupKey?: pulumi.Input<string>;
    /**
     * Set of key-value pairs that you can attach to an object. This can be useful for storing additional information about the
     * object in a structured format.
     */
    metadata?: pulumi.Input<{
        [key: string]: pulumi.Input<string>;
    }>;
    /**
     * A brief description of the price, hidden from customers.
     */
    nickname?: pulumi.Input<string>;
    /**
     * The ID of the product that this price will belong to.
     */
    product: pulumi.Input<string>;
    /**
     * The recurring components of a price such as interval and usage_type.
     */
    recurring?: pulumi.Input<inputs.PriceRecurring>;
    /**
     * Specifies whether the price is considered inclusive of taxes or exclusive of taxes. One of inclusive, exclusive, or
     * unspecified. Once specified as either inclusive or exclusive, it cannot be changed.
     */
    taxBehavior?: pulumi.Input<string>;
    /**
     * Each element represents a pricing tier. This parameter requires billingScheme to be set to tiered. See also the
     * documentation for billing_scheme.
     */
    tiers?: pulumi.Input<pulumi.Input<inputs.PriceTier>[]>;
    /**
     * Defines if the tiering price should be graduated or volume based. In volume-based tiering, the maximum quantity within a
     * period determines the per unit price, in graduated tiering pricing can successively change as the quantity grows.
     */
    tiersMode?: pulumi.Input<string>;
    /**
     * If set to true, will atomically remove the lookup key from the existing price, and assign it to this price.
     */
    transferLookupKey?: pulumi.Input<boolean>;
    /**
     * Apply a transformation to the reported usage or set quantity before computing the billed price. Cannot be combined with
     * tiers
     */
    transformQuantity?: pulumi.Input<inputs.PriceTransformQuantity>;
    /**
     * A positive integer in cents (or -1 for a free price) representing how much to charge.
     */
    unitAmount?: pulumi.Input<number>;
    /**
     * Same as unit_amount, but accepts a decimal value in cents with at most 12 decimal places. Only one of unitAmount and
     * unitAmountDecimal can be set
     */
    unitAmountDecimal?: pulumi.Input<number>;
}