Enumerations

Classes

`djstripe.enums.APIKeyType`

API Key Types (internal model only)

`djstripe.enums.APIKeyType.publishable`

`djstripe.enums.APIKeyType.restricted`

`djstripe.enums.APIKeyType.secret`

`djstripe.enums.APIKeyType.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.AccountType`

`djstripe.enums.AccountType.custom`

`djstripe.enums.AccountType.express`

`djstripe.enums.AccountType.standard`

`djstripe.enums.AccountType.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.ApiErrorCode`

Charge failure error codes.

https://stripe.com/docs/error-codes

`djstripe.enums.ApiErrorCode.account_already_exists`

`djstripe.enums.ApiErrorCode.account_country_invalid_address`

`djstripe.enums.ApiErrorCode.account_invalid`

`djstripe.enums.ApiErrorCode.account_number_invalid`

`djstripe.enums.ApiErrorCode.alipay_upgrade_required`

`djstripe.enums.ApiErrorCode.amount_too_large`

`djstripe.enums.ApiErrorCode.amount_too_small`

`djstripe.enums.ApiErrorCode.api_key_expired`

`djstripe.enums.ApiErrorCode.balance_insufficient`

`djstripe.enums.ApiErrorCode.bank_account_exists`

`djstripe.enums.ApiErrorCode.bank_account_unusable`

`djstripe.enums.ApiErrorCode.bank_account_unverified`

`djstripe.enums.ApiErrorCode.bitcoin_upgrade_required`

`djstripe.enums.ApiErrorCode.card_declined`

`djstripe.enums.ApiErrorCode.charge_already_captured`

`djstripe.enums.ApiErrorCode.charge_already_refunded`

`djstripe.enums.ApiErrorCode.charge_disputed`

`djstripe.enums.ApiErrorCode.charge_exceeds_source_limit`

`djstripe.enums.ApiErrorCode.charge_expired_for_capture`

`djstripe.enums.ApiErrorCode.country_unsupported`

`djstripe.enums.ApiErrorCode.coupon_expired`

`djstripe.enums.ApiErrorCode.customer_max_subscriptions`

`djstripe.enums.ApiErrorCode.email_invalid`

`djstripe.enums.ApiErrorCode.expired_card`

`djstripe.enums.ApiErrorCode.idempotency_key_in_use`

`djstripe.enums.ApiErrorCode.incorrect_address`

`djstripe.enums.ApiErrorCode.incorrect_cvc`

`djstripe.enums.ApiErrorCode.incorrect_number`

`djstripe.enums.ApiErrorCode.incorrect_zip`

`djstripe.enums.ApiErrorCode.instant_payouts_unsupported`

`djstripe.enums.ApiErrorCode.invalid_card_type`

`djstripe.enums.ApiErrorCode.invalid_charge_amount`

`djstripe.enums.ApiErrorCode.invalid_cvc`

`djstripe.enums.ApiErrorCode.invalid_expiry_month`

`djstripe.enums.ApiErrorCode.invalid_expiry_year`

`djstripe.enums.ApiErrorCode.invalid_number`

`djstripe.enums.ApiErrorCode.invalid_source_usage`

`djstripe.enums.ApiErrorCode.invalid_swipe_data`

`djstripe.enums.ApiErrorCode.invoice_no_customer_line_items`

`djstripe.enums.ApiErrorCode.invoice_no_subscription_line_items`

`djstripe.enums.ApiErrorCode.invoice_not_editable`

`djstripe.enums.ApiErrorCode.invoice_upcoming_none`

`djstripe.enums.ApiErrorCode.livemode_mismatch`

`djstripe.enums.ApiErrorCode.missing`

`djstripe.enums.ApiErrorCode.not_allowed_on_standard_account`

`djstripe.enums.ApiErrorCode.order_creation_failed`

`djstripe.enums.ApiErrorCode.order_required_settings`

`djstripe.enums.ApiErrorCode.order_status_invalid`

`djstripe.enums.ApiErrorCode.order_upstream_timeout`

`djstripe.enums.ApiErrorCode.out_of_inventory`

`djstripe.enums.ApiErrorCode.parameter_invalid_empty`

`djstripe.enums.ApiErrorCode.parameter_invalid_integer`

`djstripe.enums.ApiErrorCode.parameter_invalid_string_blank`

`djstripe.enums.ApiErrorCode.parameter_invalid_string_empty`

`djstripe.enums.ApiErrorCode.parameter_missing`

`djstripe.enums.ApiErrorCode.parameter_unknown`

`djstripe.enums.ApiErrorCode.parameters_exclusive`

`djstripe.enums.ApiErrorCode.payment_intent_authentication_failure`

`djstripe.enums.ApiErrorCode.payment_intent_incompatible_payment_method`

