Struct stripe::generated::billing::plan::Plan

pub struct Plan {

    pub id: PlanId,
    pub active: Option<bool>,
    pub aggregate_usage: Option<PlanAggregateUsage>,
    pub amount: Option<i64>,
    pub amount_decimal: Option<String>,
    pub billing_scheme: Option<PlanBillingScheme>,
    pub created: Option<Timestamp>,
    pub currency: Option<Currency>,
    pub deleted: bool,
    pub interval: Option<PlanInterval>,
    pub interval_count: Option<u64>,
    pub livemode: Option<bool>,
    pub metadata: Metadata,
    pub nickname: Option<String>,
    pub product: Option<Expandable<Product>>,
    pub tiers: Option<Vec<PlanTier>>,
    pub tiers_mode: Option<PlanTiersMode>,
    pub transform_usage: Option<TransformUsage>,
    pub trial_period_days: Option<u32>,
    pub usage_type: Option<PlanUsageType>,
}

The resource representing a Stripe “Plan”.

For more details see https://stripe.com/docs/api/plans/object

Fields

id: PlanId

Unique identifier for the object.

active: Option<bool>

Whether the plan can be used for new purchases.

aggregate_usage: Option<PlanAggregateUsage>

Specifies a usage aggregation strategy for plans of usage_type=metered.

Allowed values are sum for summing up all usage during a period, last_during_period for using the last usage record reported within a period, last_ever for using the last usage record ever (across period bounds) or max which uses the usage record with the maximum reported usage during a period. Defaults to sum.

amount: Option<i64>

The unit amount in %s to be charged, represented as a whole integer if possible.

Only set if billing_scheme=per_unit.

amount_decimal: Option<String>

The unit amount in %s to be charged, represented as a decimal string with at most 12 decimal places.

Only set if billing_scheme=per_unit.

billing_scheme: Option<PlanBillingScheme>

Describes how to compute the price per period.

Either per_unit or tiered. per_unit indicates that the fixed amount (specified in amount) will be charged per unit in quantity (for plans with usage_type=licensed), or per unit of total usage (for plans with usage_type=metered). tiered indicates that the unit pricing will be computed using a tiering strategy as defined using the tiers and tiers_mode attributes.

created: Option<Timestamp>

Time at which the object was created.

Measured in seconds since the Unix epoch.

currency: Option<Currency>

Three-letter ISO currency code, in lowercase.

Must be a supported currency.

deleted: bool

interval: Option<PlanInterval>

The frequency at which a subscription is billed.

One of day, week, month or year.

interval_count: Option<u64>

The number of intervals (specified in the interval attribute) between subscription billings.

For example, interval=month and interval_count=3 bills every 3 months.

livemode: Option<bool>

Has the value true if the object exists in live mode or the value false if the object exists in test mode.

metadata: Metadata

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.

nickname: Option<String>

A brief description of the plan, hidden from customers.

product: Option<Expandable<Product>>

The product whose pricing this plan determines.

tiers: Option<Vec<PlanTier>>

Each element represents a pricing tier.

This parameter requires billing_scheme to be set to tiered. See also the documentation for billing_scheme.

tiers_mode: Option<PlanTiersMode>

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 change as the quantity grows.

transform_usage: Option<TransformUsage>

Apply a transformation to the reported usage or set quantity before computing the amount billed.

Cannot be combined with tiers.

trial_period_days: Option<u32>

Default number of trial days when subscribing a customer to this plan using trial_from_plan=true.

usage_type: Option<PlanUsageType>

Configures how the quantity per period should be determined.

Can be either metered or licensed. licensed automatically bills the quantity set when adding it to a subscription. metered aggregates the total usage based on usage records. Defaults to licensed.

Implementations

impl Plan

pub fn list(client: &Client, params: &ListPlans<'_>) -> Response<List<Plan>>

Returns a list of your plans.

pub fn retrieve(client: &Client, id: &PlanId, expand: &[&str]) -> Response<Plan>

Retrieves the plan with the given ID.

pub fn update( client: &Client, id: &PlanId, params: UpdatePlan<'_> ) -> Response<Plan>

Updates the specified plan by setting the values of the parameters passed.

Any parameters not provided are left unchanged. By design, you cannot change a plan’s ID, amount, currency, or billing cycle.

pub fn delete(client: &Client, id: &PlanId) -> Response<Deleted<PlanId>>

Deleting plans means new subscribers can’t be added.

Existing subscribers aren’t affected.

Trait Implementations

impl Clone for Plan

fn clone(&self) -> Plan

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Plan

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Plan

fn default() -> Plan

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Plan

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Object for Plan

type Id = PlanId

The canonical id type for this object.

fn id(&self) -> Self::Id

The id of the object.

fn object(&self) -> &'static str

The object’s type, typically represented in wire format as the object property.

impl Serialize for Plan

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where __S: Serializer,

Serialize this value into the given Serde serializer.