Struct stripe::Plan

pub struct Plan {
    pub id: PlanId,
    pub active: bool,
    pub aggregate_usage: Option<PlanAggregateUsage>,
    pub amount: Option<i64>,
    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: 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: bool

Whether the plan is currently available for new subscriptions.

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 picking the last usage record reported within a period, last_ever for picking the last usage record ever (across period bounds) or max which picks the usage record with the maximum reported usage during a period. Defaults to sum.

amount: Option<i64>

The amount in %s to be charged on the interval specified.

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>

One of day, week, month or year.

The frequency with which a subscription should be billed.

interval_count: Option<u64>

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

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

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

transform_usage: Option<TransformUsage>

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

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 will automatically bill the quantity set for a plan when adding it to a subscription, metered will aggregate the total usage based on usage records. Defaults to licensed.

Methods

impl Plan

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

Returns a list of your plans.

pub fn create(client: &Client, params: CreatePlan) -> Response<Plan>

You can create plans using the API, or in the Stripe Dashboard.

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 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 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 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.

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.