`djstripe.enums.ApiErrorCode.payment_intent_invalid_parameter`

`djstripe.enums.ApiErrorCode.payment_intent_payment_attempt_failed`

`djstripe.enums.ApiErrorCode.payment_intent_unexpected_state`

`djstripe.enums.ApiErrorCode.payment_method_unactivated`

`djstripe.enums.ApiErrorCode.payment_method_unexpected_state`

`djstripe.enums.ApiErrorCode.payouts_not_allowed`

`djstripe.enums.ApiErrorCode.platform_api_key_expired`

`djstripe.enums.ApiErrorCode.postal_code_invalid`

`djstripe.enums.ApiErrorCode.processing_error`

`djstripe.enums.ApiErrorCode.product_inactive`

`djstripe.enums.ApiErrorCode.rate_limit`

`djstripe.enums.ApiErrorCode.resource_already_exists`

`djstripe.enums.ApiErrorCode.resource_missing`

`djstripe.enums.ApiErrorCode.routing_number_invalid`

`djstripe.enums.ApiErrorCode.secret_key_required`

`djstripe.enums.ApiErrorCode.sepa_unsupported_account`

`djstripe.enums.ApiErrorCode.shipping_calculation_failed`

`djstripe.enums.ApiErrorCode.sku_inactive`

`djstripe.enums.ApiErrorCode.state_unsupported`

`djstripe.enums.ApiErrorCode.tax_id_invalid`

`djstripe.enums.ApiErrorCode.taxes_calculation_failed`

`djstripe.enums.ApiErrorCode.testmode_charges_only`

`djstripe.enums.ApiErrorCode.tls_version_unsupported`

`djstripe.enums.ApiErrorCode.token_already_used`

`djstripe.enums.ApiErrorCode.token_in_use`

`djstripe.enums.ApiErrorCode.transfers_not_allowed`

`djstripe.enums.ApiErrorCode.upstream_order_creation_failed`

`djstripe.enums.ApiErrorCode.url_invalid`

`djstripe.enums.ApiErrorCode.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.BalanceTransactionReportingCategory`

https://stripe.com/docs/reports/reporting-categories

`djstripe.enums.BalanceTransactionReportingCategory.advance`

`djstripe.enums.BalanceTransactionReportingCategory.advance_funding`

`djstripe.enums.BalanceTransactionReportingCategory.anticipation_repayment`

`djstripe.enums.BalanceTransactionReportingCategory.charge`

`djstripe.enums.BalanceTransactionReportingCategory.charge_failure`

`djstripe.enums.BalanceTransactionReportingCategory.connect_collection_transfer`

`djstripe.enums.BalanceTransactionReportingCategory.connect_reserved_funds`

`djstripe.enums.BalanceTransactionReportingCategory.dispute`

`djstripe.enums.BalanceTransactionReportingCategory.dispute_reversal`

`djstripe.enums.BalanceTransactionReportingCategory.fee`

`djstripe.enums.BalanceTransactionReportingCategory.issuing_authorization_hold`

`djstripe.enums.BalanceTransactionReportingCategory.issuing_authorization_release`

`djstripe.enums.BalanceTransactionReportingCategory.issuing_dispute`

`djstripe.enums.BalanceTransactionReportingCategory.issuing_transaction`

`djstripe.enums.BalanceTransactionReportingCategory.other_adjustment`

`djstripe.enums.BalanceTransactionReportingCategory.partial_capture_reversal`

`djstripe.enums.BalanceTransactionReportingCategory.payout`

`djstripe.enums.BalanceTransactionReportingCategory.payout_reversal`

`djstripe.enums.BalanceTransactionReportingCategory.platform_earning`

`djstripe.enums.BalanceTransactionReportingCategory.platform_earning_refund`

`djstripe.enums.BalanceTransactionReportingCategory.refund`

`djstripe.enums.BalanceTransactionReportingCategory.refund_failure`

`djstripe.enums.BalanceTransactionReportingCategory.risk_reserved_funds`

`djstripe.enums.BalanceTransactionReportingCategory.tax`

`djstripe.enums.BalanceTransactionReportingCategory.topup`

`djstripe.enums.BalanceTransactionReportingCategory.topup_reversal`

`djstripe.enums.BalanceTransactionReportingCategory.transfer`

`djstripe.enums.BalanceTransactionReportingCategory.transfer_reversal`

`djstripe.enums.BalanceTransactionReportingCategory.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.BalanceTransactionStatus`

`djstripe.enums.BalanceTransactionStatus.available`

`djstripe.enums.BalanceTransactionStatus.pending`

`djstripe.enums.BalanceTransactionStatus.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.BalanceTransactionType`

`djstripe.enums.BalanceTransactionType.adjustment`

`djstripe.enums.BalanceTransactionType.advance`

`djstripe.enums.BalanceTransactionType.advance_funding`

`djstripe.enums.BalanceTransactionType.anticipation_repayment`

`djstripe.enums.BalanceTransactionType.application_fee`

`djstripe.enums.BalanceTransactionType.application_fee_refund`

`djstripe.enums.BalanceTransactionType.balance_transfer_inbound`

`djstripe.enums.BalanceTransactionType.balance_transfer_outbound`

`djstripe.enums.BalanceTransactionType.charge`

`djstripe.enums.BalanceTransactionType.connect_collection_transfer`

`djstripe.enums.BalanceTransactionType.contribution`

`djstripe.enums.BalanceTransactionType.issuing_authorization_hold`

`djstripe.enums.BalanceTransactionType.issuing_authorization_release`

`djstripe.enums.BalanceTransactionType.issuing_dispute`

`djstripe.enums.BalanceTransactionType.issuing_transaction`

`djstripe.enums.BalanceTransactionType.network_cost`

`djstripe.enums.BalanceTransactionType.payment`

`djstripe.enums.BalanceTransactionType.payment_failure_refund`

`djstripe.enums.BalanceTransactionType.payment_refund`

`djstripe.enums.BalanceTransactionType.payout`

`djstripe.enums.BalanceTransactionType.payout_cancel`

`djstripe.enums.BalanceTransactionType.payout_failure`

`djstripe.enums.BalanceTransactionType.refund`

`djstripe.enums.BalanceTransactionType.refund_failure`

`djstripe.enums.BalanceTransactionType.reserve_transaction`

`djstripe.enums.BalanceTransactionType.reserved_funds`

`djstripe.enums.BalanceTransactionType.stripe_fee`

`djstripe.enums.BalanceTransactionType.stripe_fx_fee`

`djstripe.enums.BalanceTransactionType.tax_fee`

`djstripe.enums.BalanceTransactionType.topup`

`djstripe.enums.BalanceTransactionType.topup_reversal`

`djstripe.enums.BalanceTransactionType.transfer`

`djstripe.enums.BalanceTransactionType.transfer_cancel`

`djstripe.enums.BalanceTransactionType.transfer_failure`

`djstripe.enums.BalanceTransactionType.transfer_refund`

`djstripe.enums.BalanceTransactionType.validation`

`djstripe.enums.BalanceTransactionType.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.BankAccountHolderType`

`djstripe.enums.BankAccountHolderType.company`

`djstripe.enums.BankAccountHolderType.individual`

`djstripe.enums.BankAccountHolderType.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.BankAccountStatus`

`djstripe.enums.BankAccountStatus.errored`

`djstripe.enums.BankAccountStatus.new`

`djstripe.enums.BankAccountStatus.validated`

`djstripe.enums.BankAccountStatus.verification_failed`

`djstripe.enums.BankAccountStatus.verified`

`djstripe.enums.BankAccountStatus.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.BillingScheme`

`djstripe.enums.BillingScheme.per_unit`

`djstripe.enums.BillingScheme.tiered`

`djstripe.enums.BillingScheme.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.BusinessType`

`djstripe.enums.BusinessType.company`

`djstripe.enums.BusinessType.individual`

`djstripe.enums.BusinessType.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.CaptureMethod`

`djstripe.enums.CaptureMethod.automatic`

`djstripe.enums.CaptureMethod.manual`

`djstripe.enums.CaptureMethod.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.CardBrand`

`djstripe.enums.CardBrand.AmericanExpress`

`djstripe.enums.CardBrand.DinersClub`

`djstripe.enums.CardBrand.Discover`

`djstripe.enums.CardBrand.JCB`

`djstripe.enums.CardBrand.MasterCard`

`djstripe.enums.CardBrand.UnionPay`

`djstripe.enums.CardBrand.Unknown`

`djstripe.enums.CardBrand.Visa`

`djstripe.enums.CardBrand.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.CardCheckResult`

`djstripe.enums.CardCheckResult.fail`

`djstripe.enums.CardCheckResult.pass_`

`djstripe.enums.CardCheckResult.unavailable`

`djstripe.enums.CardCheckResult.unchecked`

`djstripe.enums.CardCheckResult.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.CardFundingType`

`djstripe.enums.CardFundingType.credit`

`djstripe.enums.CardFundingType.debit`

`djstripe.enums.CardFundingType.prepaid`

`djstripe.enums.CardFundingType.unknown`

`djstripe.enums.CardFundingType.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.CardTokenizationMethod`

`djstripe.enums.CardTokenizationMethod.android_pay`

`djstripe.enums.CardTokenizationMethod.apple_pay`

`djstripe.enums.CardTokenizationMethod.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.ChargeStatus`

`djstripe.enums.ChargeStatus.failed`

`djstripe.enums.ChargeStatus.pending`

`djstripe.enums.ChargeStatus.succeeded`

`djstripe.enums.ChargeStatus.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.ConfirmationMethod`

`djstripe.enums.ConfirmationMethod.automatic`

`djstripe.enums.ConfirmationMethod.manual`

`djstripe.enums.ConfirmationMethod.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.CouponDuration`

`djstripe.enums.CouponDuration.forever`

`djstripe.enums.CouponDuration.once`

`djstripe.enums.CouponDuration.repeating`

`djstripe.enums.CouponDuration.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.CustomerTaxExempt`

`djstripe.enums.CustomerTaxExempt.exempt`

`djstripe.enums.CustomerTaxExempt.none`

`djstripe.enums.CustomerTaxExempt.reverse`

`djstripe.enums.CustomerTaxExempt.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.DisputeReason`

`djstripe.enums.DisputeReason.bank_cannot_process`

`djstripe.enums.DisputeReason.credit_not_processed`

`djstripe.enums.DisputeReason.customer_initiated`

`djstripe.enums.DisputeReason.debit_not_authorized`

`djstripe.enums.DisputeReason.duplicate`

`djstripe.enums.DisputeReason.fraudulent`

`djstripe.enums.DisputeReason.general`

`djstripe.enums.DisputeReason.incorrect_account_details`

`djstripe.enums.DisputeReason.insufficient_funds`

`djstripe.enums.DisputeReason.product_not_received`

`djstripe.enums.DisputeReason.product_unacceptable`

`djstripe.enums.DisputeReason.subscription_canceled`

`djstripe.enums.DisputeReason.unrecognized`

`djstripe.enums.DisputeReason.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.DisputeStatus`

`djstripe.enums.DisputeStatus.charge_refunded`

`djstripe.enums.DisputeStatus.lost`

`djstripe.enums.DisputeStatus.needs_response`

`djstripe.enums.DisputeStatus.under_review`

`djstripe.enums.DisputeStatus.warning_closed`

`djstripe.enums.DisputeStatus.warning_needs_response`

`djstripe.enums.DisputeStatus.warning_under_review`

`djstripe.enums.DisputeStatus.won`

`djstripe.enums.DisputeStatus.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.DjstripePaymentMethodType`

A djstripe-specific enum for the DjStripePaymentMethod model.

`djstripe.enums.DjstripePaymentMethodType.alipay_account`

`djstripe.enums.DjstripePaymentMethodType.bank_account`

`djstripe.enums.DjstripePaymentMethodType.card`

`djstripe.enums.DjstripePaymentMethodType.source`

`djstripe.enums.DjstripePaymentMethodType.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.Enum`

`djstripe.enums.Enum.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.EnumMetaClass`

Methods

`djstripe.enums.EnumMetaClass.init(cls, name, bases, classdict)` `special`

Source code in djstripe/enums.py

def __init__(cls, name, bases, classdict):
    def _human_enum_values(enum):
        return cls.__choices__[enum]

    # add a class attribute
    cls.humanize = _human_enum_values

`djstripe.enums.EnumMetaClass.new(cls, name, bases, classdict)` `special` `staticmethod`

Create and return a new object. See help(type) for accurate signature.

Source code in djstripe/enums.py

def __new__(cls, name, bases, classdict):
    members = []
    keys = {}
    choices = OrderedDict()
    for key, value in classdict.items():
        if key.startswith("__"):
            continue
        members.append(key)
        if isinstance(value, tuple):
            value, alias = value
            keys[alias] = key
        else:
            alias = None
        keys[alias or key] = key
        choices[alias or key] = value

    for k, v in keys.items():
        classdict[v] = k

    classdict["__choices__"] = choices
    classdict["__members__"] = members

    # Note: Differences between Python 2.x and Python 3.x force us to
    # explicitly use unicode here, and to explicitly sort the list. In
    # Python 2.x, class members are unordered and so the ordering will
    # vary on different systems based on internal hashing. Without this
    # Django will continually require new no-op migrations.
    classdict["choices"] = tuple(
        (str(k), str(v))
        for k, v in sorted(choices.items(), key=operator.itemgetter(0))
    )

    return type.__new__(cls, name, bases, classdict)

`djstripe.enums.EnumMetaClass.prepare(name, bases)` `classmethod` `special`

prepare() -> dict used to create the namespace for the class statement

Source code in djstripe/enums.py

@classmethod
def __prepare__(cls, name, bases):
    return OrderedDict()

`djstripe.enums.FilePurpose`

`djstripe.enums.FilePurpose.account_requirement`

`djstripe.enums.FilePurpose.additional_verification`

`djstripe.enums.FilePurpose.business_icon`

`djstripe.enums.FilePurpose.business_logo`

`djstripe.enums.FilePurpose.customer_signature`

`djstripe.enums.FilePurpose.dispute_evidence`

`djstripe.enums.FilePurpose.document_provider_identity_document`

`djstripe.enums.FilePurpose.finance_report_run`

`djstripe.enums.FilePurpose.identity_document`

`djstripe.enums.FilePurpose.identity_document_downloadable`

`djstripe.enums.FilePurpose.invoice_statement`

`djstripe.enums.FilePurpose.pci_document`

`djstripe.enums.FilePurpose.selfie`

`djstripe.enums.FilePurpose.sigma_scheduled_query`

`djstripe.enums.FilePurpose.tax_document_user_upload`

`djstripe.enums.FilePurpose.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.FileType`

`djstripe.enums.FileType.csv`

`djstripe.enums.FileType.docx`

`djstripe.enums.FileType.jpg`

`djstripe.enums.FileType.pdf`

`djstripe.enums.FileType.png`

`djstripe.enums.FileType.xls`

`djstripe.enums.FileType.xlsx`

`djstripe.enums.FileType.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.IntentStatus`

Status of Intents which apply both to PaymentIntents and SetupIntents.

`djstripe.enums.IntentStatus.canceled`

`djstripe.enums.IntentStatus.processing`

`djstripe.enums.IntentStatus.requires_action`

`djstripe.enums.IntentStatus.requires_confirmation`

`djstripe.enums.IntentStatus.requires_payment_method`

`djstripe.enums.IntentStatus.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.IntentUsage`

`djstripe.enums.IntentUsage.off_session`

`djstripe.enums.IntentUsage.on_session`

`djstripe.enums.IntentUsage.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.InvoiceBillingReason`

`djstripe.enums.InvoiceBillingReason.manual`

`djstripe.enums.InvoiceBillingReason.subscription`

`djstripe.enums.InvoiceBillingReason.subscription_create`

`djstripe.enums.InvoiceBillingReason.subscription_cycle`

`djstripe.enums.InvoiceBillingReason.subscription_threshold`

`djstripe.enums.InvoiceBillingReason.subscription_update`

`djstripe.enums.InvoiceBillingReason.upcoming`

`djstripe.enums.InvoiceBillingReason.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.InvoiceCollectionMethod`

`djstripe.enums.InvoiceCollectionMethod.charge_automatically`

`djstripe.enums.InvoiceCollectionMethod.send_invoice`

`djstripe.enums.InvoiceCollectionMethod.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.InvoiceStatus`

`djstripe.enums.InvoiceStatus.draft`

`djstripe.enums.InvoiceStatus.open`

`djstripe.enums.InvoiceStatus.paid`

`djstripe.enums.InvoiceStatus.uncollectible`

`djstripe.enums.InvoiceStatus.void`

`djstripe.enums.InvoiceStatus.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.LegacySourceType`

`djstripe.enums.LegacySourceType.alipay_account`

`djstripe.enums.LegacySourceType.bank_account`

`djstripe.enums.LegacySourceType.bitcoin_receiver`

`djstripe.enums.LegacySourceType.card`

`djstripe.enums.LegacySourceType.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.MandateStatus`

`djstripe.enums.MandateStatus.active`

`djstripe.enums.MandateStatus.inactive`

`djstripe.enums.MandateStatus.pending`

`djstripe.enums.MandateStatus.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.MandateType`

`djstripe.enums.MandateType.multi_use`

`djstripe.enums.MandateType.single_use`

`djstripe.enums.MandateType.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.PaymentIntentCancellationReason`

`djstripe.enums.PaymentIntentCancellationReason.abandoned`

`djstripe.enums.PaymentIntentCancellationReason.automatic`

`djstripe.enums.PaymentIntentCancellationReason.duplicate`

`djstripe.enums.PaymentIntentCancellationReason.failed_invoice`

`djstripe.enums.PaymentIntentCancellationReason.fraudulent`

`djstripe.enums.PaymentIntentCancellationReason.requested_by_customer`

`djstripe.enums.PaymentIntentCancellationReason.void_invoice`

`djstripe.enums.PaymentIntentCancellationReason.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.PaymentIntentStatus`

`djstripe.enums.PaymentIntentStatus.canceled`

`djstripe.enums.PaymentIntentStatus.processing`

`djstripe.enums.PaymentIntentStatus.requires_action`

`djstripe.enums.PaymentIntentStatus.requires_capture`

`djstripe.enums.PaymentIntentStatus.requires_confirmation`

`djstripe.enums.PaymentIntentStatus.requires_payment_method`

`djstripe.enums.PaymentIntentStatus.succeeded`

`djstripe.enums.PaymentIntentStatus.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.PaymentMethodType`

`djstripe.enums.PaymentMethodType.acss_debit`

`djstripe.enums.PaymentMethodType.afterpay_clearpay`

`djstripe.enums.PaymentMethodType.alipay`

`djstripe.enums.PaymentMethodType.au_becs_debit`

`djstripe.enums.PaymentMethodType.bacs_debit`

`djstripe.enums.PaymentMethodType.bancontact`

`djstripe.enums.PaymentMethodType.boleto`

`djstripe.enums.PaymentMethodType.card`

`djstripe.enums.PaymentMethodType.card_present`

`djstripe.enums.PaymentMethodType.eps`

`djstripe.enums.PaymentMethodType.fpx`

`djstripe.enums.PaymentMethodType.giropay`

`djstripe.enums.PaymentMethodType.grabpay`

`djstripe.enums.PaymentMethodType.ideal`

`djstripe.enums.PaymentMethodType.interac_present`

`djstripe.enums.PaymentMethodType.klarna`

`djstripe.enums.PaymentMethodType.oxxo`

`djstripe.enums.PaymentMethodType.p24`

`djstripe.enums.PaymentMethodType.sepa_debit`

`djstripe.enums.PaymentMethodType.sofort`

`djstripe.enums.PaymentMethodType.wechat_pay`

`djstripe.enums.PaymentMethodType.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.PayoutFailureCode`

Payout failure error codes.

https://stripe.com/docs/api#payout_failures

`djstripe.enums.PayoutFailureCode.account_closed`

`djstripe.enums.PayoutFailureCode.account_frozen`

`djstripe.enums.PayoutFailureCode.bank_account_restricted`

`djstripe.enums.PayoutFailureCode.bank_ownership_changed`

`djstripe.enums.PayoutFailureCode.could_not_process`

`djstripe.enums.PayoutFailureCode.debit_not_authorized`

`djstripe.enums.PayoutFailureCode.insufficient_funds`

`djstripe.enums.PayoutFailureCode.invalid_account_number`

`djstripe.enums.PayoutFailureCode.invalid_currency`

`djstripe.enums.PayoutFailureCode.no_account`

`djstripe.enums.PayoutFailureCode.unsupported_card`

`djstripe.enums.PayoutFailureCode.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.PayoutMethod`

`djstripe.enums.PayoutMethod.instant`

`djstripe.enums.PayoutMethod.standard`

`djstripe.enums.PayoutMethod.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.PayoutSourceType`

`djstripe.enums.PayoutSourceType.bank_account`

`djstripe.enums.PayoutSourceType.card`

`djstripe.enums.PayoutSourceType.fpx`

`djstripe.enums.PayoutSourceType.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.PayoutStatus`

`djstripe.enums.PayoutStatus.canceled`

`djstripe.enums.PayoutStatus.failed`

`djstripe.enums.PayoutStatus.in_transit`

`djstripe.enums.PayoutStatus.paid`

`djstripe.enums.PayoutStatus.pending`

`djstripe.enums.PayoutStatus.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.PayoutType`

`djstripe.enums.PayoutType.bank_account`

`djstripe.enums.PayoutType.card`

`djstripe.enums.PayoutType.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.PlanAggregateUsage`

`djstripe.enums.PlanAggregateUsage.last_during_period`

`djstripe.enums.PlanAggregateUsage.last_ever`

`djstripe.enums.PlanAggregateUsage.max`

`djstripe.enums.PlanAggregateUsage.sum`

`djstripe.enums.PlanAggregateUsage.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.PlanInterval`

`djstripe.enums.PlanInterval.day`

`djstripe.enums.PlanInterval.month`

`djstripe.enums.PlanInterval.week`

`djstripe.enums.PlanInterval.year`

`djstripe.enums.PlanInterval.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.PlanTiersMode`

`djstripe.enums.PlanTiersMode.graduated`

`djstripe.enums.PlanTiersMode.volume`

`djstripe.enums.PlanTiersMode.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.PlanUsageType`

`djstripe.enums.PlanUsageType.licensed`

`djstripe.enums.PlanUsageType.metered`

`djstripe.enums.PlanUsageType.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.PriceTiersMode`

`djstripe.enums.PriceTiersMode.graduated`

`djstripe.enums.PriceTiersMode.volume`

`djstripe.enums.PriceTiersMode.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.PriceType`

`djstripe.enums.PriceType.one_time`

`djstripe.enums.PriceType.recurring`

`djstripe.enums.PriceType.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.PriceUsageType`

`djstripe.enums.PriceUsageType.licensed`

`djstripe.enums.PriceUsageType.metered`

`djstripe.enums.PriceUsageType.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.ProductType`

`djstripe.enums.ProductType.good`

`djstripe.enums.ProductType.service`

`djstripe.enums.ProductType.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.RefundFailureReason`

`djstripe.enums.RefundFailureReason.expired_or_canceled_card`

`djstripe.enums.RefundFailureReason.lost_or_stolen_card`

`djstripe.enums.RefundFailureReason.unknown`

`djstripe.enums.RefundFailureReason.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.RefundReason`

`djstripe.enums.RefundReason.duplicate`

`djstripe.enums.RefundReason.expired_uncaptured_charge`

`djstripe.enums.RefundReason.fraudulent`

`djstripe.enums.RefundReason.requested_by_customer`

`djstripe.enums.RefundReason.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.RefundStatus`

`djstripe.enums.RefundStatus.canceled`

`djstripe.enums.RefundStatus.failed`

`djstripe.enums.RefundStatus.pending`

`djstripe.enums.RefundStatus.succeeded`

`djstripe.enums.RefundStatus.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.ScheduledQueryRunStatus`

`djstripe.enums.ScheduledQueryRunStatus.canceled`

`djstripe.enums.ScheduledQueryRunStatus.failed`

`djstripe.enums.ScheduledQueryRunStatus.timed_out`

`djstripe.enums.ScheduledQueryRunStatus.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.SessionBillingAddressCollection`

`djstripe.enums.SessionBillingAddressCollection.auto`

`djstripe.enums.SessionBillingAddressCollection.required`

`djstripe.enums.SessionBillingAddressCollection.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.SessionMode`

`djstripe.enums.SessionMode.payment`

`djstripe.enums.SessionMode.setup`

`djstripe.enums.SessionMode.subscription`

`djstripe.enums.SessionMode.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.SetupIntentCancellationReason`

`djstripe.enums.SetupIntentCancellationReason.abandoned`

`djstripe.enums.SetupIntentCancellationReason.duplicate`

`djstripe.enums.SetupIntentCancellationReason.requested_by_customer`

`djstripe.enums.SetupIntentCancellationReason.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.SetupIntentStatus`

`djstripe.enums.SetupIntentStatus.canceled`

`djstripe.enums.SetupIntentStatus.processing`

`djstripe.enums.SetupIntentStatus.requires_action`

`djstripe.enums.SetupIntentStatus.requires_confirmation`

`djstripe.enums.SetupIntentStatus.requires_payment_method`

`djstripe.enums.SetupIntentStatus.succeeded`

`djstripe.enums.SetupIntentStatus.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.SourceCodeVerificationStatus`

`djstripe.enums.SourceCodeVerificationStatus.failed`

`djstripe.enums.SourceCodeVerificationStatus.pending`

`djstripe.enums.SourceCodeVerificationStatus.succeeded`

`djstripe.enums.SourceCodeVerificationStatus.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.SourceFlow`

`djstripe.enums.SourceFlow.code_verification`

`djstripe.enums.SourceFlow.none`

`djstripe.enums.SourceFlow.receiver`

`djstripe.enums.SourceFlow.redirect`

`djstripe.enums.SourceFlow.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.SourceRedirectFailureReason`

`djstripe.enums.SourceRedirectFailureReason.declined`

`djstripe.enums.SourceRedirectFailureReason.processing_error`

`djstripe.enums.SourceRedirectFailureReason.user_abort`

`djstripe.enums.SourceRedirectFailureReason.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.SourceRedirectStatus`

`djstripe.enums.SourceRedirectStatus.failed`

`djstripe.enums.SourceRedirectStatus.not_required`

`djstripe.enums.SourceRedirectStatus.pending`

`djstripe.enums.SourceRedirectStatus.succeeded`

`djstripe.enums.SourceRedirectStatus.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.SourceStatus`

`djstripe.enums.SourceStatus.canceled`

`djstripe.enums.SourceStatus.chargeable`

`djstripe.enums.SourceStatus.consumed`

`djstripe.enums.SourceStatus.failed`

`djstripe.enums.SourceStatus.pending`

`djstripe.enums.SourceStatus.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.SourceType`

`djstripe.enums.SourceType.ach_credit_transfer`

`djstripe.enums.SourceType.ach_debit`

`djstripe.enums.SourceType.acss_debit`

`djstripe.enums.SourceType.alipay`

`djstripe.enums.SourceType.au_becs_debit`

`djstripe.enums.SourceType.bancontact`

`djstripe.enums.SourceType.bitcoin`

`djstripe.enums.SourceType.card`

`djstripe.enums.SourceType.card_present`

`djstripe.enums.SourceType.eps`

`djstripe.enums.SourceType.giropay`

`djstripe.enums.SourceType.ideal`

`djstripe.enums.SourceType.klarna`

`djstripe.enums.SourceType.multibanco`

`djstripe.enums.SourceType.p24`

`djstripe.enums.SourceType.paper_check`

`djstripe.enums.SourceType.sepa_credit_transfer`

`djstripe.enums.SourceType.sepa_debit`

`djstripe.enums.SourceType.sofort`

`djstripe.enums.SourceType.three_d_secure`

`djstripe.enums.SourceType.wechat`

`djstripe.enums.SourceType.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.SourceUsage`

`djstripe.enums.SourceUsage.reusable`

`djstripe.enums.SourceUsage.single_use`

`djstripe.enums.SourceUsage.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.SubmitTypeStatus`

`djstripe.enums.SubmitTypeStatus.auto`

`djstripe.enums.SubmitTypeStatus.book`

`djstripe.enums.SubmitTypeStatus.donate`

`djstripe.enums.SubmitTypeStatus.pay`

`djstripe.enums.SubmitTypeStatus.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.SubscriptionScheduleEndBehavior`

`djstripe.enums.SubscriptionScheduleEndBehavior.cancel`

`djstripe.enums.SubscriptionScheduleEndBehavior.release`

`djstripe.enums.SubscriptionScheduleEndBehavior.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.SubscriptionScheduleStatus`

`djstripe.enums.SubscriptionScheduleStatus.active`

`djstripe.enums.SubscriptionScheduleStatus.canceled`

`djstripe.enums.SubscriptionScheduleStatus.completed`

`djstripe.enums.SubscriptionScheduleStatus.not_started`

`djstripe.enums.SubscriptionScheduleStatus.released`

`djstripe.enums.SubscriptionScheduleStatus.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.SubscriptionStatus`

`djstripe.enums.SubscriptionStatus.active`

`djstripe.enums.SubscriptionStatus.canceled`

`djstripe.enums.SubscriptionStatus.incomplete`

`djstripe.enums.SubscriptionStatus.incomplete_expired`

`djstripe.enums.SubscriptionStatus.past_due`

`djstripe.enums.SubscriptionStatus.trialing`

`djstripe.enums.SubscriptionStatus.unpaid`

`djstripe.enums.SubscriptionStatus.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.TaxIdType`

`djstripe.enums.TaxIdType.ae_trn`

`djstripe.enums.TaxIdType.au_abn`

`djstripe.enums.TaxIdType.br_cnp`

`djstripe.enums.TaxIdType.br_cpf`

`djstripe.enums.TaxIdType.ca_bn`

`djstripe.enums.TaxIdType.ca_qst`

`djstripe.enums.TaxIdType.ch_vat`

`djstripe.enums.TaxIdType.cl_tin`

`djstripe.enums.TaxIdType.es_cif`

`djstripe.enums.TaxIdType.eu_vat`

`djstripe.enums.TaxIdType.hk_br`

`djstripe.enums.TaxIdType.id_npw`

`djstripe.enums.TaxIdType.in_gst`

`djstripe.enums.TaxIdType.jp_cn`

`djstripe.enums.TaxIdType.jp_rn`

`djstripe.enums.TaxIdType.kr_brn`

`djstripe.enums.TaxIdType.li_uid`

`djstripe.enums.TaxIdType.mx_rfc`

`djstripe.enums.TaxIdType.my_frp`

`djstripe.enums.TaxIdType.my_itn`

`djstripe.enums.TaxIdType.my_sst`

`djstripe.enums.TaxIdType.no_vat`

`djstripe.enums.TaxIdType.nz_gst`

`djstripe.enums.TaxIdType.ru_inn`

`djstripe.enums.TaxIdType.ru_kpp`

`djstripe.enums.TaxIdType.sa_vat`

`djstripe.enums.TaxIdType.sg_gst`

`djstripe.enums.TaxIdType.sg_uen`

`djstripe.enums.TaxIdType.th_vat`

`djstripe.enums.TaxIdType.tw_vat`

`djstripe.enums.TaxIdType.unknown`

`djstripe.enums.TaxIdType.us_ein`

`djstripe.enums.TaxIdType.za_vat`

`djstripe.enums.TaxIdType.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.UsageAction`

`djstripe.enums.UsageAction.increment`

`djstripe.enums.UsageAction.set`

`djstripe.enums.UsageAction.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]

`djstripe.enums.WebhookEndpointStatus`

`djstripe.enums.WebhookEndpointStatus.disabled`

`djstripe.enums.WebhookEndpointStatus.enabled`

`djstripe.enums.WebhookEndpointStatus.humanize(enum)`

Source code in djstripe/enums.py

def _human_enum_values(enum):
    return cls.__choices__[enum]