├── .github ├── ISSUE_TEMPLATE │ ├── bug_report.yml │ ├── config.yml │ └── feature_request.yml └── PULL_REQUEST_TEMPLATE.md ├── .gitignore ├── CHANGELOG.md ├── LICENSE ├── MANIFEST.in ├── README.md ├── SECURITY.md ├── chargebee ├── __init__.py ├── api_error.py ├── compat.py ├── environment.py ├── filters │ ├── __init__.py │ └── filters.py ├── http_request.py ├── main.py ├── model.py ├── models │ ├── __init__.py │ ├── addon │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── address │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── advance_invoice_schedule │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── attached_item │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── attribute │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── business_entity │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── business_entity_transfer │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── card │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── comment │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── configuration │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── contact │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── contract_term │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── coupon │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── coupon_code │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── coupon_set │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── credit_note │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── credit_note_estimate │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── currency │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── customer │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── customer_entitlement │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── differential_price │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── discount │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── download │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── entitlement │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── entitlement_override │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── enums.py │ ├── estimate │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── event │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── export │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── feature │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── gateway_error_detail │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── gift │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── hierarchy │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── hosted_page │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── impacted_item │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── impacted_item_price │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── impacted_subscription │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── in_app_subscription │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── invoice │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── invoice_estimate │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── item │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── item_entitlement │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── item_family │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── item_price │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── metadata │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── omnichannel_subscription │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── omnichannel_subscription_item │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── omnichannel_subscription_item_scheduled_change │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── omnichannel_transaction │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── order │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── payment_intent │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── payment_reference_number │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── payment_schedule │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── payment_schedule_estimate │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── payment_schedule_scheme │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── payment_source │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── payment_voucher │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── plan │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── portal_session │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── price_variant │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── pricing_page_session │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── promotional_credit │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── purchase │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── quote │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── quote_line_group │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── quoted_charge │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── quoted_subscription │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── ramp │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── recorded_purchase │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── resource_migration │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── rule │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── site_migration_detail │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── subscription │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── subscription_entitlement │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── subscription_estimate │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── tax_withheld │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── third_party_payment_method │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── time_machine │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── token │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── transaction │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── unbilled_charge │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── usage │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── usage_event │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ ├── usage_file │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py │ └── virtual_bank_account │ │ ├── __init__.py │ │ ├── operations.py │ │ └── responses.py ├── request.py ├── response.py ├── responses.py ├── ssl │ └── ca-certs.crt ├── util.py └── version.py ├── pyproject.toml ├── setup.py └── tests ├── __init__.py └── util.py /.github/ISSUE_TEMPLATE/bug_report.yml: -------------------------------------------------------------------------------- 1 | name: Bug Report 2 | description: Report a bug for this repository. 3 | labels: 4 | - Bug 5 | 6 | body: 7 | 8 | - type: textarea 9 | id: what-happened 10 | attributes: 11 | label: Description of the Bug 12 | description: Please provide a clear and concise description of the bug. 13 | placeholder: Describe what you're experiencing. 14 | validations: 15 | required: true 16 | 17 | - type: textarea 18 | id: repro-steps 19 | attributes: 20 | label: Steps to reproduce 21 | description: Clear and concise instructions to reproduce the bug are essential for quick resolution. 22 | placeholder: | 23 | 1. Fetch '...' 24 | 2. Update the '....' 25 | 3. Encounter the error 26 | validations: 27 | required: true 28 | 29 | - type: textarea 30 | id: expected-behavior 31 | attributes: 32 | label: Expected Behavior 33 | description: Describe what you expected to happen. 34 | validations: 35 | required: true 36 | 37 | - type: textarea 38 | id: code-snippets 39 | attributes: 40 | label: Code Snippets (if applicable) 41 | description: If relevant, provide code snippets to clarify the issue. 42 | render: Python 43 | validations: 44 | required: false 45 | 46 | - type: input 47 | id: os 48 | attributes: 49 | label: Operating System 50 | placeholder: macOS 51 | validations: 52 | required: true 53 | 54 | - type: input 55 | id: language-version 56 | attributes: 57 | label: Language version 58 | placeholder: Python 3.10.4 59 | validations: 60 | required: true 61 | 62 | - type: input 63 | id: lib-version 64 | attributes: 65 | label: Library version 66 | placeholder: v2.31.0 67 | validations: 68 | required: true 69 | 70 | - type: textarea 71 | id: additional-context 72 | attributes: 73 | label: Additional context 74 | description: Provide any other relevant information about the problem. 75 | validations: 76 | required: false 77 | 78 | - type: markdown 79 | attributes: 80 | value: | 81 | Thank you for taking the time to submit this bug report! 82 | -------------------------------------------------------------------------------- /.github/ISSUE_TEMPLATE/config.yml: -------------------------------------------------------------------------------- 1 | blank_issues_enabled: false 2 | contact_links: 3 | - name: Chargebee support 4 | url: https://support.chargebee.com/ 5 | about: | 6 | Github issues are not an official support channel for Chargebee. If you have an urgent request we suggest you contact us through an official channel: support@chargebee.com or https://support.chargebee.com/ -------------------------------------------------------------------------------- /.github/ISSUE_TEMPLATE/feature_request.yml: -------------------------------------------------------------------------------- 1 | name: Feature Request 2 | description: Request a New Feature for the project. 3 | labels: 4 | - Feature Request 5 | 6 | body: 7 | - type: textarea 8 | id: problem 9 | attributes: 10 | label: What problem does your feature request address? 11 | description: Please provide a clear and concise description of the problem you'd like to solve. For example, "I'm frequently frustrated when..." 12 | 13 | - type: textarea 14 | id: solution 15 | attributes: 16 | label: Describe the desired solution 17 | description: Please provide a clear and concise description of the solution you would like to see implemented. 18 | 19 | - type: textarea 20 | id: alternatives 21 | attributes: 22 | label: Alternatives considered 23 | description: Describe any alternative solutions or features you may have thought about in relation to this problem. 24 | 25 | - type: textarea 26 | id: context 27 | attributes: 28 | label: Additional context 29 | description: Feel free to include any other relevant information or context regarding your feature request. 30 | 31 | - type: markdown 32 | attributes: 33 | value: | 34 | Thank you for taking the time to submit your feature request! 35 | -------------------------------------------------------------------------------- /.github/PULL_REQUEST_TEMPLATE.md: -------------------------------------------------------------------------------- 1 | ### Description 2 | 3 | Please provide a brief overview of the changes introduced by this pull request. 4 | 5 | ### Related Issues 6 | 7 | Closes #IssueNumber 8 | 9 | 10 | ### Additional Information 11 | 12 | Include any additional information that might be helpful in reviewing the changes introduced by this pull request. 13 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | *.py[co] 2 | 3 | # Packages 4 | *.egg 5 | *.egg-info 6 | dist 7 | build 8 | eggs 9 | parts 10 | bin 11 | var 12 | sdist 13 | develop-eggs 14 | .installed.cfg 15 | .DS_Store 16 | 17 | # Installer logs 18 | pip-log.txt 19 | 20 | # Unit test / coverage reports 21 | .coverage 22 | .tox 23 | 24 | #Translations 25 | *.mo 26 | 27 | #Mr Developer 28 | .mr.developer.cfg 29 | 30 | .idea 31 | venv 32 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | The MIT License 2 | 3 | Copyright (c) 2011-2025 ChargeBee, Inc. 4 | 5 | Permission is hereby granted, free of charge, to any person 6 | obtaining a copy of this software and associated documentation 7 | files (the "Software"), to deal in the Software without 8 | restriction, including without limitation the rights to use, 9 | copy, modify, merge, publish, distribute, sublicense, and/or sell 10 | copies of the Software, and to permit persons to whom the 11 | Software is furnished to do so, subject to the following 12 | conditions: 13 | 14 | The above copyright notice and this permission notice shall be 15 | included in all copies or substantial portions of the Software. 16 | 17 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 18 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 19 | OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 20 | NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 21 | HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 22 | WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 23 | FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 24 | OTHER DEALINGS IN THE SOFTWARE. 25 | -------------------------------------------------------------------------------- /MANIFEST.in: -------------------------------------------------------------------------------- 1 | include chargebee/ssl/ca-certs.crt -------------------------------------------------------------------------------- /SECURITY.md: -------------------------------------------------------------------------------- 1 | # Security Policy 2 | 3 | At Chargebee, we take data integrity and security very seriously. Due to the nature of the product and service we provide, we are committed to working with individuals to stay updated on the latest security techniques and fix any security weakness in our application or infrastructure reported to us responsibly by external parties. 4 | 5 | https://www.chargebee.com/security/responsible-disclosure-policy/ 6 | 7 | ## Reporting a vulnerability 8 | Reach out to us at security@chargebee.com. Please do not open GitHub issues or pull requests as this makes the problem immediately visible to everyone, including malicious actors. Chargebee's security team will triage your report and respond according to its impact. 9 | -------------------------------------------------------------------------------- /chargebee/__init__.py: -------------------------------------------------------------------------------- 1 | from chargebee.api_error import ( 2 | APIError, 3 | PaymentError, 4 | InvalidRequestError, 5 | OperationFailedError, 6 | ) 7 | from chargebee.filters import Filters 8 | from chargebee.main import Chargebee 9 | from chargebee.models import * 10 | -------------------------------------------------------------------------------- /chargebee/api_error.py: -------------------------------------------------------------------------------- 1 | class APIError(Exception): 2 | 3 | def __init__(self, http_code, json_obj, headers=None): 4 | Exception.__init__(self, json_obj.get("message")) 5 | self.json_obj = json_obj 6 | self.http_status_code = http_code 7 | self.type = json_obj.get("type") 8 | self.api_error_code = json_obj.get("api_error_code") 9 | self.param = json_obj.get("param") 10 | 11 | self.error_cause_id = json_obj.get("error_cause_id", None) 12 | self.http_headers = headers 13 | self.http_code = http_code 14 | self.http_body = None 15 | self.error_code = json_obj["error_code"] 16 | 17 | 18 | class PaymentError(APIError): 19 | def __init__(self, http_code, json_obj, headers=None): 20 | APIError.__init__(self, http_code, json_obj, headers) 21 | 22 | 23 | class InvalidRequestError(APIError): 24 | def __init__(self, http_code, json_obj, headers=None): 25 | APIError.__init__(self, http_code, json_obj, headers) 26 | 27 | 28 | class OperationFailedError(APIError): 29 | def __init__(self, http_code, json_obj, headers=None): 30 | APIError.__init__(self, http_code, json_obj, headers) 31 | -------------------------------------------------------------------------------- /chargebee/compat.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | try: 4 | import simplejson as json 5 | except ImportError: 6 | import json 7 | 8 | py_major_v = sys.version_info[0] 9 | py_minor_v = sys.version_info[1] 10 | 11 | if py_major_v >= 3: 12 | from urllib.parse import urlencode, urlparse 13 | -------------------------------------------------------------------------------- /chargebee/environment.py: -------------------------------------------------------------------------------- 1 | class Environment(object): 2 | chargebee_domain = "chargebee.com" 3 | protocol = "https" 4 | API_VERSION = "v2" 5 | connect_timeout = 30 6 | read_timeout = 80 7 | export_retry_delay_ms = 10000 8 | time_travel_retry_delay_ms = 3000 9 | 10 | def __init__(self, options): 11 | self.api_key = options["api_key"] 12 | self.site = options["site"] 13 | 14 | def set_api_endpoint(self): 15 | self.api_endpoint = "%s://%s.%s/api/%s" % ( 16 | self.protocol, 17 | self.site, 18 | self.chargebee_domain, 19 | self.API_VERSION, 20 | ) 21 | 22 | def api_url(self, url, subDomain=None): 23 | if subDomain is None: 24 | return self.api_endpoint + url 25 | else: 26 | if self.chargebee_domain is None: 27 | return ( 28 | "%s://%s.%s.chargebee.com/api/%s" 29 | % (self.protocol, self.site, subDomain, self.API_VERSION) 30 | + url 31 | ) 32 | else: 33 | return ( 34 | "%s://%s.%s.%s/api/%s" 35 | % ( 36 | self.protocol, 37 | self.site, 38 | subDomain, 39 | self.chargebee_domain, 40 | self.API_VERSION, 41 | ) 42 | + url 43 | ) 44 | -------------------------------------------------------------------------------- /chargebee/filters/__init__.py: -------------------------------------------------------------------------------- 1 | from .filters import Filters 2 | -------------------------------------------------------------------------------- /chargebee/filters/filters.py: -------------------------------------------------------------------------------- 1 | from typing import List, NotRequired, TypedDict 2 | 3 | 4 | class Filters: 5 | class StringFilter(TypedDict): 6 | IS: NotRequired[str] 7 | IS_NOT: NotRequired[str] 8 | STARTS_WITH: NotRequired[str] 9 | IN: NotRequired[List[str]] 10 | NOT_IN: NotRequired[List[str]] 11 | IS_PRESENT: NotRequired[bool] 12 | 13 | class BooleanFilter(TypedDict): 14 | IS: NotRequired[bool] 15 | IS_PRESENT: NotRequired[bool] 16 | 17 | class EnumFilter(TypedDict): 18 | IS: NotRequired[str] 19 | IS_NOT: NotRequired[str] 20 | IS_PRESENT: NotRequired[bool] 21 | IN: NotRequired[List[str]] 22 | NOT_IN: NotRequired[List[str]] 23 | 24 | class NumberFilter(TypedDict): 25 | IS: NotRequired[int] 26 | IS_NOT: NotRequired[int] 27 | LT: NotRequired[int] 28 | LTE: NotRequired[int] 29 | GT: NotRequired[int] 30 | GTE: NotRequired[int] 31 | BETWEEN: NotRequired[List[int]] 32 | IS_PRESENT: NotRequired[bool] 33 | 34 | class SortFilter(TypedDict): 35 | ASC: NotRequired[str] 36 | DESC: NotRequired[str] 37 | 38 | class TimestampFilter(TypedDict): 39 | AFTER: NotRequired[int] 40 | BEFORE: NotRequired[int] 41 | ON: NotRequired[int] 42 | BETWEEN: NotRequired[List[int]] 43 | IS_PRESENT: NotRequired[bool] 44 | -------------------------------------------------------------------------------- /chargebee/model.py: -------------------------------------------------------------------------------- 1 | from chargebee.compat import json 2 | from typing import get_type_hints, get_origin, get_args 3 | 4 | 5 | class Model(object): 6 | 7 | def __init__(self, values): 8 | self.raw_data = values 9 | self._response_type = self.__class__ 10 | 11 | def __str__(self): 12 | return json.dumps(self.raw_data, indent=4) 13 | 14 | def __getattr__(self, name): 15 | raise AttributeError("Attribute %s not found " % name) 16 | 17 | def hydrate(self, depth=0): 18 | if depth > 10: 19 | return 20 | 21 | type_map = { 22 | name: type_ for name, type_ in get_type_hints(self.__class__).items() 23 | } 24 | for k, v in list(self.raw_data.items()): 25 | val = None 26 | field_type = type_map.get(k, None) 27 | if isinstance(v, dict): 28 | if field_type and hasattr(field_type, "construct"): 29 | val = field_type.construct(v, depth=depth + 1) 30 | else: 31 | val = v 32 | elif isinstance(v, (list, tuple)): 33 | if field_type and get_origin(field_type) in (list, tuple): 34 | item_type = ( 35 | get_args(field_type)[0] if get_args(field_type) else None 36 | ) 37 | val = [] 38 | for item in v: 39 | if ( 40 | isinstance(item, dict) 41 | and item_type 42 | and hasattr(item_type, "construct") 43 | ): 44 | val.append(item_type.construct(item, depth=depth + 1)) 45 | else: 46 | val.append(item) 47 | else: 48 | val = [ 49 | ( 50 | self.construct(item, depth=depth + 1) 51 | if isinstance(item, dict) 52 | else item 53 | ) 54 | for item in v 55 | ] 56 | else: 57 | val = v 58 | 59 | setattr(self, k, val) 60 | 61 | @classmethod 62 | def construct(cls, values, depth=0): 63 | obj = cls(values) 64 | obj.hydrate(depth=depth + 1) 65 | return obj 66 | -------------------------------------------------------------------------------- /chargebee/models/addon/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import Addon 2 | from .responses import AddonResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/addon/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | from chargebee.response import Response 5 | 6 | 7 | @dataclass 8 | class TierResponse(Model): 9 | raw_data: Dict[Any, Any] = None 10 | starting_unit: int = None 11 | ending_unit: int = None 12 | price: int = None 13 | starting_unit_in_decimal: str = None 14 | ending_unit_in_decimal: str = None 15 | price_in_decimal: str = None 16 | pricing_type: str = None 17 | package_size: int = None 18 | 19 | 20 | @dataclass 21 | class TaxProvidersFieldResponse(Model): 22 | raw_data: Dict[Any, Any] = None 23 | provider_name: str = None 24 | field_id: str = None 25 | field_value: str = None 26 | 27 | 28 | @dataclass 29 | class AddonResponse(Model): 30 | raw_data: Dict[Any, Any] = None 31 | id: str = None 32 | name: str = None 33 | invoice_name: str = None 34 | description: str = None 35 | pricing_model: str = None 36 | type: str = None 37 | charge_type: str = None 38 | price: int = None 39 | currency_code: str = None 40 | period: int = None 41 | period_unit: str = None 42 | unit: str = None 43 | status: str = None 44 | archived_at: int = None 45 | enabled_in_portal: bool = None 46 | tax_code: str = None 47 | hsn_code: str = None 48 | taxjar_product_code: str = None 49 | avalara_sale_type: str = None 50 | avalara_transaction_type: int = None 51 | avalara_service_type: int = None 52 | sku: str = None 53 | accounting_code: str = None 54 | accounting_category1: str = None 55 | accounting_category2: str = None 56 | accounting_category3: str = None 57 | accounting_category4: str = None 58 | is_shippable: bool = None 59 | shipping_frequency_period: int = None 60 | shipping_frequency_period_unit: str = None 61 | resource_version: int = None 62 | updated_at: int = None 63 | price_in_decimal: str = None 64 | included_in_mrr: bool = None 65 | channel: str = None 66 | proration_type: str = None 67 | invoice_notes: str = None 68 | taxable: bool = None 69 | tax_profile_id: str = None 70 | meta_data: Dict[Any, Any] = None 71 | tiers: List[TierResponse] = None 72 | tax_providers_fields: List[TaxProvidersFieldResponse] = None 73 | show_description_in_invoices: bool = None 74 | show_description_in_quotes: bool = None 75 | 76 | 77 | @dataclass 78 | class CreateResponse(Response): 79 | is_idempotency_replayed: bool 80 | addon: AddonResponse 81 | 82 | 83 | @dataclass 84 | class UpdateResponse(Response): 85 | is_idempotency_replayed: bool 86 | addon: AddonResponse 87 | 88 | 89 | @dataclass 90 | class ListAddonResponse: 91 | addon: AddonResponse 92 | 93 | 94 | @dataclass 95 | class ListResponse(Response): 96 | 97 | list: List[ListAddonResponse] 98 | next_offset: str = None 99 | 100 | 101 | @dataclass 102 | class RetrieveResponse(Response): 103 | 104 | addon: AddonResponse 105 | 106 | 107 | @dataclass 108 | class DeleteResponse(Response): 109 | is_idempotency_replayed: bool 110 | addon: AddonResponse 111 | 112 | 113 | @dataclass 114 | class CopyResponse(Response): 115 | is_idempotency_replayed: bool 116 | addon: AddonResponse 117 | 118 | 119 | @dataclass 120 | class UnarchiveResponse(Response): 121 | is_idempotency_replayed: bool 122 | addon: AddonResponse 123 | -------------------------------------------------------------------------------- /chargebee/models/address/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import Address 2 | from .responses import AddressResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/address/operations.py: -------------------------------------------------------------------------------- 1 | from .responses import * 2 | from chargebee import request, environment 3 | from typing import TypedDict, Required, NotRequired, Dict, List, Any, cast 4 | from chargebee.models import enums 5 | 6 | 7 | @dataclass 8 | class Address: 9 | 10 | env: environment.Environment 11 | 12 | class RetrieveParams(TypedDict): 13 | subscription_id: Required[str] 14 | label: Required[str] 15 | 16 | class UpdateParams(TypedDict): 17 | subscription_id: Required[str] 18 | label: Required[str] 19 | first_name: NotRequired[str] 20 | last_name: NotRequired[str] 21 | email: NotRequired[str] 22 | company: NotRequired[str] 23 | phone: NotRequired[str] 24 | addr: NotRequired[str] 25 | extended_addr: NotRequired[str] 26 | extended_addr2: NotRequired[str] 27 | city: NotRequired[str] 28 | state_code: NotRequired[str] 29 | state: NotRequired[str] 30 | zip: NotRequired[str] 31 | country: NotRequired[str] 32 | validation_status: NotRequired[enums.ValidationStatus] 33 | 34 | def retrieve(self, params: RetrieveParams, headers=None) -> RetrieveResponse: 35 | jsonKeys = {} 36 | return request.send( 37 | "get", 38 | request.uri_path("addresses"), 39 | self.env, 40 | cast(Dict[Any, Any], params), 41 | headers, 42 | RetrieveResponse, 43 | None, 44 | False, 45 | jsonKeys, 46 | ) 47 | 48 | def update(self, params: UpdateParams, headers=None) -> UpdateResponse: 49 | jsonKeys = {} 50 | return request.send( 51 | "post", 52 | request.uri_path("addresses"), 53 | self.env, 54 | cast(Dict[Any, Any], params), 55 | headers, 56 | UpdateResponse, 57 | None, 58 | False, 59 | jsonKeys, 60 | ) 61 | -------------------------------------------------------------------------------- /chargebee/models/address/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | from chargebee.response import Response 5 | 6 | 7 | @dataclass 8 | class AddressResponse(Model): 9 | raw_data: Dict[Any, Any] = None 10 | label: str = None 11 | first_name: str = None 12 | last_name: str = None 13 | email: str = None 14 | company: str = None 15 | phone: str = None 16 | addr: str = None 17 | extended_addr: str = None 18 | extended_addr2: str = None 19 | city: str = None 20 | state_code: str = None 21 | state: str = None 22 | country: str = None 23 | zip: str = None 24 | validation_status: str = None 25 | subscription_id: str = None 26 | 27 | 28 | @dataclass 29 | class RetrieveResponse(Response): 30 | 31 | address: AddressResponse 32 | 33 | 34 | @dataclass 35 | class UpdateResponse(Response): 36 | is_idempotency_replayed: bool 37 | address: AddressResponse 38 | -------------------------------------------------------------------------------- /chargebee/models/advance_invoice_schedule/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import AdvanceInvoiceSchedule 2 | from .responses import AdvanceInvoiceScheduleResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/advance_invoice_schedule/operations.py: -------------------------------------------------------------------------------- 1 | from .responses import * 2 | from chargebee import request, environment 3 | from typing import TypedDict, Required, NotRequired, Dict, List, Any, cast 4 | from enum import Enum 5 | from chargebee.models import enums 6 | 7 | 8 | @dataclass 9 | class AdvanceInvoiceSchedule: 10 | 11 | env: environment.Environment 12 | 13 | class ScheduleType(Enum): 14 | FIXED_INTERVALS = "fixed_intervals" 15 | SPECIFIC_DATES = "specific_dates" 16 | 17 | def __str__(self): 18 | return self.value 19 | 20 | class FixedIntervalSchedule(TypedDict): 21 | end_schedule_on: NotRequired[enums.EndScheduleOn] 22 | number_of_occurrences: NotRequired[int] 23 | days_before_renewal: NotRequired[int] 24 | end_date: NotRequired[int] 25 | created_at: Required[int] 26 | terms_to_charge: NotRequired[int] 27 | 28 | class SpecificDatesSchedule(TypedDict): 29 | terms_to_charge: NotRequired[int] 30 | date: NotRequired[int] 31 | created_at: Required[int] 32 | 33 | pass 34 | -------------------------------------------------------------------------------- /chargebee/models/advance_invoice_schedule/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | 5 | 6 | @dataclass 7 | class FixedIntervalScheduleResponse(Model): 8 | raw_data: Dict[Any, Any] = None 9 | end_schedule_on: str = None 10 | number_of_occurrences: int = None 11 | days_before_renewal: int = None 12 | end_date: int = None 13 | created_at: int = None 14 | terms_to_charge: int = None 15 | 16 | 17 | @dataclass 18 | class SpecificDatesScheduleResponse(Model): 19 | raw_data: Dict[Any, Any] = None 20 | terms_to_charge: int = None 21 | date: int = None 22 | created_at: int = None 23 | 24 | 25 | @dataclass 26 | class AdvanceInvoiceScheduleResponse(Model): 27 | raw_data: Dict[Any, Any] = None 28 | id: str = None 29 | schedule_type: str = None 30 | fixed_interval_schedule: FixedIntervalScheduleResponse = None 31 | specific_dates_schedule: SpecificDatesScheduleResponse = None 32 | -------------------------------------------------------------------------------- /chargebee/models/attached_item/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import AttachedItem 2 | from .responses import AttachedItemResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/attached_item/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | from chargebee.response import Response 5 | 6 | 7 | @dataclass 8 | class AttachedItemResponse(Model): 9 | raw_data: Dict[Any, Any] = None 10 | id: str = None 11 | parent_item_id: str = None 12 | item_id: str = None 13 | type: str = None 14 | status: str = None 15 | quantity: int = None 16 | quantity_in_decimal: str = None 17 | billing_cycles: int = None 18 | charge_on_event: str = None 19 | charge_once: bool = None 20 | created_at: int = None 21 | resource_version: int = None 22 | updated_at: int = None 23 | channel: str = None 24 | business_entity_id: str = None 25 | deleted: bool = None 26 | 27 | 28 | @dataclass 29 | class CreateResponse(Response): 30 | is_idempotency_replayed: bool 31 | attached_item: AttachedItemResponse 32 | 33 | 34 | @dataclass 35 | class UpdateResponse(Response): 36 | is_idempotency_replayed: bool 37 | attached_item: AttachedItemResponse 38 | 39 | 40 | @dataclass 41 | class RetrieveResponse(Response): 42 | 43 | attached_item: AttachedItemResponse 44 | 45 | 46 | @dataclass 47 | class DeleteResponse(Response): 48 | is_idempotency_replayed: bool 49 | attached_item: AttachedItemResponse 50 | 51 | 52 | @dataclass 53 | class ListAttachedItemResponse: 54 | attached_item: AttachedItemResponse 55 | 56 | 57 | @dataclass 58 | class ListResponse(Response): 59 | 60 | list: List[ListAttachedItemResponse] 61 | next_offset: str = None 62 | -------------------------------------------------------------------------------- /chargebee/models/attribute/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import Attribute 2 | from .responses import AttributeResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/attribute/operations.py: -------------------------------------------------------------------------------- 1 | from .responses import * 2 | from chargebee import request, environment 3 | from typing import TypedDict, Required, NotRequired, Dict, List, Any, cast 4 | 5 | 6 | @dataclass 7 | class Attribute: 8 | 9 | env: environment.Environment 10 | 11 | pass 12 | -------------------------------------------------------------------------------- /chargebee/models/attribute/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | 5 | 6 | @dataclass 7 | class AttributeResponse(Model): 8 | raw_data: Dict[Any, Any] = None 9 | name: str = None 10 | value: str = None 11 | -------------------------------------------------------------------------------- /chargebee/models/business_entity/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import BusinessEntity 2 | from .responses import BusinessEntityResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/business_entity/operations.py: -------------------------------------------------------------------------------- 1 | from .responses import * 2 | from chargebee import request, environment 3 | from typing import TypedDict, Required, NotRequired, Dict, List, Any, cast 4 | from enum import Enum 5 | from chargebee.filters import Filters 6 | 7 | 8 | @dataclass 9 | class BusinessEntity: 10 | 11 | env: environment.Environment 12 | 13 | class Status(Enum): 14 | ACTIVE = "active" 15 | INACTIVE = "inactive" 16 | 17 | def __str__(self): 18 | return self.value 19 | 20 | class CreateTransfersParams(TypedDict): 21 | active_resource_ids: Required[List[str]] 22 | destination_business_entity_ids: Required[List[str]] 23 | source_business_entity_ids: NotRequired[List[str]] 24 | resource_types: Required[List[str]] 25 | reason_codes: Required[List[str]] 26 | 27 | class GetTransfersParams(TypedDict): 28 | limit: NotRequired[int] 29 | offset: NotRequired[str] 30 | resource_type: NotRequired[Filters.StringFilter] 31 | resource_id: NotRequired[Filters.StringFilter] 32 | active_resource_id: NotRequired[Filters.StringFilter] 33 | created_at: NotRequired[Filters.TimestampFilter] 34 | sort_by: NotRequired[Filters.SortFilter] 35 | 36 | def create_transfers( 37 | self, params: CreateTransfersParams, headers=None 38 | ) -> CreateTransfersResponse: 39 | jsonKeys = {} 40 | return request.send( 41 | "post", 42 | request.uri_path("business_entities", "transfers"), 43 | self.env, 44 | cast(Dict[Any, Any], params), 45 | headers, 46 | CreateTransfersResponse, 47 | None, 48 | False, 49 | jsonKeys, 50 | ) 51 | 52 | def get_transfers( 53 | self, params: GetTransfersParams = None, headers=None 54 | ) -> GetTransfersResponse: 55 | jsonKeys = {} 56 | return request.send( 57 | "get", 58 | request.uri_path("business_entities", "transfers"), 59 | self.env, 60 | cast(Dict[Any, Any], params), 61 | headers, 62 | GetTransfersResponse, 63 | None, 64 | False, 65 | jsonKeys, 66 | ) 67 | -------------------------------------------------------------------------------- /chargebee/models/business_entity/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | from chargebee.response import Response 5 | from chargebee.models import business_entity_transfer 6 | 7 | 8 | @dataclass 9 | class BusinessEntityResponse(Model): 10 | raw_data: Dict[Any, Any] = None 11 | id: str = None 12 | name: str = None 13 | status: str = None 14 | deleted: bool = None 15 | created_at: int = None 16 | resource_version: int = None 17 | updated_at: int = None 18 | 19 | 20 | @dataclass 21 | class CreateTransfersResponse(Response): 22 | is_idempotency_replayed: bool 23 | business_entity_transfer: "business_entity_transfer.BusinessEntityTransferResponse" 24 | 25 | 26 | @dataclass 27 | class GetTransfersBusinessEntityResponse: 28 | business_entity_transfer: "business_entity_transfer.BusinessEntityTransferResponse" 29 | 30 | 31 | @dataclass 32 | class GetTransfersResponse(Response): 33 | 34 | list: List[GetTransfersBusinessEntityResponse] 35 | next_offset: str = None 36 | -------------------------------------------------------------------------------- /chargebee/models/business_entity_transfer/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import BusinessEntityTransfer 2 | from .responses import BusinessEntityTransferResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/business_entity_transfer/operations.py: -------------------------------------------------------------------------------- 1 | from .responses import * 2 | from chargebee import request, environment 3 | from typing import TypedDict, Required, NotRequired, Dict, List, Any, cast 4 | from enum import Enum 5 | 6 | 7 | @dataclass 8 | class BusinessEntityTransfer: 9 | 10 | env: environment.Environment 11 | 12 | class ResourceType(Enum): 13 | CUSTOMER = "customer" 14 | SUBSCRIPTION = "subscription" 15 | 16 | def __str__(self): 17 | return self.value 18 | 19 | class ReasonCode(Enum): 20 | CORRECTION = "correction" 21 | 22 | def __str__(self): 23 | return self.value 24 | 25 | pass 26 | -------------------------------------------------------------------------------- /chargebee/models/business_entity_transfer/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | 5 | 6 | @dataclass 7 | class BusinessEntityTransferResponse(Model): 8 | raw_data: Dict[Any, Any] = None 9 | id: str = None 10 | resource_type: str = None 11 | resource_id: str = None 12 | active_resource_id: str = None 13 | destination_business_entity_id: str = None 14 | source_business_entity_id: str = None 15 | reason_code: str = None 16 | created_at: int = None 17 | -------------------------------------------------------------------------------- /chargebee/models/card/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import Card 2 | from .responses import CardResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/card/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | from chargebee.response import Response 5 | from chargebee.models import third_party_payment_method, customer 6 | 7 | 8 | @dataclass 9 | class CardResponse(Model): 10 | raw_data: Dict[Any, Any] = None 11 | payment_source_id: str = None 12 | status: str = None 13 | gateway: str = None 14 | gateway_account_id: str = None 15 | ref_tx_id: str = None 16 | first_name: str = None 17 | last_name: str = None 18 | iin: str = None 19 | last4: str = None 20 | card_type: str = None 21 | funding_type: str = None 22 | expiry_month: int = None 23 | expiry_year: int = None 24 | issuing_country: str = None 25 | billing_addr1: str = None 26 | billing_addr2: str = None 27 | billing_city: str = None 28 | billing_state_code: str = None 29 | billing_state: str = None 30 | billing_country: str = None 31 | billing_zip: str = None 32 | created_at: int = None 33 | resource_version: int = None 34 | updated_at: int = None 35 | ip_address: str = None 36 | powered_by: str = None 37 | customer_id: str = None 38 | masked_number: str = None 39 | 40 | 41 | @dataclass 42 | class RetrieveResponse(Response): 43 | 44 | card: CardResponse 45 | 46 | 47 | @dataclass 48 | class UpdateCardForCustomerResponse(Response): 49 | is_idempotency_replayed: bool 50 | customer: "customer.CustomerResponse" 51 | card: CardResponse 52 | 53 | 54 | @dataclass 55 | class SwitchGatewayForCustomerResponse(Response): 56 | is_idempotency_replayed: bool 57 | customer: "customer.CustomerResponse" 58 | card: CardResponse 59 | 60 | 61 | @dataclass 62 | class CopyCardForCustomerResponse(Response): 63 | is_idempotency_replayed: bool 64 | third_party_payment_method: ( 65 | "third_party_payment_method.ThirdPartyPaymentMethodResponse" 66 | ) 67 | 68 | 69 | @dataclass 70 | class DeleteCardForCustomerResponse(Response): 71 | is_idempotency_replayed: bool 72 | customer: "customer.CustomerResponse" 73 | -------------------------------------------------------------------------------- /chargebee/models/comment/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import Comment 2 | from .responses import CommentResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/comment/operations.py: -------------------------------------------------------------------------------- 1 | from .responses import * 2 | from chargebee import request, environment 3 | from typing import TypedDict, Required, NotRequired, Dict, List, Any, cast 4 | from enum import Enum 5 | from chargebee.filters import Filters 6 | from chargebee.models import enums 7 | 8 | 9 | @dataclass 10 | class Comment: 11 | 12 | env: environment.Environment 13 | 14 | class Type(Enum): 15 | USER = "user" 16 | SYSTEM = "system" 17 | 18 | def __str__(self): 19 | return self.value 20 | 21 | class CreateParams(TypedDict): 22 | entity_type: Required[enums.EntityType] 23 | entity_id: Required[str] 24 | notes: Required[str] 25 | added_by: NotRequired[str] 26 | 27 | class ListParams(TypedDict): 28 | limit: NotRequired[int] 29 | offset: NotRequired[str] 30 | entity_type: NotRequired[enums.EntityType] 31 | entity_id: NotRequired[str] 32 | created_at: NotRequired[Filters.TimestampFilter] 33 | sort_by: NotRequired[Filters.SortFilter] 34 | 35 | def create(self, params: CreateParams, headers=None) -> CreateResponse: 36 | jsonKeys = {} 37 | return request.send( 38 | "post", 39 | request.uri_path("comments"), 40 | self.env, 41 | cast(Dict[Any, Any], params), 42 | headers, 43 | CreateResponse, 44 | None, 45 | False, 46 | jsonKeys, 47 | ) 48 | 49 | def retrieve(self, id, headers=None) -> RetrieveResponse: 50 | jsonKeys = {} 51 | return request.send( 52 | "get", 53 | request.uri_path("comments", id), 54 | self.env, 55 | None, 56 | headers, 57 | RetrieveResponse, 58 | None, 59 | False, 60 | jsonKeys, 61 | ) 62 | 63 | def list(self, params: ListParams = None, headers=None) -> ListResponse: 64 | jsonKeys = {} 65 | return request.send_list_request( 66 | "get", 67 | request.uri_path("comments"), 68 | self.env, 69 | cast(Dict[Any, Any], params), 70 | headers, 71 | ListResponse, 72 | None, 73 | False, 74 | jsonKeys, 75 | ) 76 | 77 | def delete(self, id, headers=None) -> DeleteResponse: 78 | jsonKeys = {} 79 | return request.send( 80 | "post", 81 | request.uri_path("comments", id, "delete"), 82 | self.env, 83 | None, 84 | headers, 85 | DeleteResponse, 86 | None, 87 | False, 88 | jsonKeys, 89 | ) 90 | -------------------------------------------------------------------------------- /chargebee/models/comment/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | from chargebee.response import Response 5 | 6 | 7 | @dataclass 8 | class CommentResponse(Model): 9 | raw_data: Dict[Any, Any] = None 10 | id: str = None 11 | entity_type: str = None 12 | added_by: str = None 13 | notes: str = None 14 | created_at: int = None 15 | type: str = None 16 | entity_id: str = None 17 | 18 | 19 | @dataclass 20 | class CreateResponse(Response): 21 | is_idempotency_replayed: bool 22 | comment: CommentResponse 23 | 24 | 25 | @dataclass 26 | class RetrieveResponse(Response): 27 | 28 | comment: CommentResponse 29 | 30 | 31 | @dataclass 32 | class ListCommentResponse: 33 | comment: CommentResponse 34 | 35 | 36 | @dataclass 37 | class ListResponse(Response): 38 | 39 | list: List[ListCommentResponse] 40 | next_offset: str = None 41 | 42 | 43 | @dataclass 44 | class DeleteResponse(Response): 45 | is_idempotency_replayed: bool 46 | comment: CommentResponse 47 | -------------------------------------------------------------------------------- /chargebee/models/configuration/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import Configuration 2 | from .responses import ConfigurationResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/configuration/operations.py: -------------------------------------------------------------------------------- 1 | from .responses import * 2 | from chargebee import request, environment 3 | from typing import TypedDict, Required, NotRequired, Dict, List, Any, cast 4 | 5 | 6 | @dataclass 7 | class Configuration: 8 | 9 | env: environment.Environment 10 | 11 | def list(self, headers=None) -> ListResponse: 12 | jsonKeys = {} 13 | return request.send_list_request( 14 | "get", 15 | request.uri_path("configurations"), 16 | self.env, 17 | None, 18 | headers, 19 | ListResponse, 20 | None, 21 | False, 22 | jsonKeys, 23 | ) 24 | -------------------------------------------------------------------------------- /chargebee/models/configuration/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | from chargebee.response import Response 5 | 6 | 7 | @dataclass 8 | class ConfigurationResponse(Model): 9 | raw_data: Dict[Any, Any] = None 10 | domain: str = None 11 | product_catalog_version: str = None 12 | 13 | 14 | @dataclass 15 | class ListResponse(Response): 16 | 17 | configurations: List[ConfigurationResponse] 18 | -------------------------------------------------------------------------------- /chargebee/models/contact/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import Contact 2 | from .responses import ContactResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/contact/operations.py: -------------------------------------------------------------------------------- 1 | from .responses import * 2 | from chargebee import request, environment 3 | from typing import TypedDict, Required, NotRequired, Dict, List, Any, cast 4 | 5 | 6 | @dataclass 7 | class Contact: 8 | 9 | env: environment.Environment 10 | 11 | pass 12 | -------------------------------------------------------------------------------- /chargebee/models/contact/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | 5 | 6 | @dataclass 7 | class ContactResponse(Model): 8 | raw_data: Dict[Any, Any] = None 9 | id: str = None 10 | first_name: str = None 11 | last_name: str = None 12 | email: str = None 13 | phone: str = None 14 | label: str = None 15 | enabled: bool = None 16 | send_account_email: bool = None 17 | send_billing_email: bool = None 18 | -------------------------------------------------------------------------------- /chargebee/models/contract_term/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import ContractTerm 2 | from .responses import ContractTermResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/contract_term/operations.py: -------------------------------------------------------------------------------- 1 | from .responses import * 2 | from chargebee import request, environment 3 | from typing import TypedDict, Required, NotRequired, Dict, List, Any, cast 4 | from enum import Enum 5 | 6 | 7 | @dataclass 8 | class ContractTerm: 9 | 10 | env: environment.Environment 11 | 12 | class Status(Enum): 13 | ACTIVE = "active" 14 | COMPLETED = "completed" 15 | CANCELLED = "cancelled" 16 | TERMINATED = "terminated" 17 | 18 | def __str__(self): 19 | return self.value 20 | 21 | class ActionAtTermEnd(Enum): 22 | RENEW = "renew" 23 | EVERGREEN = "evergreen" 24 | CANCEL = "cancel" 25 | RENEW_ONCE = "renew_once" 26 | 27 | def __str__(self): 28 | return self.value 29 | 30 | pass 31 | -------------------------------------------------------------------------------- /chargebee/models/contract_term/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | 5 | 6 | @dataclass 7 | class ContractTermResponse(Model): 8 | raw_data: Dict[Any, Any] = None 9 | id: str = None 10 | status: str = None 11 | contract_start: int = None 12 | contract_end: int = None 13 | billing_cycle: int = None 14 | action_at_term_end: str = None 15 | total_contract_value: int = None 16 | total_contract_value_before_tax: int = None 17 | cancellation_cutoff_period: int = None 18 | created_at: int = None 19 | subscription_id: str = None 20 | remaining_billing_cycles: int = None 21 | -------------------------------------------------------------------------------- /chargebee/models/coupon/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import Coupon 2 | from .responses import CouponResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/coupon/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | from chargebee.response import Response 5 | 6 | 7 | @dataclass 8 | class ItemConstraintResponse(Model): 9 | raw_data: Dict[Any, Any] = None 10 | item_type: str = None 11 | constraint: str = None 12 | item_price_ids: List[Dict[Any, Any]] = None 13 | 14 | 15 | @dataclass 16 | class ItemConstraintCriteriaResponse(Model): 17 | raw_data: Dict[Any, Any] = None 18 | item_type: str = None 19 | currencies: List[Dict[Any, Any]] = None 20 | item_family_ids: List[Dict[Any, Any]] = None 21 | item_price_periods: List[Dict[Any, Any]] = None 22 | 23 | 24 | @dataclass 25 | class CouponConstraintResponse(Model): 26 | raw_data: Dict[Any, Any] = None 27 | entity_type: str = None 28 | type: str = None 29 | value: str = None 30 | 31 | 32 | @dataclass 33 | class CouponResponse(Model): 34 | raw_data: Dict[Any, Any] = None 35 | id: str = None 36 | name: str = None 37 | invoice_name: str = None 38 | discount_type: str = None 39 | discount_percentage: float = None 40 | discount_amount: int = None 41 | discount_quantity: int = None 42 | currency_code: str = None 43 | duration_type: str = None 44 | duration_month: int = None 45 | valid_from: int = None 46 | valid_till: int = None 47 | max_redemptions: int = None 48 | status: str = None 49 | apply_discount_on: str = None 50 | apply_on: str = None 51 | plan_constraint: str = None 52 | addon_constraint: str = None 53 | created_at: int = None 54 | archived_at: int = None 55 | resource_version: int = None 56 | updated_at: int = None 57 | included_in_mrr: bool = None 58 | period: int = None 59 | period_unit: str = None 60 | plan_ids: List[str] = None 61 | addon_ids: List[str] = None 62 | item_constraints: List[ItemConstraintResponse] = None 63 | item_constraint_criteria: List[ItemConstraintCriteriaResponse] = None 64 | redemptions: int = None 65 | invoice_notes: str = None 66 | meta_data: Dict[Any, Any] = None 67 | coupon_constraints: List[CouponConstraintResponse] = None 68 | deleted: bool = None 69 | 70 | 71 | @dataclass 72 | class CreateResponse(Response): 73 | is_idempotency_replayed: bool 74 | coupon: CouponResponse 75 | 76 | 77 | @dataclass 78 | class CreateForItemsResponse(Response): 79 | is_idempotency_replayed: bool 80 | coupon: CouponResponse 81 | 82 | 83 | @dataclass 84 | class UpdateForItemsResponse(Response): 85 | is_idempotency_replayed: bool 86 | coupon: CouponResponse 87 | 88 | 89 | @dataclass 90 | class ListCouponResponse: 91 | coupon: CouponResponse 92 | 93 | 94 | @dataclass 95 | class ListResponse(Response): 96 | 97 | list: List[ListCouponResponse] 98 | next_offset: str = None 99 | 100 | 101 | @dataclass 102 | class RetrieveResponse(Response): 103 | 104 | coupon: CouponResponse 105 | 106 | 107 | @dataclass 108 | class UpdateResponse(Response): 109 | is_idempotency_replayed: bool 110 | coupon: CouponResponse 111 | 112 | 113 | @dataclass 114 | class DeleteResponse(Response): 115 | is_idempotency_replayed: bool 116 | coupon: CouponResponse 117 | 118 | 119 | @dataclass 120 | class CopyResponse(Response): 121 | is_idempotency_replayed: bool 122 | coupon: CouponResponse 123 | 124 | 125 | @dataclass 126 | class UnarchiveResponse(Response): 127 | is_idempotency_replayed: bool 128 | coupon: CouponResponse 129 | -------------------------------------------------------------------------------- /chargebee/models/coupon_code/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import CouponCode 2 | from .responses import CouponCodeResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/coupon_code/operations.py: -------------------------------------------------------------------------------- 1 | from .responses import * 2 | from chargebee import request, environment 3 | from typing import TypedDict, Required, NotRequired, Dict, List, Any, cast 4 | from enum import Enum 5 | from chargebee.filters import Filters 6 | 7 | 8 | @dataclass 9 | class CouponCode: 10 | 11 | env: environment.Environment 12 | 13 | class Status(Enum): 14 | NOT_REDEEMED = "not_redeemed" 15 | REDEEMED = "redeemed" 16 | ARCHIVED = "archived" 17 | 18 | def __str__(self): 19 | return self.value 20 | 21 | class CreateParams(TypedDict): 22 | coupon_id: Required[str] 23 | coupon_set_name: Required[str] 24 | code: Required[str] 25 | 26 | class ListParams(TypedDict): 27 | limit: NotRequired[int] 28 | offset: NotRequired[str] 29 | code: NotRequired[Filters.StringFilter] 30 | coupon_id: NotRequired[Filters.StringFilter] 31 | coupon_set_name: NotRequired[Filters.StringFilter] 32 | status: NotRequired[Filters.EnumFilter] 33 | 34 | def create(self, params: CreateParams, headers=None) -> CreateResponse: 35 | jsonKeys = {} 36 | return request.send( 37 | "post", 38 | request.uri_path("coupon_codes"), 39 | self.env, 40 | cast(Dict[Any, Any], params), 41 | headers, 42 | CreateResponse, 43 | None, 44 | False, 45 | jsonKeys, 46 | ) 47 | 48 | def retrieve(self, id, headers=None) -> RetrieveResponse: 49 | jsonKeys = {} 50 | return request.send( 51 | "get", 52 | request.uri_path("coupon_codes", id), 53 | self.env, 54 | None, 55 | headers, 56 | RetrieveResponse, 57 | None, 58 | False, 59 | jsonKeys, 60 | ) 61 | 62 | def list(self, params: ListParams = None, headers=None) -> ListResponse: 63 | jsonKeys = {} 64 | return request.send_list_request( 65 | "get", 66 | request.uri_path("coupon_codes"), 67 | self.env, 68 | cast(Dict[Any, Any], params), 69 | headers, 70 | ListResponse, 71 | None, 72 | False, 73 | jsonKeys, 74 | ) 75 | 76 | def archive(self, id, headers=None) -> ArchiveResponse: 77 | jsonKeys = {} 78 | return request.send( 79 | "post", 80 | request.uri_path("coupon_codes", id, "archive"), 81 | self.env, 82 | None, 83 | headers, 84 | ArchiveResponse, 85 | None, 86 | False, 87 | jsonKeys, 88 | ) 89 | -------------------------------------------------------------------------------- /chargebee/models/coupon_code/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | from chargebee.response import Response 5 | 6 | 7 | @dataclass 8 | class CouponCodeResponse(Model): 9 | raw_data: Dict[Any, Any] = None 10 | code: str = None 11 | status: str = None 12 | coupon_id: str = None 13 | coupon_set_id: str = None 14 | coupon_set_name: str = None 15 | 16 | 17 | @dataclass 18 | class CreateResponse(Response): 19 | is_idempotency_replayed: bool 20 | coupon_code: CouponCodeResponse 21 | 22 | 23 | @dataclass 24 | class RetrieveResponse(Response): 25 | 26 | coupon_code: CouponCodeResponse 27 | 28 | 29 | @dataclass 30 | class ListCouponCodeResponse: 31 | coupon_code: CouponCodeResponse 32 | 33 | 34 | @dataclass 35 | class ListResponse(Response): 36 | 37 | list: List[ListCouponCodeResponse] 38 | next_offset: str = None 39 | 40 | 41 | @dataclass 42 | class ArchiveResponse(Response): 43 | is_idempotency_replayed: bool 44 | coupon_code: CouponCodeResponse 45 | -------------------------------------------------------------------------------- /chargebee/models/coupon_set/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import CouponSet 2 | from .responses import CouponSetResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/coupon_set/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | from chargebee.response import Response 5 | 6 | 7 | @dataclass 8 | class CouponSetResponse(Model): 9 | raw_data: Dict[Any, Any] = None 10 | id: str = None 11 | coupon_id: str = None 12 | name: str = None 13 | total_count: int = None 14 | redeemed_count: int = None 15 | archived_count: int = None 16 | meta_data: Dict[Any, Any] = None 17 | 18 | 19 | @dataclass 20 | class CreateResponse(Response): 21 | is_idempotency_replayed: bool 22 | coupon_set: CouponSetResponse 23 | 24 | 25 | @dataclass 26 | class AddCouponCodesResponse(Response): 27 | is_idempotency_replayed: bool 28 | coupon_set: CouponSetResponse 29 | 30 | 31 | @dataclass 32 | class ListCouponSetResponse: 33 | coupon_set: CouponSetResponse 34 | 35 | 36 | @dataclass 37 | class ListResponse(Response): 38 | 39 | list: List[ListCouponSetResponse] 40 | next_offset: str = None 41 | 42 | 43 | @dataclass 44 | class RetrieveResponse(Response): 45 | 46 | coupon_set: CouponSetResponse 47 | 48 | 49 | @dataclass 50 | class UpdateResponse(Response): 51 | is_idempotency_replayed: bool 52 | coupon_set: CouponSetResponse 53 | 54 | 55 | @dataclass 56 | class DeleteResponse(Response): 57 | is_idempotency_replayed: bool 58 | coupon_set: CouponSetResponse 59 | 60 | 61 | @dataclass 62 | class DeleteUnusedCouponCodesResponse(Response): 63 | is_idempotency_replayed: bool 64 | coupon_set: CouponSetResponse 65 | -------------------------------------------------------------------------------- /chargebee/models/credit_note/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import CreditNote 2 | from .responses import CreditNoteResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/credit_note_estimate/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import CreditNoteEstimate 2 | from .responses import CreditNoteEstimateResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/credit_note_estimate/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | 5 | 6 | @dataclass 7 | class LineItemResponse(Model): 8 | raw_data: Dict[Any, Any] = None 9 | id: str = None 10 | subscription_id: str = None 11 | date_from: int = None 12 | date_to: int = None 13 | unit_amount: int = None 14 | quantity: int = None 15 | amount: int = None 16 | pricing_model: str = None 17 | is_taxed: bool = None 18 | tax_amount: int = None 19 | tax_rate: float = None 20 | unit_amount_in_decimal: str = None 21 | quantity_in_decimal: str = None 22 | amount_in_decimal: str = None 23 | discount_amount: int = None 24 | item_level_discount_amount: int = None 25 | metered: bool = None 26 | percentage: str = None 27 | reference_line_item_id: str = None 28 | description: str = None 29 | entity_description: str = None 30 | entity_type: str = None 31 | tax_exempt_reason: str = None 32 | entity_id: str = None 33 | customer_id: str = None 34 | 35 | 36 | @dataclass 37 | class DiscountResponse(Model): 38 | raw_data: Dict[Any, Any] = None 39 | amount: int = None 40 | description: str = None 41 | entity_type: str = None 42 | discount_type: str = None 43 | entity_id: str = None 44 | coupon_set_code: str = None 45 | 46 | 47 | @dataclass 48 | class TaxResponse(Model): 49 | raw_data: Dict[Any, Any] = None 50 | name: str = None 51 | amount: int = None 52 | description: str = None 53 | 54 | 55 | @dataclass 56 | class LineItemTaxResponse(Model): 57 | raw_data: Dict[Any, Any] = None 58 | line_item_id: str = None 59 | tax_name: str = None 60 | tax_rate: float = None 61 | date_to: int = None 62 | date_from: int = None 63 | prorated_taxable_amount: float = None 64 | is_partial_tax_applied: bool = None 65 | is_non_compliance_tax: bool = None 66 | taxable_amount: int = None 67 | tax_amount: int = None 68 | tax_juris_type: str = None 69 | tax_juris_name: str = None 70 | tax_juris_code: str = None 71 | tax_amount_in_local_currency: int = None 72 | local_currency_code: str = None 73 | 74 | 75 | @dataclass 76 | class LineItemDiscountResponse(Model): 77 | raw_data: Dict[Any, Any] = None 78 | line_item_id: str = None 79 | discount_type: str = None 80 | coupon_id: str = None 81 | entity_id: str = None 82 | discount_amount: int = None 83 | 84 | 85 | @dataclass 86 | class LineItemTierResponse(Model): 87 | raw_data: Dict[Any, Any] = None 88 | line_item_id: str = None 89 | starting_unit: int = None 90 | ending_unit: int = None 91 | quantity_used: int = None 92 | unit_amount: int = None 93 | starting_unit_in_decimal: str = None 94 | ending_unit_in_decimal: str = None 95 | quantity_used_in_decimal: str = None 96 | unit_amount_in_decimal: str = None 97 | pricing_type: str = None 98 | package_size: int = None 99 | 100 | 101 | @dataclass 102 | class CreditNoteEstimateResponse(Model): 103 | raw_data: Dict[Any, Any] = None 104 | reference_invoice_id: str = None 105 | type: str = None 106 | price_type: str = None 107 | currency_code: str = None 108 | sub_total: int = None 109 | total: int = None 110 | amount_allocated: int = None 111 | amount_available: int = None 112 | line_items: List[LineItemResponse] = None 113 | discounts: List[DiscountResponse] = None 114 | taxes: List[TaxResponse] = None 115 | line_item_taxes: List[LineItemTaxResponse] = None 116 | line_item_discounts: List[LineItemDiscountResponse] = None 117 | line_item_tiers: List[LineItemTierResponse] = None 118 | round_off_amount: int = None 119 | customer_id: str = None 120 | -------------------------------------------------------------------------------- /chargebee/models/currency/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import Currency 2 | from .responses import CurrencyResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/currency/operations.py: -------------------------------------------------------------------------------- 1 | from .responses import * 2 | from chargebee import request, environment 3 | from typing import TypedDict, Required, NotRequired, Dict, List, Any, cast 4 | from enum import Enum 5 | 6 | 7 | @dataclass 8 | class Currency: 9 | 10 | env: environment.Environment 11 | 12 | class ForexType(Enum): 13 | MANUAL = "manual" 14 | AUTO = "auto" 15 | 16 | def __str__(self): 17 | return self.value 18 | 19 | class CreateParams(TypedDict): 20 | currency_code: Required[str] 21 | forex_type: Required["Currency.ForexType"] 22 | manual_exchange_rate: NotRequired[str] 23 | 24 | class UpdateParams(TypedDict): 25 | forex_type: Required["Currency.ForexType"] 26 | manual_exchange_rate: NotRequired[str] 27 | 28 | class AddScheduleParams(TypedDict): 29 | manual_exchange_rate: Required[str] 30 | schedule_at: Required[int] 31 | 32 | def list(self, headers=None) -> ListResponse: 33 | jsonKeys = {} 34 | return request.send_list_request( 35 | "get", 36 | request.uri_path("currencies", "list"), 37 | self.env, 38 | None, 39 | headers, 40 | ListResponse, 41 | None, 42 | False, 43 | jsonKeys, 44 | ) 45 | 46 | def retrieve(self, id, headers=None) -> RetrieveResponse: 47 | jsonKeys = {} 48 | return request.send( 49 | "get", 50 | request.uri_path("currencies", id), 51 | self.env, 52 | None, 53 | headers, 54 | RetrieveResponse, 55 | None, 56 | False, 57 | jsonKeys, 58 | ) 59 | 60 | def create(self, params: CreateParams, headers=None) -> CreateResponse: 61 | jsonKeys = {} 62 | return request.send( 63 | "post", 64 | request.uri_path("currencies"), 65 | self.env, 66 | cast(Dict[Any, Any], params), 67 | headers, 68 | CreateResponse, 69 | None, 70 | False, 71 | jsonKeys, 72 | ) 73 | 74 | def update(self, id, params: UpdateParams, headers=None) -> UpdateResponse: 75 | jsonKeys = {} 76 | return request.send( 77 | "post", 78 | request.uri_path("currencies", id), 79 | self.env, 80 | cast(Dict[Any, Any], params), 81 | headers, 82 | UpdateResponse, 83 | None, 84 | False, 85 | jsonKeys, 86 | ) 87 | 88 | def add_schedule( 89 | self, id, params: AddScheduleParams, headers=None 90 | ) -> AddScheduleResponse: 91 | jsonKeys = {} 92 | return request.send( 93 | "post", 94 | request.uri_path("currencies", id, "add_schedule"), 95 | self.env, 96 | cast(Dict[Any, Any], params), 97 | headers, 98 | AddScheduleResponse, 99 | None, 100 | False, 101 | jsonKeys, 102 | ) 103 | 104 | def remove_schedule(self, id, headers=None) -> RemoveScheduleResponse: 105 | jsonKeys = {} 106 | return request.send( 107 | "post", 108 | request.uri_path("currencies", id, "remove_schedule"), 109 | self.env, 110 | None, 111 | headers, 112 | RemoveScheduleResponse, 113 | None, 114 | False, 115 | jsonKeys, 116 | ) 117 | -------------------------------------------------------------------------------- /chargebee/models/currency/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | from chargebee.response import Response 5 | 6 | 7 | @dataclass 8 | class CurrencyResponse(Model): 9 | raw_data: Dict[Any, Any] = None 10 | id: str = None 11 | enabled: bool = None 12 | forex_type: str = None 13 | currency_code: str = None 14 | is_base_currency: bool = None 15 | manual_exchange_rate: str = None 16 | 17 | 18 | @dataclass 19 | class ListResponse(Response): 20 | 21 | currency: CurrencyResponse 22 | 23 | 24 | @dataclass 25 | class RetrieveResponse(Response): 26 | 27 | currency: CurrencyResponse 28 | 29 | 30 | @dataclass 31 | class CreateResponse(Response): 32 | is_idempotency_replayed: bool 33 | currency: CurrencyResponse 34 | 35 | 36 | @dataclass 37 | class UpdateResponse(Response): 38 | is_idempotency_replayed: bool 39 | currency: CurrencyResponse 40 | 41 | 42 | @dataclass 43 | class AddScheduleResponse(Response): 44 | is_idempotency_replayed: bool 45 | scheduled_at: int 46 | currency: CurrencyResponse 47 | 48 | 49 | @dataclass 50 | class RemoveScheduleResponse(Response): 51 | is_idempotency_replayed: bool 52 | scheduled_at: int 53 | currency: CurrencyResponse 54 | -------------------------------------------------------------------------------- /chargebee/models/customer/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import Customer 2 | from .responses import CustomerResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/customer_entitlement/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import CustomerEntitlement 2 | from .responses import CustomerEntitlementResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/customer_entitlement/operations.py: -------------------------------------------------------------------------------- 1 | from .responses import * 2 | from chargebee import request, environment 3 | from typing import TypedDict, Required, NotRequired, Dict, List, Any, cast 4 | 5 | 6 | @dataclass 7 | class CustomerEntitlement: 8 | 9 | env: environment.Environment 10 | 11 | class EntitlementsForCustomerParams(TypedDict): 12 | limit: NotRequired[int] 13 | offset: NotRequired[str] 14 | 15 | def entitlements_for_customer( 16 | self, id, params: EntitlementsForCustomerParams = None, headers=None 17 | ) -> EntitlementsForCustomerResponse: 18 | jsonKeys = {} 19 | return request.send( 20 | "get", 21 | request.uri_path("customers", id, "customer_entitlements"), 22 | self.env, 23 | cast(Dict[Any, Any], params), 24 | headers, 25 | EntitlementsForCustomerResponse, 26 | None, 27 | False, 28 | jsonKeys, 29 | ) 30 | -------------------------------------------------------------------------------- /chargebee/models/customer_entitlement/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | from chargebee.response import Response 5 | 6 | 7 | @dataclass 8 | class CustomerEntitlementResponse(Model): 9 | raw_data: Dict[Any, Any] = None 10 | customer_id: str = None 11 | subscription_id: str = None 12 | feature_id: str = None 13 | value: str = None 14 | name: str = None 15 | is_enabled: bool = None 16 | 17 | 18 | @dataclass 19 | class EntitlementsForCustomerCustomerEntitlementResponse: 20 | customer_entitlement: CustomerEntitlementResponse 21 | 22 | 23 | @dataclass 24 | class EntitlementsForCustomerResponse(Response): 25 | 26 | list: List[EntitlementsForCustomerCustomerEntitlementResponse] 27 | next_offset: str = None 28 | -------------------------------------------------------------------------------- /chargebee/models/differential_price/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import DifferentialPrice 2 | from .responses import DifferentialPriceResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/differential_price/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | from chargebee.response import Response 5 | 6 | 7 | @dataclass 8 | class TierResponse(Model): 9 | raw_data: Dict[Any, Any] = None 10 | starting_unit: int = None 11 | ending_unit: int = None 12 | price: int = None 13 | starting_unit_in_decimal: str = None 14 | ending_unit_in_decimal: str = None 15 | price_in_decimal: str = None 16 | pricing_type: str = None 17 | package_size: int = None 18 | 19 | 20 | @dataclass 21 | class ParentPeriodResponse(Model): 22 | raw_data: Dict[Any, Any] = None 23 | period_unit: str = None 24 | period: List[Dict[Any, Any]] = None 25 | 26 | 27 | @dataclass 28 | class DifferentialPriceResponse(Model): 29 | raw_data: Dict[Any, Any] = None 30 | id: str = None 31 | item_price_id: str = None 32 | parent_item_id: str = None 33 | price: int = None 34 | price_in_decimal: str = None 35 | status: str = None 36 | resource_version: int = None 37 | updated_at: int = None 38 | created_at: int = None 39 | modified_at: int = None 40 | tiers: List[TierResponse] = None 41 | currency_code: str = None 42 | parent_periods: List[ParentPeriodResponse] = None 43 | business_entity_id: str = None 44 | deleted: bool = None 45 | 46 | 47 | @dataclass 48 | class CreateResponse(Response): 49 | is_idempotency_replayed: bool 50 | differential_price: DifferentialPriceResponse 51 | 52 | 53 | @dataclass 54 | class RetrieveResponse(Response): 55 | 56 | differential_price: DifferentialPriceResponse 57 | 58 | 59 | @dataclass 60 | class UpdateResponse(Response): 61 | is_idempotency_replayed: bool 62 | differential_price: DifferentialPriceResponse 63 | 64 | 65 | @dataclass 66 | class DeleteResponse(Response): 67 | is_idempotency_replayed: bool 68 | differential_price: DifferentialPriceResponse 69 | 70 | 71 | @dataclass 72 | class ListDifferentialPriceResponse: 73 | differential_price: DifferentialPriceResponse 74 | 75 | 76 | @dataclass 77 | class ListResponse(Response): 78 | 79 | list: List[ListDifferentialPriceResponse] 80 | next_offset: str = None 81 | -------------------------------------------------------------------------------- /chargebee/models/discount/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import Discount 2 | from .responses import DiscountResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/discount/operations.py: -------------------------------------------------------------------------------- 1 | from .responses import * 2 | from chargebee import request, environment 3 | from typing import TypedDict, Required, NotRequired, Dict, List, Any, cast 4 | from enum import Enum 5 | 6 | 7 | @dataclass 8 | class Discount: 9 | 10 | env: environment.Environment 11 | 12 | class Type(Enum): 13 | FIXED_AMOUNT = "fixed_amount" 14 | PERCENTAGE = "percentage" 15 | 16 | def __str__(self): 17 | return self.value 18 | 19 | pass 20 | -------------------------------------------------------------------------------- /chargebee/models/discount/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | 5 | 6 | @dataclass 7 | class DiscountResponse(Model): 8 | raw_data: Dict[Any, Any] = None 9 | id: str = None 10 | invoice_name: str = None 11 | type: str = None 12 | percentage: float = None 13 | amount: int = None 14 | currency_code: str = None 15 | duration_type: str = None 16 | period: int = None 17 | period_unit: str = None 18 | included_in_mrr: bool = None 19 | apply_on: str = None 20 | item_price_id: str = None 21 | created_at: int = None 22 | apply_till: int = None 23 | applied_count: int = None 24 | coupon_id: str = None 25 | index: int = None 26 | -------------------------------------------------------------------------------- /chargebee/models/download/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import Download 2 | from .responses import DownloadResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/download/operations.py: -------------------------------------------------------------------------------- 1 | from .responses import * 2 | from chargebee import request, environment 3 | from typing import TypedDict, Required, NotRequired, Dict, List, Any, cast 4 | 5 | 6 | @dataclass 7 | class Download: 8 | 9 | env: environment.Environment 10 | 11 | pass 12 | -------------------------------------------------------------------------------- /chargebee/models/download/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | 5 | 6 | @dataclass 7 | class DownloadResponse(Model): 8 | raw_data: Dict[Any, Any] = None 9 | download_url: str = None 10 | valid_till: int = None 11 | mime_type: str = None 12 | -------------------------------------------------------------------------------- /chargebee/models/entitlement/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import Entitlement 2 | from .responses import EntitlementResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/entitlement/operations.py: -------------------------------------------------------------------------------- 1 | from .responses import * 2 | from chargebee import request, environment 3 | from typing import TypedDict, Required, NotRequired, Dict, List, Any, cast 4 | from enum import Enum 5 | from chargebee.filters import Filters 6 | from chargebee.models import enums 7 | 8 | 9 | @dataclass 10 | class Entitlement: 11 | 12 | env: environment.Environment 13 | 14 | class EntityType(Enum): 15 | PLAN = "plan" 16 | ADDON = "addon" 17 | CHARGE = "charge" 18 | PLAN_PRICE = "plan_price" 19 | ADDON_PRICE = "addon_price" 20 | 21 | def __str__(self): 22 | return self.value 23 | 24 | class CreateEntitlementParams(TypedDict): 25 | entity_id: Required[str] 26 | feature_id: Required[str] 27 | entity_type: NotRequired["Entitlement.EntityType"] 28 | value: NotRequired[str] 29 | 30 | class ListParams(TypedDict): 31 | limit: NotRequired[int] 32 | offset: NotRequired[str] 33 | feature_id: NotRequired[Filters.StringFilter] 34 | entity_type: NotRequired[Filters.EnumFilter] 35 | entity_id: NotRequired[Filters.StringFilter] 36 | include_drafts: NotRequired[bool] 37 | embed: NotRequired[str] 38 | 39 | class CreateParams(TypedDict): 40 | action: Required[enums.Action] 41 | entitlements: Required[List["Entitlement.CreateEntitlementParams"]] 42 | 43 | def list(self, params: ListParams = None, headers=None) -> ListResponse: 44 | jsonKeys = {} 45 | return request.send_list_request( 46 | "get", 47 | request.uri_path("entitlements"), 48 | self.env, 49 | cast(Dict[Any, Any], params), 50 | headers, 51 | ListResponse, 52 | None, 53 | False, 54 | jsonKeys, 55 | ) 56 | 57 | def create(self, params: CreateParams, headers=None) -> CreateResponse: 58 | jsonKeys = {} 59 | return request.send( 60 | "post", 61 | request.uri_path("entitlements"), 62 | self.env, 63 | cast(Dict[Any, Any], params), 64 | headers, 65 | CreateResponse, 66 | None, 67 | False, 68 | jsonKeys, 69 | ) 70 | -------------------------------------------------------------------------------- /chargebee/models/entitlement/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | from chargebee.response import Response 5 | 6 | 7 | @dataclass 8 | class EntitlementResponse(Model): 9 | raw_data: Dict[Any, Any] = None 10 | id: str = None 11 | entity_id: str = None 12 | entity_type: str = None 13 | feature_id: str = None 14 | feature_name: str = None 15 | value: str = None 16 | name: str = None 17 | 18 | 19 | @dataclass 20 | class ListEntitlementResponse: 21 | entitlement: EntitlementResponse 22 | 23 | 24 | @dataclass 25 | class ListResponse(Response): 26 | 27 | list: List[ListEntitlementResponse] 28 | next_offset: str = None 29 | 30 | 31 | @dataclass 32 | class CreateResponse(Response): 33 | is_idempotency_replayed: bool 34 | entitlement: EntitlementResponse 35 | -------------------------------------------------------------------------------- /chargebee/models/entitlement_override/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import EntitlementOverride 2 | from .responses import EntitlementOverrideResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/entitlement_override/operations.py: -------------------------------------------------------------------------------- 1 | from .responses import * 2 | from chargebee import request, environment 3 | from typing import TypedDict, Required, NotRequired, Dict, List, Any, cast 4 | from enum import Enum 5 | from chargebee.models import enums 6 | 7 | 8 | @dataclass 9 | class EntitlementOverride: 10 | 11 | env: environment.Environment 12 | 13 | class ScheduleStatus(Enum): 14 | ACTIVATED = "activated" 15 | SCHEDULED = "scheduled" 16 | FAILED = "failed" 17 | 18 | def __str__(self): 19 | return self.value 20 | 21 | class AddEntitlementOverrideForSubscriptionEntitlementOverrideParams(TypedDict): 22 | feature_id: Required[str] 23 | value: NotRequired[str] 24 | expires_at: NotRequired[int] 25 | effective_from: NotRequired[int] 26 | 27 | class AddEntitlementOverrideForSubscriptionParams(TypedDict): 28 | action: NotRequired[enums.Action] 29 | entitlement_overrides: Required[ 30 | List[ 31 | "EntitlementOverride.AddEntitlementOverrideForSubscriptionEntitlementOverrideParams" 32 | ] 33 | ] 34 | 35 | class ListEntitlementOverrideForSubscriptionParams(TypedDict): 36 | limit: NotRequired[int] 37 | offset: NotRequired[str] 38 | embed: NotRequired[str] 39 | include_drafts: NotRequired[bool] 40 | include_scheduled_overrides: NotRequired[bool] 41 | 42 | def add_entitlement_override_for_subscription( 43 | self, id, params: AddEntitlementOverrideForSubscriptionParams, headers=None 44 | ) -> AddEntitlementOverrideForSubscriptionResponse: 45 | jsonKeys = {} 46 | return request.send( 47 | "post", 48 | request.uri_path("subscriptions", id, "entitlement_overrides"), 49 | self.env, 50 | cast(Dict[Any, Any], params), 51 | headers, 52 | AddEntitlementOverrideForSubscriptionResponse, 53 | None, 54 | False, 55 | jsonKeys, 56 | ) 57 | 58 | def list_entitlement_override_for_subscription( 59 | self, 60 | id, 61 | params: ListEntitlementOverrideForSubscriptionParams = None, 62 | headers=None, 63 | ) -> ListEntitlementOverrideForSubscriptionResponse: 64 | jsonKeys = {} 65 | return request.send( 66 | "get", 67 | request.uri_path("subscriptions", id, "entitlement_overrides"), 68 | self.env, 69 | cast(Dict[Any, Any], params), 70 | headers, 71 | ListEntitlementOverrideForSubscriptionResponse, 72 | None, 73 | False, 74 | jsonKeys, 75 | ) 76 | -------------------------------------------------------------------------------- /chargebee/models/entitlement_override/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | from chargebee.response import Response 5 | 6 | 7 | @dataclass 8 | class EntitlementOverrideResponse(Model): 9 | raw_data: Dict[Any, Any] = None 10 | id: str = None 11 | entity_id: str = None 12 | entity_type: str = None 13 | feature_id: str = None 14 | feature_name: str = None 15 | value: str = None 16 | name: str = None 17 | expires_at: int = None 18 | effective_from: int = None 19 | schedule_status: str = None 20 | 21 | 22 | @dataclass 23 | class AddEntitlementOverrideForSubscriptionResponse(Response): 24 | is_idempotency_replayed: bool 25 | entitlement_override: EntitlementOverrideResponse 26 | 27 | 28 | @dataclass 29 | class ListEntitlementOverrideForSubscriptionEntitlementOverrideResponse: 30 | entitlement_override: EntitlementOverrideResponse 31 | 32 | 33 | @dataclass 34 | class ListEntitlementOverrideForSubscriptionResponse(Response): 35 | 36 | list: List[ListEntitlementOverrideForSubscriptionEntitlementOverrideResponse] 37 | next_offset: str = None 38 | -------------------------------------------------------------------------------- /chargebee/models/estimate/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import Estimate 2 | from .responses import EstimateResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/event/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import Event 2 | from .responses import EventResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/event/operations.py: -------------------------------------------------------------------------------- 1 | from .responses import * 2 | from chargebee import request, environment 3 | from typing import TypedDict, Required, NotRequired, Dict, List, Any, cast 4 | from enum import Enum 5 | import json 6 | from chargebee.main import Environment 7 | from chargebee.filters import Filters 8 | 9 | 10 | @dataclass 11 | class Event: 12 | 13 | env: environment.Environment 14 | 15 | class WebhookStatus(Enum): 16 | NOT_CONFIGURED = "not_configured" 17 | SCHEDULED = "scheduled" 18 | SUCCEEDED = "succeeded" 19 | RE_SCHEDULED = "re_scheduled" 20 | FAILED = "failed" 21 | SKIPPED = "skipped" 22 | NOT_APPLICABLE = "not_applicable" 23 | DISABLED = "disabled" 24 | 25 | def __str__(self): 26 | return self.value 27 | 28 | class WebhookWebhookStatus(Enum): 29 | NOT_CONFIGURED = "not_configured" 30 | SCHEDULED = "scheduled" 31 | SUCCEEDED = "succeeded" 32 | RE_SCHEDULED = "re_scheduled" 33 | FAILED = "failed" 34 | SKIPPED = "skipped" 35 | NOT_APPLICABLE = "not_applicable" 36 | DISABLED = "disabled" 37 | 38 | def __str__(self): 39 | return self.value 40 | 41 | class Webhook(TypedDict): 42 | id: Required[str] 43 | webhook_status: Required["Event.WebhookWebhookStatus"] 44 | 45 | def deserialize(self, json_data) -> EventResponse: 46 | try: 47 | webhook_data = json.loads(json_data) 48 | except (TypeError, ValueError) as ex: 49 | raise Exception( 50 | "The passed json_data is not JSON formatted . " + ex.message 51 | ) 52 | 53 | api_version = webhook_data.get("api_version", None) 54 | env_version = self.env.API_VERSION 55 | if api_version is not None and api_version.upper() != env_version.upper(): 56 | raise Exception( 57 | "API version [" 58 | + api_version.upper() 59 | + "] in response does not match " 60 | + "with client library API version [" 61 | + env_version.upper() 62 | + "]" 63 | ) 64 | return EventResponse.construct(webhook_data) 65 | 66 | class ListParams(TypedDict): 67 | limit: NotRequired[int] 68 | offset: NotRequired[str] 69 | start_time: NotRequired[int] 70 | end_time: NotRequired[int] 71 | id: NotRequired[Filters.StringFilter] 72 | webhook_status: NotRequired[Filters.EnumFilter] 73 | event_type: NotRequired[Filters.EnumFilter] 74 | source: NotRequired[Filters.EnumFilter] 75 | occurred_at: NotRequired[Filters.TimestampFilter] 76 | sort_by: NotRequired[Filters.SortFilter] 77 | 78 | def list(self, params: ListParams = None, headers=None) -> ListResponse: 79 | jsonKeys = {} 80 | return request.send_list_request( 81 | "get", 82 | request.uri_path("events"), 83 | self.env, 84 | cast(Dict[Any, Any], params), 85 | headers, 86 | ListResponse, 87 | None, 88 | False, 89 | jsonKeys, 90 | ) 91 | 92 | def retrieve(self, id, headers=None) -> RetrieveResponse: 93 | jsonKeys = {} 94 | return request.send( 95 | "get", 96 | request.uri_path("events", id), 97 | self.env, 98 | None, 99 | headers, 100 | RetrieveResponse, 101 | None, 102 | False, 103 | jsonKeys, 104 | ) 105 | -------------------------------------------------------------------------------- /chargebee/models/event/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | from chargebee.response import Response 5 | 6 | 7 | @dataclass 8 | class WebhookResponse(Model): 9 | raw_data: Dict[Any, Any] = None 10 | id: str = None 11 | webhook_status: str = None 12 | 13 | 14 | @dataclass 15 | class EventResponse(Model): 16 | raw_data: Dict[Any, Any] = None 17 | id: str = None 18 | occurred_at: int = None 19 | source: str = None 20 | user: str = None 21 | webhook_status: str = None 22 | webhook_failure_reason: str = None 23 | webhooks: List[WebhookResponse] = None 24 | event_type: str = None 25 | api_version: str = None 26 | content: Dict[Any, Any] = None 27 | origin_user: str = None 28 | 29 | 30 | @dataclass 31 | class ListEventResponse: 32 | event: EventResponse 33 | 34 | 35 | @dataclass 36 | class ListResponse(Response): 37 | 38 | list: List[ListEventResponse] 39 | next_offset: str = None 40 | 41 | 42 | @dataclass 43 | class RetrieveResponse(Response): 44 | 45 | event: EventResponse 46 | -------------------------------------------------------------------------------- /chargebee/models/export/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import Export 2 | from .responses import ExportResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/export/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | from chargebee.response import Response 5 | 6 | 7 | @dataclass 8 | class DownloadResponse(Model): 9 | raw_data: Dict[Any, Any] = None 10 | download_url: str = None 11 | valid_till: int = None 12 | mime_type: str = None 13 | 14 | 15 | @dataclass 16 | class ExportResponse(Model): 17 | raw_data: Dict[Any, Any] = None 18 | id: str = None 19 | operation_type: str = None 20 | mime_type: str = None 21 | status: str = None 22 | created_at: int = None 23 | download: DownloadResponse = None 24 | 25 | 26 | @dataclass 27 | class RetrieveResponse(Response): 28 | 29 | export: ExportResponse 30 | 31 | 32 | @dataclass 33 | class RevenueRecognitionResponse(Response): 34 | is_idempotency_replayed: bool 35 | export: ExportResponse 36 | 37 | 38 | @dataclass 39 | class DeferredRevenueResponse(Response): 40 | is_idempotency_replayed: bool 41 | export: ExportResponse 42 | 43 | 44 | @dataclass 45 | class PlansResponse(Response): 46 | is_idempotency_replayed: bool 47 | export: ExportResponse 48 | 49 | 50 | @dataclass 51 | class AddonsResponse(Response): 52 | is_idempotency_replayed: bool 53 | export: ExportResponse 54 | 55 | 56 | @dataclass 57 | class CouponsResponse(Response): 58 | is_idempotency_replayed: bool 59 | export: ExportResponse 60 | 61 | 62 | @dataclass 63 | class CustomersResponse(Response): 64 | is_idempotency_replayed: bool 65 | export: ExportResponse 66 | 67 | 68 | @dataclass 69 | class SubscriptionsResponse(Response): 70 | is_idempotency_replayed: bool 71 | export: ExportResponse 72 | 73 | 74 | @dataclass 75 | class InvoicesResponse(Response): 76 | is_idempotency_replayed: bool 77 | export: ExportResponse 78 | 79 | 80 | @dataclass 81 | class CreditNotesResponse(Response): 82 | is_idempotency_replayed: bool 83 | export: ExportResponse 84 | 85 | 86 | @dataclass 87 | class TransactionsResponse(Response): 88 | is_idempotency_replayed: bool 89 | export: ExportResponse 90 | 91 | 92 | @dataclass 93 | class OrdersResponse(Response): 94 | is_idempotency_replayed: bool 95 | export: ExportResponse 96 | 97 | 98 | @dataclass 99 | class ItemFamiliesResponse(Response): 100 | is_idempotency_replayed: bool 101 | export: ExportResponse 102 | 103 | 104 | @dataclass 105 | class ItemsResponse(Response): 106 | is_idempotency_replayed: bool 107 | export: ExportResponse 108 | 109 | 110 | @dataclass 111 | class ItemPricesResponse(Response): 112 | is_idempotency_replayed: bool 113 | export: ExportResponse 114 | 115 | 116 | @dataclass 117 | class AttachedItemsResponse(Response): 118 | is_idempotency_replayed: bool 119 | export: ExportResponse 120 | 121 | 122 | @dataclass 123 | class DifferentialPricesResponse(Response): 124 | is_idempotency_replayed: bool 125 | export: ExportResponse 126 | 127 | 128 | @dataclass 129 | class PriceVariantsResponse(Response): 130 | is_idempotency_replayed: bool 131 | export: ExportResponse 132 | -------------------------------------------------------------------------------- /chargebee/models/feature/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import Feature 2 | from .responses import FeatureResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/feature/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | from chargebee.response import Response 5 | 6 | 7 | @dataclass 8 | class LevelResponse(Model): 9 | raw_data: Dict[Any, Any] = None 10 | name: str = None 11 | value: str = None 12 | level: int = None 13 | is_unlimited: bool = None 14 | 15 | 16 | @dataclass 17 | class FeatureResponse(Model): 18 | raw_data: Dict[Any, Any] = None 19 | id: str = None 20 | name: str = None 21 | description: str = None 22 | status: str = None 23 | type: str = None 24 | unit: str = None 25 | resource_version: int = None 26 | updated_at: int = None 27 | created_at: int = None 28 | levels: List[LevelResponse] = None 29 | 30 | 31 | @dataclass 32 | class ListFeatureResponse: 33 | feature: FeatureResponse 34 | 35 | 36 | @dataclass 37 | class ListResponse(Response): 38 | 39 | list: List[ListFeatureResponse] 40 | next_offset: str = None 41 | 42 | 43 | @dataclass 44 | class CreateResponse(Response): 45 | is_idempotency_replayed: bool 46 | feature: FeatureResponse 47 | 48 | 49 | @dataclass 50 | class UpdateResponse(Response): 51 | is_idempotency_replayed: bool 52 | feature: FeatureResponse 53 | 54 | 55 | @dataclass 56 | class RetrieveResponse(Response): 57 | 58 | feature: FeatureResponse 59 | 60 | 61 | @dataclass 62 | class DeleteResponse(Response): 63 | is_idempotency_replayed: bool 64 | feature: FeatureResponse 65 | 66 | 67 | @dataclass 68 | class ActivateResponse(Response): 69 | is_idempotency_replayed: bool 70 | feature: FeatureResponse 71 | 72 | 73 | @dataclass 74 | class ArchiveResponse(Response): 75 | is_idempotency_replayed: bool 76 | feature: FeatureResponse 77 | 78 | 79 | @dataclass 80 | class ReactivateResponse(Response): 81 | is_idempotency_replayed: bool 82 | feature: FeatureResponse 83 | -------------------------------------------------------------------------------- /chargebee/models/gateway_error_detail/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import GatewayErrorDetail 2 | from .responses import GatewayErrorDetailResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/gateway_error_detail/operations.py: -------------------------------------------------------------------------------- 1 | from .responses import * 2 | from chargebee import request, environment 3 | from typing import TypedDict, Required, NotRequired, Dict, List, Any, cast 4 | 5 | 6 | @dataclass 7 | class GatewayErrorDetail: 8 | 9 | env: environment.Environment 10 | 11 | pass 12 | -------------------------------------------------------------------------------- /chargebee/models/gateway_error_detail/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | 5 | 6 | @dataclass 7 | class GatewayErrorDetailResponse(Model): 8 | raw_data: Dict[Any, Any] = None 9 | request_id: str = None 10 | error_category: str = None 11 | error_code: str = None 12 | error_message: str = None 13 | decline_code: str = None 14 | decline_message: str = None 15 | network_error_code: str = None 16 | network_error_message: str = None 17 | error_field: str = None 18 | recommendation_code: str = None 19 | recommendation_message: str = None 20 | processor_error_code: str = None 21 | processor_error_message: str = None 22 | error_cause_id: str = None 23 | -------------------------------------------------------------------------------- /chargebee/models/gift/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import Gift 2 | from .responses import GiftResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/gift/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | from chargebee.response import Response 5 | from chargebee.models import payment_intent, subscription, invoice 6 | 7 | 8 | @dataclass 9 | class GifterResponse(Model): 10 | raw_data: Dict[Any, Any] = None 11 | customer_id: str = None 12 | invoice_id: str = None 13 | signature: str = None 14 | note: str = None 15 | 16 | 17 | @dataclass 18 | class GiftReceiverResponse(Model): 19 | raw_data: Dict[Any, Any] = None 20 | customer_id: str = None 21 | subscription_id: str = None 22 | first_name: str = None 23 | last_name: str = None 24 | email: str = None 25 | 26 | 27 | @dataclass 28 | class GiftTimelineResponse(Model): 29 | raw_data: Dict[Any, Any] = None 30 | status: str = None 31 | occurred_at: int = None 32 | 33 | 34 | @dataclass 35 | class GiftResponse(Model): 36 | raw_data: Dict[Any, Any] = None 37 | id: str = None 38 | status: str = None 39 | scheduled_at: int = None 40 | auto_claim: bool = None 41 | no_expiry: bool = None 42 | claim_expiry_date: int = None 43 | resource_version: int = None 44 | updated_at: int = None 45 | gifter: GifterResponse = None 46 | gift_receiver: GiftReceiverResponse = None 47 | gift_timelines: List[GiftTimelineResponse] = None 48 | 49 | 50 | @dataclass 51 | class CreateResponse(Response): 52 | is_idempotency_replayed: bool 53 | gift: GiftResponse 54 | subscription: "subscription.SubscriptionResponse" 55 | invoice: "invoice.InvoiceResponse" = None 56 | 57 | 58 | @dataclass 59 | class CreateForItemsResponse(Response): 60 | is_idempotency_replayed: bool 61 | gift: GiftResponse 62 | subscription: "subscription.SubscriptionResponse" 63 | invoice: "invoice.InvoiceResponse" = None 64 | 65 | 66 | @dataclass 67 | class RetrieveResponse(Response): 68 | 69 | gift: GiftResponse 70 | subscription: "subscription.SubscriptionResponse" 71 | 72 | 73 | @dataclass 74 | class ListGiftResponse: 75 | gift: GiftResponse 76 | subscription: "subscription.SubscriptionResponse" 77 | 78 | 79 | @dataclass 80 | class ListResponse(Response): 81 | 82 | list: List[ListGiftResponse] 83 | next_offset: str = None 84 | 85 | 86 | @dataclass 87 | class ClaimResponse(Response): 88 | is_idempotency_replayed: bool 89 | gift: GiftResponse 90 | subscription: "subscription.SubscriptionResponse" 91 | 92 | 93 | @dataclass 94 | class CancelResponse(Response): 95 | is_idempotency_replayed: bool 96 | gift: GiftResponse 97 | subscription: "subscription.SubscriptionResponse" 98 | 99 | 100 | @dataclass 101 | class UpdateGiftResponse(Response): 102 | is_idempotency_replayed: bool 103 | gift: GiftResponse 104 | subscription: "subscription.SubscriptionResponse" 105 | -------------------------------------------------------------------------------- /chargebee/models/hierarchy/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import Hierarchy 2 | from .responses import HierarchyResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/hierarchy/operations.py: -------------------------------------------------------------------------------- 1 | from .responses import * 2 | from chargebee import request, environment 3 | from typing import TypedDict, Required, NotRequired, Dict, List, Any, cast 4 | 5 | 6 | @dataclass 7 | class Hierarchy: 8 | 9 | env: environment.Environment 10 | 11 | pass 12 | -------------------------------------------------------------------------------- /chargebee/models/hierarchy/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | 5 | 6 | @dataclass 7 | class HierarchyResponse(Model): 8 | raw_data: Dict[Any, Any] = None 9 | customer_id: str = None 10 | parent_id: str = None 11 | payment_owner_id: str = None 12 | invoice_owner_id: str = None 13 | children_ids: List[str] = None 14 | -------------------------------------------------------------------------------- /chargebee/models/hosted_page/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import HostedPage 2 | from .responses import HostedPageResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/impacted_item/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import ImpactedItem 2 | from .responses import ImpactedItemResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/impacted_item/operations.py: -------------------------------------------------------------------------------- 1 | from .responses import * 2 | from chargebee import request, environment 3 | from typing import TypedDict, Required, NotRequired, Dict, List, Any, cast 4 | 5 | 6 | @dataclass 7 | class ImpactedItem: 8 | 9 | env: environment.Environment 10 | 11 | class Download(TypedDict): 12 | download_url: Required[str] 13 | valid_till: Required[int] 14 | mime_type: NotRequired[str] 15 | 16 | pass 17 | -------------------------------------------------------------------------------- /chargebee/models/impacted_item/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | 5 | 6 | @dataclass 7 | class DownloadResponse(Model): 8 | raw_data: Dict[Any, Any] = None 9 | download_url: str = None 10 | valid_till: int = None 11 | mime_type: str = None 12 | 13 | 14 | @dataclass 15 | class ImpactedItemResponse(Model): 16 | raw_data: Dict[Any, Any] = None 17 | count: int = None 18 | download: DownloadResponse = None 19 | items: List[Dict[Any, Any]] = None 20 | -------------------------------------------------------------------------------- /chargebee/models/impacted_item_price/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import ImpactedItemPrice 2 | from .responses import ImpactedItemPriceResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/impacted_item_price/operations.py: -------------------------------------------------------------------------------- 1 | from .responses import * 2 | from chargebee import request, environment 3 | from typing import TypedDict, Required, NotRequired, Dict, List, Any, cast 4 | 5 | 6 | @dataclass 7 | class ImpactedItemPrice: 8 | 9 | env: environment.Environment 10 | 11 | class Download(TypedDict): 12 | download_url: Required[str] 13 | valid_till: Required[int] 14 | mime_type: NotRequired[str] 15 | 16 | pass 17 | -------------------------------------------------------------------------------- /chargebee/models/impacted_item_price/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | 5 | 6 | @dataclass 7 | class DownloadResponse(Model): 8 | raw_data: Dict[Any, Any] = None 9 | download_url: str = None 10 | valid_till: int = None 11 | mime_type: str = None 12 | 13 | 14 | @dataclass 15 | class ImpactedItemPriceResponse(Model): 16 | raw_data: Dict[Any, Any] = None 17 | count: int = None 18 | download: DownloadResponse = None 19 | item_prices: List[Dict[Any, Any]] = None 20 | -------------------------------------------------------------------------------- /chargebee/models/impacted_subscription/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import ImpactedSubscription 2 | from .responses import ImpactedSubscriptionResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/impacted_subscription/operations.py: -------------------------------------------------------------------------------- 1 | from .responses import * 2 | from chargebee import request, environment 3 | from typing import TypedDict, Required, NotRequired, Dict, List, Any, cast 4 | 5 | 6 | @dataclass 7 | class ImpactedSubscription: 8 | 9 | env: environment.Environment 10 | 11 | class Download(TypedDict): 12 | download_url: Required[str] 13 | valid_till: Required[int] 14 | mime_type: NotRequired[str] 15 | 16 | pass 17 | -------------------------------------------------------------------------------- /chargebee/models/impacted_subscription/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | 5 | 6 | @dataclass 7 | class DownloadResponse(Model): 8 | raw_data: Dict[Any, Any] = None 9 | download_url: str = None 10 | valid_till: int = None 11 | mime_type: str = None 12 | 13 | 14 | @dataclass 15 | class ImpactedSubscriptionResponse(Model): 16 | raw_data: Dict[Any, Any] = None 17 | count: int = None 18 | download: DownloadResponse = None 19 | subscription_ids: List[Dict[Any, Any]] = None 20 | -------------------------------------------------------------------------------- /chargebee/models/in_app_subscription/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import InAppSubscription 2 | from .responses import InAppSubscriptionResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/in_app_subscription/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | from chargebee.response import Response 5 | 6 | 7 | @dataclass 8 | class InAppSubscriptionResponse(Model): 9 | raw_data: Dict[Any, Any] = None 10 | app_id: str = None 11 | subscription_id: str = None 12 | customer_id: str = None 13 | plan_id: str = None 14 | store_status: str = None 15 | invoice_id: str = None 16 | 17 | 18 | @dataclass 19 | class ProcessReceiptResponse(Response): 20 | is_idempotency_replayed: bool 21 | in_app_subscription: InAppSubscriptionResponse 22 | 23 | 24 | @dataclass 25 | class ImportReceiptResponse(Response): 26 | is_idempotency_replayed: bool 27 | in_app_subscriptions: List[InAppSubscriptionResponse] 28 | 29 | 30 | @dataclass 31 | class ImportSubscriptionResponse(Response): 32 | is_idempotency_replayed: bool 33 | in_app_subscription: InAppSubscriptionResponse 34 | 35 | 36 | @dataclass 37 | class RetrieveStoreSubsResponse(Response): 38 | is_idempotency_replayed: bool 39 | in_app_subscriptions: List[InAppSubscriptionResponse] 40 | -------------------------------------------------------------------------------- /chargebee/models/invoice/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import Invoice 2 | from .responses import InvoiceResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/invoice_estimate/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import InvoiceEstimate 2 | from .responses import InvoiceEstimateResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/item/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import Item 2 | from .responses import ItemResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/item/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | from chargebee.response import Response 5 | 6 | 7 | @dataclass 8 | class ApplicableItemResponse(Model): 9 | raw_data: Dict[Any, Any] = None 10 | id: str = None 11 | 12 | 13 | @dataclass 14 | class BundleItemResponse(Model): 15 | raw_data: Dict[Any, Any] = None 16 | item_id: str = None 17 | item_type: str = None 18 | quantity: int = None 19 | price_allocation: float = None 20 | 21 | 22 | @dataclass 23 | class BundleConfigurationResponse(Model): 24 | raw_data: Dict[Any, Any] = None 25 | type: str = None 26 | 27 | 28 | @dataclass 29 | class ItemResponse(Model): 30 | raw_data: Dict[Any, Any] = None 31 | id: str = None 32 | name: str = None 33 | external_name: str = None 34 | description: str = None 35 | status: str = None 36 | resource_version: int = None 37 | updated_at: int = None 38 | item_family_id: str = None 39 | type: str = None 40 | is_shippable: bool = None 41 | is_giftable: bool = None 42 | redirect_url: str = None 43 | enabled_for_checkout: bool = None 44 | enabled_in_portal: bool = None 45 | included_in_mrr: bool = None 46 | item_applicability: str = None 47 | gift_claim_redirect_url: str = None 48 | unit: str = None 49 | metered: bool = None 50 | usage_calculation: str = None 51 | is_percentage_pricing: bool = None 52 | archived_at: int = None 53 | channel: str = None 54 | applicable_items: List[ApplicableItemResponse] = None 55 | bundle_items: List[BundleItemResponse] = None 56 | bundle_configuration: BundleConfigurationResponse = None 57 | metadata: Dict[Any, Any] = None 58 | deleted: bool = None 59 | business_entity_id: str = None 60 | 61 | 62 | @dataclass 63 | class CreateResponse(Response): 64 | is_idempotency_replayed: bool 65 | item: ItemResponse 66 | 67 | 68 | @dataclass 69 | class RetrieveResponse(Response): 70 | 71 | item: ItemResponse 72 | 73 | 74 | @dataclass 75 | class UpdateResponse(Response): 76 | is_idempotency_replayed: bool 77 | item: ItemResponse 78 | 79 | 80 | @dataclass 81 | class ListItemResponse: 82 | item: ItemResponse 83 | 84 | 85 | @dataclass 86 | class ListResponse(Response): 87 | 88 | list: List[ListItemResponse] 89 | next_offset: str = None 90 | 91 | 92 | @dataclass 93 | class DeleteResponse(Response): 94 | is_idempotency_replayed: bool 95 | item: ItemResponse 96 | -------------------------------------------------------------------------------- /chargebee/models/item_entitlement/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import ItemEntitlement 2 | from .responses import ItemEntitlementResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/item_entitlement/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | from chargebee.response import Response 5 | 6 | 7 | @dataclass 8 | class ItemEntitlementResponse(Model): 9 | raw_data: Dict[Any, Any] = None 10 | id: str = None 11 | item_id: str = None 12 | item_type: str = None 13 | feature_id: str = None 14 | feature_name: str = None 15 | value: str = None 16 | name: str = None 17 | 18 | 19 | @dataclass 20 | class ItemEntitlementsForItemItemEntitlementResponse: 21 | item_entitlement: ItemEntitlementResponse 22 | 23 | 24 | @dataclass 25 | class ItemEntitlementsForItemResponse(Response): 26 | 27 | list: List[ItemEntitlementsForItemItemEntitlementResponse] 28 | next_offset: str = None 29 | 30 | 31 | @dataclass 32 | class ItemEntitlementsForFeatureItemEntitlementResponse: 33 | item_entitlement: ItemEntitlementResponse 34 | 35 | 36 | @dataclass 37 | class ItemEntitlementsForFeatureResponse(Response): 38 | 39 | list: List[ItemEntitlementsForFeatureItemEntitlementResponse] 40 | next_offset: str = None 41 | 42 | 43 | @dataclass 44 | class AddItemEntitlementsResponse(Response): 45 | is_idempotency_replayed: bool 46 | item_entitlement: ItemEntitlementResponse 47 | 48 | 49 | @dataclass 50 | class UpsertOrRemoveItemEntitlementsForItemResponse(Response): 51 | is_idempotency_replayed: bool 52 | item_entitlement: ItemEntitlementResponse 53 | -------------------------------------------------------------------------------- /chargebee/models/item_family/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import ItemFamily 2 | from .responses import ItemFamilyResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/item_family/operations.py: -------------------------------------------------------------------------------- 1 | from .responses import * 2 | from chargebee import request, environment 3 | from typing import TypedDict, Required, NotRequired, Dict, List, Any, cast 4 | from enum import Enum 5 | from chargebee.filters import Filters 6 | 7 | 8 | @dataclass 9 | class ItemFamily: 10 | 11 | env: environment.Environment 12 | 13 | class Status(Enum): 14 | ACTIVE = "active" 15 | DELETED = "deleted" 16 | 17 | def __str__(self): 18 | return self.value 19 | 20 | class CreateParams(TypedDict): 21 | id: Required[str] 22 | name: Required[str] 23 | description: NotRequired[str] 24 | business_entity_id: NotRequired[str] 25 | 26 | class ListParams(TypedDict): 27 | limit: NotRequired[int] 28 | offset: NotRequired[str] 29 | id: NotRequired[Filters.StringFilter] 30 | name: NotRequired[Filters.StringFilter] 31 | updated_at: NotRequired[Filters.TimestampFilter] 32 | business_entity_id: NotRequired[Filters.StringFilter] 33 | include_site_level_resources: NotRequired[Filters.BooleanFilter] 34 | 35 | class UpdateParams(TypedDict): 36 | name: NotRequired[str] 37 | description: NotRequired[str] 38 | 39 | def create(self, params: CreateParams, headers=None) -> CreateResponse: 40 | jsonKeys = {} 41 | return request.send( 42 | "post", 43 | request.uri_path("item_families"), 44 | self.env, 45 | cast(Dict[Any, Any], params), 46 | headers, 47 | CreateResponse, 48 | None, 49 | False, 50 | jsonKeys, 51 | ) 52 | 53 | def retrieve(self, id, headers=None) -> RetrieveResponse: 54 | jsonKeys = {} 55 | return request.send( 56 | "get", 57 | request.uri_path("item_families", id), 58 | self.env, 59 | None, 60 | headers, 61 | RetrieveResponse, 62 | None, 63 | False, 64 | jsonKeys, 65 | ) 66 | 67 | def list(self, params: ListParams = None, headers=None) -> ListResponse: 68 | jsonKeys = {} 69 | return request.send_list_request( 70 | "get", 71 | request.uri_path("item_families"), 72 | self.env, 73 | cast(Dict[Any, Any], params), 74 | headers, 75 | ListResponse, 76 | None, 77 | False, 78 | jsonKeys, 79 | ) 80 | 81 | def update(self, id, params: UpdateParams = None, headers=None) -> UpdateResponse: 82 | jsonKeys = {} 83 | return request.send( 84 | "post", 85 | request.uri_path("item_families", id), 86 | self.env, 87 | cast(Dict[Any, Any], params), 88 | headers, 89 | UpdateResponse, 90 | None, 91 | False, 92 | jsonKeys, 93 | ) 94 | 95 | def delete(self, id, headers=None) -> DeleteResponse: 96 | jsonKeys = {} 97 | return request.send( 98 | "post", 99 | request.uri_path("item_families", id, "delete"), 100 | self.env, 101 | None, 102 | headers, 103 | DeleteResponse, 104 | None, 105 | False, 106 | jsonKeys, 107 | ) 108 | -------------------------------------------------------------------------------- /chargebee/models/item_family/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | from chargebee.response import Response 5 | 6 | 7 | @dataclass 8 | class ItemFamilyResponse(Model): 9 | raw_data: Dict[Any, Any] = None 10 | id: str = None 11 | name: str = None 12 | description: str = None 13 | status: str = None 14 | resource_version: int = None 15 | updated_at: int = None 16 | channel: str = None 17 | business_entity_id: str = None 18 | deleted: bool = None 19 | 20 | 21 | @dataclass 22 | class CreateResponse(Response): 23 | is_idempotency_replayed: bool 24 | item_family: ItemFamilyResponse 25 | 26 | 27 | @dataclass 28 | class RetrieveResponse(Response): 29 | 30 | item_family: ItemFamilyResponse 31 | 32 | 33 | @dataclass 34 | class ListItemFamilyResponse: 35 | item_family: ItemFamilyResponse 36 | 37 | 38 | @dataclass 39 | class ListResponse(Response): 40 | 41 | list: List[ListItemFamilyResponse] 42 | next_offset: str = None 43 | 44 | 45 | @dataclass 46 | class UpdateResponse(Response): 47 | is_idempotency_replayed: bool 48 | item_family: ItemFamilyResponse 49 | 50 | 51 | @dataclass 52 | class DeleteResponse(Response): 53 | is_idempotency_replayed: bool 54 | item_family: ItemFamilyResponse 55 | -------------------------------------------------------------------------------- /chargebee/models/item_price/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import ItemPrice 2 | from .responses import ItemPriceResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/metadata/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import Metadata 2 | from .responses import MetadataResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/metadata/operations.py: -------------------------------------------------------------------------------- 1 | from .responses import * 2 | from chargebee import request, environment 3 | from typing import TypedDict, Required, NotRequired, Dict, List, Any, cast 4 | 5 | 6 | @dataclass 7 | class Metadata: 8 | 9 | env: environment.Environment 10 | 11 | pass 12 | -------------------------------------------------------------------------------- /chargebee/models/metadata/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | 5 | 6 | @dataclass 7 | class MetadataResponse(Model): 8 | raw_data: Dict[Any, Any] = None 9 | change_type: str = None 10 | -------------------------------------------------------------------------------- /chargebee/models/omnichannel_subscription/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import OmnichannelSubscription 2 | from .responses import OmnichannelSubscriptionResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/omnichannel_subscription/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | from chargebee.response import Response 5 | from chargebee.models import omnichannel_subscription_item, omnichannel_transaction 6 | 7 | 8 | @dataclass 9 | class OmnichannelTransactionResponse(Model): 10 | raw_data: Dict[Any, Any] = None 11 | id: str = None 12 | id_at_source: str = None 13 | app_id: str = None 14 | price_currency: str = None 15 | price_units: int = None 16 | price_nanos: int = None 17 | type: str = None 18 | transacted_at: int = None 19 | created_at: int = None 20 | resource_version: int = None 21 | 22 | 23 | @dataclass 24 | class OmnichannelSubscriptionResponse(Model): 25 | raw_data: Dict[Any, Any] = None 26 | id: str = None 27 | id_at_source: str = None 28 | app_id: str = None 29 | source: str = None 30 | customer_id: str = None 31 | created_at: int = None 32 | resource_version: int = None 33 | omnichannel_subscription_items: List[ 34 | "omnichannel_subscription_item.OmnichannelSubscriptionItemResponse" 35 | ] = None 36 | initial_purchase_transaction: ( 37 | "omnichannel_transaction.OmnichannelTransactionResponse" 38 | ) = None 39 | 40 | 41 | @dataclass 42 | class RetrieveResponse(Response): 43 | 44 | omnichannel_subscription: OmnichannelSubscriptionResponse 45 | 46 | 47 | @dataclass 48 | class ListOmnichannelSubscriptionResponse: 49 | omnichannel_subscription: OmnichannelSubscriptionResponse 50 | 51 | 52 | @dataclass 53 | class ListResponse(Response): 54 | 55 | list: List[ListOmnichannelSubscriptionResponse] 56 | next_offset: str = None 57 | 58 | 59 | @dataclass 60 | class OmnichannelTransactionsForOmnichannelSubscriptionOmnichannelSubscriptionResponse: 61 | omnichannel_transaction: "omnichannel_transaction.OmnichannelTransactionResponse" 62 | 63 | 64 | @dataclass 65 | class OmnichannelTransactionsForOmnichannelSubscriptionResponse(Response): 66 | 67 | list: List[ 68 | OmnichannelTransactionsForOmnichannelSubscriptionOmnichannelSubscriptionResponse 69 | ] 70 | next_offset: str = None 71 | -------------------------------------------------------------------------------- /chargebee/models/omnichannel_subscription_item/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import OmnichannelSubscriptionItem 2 | from .responses import OmnichannelSubscriptionItemResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/omnichannel_subscription_item/operations.py: -------------------------------------------------------------------------------- 1 | from .responses import * 2 | from chargebee import request, environment 3 | from typing import TypedDict, Required, NotRequired, Dict, List, Any, cast 4 | from enum import Enum 5 | 6 | 7 | @dataclass 8 | class OmnichannelSubscriptionItem: 9 | 10 | env: environment.Environment 11 | 12 | class Status(Enum): 13 | ACTIVE = "active" 14 | EXPIRED = "expired" 15 | CANCELLED = "cancelled" 16 | IN_DUNNING = "in_dunning" 17 | IN_GRACE_PERIOD = "in_grace_period" 18 | PAUSED = "paused" 19 | 20 | def __str__(self): 21 | return self.value 22 | 23 | class AutoRenewStatus(Enum): 24 | OFF = "off" 25 | ON = "on" 26 | 27 | def __str__(self): 28 | return self.value 29 | 30 | class ExpirationReason(Enum): 31 | BILLING_ERROR = "billing_error" 32 | PRODUCT_NOT_AVAILABLE = "product_not_available" 33 | OTHER = "other" 34 | 35 | def __str__(self): 36 | return self.value 37 | 38 | class CancellationReason(Enum): 39 | CUSTOMER_CANCELLED = "customer_cancelled" 40 | CUSTOMER_DID_NOT_CONSENT_TO_PRICE_INCREASE = ( 41 | "customer_did_not_consent_to_price_increase" 42 | ) 43 | REFUNDED_DUE_TO_APP_ISSUE = "refunded_due_to_app_issue" 44 | REFUNDED_FOR_OTHER_REASON = "refunded_for_other_reason" 45 | MERCHANT_REVOKED = "merchant_revoked" 46 | 47 | def __str__(self): 48 | return self.value 49 | 50 | class UpcomingRenewal(TypedDict): 51 | price_currency: NotRequired[str] 52 | price_units: NotRequired[int] 53 | price_nanos: NotRequired[int] 54 | 55 | class ListOmniSubItemScheduleChangesParams(TypedDict): 56 | limit: NotRequired[int] 57 | offset: NotRequired[str] 58 | 59 | def list_omni_sub_item_schedule_changes( 60 | self, id, params: ListOmniSubItemScheduleChangesParams = None, headers=None 61 | ) -> ListOmniSubItemScheduleChangesResponse: 62 | jsonKeys = {} 63 | return request.send( 64 | "get", 65 | request.uri_path("omnichannel_subscription_items", id, "scheduled_changes"), 66 | self.env, 67 | cast(Dict[Any, Any], params), 68 | headers, 69 | ListOmniSubItemScheduleChangesResponse, 70 | None, 71 | False, 72 | jsonKeys, 73 | ) 74 | -------------------------------------------------------------------------------- /chargebee/models/omnichannel_subscription_item/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | from chargebee.response import Response 5 | from chargebee.models import omnichannel_subscription_item_scheduled_change 6 | 7 | 8 | @dataclass 9 | class UpcomingRenewalResponse(Model): 10 | raw_data: Dict[Any, Any] = None 11 | price_currency: str = None 12 | price_units: int = None 13 | price_nanos: int = None 14 | 15 | 16 | @dataclass 17 | class OmnichannelSubscriptionItemResponse(Model): 18 | raw_data: Dict[Any, Any] = None 19 | id: str = None 20 | item_id_at_source: str = None 21 | item_parent_id_at_source: str = None 22 | status: str = None 23 | auto_renew_status: str = None 24 | current_term_start: int = None 25 | current_term_end: int = None 26 | expired_at: int = None 27 | expiration_reason: str = None 28 | cancelled_at: int = None 29 | cancellation_reason: str = None 30 | grace_period_expires_at: int = None 31 | has_scheduled_changes: bool = None 32 | resource_version: int = None 33 | upcoming_renewal: UpcomingRenewalResponse = None 34 | 35 | 36 | @dataclass 37 | class ListOmniSubItemScheduleChangesOmnichannelSubscriptionItemResponse: 38 | omnichannel_subscription_item_scheduled_change: "omnichannel_subscription_item_scheduled_change.OmnichannelSubscriptionItemScheduledChangeResponse" 39 | 40 | 41 | @dataclass 42 | class ListOmniSubItemScheduleChangesResponse(Response): 43 | 44 | list: List[ListOmniSubItemScheduleChangesOmnichannelSubscriptionItemResponse] 45 | next_offset: str = None 46 | -------------------------------------------------------------------------------- /chargebee/models/omnichannel_subscription_item_scheduled_change/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import OmnichannelSubscriptionItemScheduledChange 2 | from .responses import OmnichannelSubscriptionItemScheduledChangeResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/omnichannel_subscription_item_scheduled_change/operations.py: -------------------------------------------------------------------------------- 1 | from .responses import * 2 | from chargebee import request, environment 3 | from typing import TypedDict, Required, NotRequired, Dict, List, Any, cast 4 | from enum import Enum 5 | 6 | 7 | @dataclass 8 | class OmnichannelSubscriptionItemScheduledChange: 9 | 10 | env: environment.Environment 11 | 12 | class ChangeType(Enum): 13 | DOWNGRADE = "downgrade" 14 | 15 | def __str__(self): 16 | return self.value 17 | 18 | class CurrentState(TypedDict): 19 | item_id_at_source: NotRequired[str] 20 | 21 | class ScheduledState(TypedDict): 22 | item_id_at_source: NotRequired[str] 23 | 24 | pass 25 | -------------------------------------------------------------------------------- /chargebee/models/omnichannel_subscription_item_scheduled_change/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | 5 | 6 | @dataclass 7 | class CurrentStateResponse(Model): 8 | raw_data: Dict[Any, Any] = None 9 | item_id_at_source: str = None 10 | 11 | 12 | @dataclass 13 | class ScheduledStateResponse(Model): 14 | raw_data: Dict[Any, Any] = None 15 | item_id_at_source: str = None 16 | 17 | 18 | @dataclass 19 | class OmnichannelSubscriptionItemScheduledChangeResponse(Model): 20 | raw_data: Dict[Any, Any] = None 21 | id: str = None 22 | omnichannel_subscription_item_id: str = None 23 | scheduled_at: int = None 24 | change_type: str = None 25 | created_at: int = None 26 | modified_at: int = None 27 | resource_version: int = None 28 | current_state: CurrentStateResponse = None 29 | scheduled_state: ScheduledStateResponse = None 30 | -------------------------------------------------------------------------------- /chargebee/models/omnichannel_transaction/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import OmnichannelTransaction 2 | from .responses import OmnichannelTransactionResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/omnichannel_transaction/operations.py: -------------------------------------------------------------------------------- 1 | from .responses import * 2 | from chargebee import request, environment 3 | from typing import TypedDict, Required, NotRequired, Dict, List, Any, cast 4 | from enum import Enum 5 | 6 | 7 | @dataclass 8 | class OmnichannelTransaction: 9 | 10 | env: environment.Environment 11 | 12 | class Type(Enum): 13 | PURCHASE = "purchase" 14 | RENEWAL = "renewal" 15 | 16 | def __str__(self): 17 | return self.value 18 | 19 | pass 20 | -------------------------------------------------------------------------------- /chargebee/models/omnichannel_transaction/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | 5 | 6 | @dataclass 7 | class OmnichannelTransactionResponse(Model): 8 | raw_data: Dict[Any, Any] = None 9 | id: str = None 10 | id_at_source: str = None 11 | app_id: str = None 12 | price_currency: str = None 13 | price_units: int = None 14 | price_nanos: int = None 15 | type: str = None 16 | transacted_at: int = None 17 | created_at: int = None 18 | resource_version: int = None 19 | -------------------------------------------------------------------------------- /chargebee/models/order/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import Order 2 | from .responses import OrderResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/payment_intent/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import PaymentIntent 2 | from .responses import PaymentIntentResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/payment_intent/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | from chargebee.response import Response 5 | from chargebee.models import gateway_error_detail 6 | 7 | 8 | @dataclass 9 | class PaymentAttemptResponse(Model): 10 | raw_data: Dict[Any, Any] = None 11 | id: str = None 12 | status: str = None 13 | payment_method_type: str = None 14 | id_at_gateway: str = None 15 | error_code: str = None 16 | error_text: str = None 17 | created_at: int = None 18 | modified_at: int = None 19 | error_detail: gateway_error_detail.GatewayErrorDetailResponse = None 20 | 21 | 22 | @dataclass 23 | class PaymentIntentResponse(Model): 24 | raw_data: Dict[Any, Any] = None 25 | id: str = None 26 | status: str = None 27 | currency_code: str = None 28 | amount: int = None 29 | gateway_account_id: str = None 30 | expires_at: int = None 31 | reference_id: str = None 32 | payment_method_type: str = None 33 | success_url: str = None 34 | failure_url: str = None 35 | created_at: int = None 36 | modified_at: int = None 37 | resource_version: int = None 38 | updated_at: int = None 39 | customer_id: str = None 40 | gateway: str = None 41 | active_payment_attempt: PaymentAttemptResponse = None 42 | business_entity_id: str = None 43 | 44 | 45 | @dataclass 46 | class CreateResponse(Response): 47 | is_idempotency_replayed: bool 48 | payment_intent: PaymentIntentResponse 49 | 50 | 51 | @dataclass 52 | class UpdateResponse(Response): 53 | is_idempotency_replayed: bool 54 | payment_intent: PaymentIntentResponse 55 | 56 | 57 | @dataclass 58 | class RetrieveResponse(Response): 59 | 60 | payment_intent: PaymentIntentResponse 61 | -------------------------------------------------------------------------------- /chargebee/models/payment_reference_number/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import PaymentReferenceNumber 2 | from .responses import PaymentReferenceNumberResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/payment_reference_number/operations.py: -------------------------------------------------------------------------------- 1 | from .responses import * 2 | from chargebee import request, environment 3 | from typing import TypedDict, Required, NotRequired, Dict, List, Any, cast 4 | from enum import Enum 5 | 6 | 7 | @dataclass 8 | class PaymentReferenceNumber: 9 | 10 | env: environment.Environment 11 | 12 | class Type(Enum): 13 | KID = "kid" 14 | OCR = "ocr" 15 | FRN = "frn" 16 | FIK = "fik" 17 | SWISS_REFERENCE = "swiss_reference" 18 | 19 | def __str__(self): 20 | return self.value 21 | 22 | pass 23 | -------------------------------------------------------------------------------- /chargebee/models/payment_reference_number/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | 5 | 6 | @dataclass 7 | class PaymentReferenceNumberResponse(Model): 8 | raw_data: Dict[Any, Any] = None 9 | id: str = None 10 | type: str = None 11 | number: str = None 12 | invoice_id: str = None 13 | -------------------------------------------------------------------------------- /chargebee/models/payment_schedule/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import PaymentSchedule 2 | from .responses import PaymentScheduleResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/payment_schedule/operations.py: -------------------------------------------------------------------------------- 1 | from .responses import * 2 | from chargebee import request, environment 3 | from typing import TypedDict, Required, NotRequired, Dict, List, Any, cast 4 | from enum import Enum 5 | 6 | 7 | @dataclass 8 | class PaymentSchedule: 9 | 10 | env: environment.Environment 11 | 12 | class EntityType(Enum): 13 | INVOICE = "invoice" 14 | 15 | def __str__(self): 16 | return self.value 17 | 18 | class ScheduleEntryStatus(Enum): 19 | POSTED = "posted" 20 | PAYMENT_DUE = "payment_due" 21 | PAID = "paid" 22 | 23 | def __str__(self): 24 | return self.value 25 | 26 | class ScheduleEntry(TypedDict): 27 | id: Required[str] 28 | date: Required[int] 29 | amount: Required[int] 30 | status: Required["PaymentSchedule.ScheduleEntryStatus"] 31 | 32 | pass 33 | -------------------------------------------------------------------------------- /chargebee/models/payment_schedule/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | 5 | 6 | @dataclass 7 | class ScheduleEntryResponse(Model): 8 | raw_data: Dict[Any, Any] = None 9 | id: str = None 10 | date: int = None 11 | amount: int = None 12 | status: str = None 13 | 14 | 15 | @dataclass 16 | class PaymentScheduleResponse(Model): 17 | raw_data: Dict[Any, Any] = None 18 | id: str = None 19 | scheme_id: str = None 20 | entity_type: str = None 21 | entity_id: str = None 22 | amount: int = None 23 | created_at: int = None 24 | resource_version: int = None 25 | updated_at: int = None 26 | currency_code: str = None 27 | schedule_entries: List[ScheduleEntryResponse] = None 28 | -------------------------------------------------------------------------------- /chargebee/models/payment_schedule_estimate/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import PaymentScheduleEstimate 2 | from .responses import PaymentScheduleEstimateResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/payment_schedule_estimate/operations.py: -------------------------------------------------------------------------------- 1 | from .responses import * 2 | from chargebee import request, environment 3 | from typing import TypedDict, Required, NotRequired, Dict, List, Any, cast 4 | from enum import Enum 5 | 6 | 7 | @dataclass 8 | class PaymentScheduleEstimate: 9 | 10 | env: environment.Environment 11 | 12 | class EntityType(Enum): 13 | INVOICE = "invoice" 14 | 15 | def __str__(self): 16 | return self.value 17 | 18 | class ScheduleEntryStatus(Enum): 19 | POSTED = "posted" 20 | PAYMENT_DUE = "payment_due" 21 | PAID = "paid" 22 | 23 | def __str__(self): 24 | return self.value 25 | 26 | class ScheduleEntry(TypedDict): 27 | id: Required[str] 28 | date: Required[int] 29 | amount: Required[int] 30 | status: Required["PaymentScheduleEstimate.ScheduleEntryStatus"] 31 | 32 | pass 33 | -------------------------------------------------------------------------------- /chargebee/models/payment_schedule_estimate/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | 5 | 6 | @dataclass 7 | class ScheduleEntryResponse(Model): 8 | raw_data: Dict[Any, Any] = None 9 | id: str = None 10 | date: int = None 11 | amount: int = None 12 | status: str = None 13 | 14 | 15 | @dataclass 16 | class PaymentScheduleEstimateResponse(Model): 17 | raw_data: Dict[Any, Any] = None 18 | id: str = None 19 | scheme_id: str = None 20 | entity_type: str = None 21 | entity_id: str = None 22 | amount: int = None 23 | currency_code: str = None 24 | schedule_entries: List[ScheduleEntryResponse] = None 25 | -------------------------------------------------------------------------------- /chargebee/models/payment_schedule_scheme/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import PaymentScheduleScheme 2 | from .responses import PaymentScheduleSchemeResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/payment_schedule_scheme/operations.py: -------------------------------------------------------------------------------- 1 | from .responses import * 2 | from chargebee import request, environment 3 | from typing import TypedDict, Required, NotRequired, Dict, List, Any, cast 4 | from enum import Enum 5 | 6 | 7 | @dataclass 8 | class PaymentScheduleScheme: 9 | 10 | env: environment.Environment 11 | 12 | class PeriodUnit(Enum): 13 | DAY = "day" 14 | WEEK = "week" 15 | MONTH = "month" 16 | 17 | def __str__(self): 18 | return self.value 19 | 20 | class PreferredSchedule(TypedDict): 21 | period: NotRequired[int] 22 | amount_percentage: NotRequired[float] 23 | 24 | class CreateFlexibleScheduleParams(TypedDict): 25 | period: NotRequired[int] 26 | amount_percentage: NotRequired[float] 27 | 28 | class CreateParams(TypedDict): 29 | number_of_schedules: Required[int] 30 | period_unit: Required["PaymentScheduleScheme.PeriodUnit"] 31 | period: NotRequired[int] 32 | name: Required[str] 33 | flexible_schedules: NotRequired[ 34 | List["PaymentScheduleScheme.CreateFlexibleScheduleParams"] 35 | ] 36 | 37 | def create(self, params: CreateParams, headers=None) -> CreateResponse: 38 | jsonKeys = {} 39 | return request.send( 40 | "post", 41 | request.uri_path("payment_schedule_schemes"), 42 | self.env, 43 | cast(Dict[Any, Any], params), 44 | headers, 45 | CreateResponse, 46 | None, 47 | False, 48 | jsonKeys, 49 | ) 50 | 51 | def retrieve(self, id, headers=None) -> RetrieveResponse: 52 | jsonKeys = {} 53 | return request.send( 54 | "get", 55 | request.uri_path("payment_schedule_schemes", id), 56 | self.env, 57 | None, 58 | headers, 59 | RetrieveResponse, 60 | None, 61 | False, 62 | jsonKeys, 63 | ) 64 | 65 | def delete(self, id, headers=None) -> DeleteResponse: 66 | jsonKeys = {} 67 | return request.send( 68 | "post", 69 | request.uri_path("payment_schedule_schemes", id, "delete"), 70 | self.env, 71 | None, 72 | headers, 73 | DeleteResponse, 74 | None, 75 | False, 76 | jsonKeys, 77 | ) 78 | -------------------------------------------------------------------------------- /chargebee/models/payment_schedule_scheme/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | from chargebee.response import Response 5 | 6 | 7 | @dataclass 8 | class PreferredScheduleResponse(Model): 9 | raw_data: Dict[Any, Any] = None 10 | period: int = None 11 | amount_percentage: float = None 12 | 13 | 14 | @dataclass 15 | class PaymentScheduleSchemeResponse(Model): 16 | raw_data: Dict[Any, Any] = None 17 | id: str = None 18 | name: str = None 19 | description: str = None 20 | number_of_schedules: int = None 21 | period_unit: str = None 22 | period: int = None 23 | created_at: int = None 24 | resource_version: int = None 25 | updated_at: int = None 26 | preferred_schedules: List[PreferredScheduleResponse] = None 27 | 28 | 29 | @dataclass 30 | class CreateResponse(Response): 31 | is_idempotency_replayed: bool 32 | payment_schedule_scheme: PaymentScheduleSchemeResponse 33 | 34 | 35 | @dataclass 36 | class RetrieveResponse(Response): 37 | 38 | payment_schedule_scheme: PaymentScheduleSchemeResponse 39 | 40 | 41 | @dataclass 42 | class DeleteResponse(Response): 43 | is_idempotency_replayed: bool 44 | payment_schedule_scheme: PaymentScheduleSchemeResponse 45 | -------------------------------------------------------------------------------- /chargebee/models/payment_source/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import PaymentSource 2 | from .responses import PaymentSourceResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/payment_voucher/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import PaymentVoucher 2 | from .responses import PaymentVoucherResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/payment_voucher/operations.py: -------------------------------------------------------------------------------- 1 | from .responses import * 2 | from chargebee import request, environment 3 | from typing import TypedDict, Required, NotRequired, Dict, List, Any, cast 4 | from enum import Enum 5 | from chargebee.filters import Filters 6 | from chargebee.models import enums 7 | 8 | 9 | @dataclass 10 | class PaymentVoucher: 11 | 12 | env: environment.Environment 13 | 14 | class Status(Enum): 15 | ACTIVE = "active" 16 | CONSUMED = "consumed" 17 | EXPIRED = "expired" 18 | FAILURE = "failure" 19 | 20 | def __str__(self): 21 | return self.value 22 | 23 | class LinkedInvoice(TypedDict): 24 | invoice_id: Required[str] 25 | txn_id: Required[str] 26 | applied_at: Required[int] 27 | 28 | class CreateVoucherPaymentSourceParams(TypedDict): 29 | voucher_type: Required[enums.VoucherType] 30 | 31 | class CreateInvoiceAllocationParams(TypedDict): 32 | invoice_id: Required[str] 33 | 34 | class CreateParams(TypedDict): 35 | customer_id: Required[str] 36 | voucher_payment_source: Required[ 37 | "PaymentVoucher.CreateVoucherPaymentSourceParams" 38 | ] 39 | invoice_allocations: Required[ 40 | List["PaymentVoucher.CreateInvoiceAllocationParams"] 41 | ] 42 | payment_source_id: NotRequired[str] 43 | 44 | class PaymentVouchersForInvoiceParams(TypedDict): 45 | limit: NotRequired[int] 46 | offset: NotRequired[str] 47 | status: NotRequired[Filters.EnumFilter] 48 | sort_by: NotRequired[Filters.SortFilter] 49 | 50 | class PaymentVouchersForCustomerParams(TypedDict): 51 | limit: NotRequired[int] 52 | offset: NotRequired[str] 53 | status: NotRequired[Filters.EnumFilter] 54 | sort_by: NotRequired[Filters.SortFilter] 55 | 56 | def create(self, params: CreateParams, headers=None) -> CreateResponse: 57 | jsonKeys = {} 58 | return request.send( 59 | "post", 60 | request.uri_path("payment_vouchers"), 61 | self.env, 62 | cast(Dict[Any, Any], params), 63 | headers, 64 | CreateResponse, 65 | None, 66 | False, 67 | jsonKeys, 68 | ) 69 | 70 | def retrieve(self, id, headers=None) -> RetrieveResponse: 71 | jsonKeys = {} 72 | return request.send( 73 | "get", 74 | request.uri_path("payment_vouchers", id), 75 | self.env, 76 | None, 77 | headers, 78 | RetrieveResponse, 79 | None, 80 | False, 81 | jsonKeys, 82 | ) 83 | 84 | def payment_vouchers_for_invoice( 85 | self, id, params: PaymentVouchersForInvoiceParams = None, headers=None 86 | ) -> PaymentVouchersForInvoiceResponse: 87 | jsonKeys = {} 88 | return request.send( 89 | "get", 90 | request.uri_path("invoices", id, "payment_vouchers"), 91 | self.env, 92 | cast(Dict[Any, Any], params), 93 | headers, 94 | PaymentVouchersForInvoiceResponse, 95 | None, 96 | False, 97 | jsonKeys, 98 | ) 99 | 100 | def payment_vouchers_for_customer( 101 | self, id, params: PaymentVouchersForCustomerParams = None, headers=None 102 | ) -> PaymentVouchersForCustomerResponse: 103 | jsonKeys = {} 104 | return request.send( 105 | "get", 106 | request.uri_path("customers", id, "payment_vouchers"), 107 | self.env, 108 | cast(Dict[Any, Any], params), 109 | headers, 110 | PaymentVouchersForCustomerResponse, 111 | None, 112 | False, 113 | jsonKeys, 114 | ) 115 | -------------------------------------------------------------------------------- /chargebee/models/payment_voucher/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | from chargebee.response import Response 5 | 6 | 7 | @dataclass 8 | class LinkedInvoiceResponse(Model): 9 | raw_data: Dict[Any, Any] = None 10 | invoice_id: str = None 11 | txn_id: str = None 12 | applied_at: int = None 13 | 14 | 15 | @dataclass 16 | class PaymentVoucherResponse(Model): 17 | raw_data: Dict[Any, Any] = None 18 | id: str = None 19 | id_at_gateway: str = None 20 | payment_voucher_type: str = None 21 | expires_at: int = None 22 | status: str = None 23 | subscription_id: str = None 24 | currency_code: str = None 25 | amount: int = None 26 | gateway_account_id: str = None 27 | payment_source_id: str = None 28 | gateway: str = None 29 | payload: str = None 30 | error_code: str = None 31 | error_text: str = None 32 | url: str = None 33 | date: int = None 34 | resource_version: int = None 35 | updated_at: int = None 36 | customer_id: str = None 37 | linked_invoices: List[LinkedInvoiceResponse] = None 38 | 39 | 40 | @dataclass 41 | class CreateResponse(Response): 42 | is_idempotency_replayed: bool 43 | payment_voucher: PaymentVoucherResponse 44 | 45 | 46 | @dataclass 47 | class RetrieveResponse(Response): 48 | 49 | payment_voucher: PaymentVoucherResponse 50 | 51 | 52 | @dataclass 53 | class PaymentVouchersForInvoicePaymentVoucherResponse: 54 | payment_voucher: PaymentVoucherResponse 55 | 56 | 57 | @dataclass 58 | class PaymentVouchersForInvoiceResponse(Response): 59 | 60 | list: List[PaymentVouchersForInvoicePaymentVoucherResponse] 61 | next_offset: str = None 62 | 63 | 64 | @dataclass 65 | class PaymentVouchersForCustomerPaymentVoucherResponse: 66 | payment_voucher: PaymentVoucherResponse 67 | 68 | 69 | @dataclass 70 | class PaymentVouchersForCustomerResponse(Response): 71 | 72 | list: List[PaymentVouchersForCustomerPaymentVoucherResponse] 73 | next_offset: str = None 74 | -------------------------------------------------------------------------------- /chargebee/models/plan/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import Plan 2 | from .responses import PlanResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/portal_session/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import PortalSession 2 | from .responses import PortalSessionResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/portal_session/operations.py: -------------------------------------------------------------------------------- 1 | from .responses import * 2 | from chargebee import request, environment 3 | from typing import TypedDict, Required, NotRequired, Dict, List, Any, cast 4 | from enum import Enum 5 | 6 | 7 | @dataclass 8 | class PortalSession: 9 | 10 | env: environment.Environment 11 | 12 | class Status(Enum): 13 | CREATED = "created" 14 | LOGGED_IN = "logged_in" 15 | LOGGED_OUT = "logged_out" 16 | NOT_YET_ACTIVATED = "not_yet_activated" 17 | ACTIVATED = "activated" 18 | 19 | def __str__(self): 20 | return self.value 21 | 22 | class LinkedCustomer(TypedDict): 23 | customer_id: Required[str] 24 | email: NotRequired[str] 25 | has_billing_address: Required[bool] 26 | has_payment_method: Required[bool] 27 | has_active_subscription: Required[bool] 28 | 29 | class CreateCustomerParams(TypedDict): 30 | id: Required[str] 31 | 32 | class CreateParams(TypedDict): 33 | customer: Required["PortalSession.CreateCustomerParams"] 34 | redirect_url: NotRequired[str] 35 | forward_url: NotRequired[str] 36 | 37 | class ActivateParams(TypedDict): 38 | token: Required[str] 39 | 40 | def create(self, params: CreateParams, headers=None) -> CreateResponse: 41 | jsonKeys = {} 42 | return request.send( 43 | "post", 44 | request.uri_path("portal_sessions"), 45 | self.env, 46 | cast(Dict[Any, Any], params), 47 | headers, 48 | CreateResponse, 49 | None, 50 | False, 51 | jsonKeys, 52 | ) 53 | 54 | def retrieve(self, id, headers=None) -> RetrieveResponse: 55 | jsonKeys = {} 56 | return request.send( 57 | "get", 58 | request.uri_path("portal_sessions", id), 59 | self.env, 60 | None, 61 | headers, 62 | RetrieveResponse, 63 | None, 64 | False, 65 | jsonKeys, 66 | ) 67 | 68 | def logout(self, id, headers=None) -> LogoutResponse: 69 | jsonKeys = {} 70 | return request.send( 71 | "post", 72 | request.uri_path("portal_sessions", id, "logout"), 73 | self.env, 74 | None, 75 | headers, 76 | LogoutResponse, 77 | None, 78 | False, 79 | jsonKeys, 80 | ) 81 | 82 | def activate(self, id, params: ActivateParams, headers=None) -> ActivateResponse: 83 | jsonKeys = {} 84 | return request.send( 85 | "post", 86 | request.uri_path("portal_sessions", id, "activate"), 87 | self.env, 88 | cast(Dict[Any, Any], params), 89 | headers, 90 | ActivateResponse, 91 | None, 92 | False, 93 | jsonKeys, 94 | ) 95 | -------------------------------------------------------------------------------- /chargebee/models/portal_session/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | from chargebee.response import Response 5 | 6 | 7 | @dataclass 8 | class LinkedCustomerResponse(Model): 9 | raw_data: Dict[Any, Any] = None 10 | customer_id: str = None 11 | email: str = None 12 | has_billing_address: bool = None 13 | has_payment_method: bool = None 14 | has_active_subscription: bool = None 15 | 16 | 17 | @dataclass 18 | class PortalSessionResponse(Model): 19 | raw_data: Dict[Any, Any] = None 20 | id: str = None 21 | token: str = None 22 | access_url: str = None 23 | redirect_url: str = None 24 | status: str = None 25 | created_at: int = None 26 | expires_at: int = None 27 | customer_id: str = None 28 | login_at: int = None 29 | logout_at: int = None 30 | login_ipaddress: str = None 31 | logout_ipaddress: str = None 32 | linked_customers: List[LinkedCustomerResponse] = None 33 | 34 | 35 | @dataclass 36 | class CreateResponse(Response): 37 | is_idempotency_replayed: bool 38 | portal_session: PortalSessionResponse 39 | 40 | 41 | @dataclass 42 | class RetrieveResponse(Response): 43 | 44 | portal_session: PortalSessionResponse 45 | 46 | 47 | @dataclass 48 | class LogoutResponse(Response): 49 | is_idempotency_replayed: bool 50 | portal_session: PortalSessionResponse 51 | 52 | 53 | @dataclass 54 | class ActivateResponse(Response): 55 | is_idempotency_replayed: bool 56 | portal_session: PortalSessionResponse 57 | -------------------------------------------------------------------------------- /chargebee/models/price_variant/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import PriceVariant 2 | from .responses import PriceVariantResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/price_variant/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | from chargebee.response import Response 5 | 6 | 7 | @dataclass 8 | class AttributeResponse(Model): 9 | raw_data: Dict[Any, Any] = None 10 | name: str = None 11 | value: str = None 12 | 13 | 14 | @dataclass 15 | class PriceVariantResponse(Model): 16 | raw_data: Dict[Any, Any] = None 17 | id: str = None 18 | name: str = None 19 | external_name: str = None 20 | variant_group: str = None 21 | description: str = None 22 | status: str = None 23 | created_at: int = None 24 | resource_version: int = None 25 | updated_at: int = None 26 | archived_at: int = None 27 | attributes: List[AttributeResponse] = None 28 | business_entity_id: str = None 29 | deleted: bool = None 30 | 31 | 32 | @dataclass 33 | class CreateResponse(Response): 34 | is_idempotency_replayed: bool 35 | price_variant: PriceVariantResponse 36 | 37 | 38 | @dataclass 39 | class RetrieveResponse(Response): 40 | 41 | price_variant: PriceVariantResponse 42 | 43 | 44 | @dataclass 45 | class UpdateResponse(Response): 46 | is_idempotency_replayed: bool 47 | price_variant: PriceVariantResponse 48 | 49 | 50 | @dataclass 51 | class DeleteResponse(Response): 52 | is_idempotency_replayed: bool 53 | price_variant: PriceVariantResponse 54 | 55 | 56 | @dataclass 57 | class ListPriceVariantResponse: 58 | price_variant: PriceVariantResponse 59 | 60 | 61 | @dataclass 62 | class ListResponse(Response): 63 | 64 | list: List[ListPriceVariantResponse] 65 | next_offset: str = None 66 | -------------------------------------------------------------------------------- /chargebee/models/pricing_page_session/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import PricingPageSession 2 | from .responses import PricingPageSessionResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/pricing_page_session/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | from chargebee.response import Response 5 | 6 | 7 | @dataclass 8 | class PricingPageSessionResponse(Model): 9 | raw_data: Dict[Any, Any] = None 10 | id: str = None 11 | url: str = None 12 | created_at: int = None 13 | expires_at: int = None 14 | 15 | 16 | @dataclass 17 | class CreateForNewSubscriptionResponse(Response): 18 | is_idempotency_replayed: bool 19 | pricing_page_session: PricingPageSessionResponse 20 | 21 | 22 | @dataclass 23 | class CreateForExistingSubscriptionResponse(Response): 24 | is_idempotency_replayed: bool 25 | pricing_page_session: PricingPageSessionResponse 26 | -------------------------------------------------------------------------------- /chargebee/models/promotional_credit/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import PromotionalCredit 2 | from .responses import PromotionalCreditResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/promotional_credit/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | from chargebee.response import Response 5 | from chargebee.models import customer 6 | 7 | 8 | @dataclass 9 | class PromotionalCreditResponse(Model): 10 | raw_data: Dict[Any, Any] = None 11 | id: str = None 12 | customer_id: str = None 13 | type: str = None 14 | amount_in_decimal: str = None 15 | amount: int = None 16 | currency_code: str = None 17 | description: str = None 18 | credit_type: str = None 19 | reference: str = None 20 | closing_balance: int = None 21 | done_by: str = None 22 | created_at: int = None 23 | 24 | 25 | @dataclass 26 | class AddResponse(Response): 27 | is_idempotency_replayed: bool 28 | customer: "customer.CustomerResponse" 29 | promotional_credit: PromotionalCreditResponse 30 | 31 | 32 | @dataclass 33 | class DeductResponse(Response): 34 | is_idempotency_replayed: bool 35 | customer: "customer.CustomerResponse" 36 | promotional_credit: PromotionalCreditResponse 37 | 38 | 39 | @dataclass 40 | class SetResponse(Response): 41 | is_idempotency_replayed: bool 42 | customer: "customer.CustomerResponse" 43 | promotional_credit: PromotionalCreditResponse 44 | 45 | 46 | @dataclass 47 | class ListPromotionalCreditResponse: 48 | promotional_credit: PromotionalCreditResponse 49 | 50 | 51 | @dataclass 52 | class ListResponse(Response): 53 | 54 | list: List[ListPromotionalCreditResponse] 55 | next_offset: str = None 56 | 57 | 58 | @dataclass 59 | class RetrieveResponse(Response): 60 | 61 | promotional_credit: PromotionalCreditResponse 62 | -------------------------------------------------------------------------------- /chargebee/models/purchase/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import Purchase 2 | from .responses import PurchaseResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/purchase/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | from chargebee.response import Response 5 | from chargebee.models import payment_intent, contract_term, estimate 6 | 7 | 8 | @dataclass 9 | class PurchaseResponse(Model): 10 | raw_data: Dict[Any, Any] = None 11 | id: str = None 12 | customer_id: str = None 13 | created_at: int = None 14 | modified_at: int = None 15 | subscription_ids: List[str] = None 16 | invoice_ids: List[str] = None 17 | 18 | 19 | @dataclass 20 | class CreateResponse(Response): 21 | is_idempotency_replayed: bool 22 | purchase: PurchaseResponse 23 | 24 | 25 | @dataclass 26 | class EstimateResponse(Response): 27 | is_idempotency_replayed: bool 28 | estimate: "estimate.EstimateResponse" 29 | -------------------------------------------------------------------------------- /chargebee/models/quote/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import Quote 2 | from .responses import QuoteResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/quote_line_group/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import QuoteLineGroup 2 | from .responses import QuoteLineGroupResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/quote_line_group/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | 5 | 6 | @dataclass 7 | class LineItemResponse(Model): 8 | raw_data: Dict[Any, Any] = None 9 | id: str = None 10 | subscription_id: str = None 11 | date_from: int = None 12 | date_to: int = None 13 | unit_amount: int = None 14 | quantity: int = None 15 | amount: int = None 16 | pricing_model: str = None 17 | is_taxed: bool = None 18 | tax_amount: int = None 19 | tax_rate: float = None 20 | unit_amount_in_decimal: str = None 21 | quantity_in_decimal: str = None 22 | amount_in_decimal: str = None 23 | discount_amount: int = None 24 | item_level_discount_amount: int = None 25 | metered: bool = None 26 | percentage: str = None 27 | reference_line_item_id: str = None 28 | description: str = None 29 | entity_description: str = None 30 | entity_type: str = None 31 | tax_exempt_reason: str = None 32 | entity_id: str = None 33 | customer_id: str = None 34 | 35 | 36 | @dataclass 37 | class DiscountResponse(Model): 38 | raw_data: Dict[Any, Any] = None 39 | amount: int = None 40 | description: str = None 41 | entity_type: str = None 42 | discount_type: str = None 43 | entity_id: str = None 44 | coupon_set_code: str = None 45 | 46 | 47 | @dataclass 48 | class LineItemDiscountResponse(Model): 49 | raw_data: Dict[Any, Any] = None 50 | line_item_id: str = None 51 | discount_type: str = None 52 | coupon_id: str = None 53 | entity_id: str = None 54 | discount_amount: int = None 55 | 56 | 57 | @dataclass 58 | class TaxResponse(Model): 59 | raw_data: Dict[Any, Any] = None 60 | name: str = None 61 | amount: int = None 62 | description: str = None 63 | 64 | 65 | @dataclass 66 | class LineItemTaxResponse(Model): 67 | raw_data: Dict[Any, Any] = None 68 | line_item_id: str = None 69 | tax_name: str = None 70 | tax_rate: float = None 71 | date_to: int = None 72 | date_from: int = None 73 | prorated_taxable_amount: float = None 74 | is_partial_tax_applied: bool = None 75 | is_non_compliance_tax: bool = None 76 | taxable_amount: int = None 77 | tax_amount: int = None 78 | tax_juris_type: str = None 79 | tax_juris_name: str = None 80 | tax_juris_code: str = None 81 | tax_amount_in_local_currency: int = None 82 | local_currency_code: str = None 83 | 84 | 85 | @dataclass 86 | class QuoteLineGroupResponse(Model): 87 | raw_data: Dict[Any, Any] = None 88 | version: int = None 89 | id: str = None 90 | sub_total: int = None 91 | total: int = None 92 | credits_applied: int = None 93 | amount_paid: int = None 94 | amount_due: int = None 95 | charge_event: str = None 96 | billing_cycle_number: int = None 97 | line_items: List[LineItemResponse] = None 98 | discounts: List[DiscountResponse] = None 99 | line_item_discounts: List[LineItemDiscountResponse] = None 100 | taxes: List[TaxResponse] = None 101 | line_item_taxes: List[LineItemTaxResponse] = None 102 | -------------------------------------------------------------------------------- /chargebee/models/quoted_charge/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import QuotedCharge 2 | from .responses import QuotedChargeResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/quoted_charge/operations.py: -------------------------------------------------------------------------------- 1 | from .responses import * 2 | from chargebee import request, environment 3 | from typing import TypedDict, Required, NotRequired, Dict, List, Any, cast 4 | from chargebee.models import enums 5 | 6 | 7 | @dataclass 8 | class QuotedCharge: 9 | 10 | env: environment.Environment 11 | 12 | class Charge(TypedDict): 13 | amount: NotRequired[int] 14 | amount_in_decimal: NotRequired[str] 15 | description: NotRequired[str] 16 | service_period_in_days: NotRequired[int] 17 | avalara_sale_type: NotRequired[enums.AvalaraSaleType] 18 | avalara_transaction_type: NotRequired[int] 19 | avalara_service_type: NotRequired[int] 20 | 21 | class InvoiceItem(TypedDict): 22 | item_price_id: Required[str] 23 | quantity: NotRequired[int] 24 | quantity_in_decimal: NotRequired[str] 25 | unit_price: NotRequired[int] 26 | unit_price_in_decimal: NotRequired[str] 27 | service_period_days: NotRequired[int] 28 | 29 | class ItemTier(TypedDict): 30 | item_price_id: Required[str] 31 | starting_unit: Required[int] 32 | ending_unit: NotRequired[int] 33 | price: Required[int] 34 | starting_unit_in_decimal: NotRequired[str] 35 | ending_unit_in_decimal: NotRequired[str] 36 | price_in_decimal: NotRequired[str] 37 | pricing_type: NotRequired[enums.PricingType] 38 | package_size: NotRequired[int] 39 | index: Required[int] 40 | 41 | class Coupon(TypedDict): 42 | coupon_id: Required[str] 43 | 44 | class Addon(TypedDict): 45 | id: Required[str] 46 | quantity: NotRequired[int] 47 | unit_price: NotRequired[int] 48 | quantity_in_decimal: NotRequired[str] 49 | unit_price_in_decimal: NotRequired[str] 50 | proration_type: NotRequired[enums.ProrationType] 51 | service_period: NotRequired[int] 52 | 53 | pass 54 | -------------------------------------------------------------------------------- /chargebee/models/quoted_charge/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | 5 | 6 | @dataclass 7 | class ChargeResponse(Model): 8 | raw_data: Dict[Any, Any] = None 9 | amount: int = None 10 | amount_in_decimal: str = None 11 | description: str = None 12 | service_period_in_days: int = None 13 | avalara_sale_type: str = None 14 | avalara_transaction_type: int = None 15 | avalara_service_type: int = None 16 | 17 | 18 | @dataclass 19 | class InvoiceItemResponse(Model): 20 | raw_data: Dict[Any, Any] = None 21 | item_price_id: str = None 22 | quantity: int = None 23 | quantity_in_decimal: str = None 24 | unit_price: int = None 25 | unit_price_in_decimal: str = None 26 | service_period_days: int = None 27 | 28 | 29 | @dataclass 30 | class ItemTierResponse(Model): 31 | raw_data: Dict[Any, Any] = None 32 | item_price_id: str = None 33 | starting_unit: int = None 34 | ending_unit: int = None 35 | price: int = None 36 | starting_unit_in_decimal: str = None 37 | ending_unit_in_decimal: str = None 38 | price_in_decimal: str = None 39 | pricing_type: str = None 40 | package_size: int = None 41 | index: int = None 42 | 43 | 44 | @dataclass 45 | class CouponResponse(Model): 46 | raw_data: Dict[Any, Any] = None 47 | coupon_id: str = None 48 | 49 | 50 | @dataclass 51 | class AddonResponse(Model): 52 | raw_data: Dict[Any, Any] = None 53 | id: str = None 54 | quantity: int = None 55 | unit_price: int = None 56 | quantity_in_decimal: str = None 57 | unit_price_in_decimal: str = None 58 | proration_type: str = None 59 | service_period: int = None 60 | 61 | 62 | @dataclass 63 | class QuotedChargeResponse(Model): 64 | raw_data: Dict[Any, Any] = None 65 | charges: List[ChargeResponse] = None 66 | addons: List[AddonResponse] = None 67 | invoice_items: List[InvoiceItemResponse] = None 68 | item_tiers: List[ItemTierResponse] = None 69 | coupons: List[CouponResponse] = None 70 | -------------------------------------------------------------------------------- /chargebee/models/quoted_subscription/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import QuotedSubscription 2 | from .responses import QuotedSubscriptionResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/ramp/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import Ramp 2 | from .responses import RampResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/recorded_purchase/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import RecordedPurchase 2 | from .responses import RecordedPurchaseResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/recorded_purchase/operations.py: -------------------------------------------------------------------------------- 1 | from .responses import * 2 | from chargebee import request, environment 3 | from typing import TypedDict, Required, NotRequired, Dict, List, Any, cast 4 | from enum import Enum 5 | 6 | 7 | @dataclass 8 | class RecordedPurchase: 9 | 10 | env: environment.Environment 11 | 12 | class Source(Enum): 13 | APPLE_APP_STORE = "apple_app_store" 14 | GOOGLE_PLAY_STORE = "google_play_store" 15 | 16 | def __str__(self): 17 | return self.value 18 | 19 | class Status(Enum): 20 | IN_PROCESS = "in_process" 21 | COMPLETED = "completed" 22 | FAILED = "failed" 23 | IGNORED = "ignored" 24 | 25 | def __str__(self): 26 | return self.value 27 | 28 | class LinkedOmnichannelSubscription(TypedDict): 29 | omnichannel_subscription_id: NotRequired[str] 30 | 31 | class ErrorDetail(TypedDict): 32 | error_message: NotRequired[str] 33 | 34 | class CreateCustomerParams(TypedDict): 35 | id: Required[str] 36 | 37 | class CreateAppleAppStoreParams(TypedDict): 38 | transaction_id: NotRequired[str] 39 | receipt: NotRequired[str] 40 | product_id: NotRequired[str] 41 | 42 | class CreateGooglePlayStoreParams(TypedDict): 43 | purchase_token: NotRequired[str] 44 | 45 | class CreateParams(TypedDict): 46 | app_id: Required[str] 47 | customer: Required["RecordedPurchase.CreateCustomerParams"] 48 | apple_app_store: NotRequired["RecordedPurchase.CreateAppleAppStoreParams"] 49 | google_play_store: NotRequired["RecordedPurchase.CreateGooglePlayStoreParams"] 50 | 51 | def create(self, params: CreateParams, headers=None) -> CreateResponse: 52 | jsonKeys = {} 53 | return request.send( 54 | "post", 55 | request.uri_path("recorded_purchases"), 56 | self.env, 57 | cast(Dict[Any, Any], params), 58 | headers, 59 | CreateResponse, 60 | None, 61 | False, 62 | jsonKeys, 63 | ) 64 | 65 | def retrieve(self, id, headers=None) -> RetrieveResponse: 66 | jsonKeys = {} 67 | return request.send( 68 | "get", 69 | request.uri_path("recorded_purchases", id), 70 | self.env, 71 | None, 72 | headers, 73 | RetrieveResponse, 74 | None, 75 | False, 76 | jsonKeys, 77 | ) 78 | -------------------------------------------------------------------------------- /chargebee/models/recorded_purchase/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | from chargebee.response import Response 5 | from chargebee.models import customer 6 | 7 | 8 | @dataclass 9 | class LinkedOmnichannelSubscriptionResponse(Model): 10 | raw_data: Dict[Any, Any] = None 11 | omnichannel_subscription_id: str = None 12 | 13 | 14 | @dataclass 15 | class ErrorDetailResponse(Model): 16 | raw_data: Dict[Any, Any] = None 17 | error_message: str = None 18 | 19 | 20 | @dataclass 21 | class RecordedPurchaseResponse(Model): 22 | raw_data: Dict[Any, Any] = None 23 | id: str = None 24 | customer_id: str = None 25 | app_id: str = None 26 | source: str = None 27 | status: str = None 28 | omnichannel_transaction_id: str = None 29 | created_at: int = None 30 | resource_version: int = None 31 | linked_omnichannel_subscriptions: List[LinkedOmnichannelSubscriptionResponse] = None 32 | error_detail: ErrorDetailResponse = None 33 | 34 | 35 | @dataclass 36 | class CreateResponse(Response): 37 | is_idempotency_replayed: bool 38 | recorded_purchase: RecordedPurchaseResponse 39 | customer: "customer.CustomerResponse" 40 | 41 | 42 | @dataclass 43 | class RetrieveResponse(Response): 44 | 45 | recorded_purchase: RecordedPurchaseResponse 46 | -------------------------------------------------------------------------------- /chargebee/models/resource_migration/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import ResourceMigration 2 | from .responses import ResourceMigrationResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/resource_migration/operations.py: -------------------------------------------------------------------------------- 1 | from .responses import * 2 | from chargebee import request, environment 3 | from typing import TypedDict, Required, NotRequired, Dict, List, Any, cast 4 | from enum import Enum 5 | from chargebee.models import enums 6 | 7 | 8 | @dataclass 9 | class ResourceMigration: 10 | 11 | env: environment.Environment 12 | 13 | class Status(Enum): 14 | SCHEDULED = "scheduled" 15 | FAILED = "failed" 16 | SUCCEEDED = "succeeded" 17 | 18 | def __str__(self): 19 | return self.value 20 | 21 | class RetrieveLatestParams(TypedDict): 22 | from_site: Required[str] 23 | entity_type: Required[enums.EntityType] 24 | entity_id: Required[str] 25 | 26 | def retrieve_latest( 27 | self, params: RetrieveLatestParams, headers=None 28 | ) -> RetrieveLatestResponse: 29 | jsonKeys = {} 30 | return request.send( 31 | "get", 32 | request.uri_path("resource_migrations", "retrieve_latest"), 33 | self.env, 34 | cast(Dict[Any, Any], params), 35 | headers, 36 | RetrieveLatestResponse, 37 | None, 38 | False, 39 | jsonKeys, 40 | ) 41 | -------------------------------------------------------------------------------- /chargebee/models/resource_migration/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | from chargebee.response import Response 5 | 6 | 7 | @dataclass 8 | class ResourceMigrationResponse(Model): 9 | raw_data: Dict[Any, Any] = None 10 | from_site: str = None 11 | entity_type: str = None 12 | entity_id: str = None 13 | status: str = None 14 | errors: str = None 15 | created_at: int = None 16 | updated_at: int = None 17 | 18 | 19 | @dataclass 20 | class RetrieveLatestResponse(Response): 21 | 22 | resource_migration: ResourceMigrationResponse 23 | -------------------------------------------------------------------------------- /chargebee/models/rule/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import Rule 2 | from .responses import RuleResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/rule/operations.py: -------------------------------------------------------------------------------- 1 | from .responses import * 2 | from chargebee import request, environment 3 | from typing import TypedDict, Required, NotRequired, Dict, List, Any, cast 4 | from enum import Enum 5 | 6 | 7 | @dataclass 8 | class Rule: 9 | 10 | env: environment.Environment 11 | 12 | class Status(Enum): 13 | ACTIVE = "active" 14 | DISABLED = "disabled" 15 | 16 | def __str__(self): 17 | return self.value 18 | 19 | def retrieve(self, id, headers=None) -> RetrieveResponse: 20 | jsonKeys = {} 21 | return request.send( 22 | "get", 23 | request.uri_path("rules", id), 24 | self.env, 25 | None, 26 | headers, 27 | RetrieveResponse, 28 | None, 29 | False, 30 | jsonKeys, 31 | ) 32 | -------------------------------------------------------------------------------- /chargebee/models/rule/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | from chargebee.response import Response 5 | 6 | 7 | @dataclass 8 | class RuleResponse(Model): 9 | raw_data: Dict[Any, Any] = None 10 | id: str = None 11 | namespace: str = None 12 | rule_name: str = None 13 | rule_order: int = None 14 | status: str = None 15 | conditions: str = None 16 | outcome: str = None 17 | deleted: bool = None 18 | created_at: int = None 19 | modified_at: int = None 20 | 21 | 22 | @dataclass 23 | class RetrieveResponse(Response): 24 | 25 | rule: RuleResponse 26 | -------------------------------------------------------------------------------- /chargebee/models/site_migration_detail/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import SiteMigrationDetail 2 | from .responses import SiteMigrationDetailResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/site_migration_detail/operations.py: -------------------------------------------------------------------------------- 1 | from .responses import * 2 | from chargebee import request, environment 3 | from typing import TypedDict, Required, NotRequired, Dict, List, Any, cast 4 | from enum import Enum 5 | from chargebee.filters import Filters 6 | 7 | 8 | @dataclass 9 | class SiteMigrationDetail: 10 | 11 | env: environment.Environment 12 | 13 | class Status(Enum): 14 | MOVED_IN = "moved_in" 15 | MOVED_OUT = "moved_out" 16 | MOVING_OUT = "moving_out" 17 | 18 | def __str__(self): 19 | return self.value 20 | 21 | class ListParams(TypedDict): 22 | limit: NotRequired[int] 23 | offset: NotRequired[str] 24 | entity_id_at_other_site: NotRequired[Filters.StringFilter] 25 | other_site_name: NotRequired[Filters.StringFilter] 26 | entity_id: NotRequired[Filters.StringFilter] 27 | entity_type: NotRequired[Filters.EnumFilter] 28 | status: NotRequired[Filters.EnumFilter] 29 | 30 | def list(self, params: ListParams = None, headers=None) -> ListResponse: 31 | jsonKeys = {} 32 | return request.send_list_request( 33 | "get", 34 | request.uri_path("site_migration_details"), 35 | self.env, 36 | cast(Dict[Any, Any], params), 37 | headers, 38 | ListResponse, 39 | None, 40 | False, 41 | jsonKeys, 42 | ) 43 | -------------------------------------------------------------------------------- /chargebee/models/site_migration_detail/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | from chargebee.response import Response 5 | 6 | 7 | @dataclass 8 | class SiteMigrationDetailResponse(Model): 9 | raw_data: Dict[Any, Any] = None 10 | entity_id: str = None 11 | other_site_name: str = None 12 | entity_id_at_other_site: str = None 13 | migrated_at: int = None 14 | entity_type: str = None 15 | status: str = None 16 | 17 | 18 | @dataclass 19 | class ListSiteMigrationDetailResponse: 20 | site_migration_detail: SiteMigrationDetailResponse 21 | 22 | 23 | @dataclass 24 | class ListResponse(Response): 25 | 26 | list: List[ListSiteMigrationDetailResponse] 27 | next_offset: str = None 28 | -------------------------------------------------------------------------------- /chargebee/models/subscription/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import Subscription 2 | from .responses import SubscriptionResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/subscription_entitlement/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import SubscriptionEntitlement 2 | from .responses import SubscriptionEntitlementResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/subscription_entitlement/operations.py: -------------------------------------------------------------------------------- 1 | from .responses import * 2 | from chargebee import request, environment 3 | from typing import TypedDict, Required, NotRequired, Dict, List, Any, cast 4 | from enum import Enum 5 | from chargebee.models import entitlement_override 6 | 7 | 8 | @dataclass 9 | class SubscriptionEntitlement: 10 | 11 | env: environment.Environment 12 | 13 | class ScheduleStatus(Enum): 14 | ACTIVATED = "activated" 15 | SCHEDULED = "scheduled" 16 | FAILED = "failed" 17 | 18 | def __str__(self): 19 | return self.value 20 | 21 | class Component(TypedDict): 22 | entitlement_overrides: NotRequired[ 23 | entitlement_override.EntitlementOverrideResponse 24 | ] 25 | 26 | class SetSubscriptionEntitlementAvailabilitySubscriptionEntitlementParams( 27 | TypedDict 28 | ): 29 | feature_id: Required[str] 30 | 31 | class SubscriptionEntitlementsForSubscriptionParams(TypedDict): 32 | limit: NotRequired[int] 33 | offset: NotRequired[str] 34 | include_drafts: NotRequired[bool] 35 | embed: NotRequired[str] 36 | include_scheduled_overrides: NotRequired[bool] 37 | 38 | class SetSubscriptionEntitlementAvailabilityParams(TypedDict): 39 | is_enabled: Required[bool] 40 | subscription_entitlements: Required[ 41 | List[ 42 | "SubscriptionEntitlement.SetSubscriptionEntitlementAvailabilitySubscriptionEntitlementParams" 43 | ] 44 | ] 45 | 46 | def subscription_entitlements_for_subscription( 47 | self, 48 | id, 49 | params: SubscriptionEntitlementsForSubscriptionParams = None, 50 | headers=None, 51 | ) -> SubscriptionEntitlementsForSubscriptionResponse: 52 | jsonKeys = {} 53 | return request.send( 54 | "get", 55 | request.uri_path("subscriptions", id, "subscription_entitlements"), 56 | self.env, 57 | cast(Dict[Any, Any], params), 58 | headers, 59 | SubscriptionEntitlementsForSubscriptionResponse, 60 | None, 61 | False, 62 | jsonKeys, 63 | ) 64 | 65 | def set_subscription_entitlement_availability( 66 | self, id, params: SetSubscriptionEntitlementAvailabilityParams, headers=None 67 | ) -> SetSubscriptionEntitlementAvailabilityResponse: 68 | jsonKeys = {} 69 | return request.send( 70 | "post", 71 | request.uri_path( 72 | "subscriptions", id, "subscription_entitlements/set_availability" 73 | ), 74 | self.env, 75 | cast(Dict[Any, Any], params), 76 | headers, 77 | SetSubscriptionEntitlementAvailabilityResponse, 78 | None, 79 | False, 80 | jsonKeys, 81 | ) 82 | -------------------------------------------------------------------------------- /chargebee/models/subscription_entitlement/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | from chargebee.response import Response 5 | from chargebee.models import entitlement_override 6 | 7 | 8 | @dataclass 9 | class ComponentResponse(Model): 10 | raw_data: Dict[Any, Any] = None 11 | entitlement_overrides: entitlement_override.EntitlementOverrideResponse = None 12 | 13 | 14 | @dataclass 15 | class SubscriptionEntitlementResponse(Model): 16 | raw_data: Dict[Any, Any] = None 17 | subscription_id: str = None 18 | feature_id: str = None 19 | feature_name: str = None 20 | feature_unit: str = None 21 | feature_type: str = None 22 | value: str = None 23 | name: str = None 24 | is_overridden: bool = None 25 | is_enabled: bool = None 26 | effective_from: int = None 27 | schedule_status: str = None 28 | expires_at: int = None 29 | components: ComponentResponse = None 30 | 31 | 32 | @dataclass 33 | class SubscriptionEntitlementsForSubscriptionSubscriptionEntitlementResponse: 34 | subscription_entitlement: SubscriptionEntitlementResponse 35 | 36 | 37 | @dataclass 38 | class SubscriptionEntitlementsForSubscriptionResponse(Response): 39 | 40 | list: List[SubscriptionEntitlementsForSubscriptionSubscriptionEntitlementResponse] 41 | next_offset: str = None 42 | 43 | 44 | @dataclass 45 | class SetSubscriptionEntitlementAvailabilityResponse(Response): 46 | is_idempotency_replayed: bool 47 | subscription_entitlement: SubscriptionEntitlementResponse 48 | -------------------------------------------------------------------------------- /chargebee/models/subscription_estimate/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import SubscriptionEstimate 2 | from .responses import SubscriptionEstimateResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/subscription_estimate/operations.py: -------------------------------------------------------------------------------- 1 | from .responses import * 2 | from chargebee import request, environment 3 | from typing import TypedDict, Required, NotRequired, Dict, List, Any, cast 4 | from enum import Enum 5 | from chargebee.models import enums 6 | 7 | 8 | @dataclass 9 | class SubscriptionEstimate: 10 | 11 | env: environment.Environment 12 | 13 | class Status(Enum): 14 | FUTURE = "future" 15 | IN_TRIAL = "in_trial" 16 | ACTIVE = "active" 17 | NON_RENEWING = "non_renewing" 18 | PAUSED = "paused" 19 | CANCELLED = "cancelled" 20 | TRANSFERRED = "transferred" 21 | 22 | def __str__(self): 23 | return self.value 24 | 25 | class ContractTermStatus(Enum): 26 | ACTIVE = "active" 27 | COMPLETED = "completed" 28 | CANCELLED = "cancelled" 29 | TERMINATED = "terminated" 30 | 31 | def __str__(self): 32 | return self.value 33 | 34 | class ContractTermActionAtTermEnd(Enum): 35 | RENEW = "renew" 36 | EVERGREEN = "evergreen" 37 | CANCEL = "cancel" 38 | RENEW_ONCE = "renew_once" 39 | 40 | def __str__(self): 41 | return self.value 42 | 43 | class ShippingAddress(TypedDict): 44 | first_name: NotRequired[str] 45 | last_name: NotRequired[str] 46 | email: NotRequired[str] 47 | company: NotRequired[str] 48 | phone: NotRequired[str] 49 | line1: NotRequired[str] 50 | line2: NotRequired[str] 51 | line3: NotRequired[str] 52 | city: NotRequired[str] 53 | state_code: NotRequired[str] 54 | state: NotRequired[str] 55 | country: NotRequired[str] 56 | zip: NotRequired[str] 57 | validation_status: NotRequired[enums.ValidationStatus] 58 | index: Required[int] 59 | 60 | class ContractTerm(TypedDict): 61 | id: Required[str] 62 | status: Required["SubscriptionEstimate.ContractTermStatus"] 63 | contract_start: Required[int] 64 | contract_end: Required[int] 65 | billing_cycle: Required[int] 66 | action_at_term_end: Required["SubscriptionEstimate.ContractTermActionAtTermEnd"] 67 | total_contract_value: Required[int] 68 | total_contract_value_before_tax: Required[int] 69 | cancellation_cutoff_period: NotRequired[int] 70 | created_at: Required[int] 71 | subscription_id: Required[str] 72 | remaining_billing_cycles: NotRequired[int] 73 | 74 | pass 75 | -------------------------------------------------------------------------------- /chargebee/models/subscription_estimate/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | 5 | 6 | @dataclass 7 | class ShippingAddressResponse(Model): 8 | raw_data: Dict[Any, Any] = None 9 | first_name: str = None 10 | last_name: str = None 11 | email: str = None 12 | company: str = None 13 | phone: str = None 14 | line1: str = None 15 | line2: str = None 16 | line3: str = None 17 | city: str = None 18 | state_code: str = None 19 | state: str = None 20 | country: str = None 21 | zip: str = None 22 | validation_status: str = None 23 | index: int = None 24 | 25 | 26 | @dataclass 27 | class ContractTermResponse(Model): 28 | raw_data: Dict[Any, Any] = None 29 | id: str = None 30 | status: str = None 31 | contract_start: int = None 32 | contract_end: int = None 33 | billing_cycle: int = None 34 | action_at_term_end: str = None 35 | total_contract_value: int = None 36 | total_contract_value_before_tax: int = None 37 | cancellation_cutoff_period: int = None 38 | created_at: int = None 39 | subscription_id: str = None 40 | remaining_billing_cycles: int = None 41 | 42 | 43 | @dataclass 44 | class SubscriptionEstimateResponse(Model): 45 | raw_data: Dict[Any, Any] = None 46 | id: str = None 47 | currency_code: str = None 48 | status: str = None 49 | trial_end_action: str = None 50 | next_billing_at: int = None 51 | pause_date: int = None 52 | resume_date: int = None 53 | shipping_address: ShippingAddressResponse = None 54 | contract_term: ContractTermResponse = None 55 | -------------------------------------------------------------------------------- /chargebee/models/tax_withheld/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import TaxWithheld 2 | from .responses import TaxWithheldResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/tax_withheld/operations.py: -------------------------------------------------------------------------------- 1 | from .responses import * 2 | from chargebee import request, environment 3 | from typing import TypedDict, Required, NotRequired, Dict, List, Any, cast 4 | from enum import Enum 5 | 6 | 7 | @dataclass 8 | class TaxWithheld: 9 | 10 | env: environment.Environment 11 | 12 | class Type(Enum): 13 | PAYMENT = "payment" 14 | REFUND = "refund" 15 | 16 | def __str__(self): 17 | return self.value 18 | 19 | class PaymentMethod(Enum): 20 | CASH = "cash" 21 | CHECK = "check" 22 | CHARGEBACK = "chargeback" 23 | BANK_TRANSFER = "bank_transfer" 24 | OTHER = "other" 25 | 26 | def __str__(self): 27 | return self.value 28 | 29 | pass 30 | -------------------------------------------------------------------------------- /chargebee/models/tax_withheld/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | 5 | 6 | @dataclass 7 | class TaxWithheldResponse(Model): 8 | raw_data: Dict[Any, Any] = None 9 | id: str = None 10 | user: str = None 11 | reference_number: str = None 12 | description: str = None 13 | type: str = None 14 | payment_method: str = None 15 | date: int = None 16 | currency_code: str = None 17 | amount: int = None 18 | resource_version: int = None 19 | updated_at: int = None 20 | exchange_rate: float = None 21 | -------------------------------------------------------------------------------- /chargebee/models/third_party_payment_method/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import ThirdPartyPaymentMethod 2 | from .responses import ThirdPartyPaymentMethodResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/third_party_payment_method/operations.py: -------------------------------------------------------------------------------- 1 | from .responses import * 2 | from chargebee import request, environment 3 | from typing import TypedDict, Required, NotRequired, Dict, List, Any, cast 4 | 5 | 6 | @dataclass 7 | class ThirdPartyPaymentMethod: 8 | 9 | env: environment.Environment 10 | 11 | pass 12 | -------------------------------------------------------------------------------- /chargebee/models/third_party_payment_method/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | 5 | 6 | @dataclass 7 | class ThirdPartyPaymentMethodResponse(Model): 8 | raw_data: Dict[Any, Any] = None 9 | type: str = None 10 | gateway: str = None 11 | gateway_account_id: str = None 12 | reference_id: str = None 13 | -------------------------------------------------------------------------------- /chargebee/models/time_machine/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import TimeMachine 2 | from .responses import TimeMachineResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/time_machine/operations.py: -------------------------------------------------------------------------------- 1 | from .responses import * 2 | from chargebee import request, environment 3 | from typing import TypedDict, Required, NotRequired, Dict, List, Any, cast 4 | from enum import Enum 5 | import json 6 | from chargebee import OperationFailedError 7 | 8 | 9 | @dataclass 10 | class TimeMachine: 11 | 12 | env: environment.Environment 13 | 14 | class TimeTravelStatus(Enum): 15 | NOT_ENABLED = "not_enabled" 16 | IN_PROGRESS = "in_progress" 17 | SUCCEEDED = "succeeded" 18 | FAILED = "failed" 19 | 20 | def __str__(self): 21 | return self.value 22 | 23 | def wait_for_time_travel_completion( 24 | self, time_machine: TimeMachineResponse 25 | ) -> RetrieveResponse: 26 | import time 27 | 28 | response: RetrieveResponse = None 29 | count = 0 30 | retry_delay_ms = ( 31 | 3000 if self.env is None else self.env.time_travel_retry_delay_ms 32 | ) / 1000.0 33 | 34 | while time_machine.time_travel_status == "in_progress": 35 | if count > 30: 36 | raise RuntimeError("Time travel is taking too much time") 37 | count += 1 38 | time.sleep(retry_delay_ms) 39 | response = self.retrieve(time_machine.name) 40 | time_machine = response.time_machine 41 | 42 | if time_machine.time_travel_status == "failed": 43 | err = json.loads(time_machine.error_json) 44 | raise OperationFailedError(err["http_code"], err) 45 | 46 | if time_machine.time_travel_status in ("not_enabled", "_unknown"): 47 | raise RuntimeError( 48 | "Time travel is in wrong state '" 49 | + time_machine.time_travel_status 50 | + "'" 51 | ) 52 | 53 | return response 54 | 55 | class StartAfreshParams(TypedDict): 56 | genesis_time: NotRequired[int] 57 | 58 | class TravelForwardParams(TypedDict): 59 | destination_time: NotRequired[int] 60 | 61 | def retrieve(self, id, headers=None) -> RetrieveResponse: 62 | jsonKeys = {} 63 | return request.send( 64 | "get", 65 | request.uri_path("time_machines", id), 66 | self.env, 67 | None, 68 | headers, 69 | RetrieveResponse, 70 | None, 71 | False, 72 | jsonKeys, 73 | ) 74 | 75 | def start_afresh( 76 | self, id, params: StartAfreshParams = None, headers=None 77 | ) -> StartAfreshResponse: 78 | jsonKeys = {} 79 | return request.send( 80 | "post", 81 | request.uri_path("time_machines", id, "start_afresh"), 82 | self.env, 83 | cast(Dict[Any, Any], params), 84 | headers, 85 | StartAfreshResponse, 86 | None, 87 | False, 88 | jsonKeys, 89 | ) 90 | 91 | def travel_forward( 92 | self, id, params: TravelForwardParams = None, headers=None 93 | ) -> TravelForwardResponse: 94 | jsonKeys = {} 95 | return request.send( 96 | "post", 97 | request.uri_path("time_machines", id, "travel_forward"), 98 | self.env, 99 | cast(Dict[Any, Any], params), 100 | headers, 101 | TravelForwardResponse, 102 | None, 103 | False, 104 | jsonKeys, 105 | ) 106 | -------------------------------------------------------------------------------- /chargebee/models/time_machine/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | from chargebee.response import Response 5 | 6 | 7 | @dataclass 8 | class TimeMachineResponse(Model): 9 | raw_data: Dict[Any, Any] = None 10 | name: str = None 11 | time_travel_status: str = None 12 | genesis_time: int = None 13 | destination_time: int = None 14 | failure_code: str = None 15 | failure_reason: str = None 16 | error_json: str = None 17 | 18 | 19 | @dataclass 20 | class RetrieveResponse(Response): 21 | 22 | time_machine: TimeMachineResponse 23 | 24 | 25 | @dataclass 26 | class StartAfreshResponse(Response): 27 | is_idempotency_replayed: bool 28 | time_machine: TimeMachineResponse 29 | 30 | 31 | @dataclass 32 | class TravelForwardResponse(Response): 33 | is_idempotency_replayed: bool 34 | time_machine: TimeMachineResponse 35 | -------------------------------------------------------------------------------- /chargebee/models/token/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import Token 2 | from .responses import TokenResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/token/operations.py: -------------------------------------------------------------------------------- 1 | from .responses import * 2 | from chargebee import request, environment 3 | from typing import TypedDict, Required, NotRequired, Dict, List, Any, cast 4 | from enum import Enum 5 | 6 | 7 | @dataclass 8 | class Token: 9 | 10 | env: environment.Environment 11 | 12 | class Status(Enum): 13 | NEW = "new" 14 | EXPIRED = "expired" 15 | CONSUMED = "consumed" 16 | 17 | def __str__(self): 18 | return self.value 19 | 20 | class Vault(Enum): 21 | SPREEDLY = "spreedly" 22 | GATEWAY = "gateway" 23 | 24 | def __str__(self): 25 | return self.value 26 | 27 | pass 28 | -------------------------------------------------------------------------------- /chargebee/models/token/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | 5 | 6 | @dataclass 7 | class TokenResponse(Model): 8 | raw_data: Dict[Any, Any] = None 9 | id: str = None 10 | gateway: str = None 11 | gateway_account_id: str = None 12 | payment_method_type: str = None 13 | status: str = None 14 | id_at_vault: str = None 15 | vault: str = None 16 | ip_address: str = None 17 | resource_version: int = None 18 | updated_at: int = None 19 | created_at: int = None 20 | expired_at: int = None 21 | -------------------------------------------------------------------------------- /chargebee/models/transaction/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import Transaction 2 | from .responses import TransactionResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/unbilled_charge/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import UnbilledCharge 2 | from .responses import UnbilledChargeResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/unbilled_charge/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | from chargebee.response import Response 5 | from chargebee.models import estimate, invoice 6 | 7 | 8 | @dataclass 9 | class TierResponse(Model): 10 | raw_data: Dict[Any, Any] = None 11 | starting_unit: int = None 12 | ending_unit: int = None 13 | quantity_used: int = None 14 | unit_amount: int = None 15 | starting_unit_in_decimal: str = None 16 | ending_unit_in_decimal: str = None 17 | quantity_used_in_decimal: str = None 18 | unit_amount_in_decimal: str = None 19 | pricing_type: str = None 20 | package_size: int = None 21 | 22 | 23 | @dataclass 24 | class UnbilledChargeResponse(Model): 25 | raw_data: Dict[Any, Any] = None 26 | id: str = None 27 | customer_id: str = None 28 | subscription_id: str = None 29 | date_from: int = None 30 | date_to: int = None 31 | unit_amount: int = None 32 | pricing_model: str = None 33 | quantity: int = None 34 | amount: int = None 35 | currency_code: str = None 36 | discount_amount: int = None 37 | description: str = None 38 | entity_type: str = None 39 | entity_id: str = None 40 | is_voided: bool = None 41 | voided_at: int = None 42 | unit_amount_in_decimal: str = None 43 | quantity_in_decimal: str = None 44 | amount_in_decimal: str = None 45 | updated_at: int = None 46 | tiers: List[TierResponse] = None 47 | is_advance_charge: bool = None 48 | business_entity_id: str = None 49 | deleted: bool = None 50 | 51 | 52 | @dataclass 53 | class CreateUnbilledChargeResponse(Response): 54 | is_idempotency_replayed: bool 55 | unbilled_charges: List[UnbilledChargeResponse] 56 | 57 | 58 | @dataclass 59 | class CreateResponse(Response): 60 | is_idempotency_replayed: bool 61 | unbilled_charges: List[UnbilledChargeResponse] 62 | 63 | 64 | @dataclass 65 | class InvoiceUnbilledChargesResponse(Response): 66 | is_idempotency_replayed: bool 67 | invoices: List["invoice.InvoiceResponse"] 68 | 69 | 70 | @dataclass 71 | class DeleteResponse(Response): 72 | is_idempotency_replayed: bool 73 | unbilled_charge: UnbilledChargeResponse 74 | 75 | 76 | @dataclass 77 | class ListUnbilledChargeResponse: 78 | unbilled_charge: UnbilledChargeResponse 79 | 80 | 81 | @dataclass 82 | class ListResponse(Response): 83 | 84 | list: List[ListUnbilledChargeResponse] 85 | next_offset: str = None 86 | 87 | 88 | @dataclass 89 | class InvoiceNowEstimateResponse(Response): 90 | is_idempotency_replayed: bool 91 | estimate: "estimate.EstimateResponse" 92 | -------------------------------------------------------------------------------- /chargebee/models/usage/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import Usage 2 | from .responses import UsageResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/usage/operations.py: -------------------------------------------------------------------------------- 1 | from .responses import * 2 | from chargebee import request, environment 3 | from typing import TypedDict, Required, NotRequired, Dict, List, Any, cast 4 | from chargebee.filters import Filters 5 | from chargebee.models import enums 6 | 7 | 8 | @dataclass 9 | class Usage: 10 | 11 | env: environment.Environment 12 | 13 | class PdfInvoiceParams(TypedDict): 14 | id: Required[str] 15 | 16 | class CreateParams(TypedDict): 17 | id: NotRequired[str] 18 | item_price_id: Required[str] 19 | quantity: Required[str] 20 | usage_date: Required[int] 21 | dedupe_option: NotRequired[enums.DedupeOption] 22 | note: NotRequired[str] 23 | 24 | class RetrieveParams(TypedDict): 25 | id: Required[str] 26 | 27 | class DeleteParams(TypedDict): 28 | id: Required[str] 29 | 30 | class ListParams(TypedDict): 31 | limit: NotRequired[int] 32 | offset: NotRequired[str] 33 | id: NotRequired[Filters.StringFilter] 34 | subscription_id: NotRequired[Filters.StringFilter] 35 | usage_date: NotRequired[Filters.TimestampFilter] 36 | updated_at: NotRequired[Filters.TimestampFilter] 37 | item_price_id: NotRequired[Filters.StringFilter] 38 | invoice_id: NotRequired[Filters.StringFilter] 39 | source: NotRequired[Filters.EnumFilter] 40 | sort_by: NotRequired[Filters.SortFilter] 41 | 42 | class PdfParams(TypedDict): 43 | invoice: Required["Usage.PdfInvoiceParams"] 44 | disposition_type: NotRequired[enums.DispositionType] 45 | 46 | def create(self, id, params: CreateParams, headers=None) -> CreateResponse: 47 | jsonKeys = {} 48 | return request.send( 49 | "post", 50 | request.uri_path("subscriptions", id, "usages"), 51 | self.env, 52 | cast(Dict[Any, Any], params), 53 | headers, 54 | CreateResponse, 55 | None, 56 | False, 57 | jsonKeys, 58 | ) 59 | 60 | def retrieve(self, id, params: RetrieveParams, headers=None) -> RetrieveResponse: 61 | jsonKeys = {} 62 | return request.send( 63 | "get", 64 | request.uri_path("subscriptions", id, "usages"), 65 | self.env, 66 | cast(Dict[Any, Any], params), 67 | headers, 68 | RetrieveResponse, 69 | None, 70 | False, 71 | jsonKeys, 72 | ) 73 | 74 | def delete(self, id, params: DeleteParams, headers=None) -> DeleteResponse: 75 | jsonKeys = {} 76 | return request.send( 77 | "post", 78 | request.uri_path("subscriptions", id, "delete_usage"), 79 | self.env, 80 | cast(Dict[Any, Any], params), 81 | headers, 82 | DeleteResponse, 83 | None, 84 | False, 85 | jsonKeys, 86 | ) 87 | 88 | def list(self, params: ListParams = None, headers=None) -> ListResponse: 89 | jsonKeys = {} 90 | return request.send_list_request( 91 | "get", 92 | request.uri_path("usages"), 93 | self.env, 94 | cast(Dict[Any, Any], params), 95 | headers, 96 | ListResponse, 97 | None, 98 | False, 99 | jsonKeys, 100 | ) 101 | 102 | def pdf(self, params: PdfParams, headers=None) -> PdfResponse: 103 | jsonKeys = {} 104 | return request.send( 105 | "post", 106 | request.uri_path("usages", "pdf"), 107 | self.env, 108 | cast(Dict[Any, Any], params), 109 | headers, 110 | PdfResponse, 111 | None, 112 | False, 113 | jsonKeys, 114 | ) 115 | -------------------------------------------------------------------------------- /chargebee/models/usage/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | from chargebee.response import Response 5 | from chargebee.models import download 6 | 7 | 8 | @dataclass 9 | class UsageResponse(Model): 10 | raw_data: Dict[Any, Any] = None 11 | id: str = None 12 | usage_date: int = None 13 | subscription_id: str = None 14 | item_price_id: str = None 15 | invoice_id: str = None 16 | line_item_id: str = None 17 | quantity: str = None 18 | source: str = None 19 | note: str = None 20 | resource_version: int = None 21 | updated_at: int = None 22 | created_at: int = None 23 | 24 | 25 | @dataclass 26 | class CreateResponse(Response): 27 | is_idempotency_replayed: bool 28 | usage: UsageResponse 29 | 30 | 31 | @dataclass 32 | class RetrieveResponse(Response): 33 | 34 | usage: UsageResponse 35 | 36 | 37 | @dataclass 38 | class DeleteResponse(Response): 39 | is_idempotency_replayed: bool 40 | usage: UsageResponse 41 | 42 | 43 | @dataclass 44 | class ListUsageResponse: 45 | usage: UsageResponse 46 | 47 | 48 | @dataclass 49 | class ListResponse(Response): 50 | 51 | list: List[ListUsageResponse] 52 | next_offset: str = None 53 | 54 | 55 | @dataclass 56 | class PdfResponse(Response): 57 | is_idempotency_replayed: bool 58 | download: "download.DownloadResponse" 59 | -------------------------------------------------------------------------------- /chargebee/models/usage_event/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import UsageEvent 2 | from .responses import UsageEventResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/usage_event/operations.py: -------------------------------------------------------------------------------- 1 | from .responses import * 2 | from chargebee import request, environment 3 | from typing import TypedDict, Required, NotRequired, Dict, List, Any, cast 4 | 5 | 6 | @dataclass 7 | class UsageEvent: 8 | 9 | env: environment.Environment 10 | 11 | class BatchIngestEventParams(TypedDict): 12 | deduplication_id: Required[str] 13 | subscription_id: Required[str] 14 | usage_timestamp: Required[int] 15 | properties: Required[Dict[Any, Any]] 16 | 17 | class CreateParams(TypedDict): 18 | deduplication_id: Required[str] 19 | subscription_id: Required[str] 20 | usage_timestamp: Required[int] 21 | properties: Required[Dict[Any, Any]] 22 | 23 | class BatchIngestParams(TypedDict): 24 | events: Required[List["UsageEvent.BatchIngestEventParams"]] 25 | 26 | def create(self, params: CreateParams, headers=None) -> CreateResponse: 27 | jsonKeys = { 28 | "properties": 0, 29 | } 30 | return request.send( 31 | "post", 32 | request.uri_path("usage_events"), 33 | self.env, 34 | cast(Dict[Any, Any], params), 35 | headers, 36 | CreateResponse, 37 | "ingest", 38 | True, 39 | jsonKeys, 40 | ) 41 | 42 | def batch_ingest( 43 | self, params: BatchIngestParams, headers=None 44 | ) -> BatchIngestResponse: 45 | jsonKeys = { 46 | "properties": 1, 47 | } 48 | return request.send( 49 | "post", 50 | request.uri_path("batch", "usage_events"), 51 | self.env, 52 | cast(Dict[Any, Any], params), 53 | headers, 54 | BatchIngestResponse, 55 | "ingest", 56 | True, 57 | jsonKeys, 58 | ) 59 | -------------------------------------------------------------------------------- /chargebee/models/usage_event/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, Any 4 | from chargebee.response import Response 5 | 6 | 7 | @dataclass 8 | class UsageEventResponse(Model): 9 | raw_data: Dict[Any, Any] = None 10 | subscription_id: str = None 11 | deduplication_id: str = None 12 | usage_timestamp: int = None 13 | properties: Dict[Any, Any] = None 14 | 15 | 16 | @dataclass 17 | class CreateResponse(Response): 18 | is_idempotency_replayed: bool 19 | usage_event: UsageEventResponse 20 | 21 | 22 | @dataclass 23 | class BatchIngestResponse(Response): 24 | is_idempotency_replayed: bool 25 | batch_id: str 26 | failed_events: Any 27 | -------------------------------------------------------------------------------- /chargebee/models/usage_file/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import UsageFile 2 | from .responses import UsageFileResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/usage_file/operations.py: -------------------------------------------------------------------------------- 1 | from .responses import * 2 | from chargebee import request, environment 3 | from typing import TypedDict, Required, NotRequired, Dict, List, Any, cast 4 | from enum import Enum 5 | 6 | 7 | @dataclass 8 | class UsageFile: 9 | 10 | env: environment.Environment 11 | 12 | class Status(Enum): 13 | QUEUED = "queued" 14 | IMPORTED = "imported" 15 | PROCESSING = "processing" 16 | PROCESSED = "processed" 17 | FAILED = "failed" 18 | 19 | def __str__(self): 20 | return self.value 21 | 22 | class UploadDetail(TypedDict): 23 | url: Required[str] 24 | expires_at: Required[int] 25 | 26 | class UploadParams(TypedDict): 27 | file_name: Required[str] 28 | mime_type: Required[str] 29 | 30 | def upload(self, params: UploadParams, headers=None) -> UploadResponse: 31 | jsonKeys = {} 32 | return request.send( 33 | "post", 34 | request.uri_path("usage_files", "upload"), 35 | self.env, 36 | cast(Dict[Any, Any], params), 37 | headers, 38 | UploadResponse, 39 | "file-ingest", 40 | False, 41 | jsonKeys, 42 | ) 43 | 44 | def status(self, id, headers=None) -> StatusResponse: 45 | jsonKeys = {} 46 | return request.send( 47 | "get", 48 | request.uri_path("usage_files", id, "status"), 49 | self.env, 50 | None, 51 | headers, 52 | StatusResponse, 53 | "file-ingest", 54 | False, 55 | jsonKeys, 56 | ) 57 | -------------------------------------------------------------------------------- /chargebee/models/usage_file/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | from chargebee.response import Response 5 | 6 | 7 | @dataclass 8 | class UploadDetailResponse(Model): 9 | raw_data: Dict[Any, Any] = None 10 | url: str = None 11 | expires_at: int = None 12 | 13 | 14 | @dataclass 15 | class UsageFileResponse(Model): 16 | raw_data: Dict[Any, Any] = None 17 | id: str = None 18 | name: str = None 19 | mime_type: str = None 20 | error_code: str = None 21 | error_reason: str = None 22 | status: str = None 23 | total_records_count: int = None 24 | processed_records_count: int = None 25 | failed_records_count: int = None 26 | file_size_in_bytes: int = None 27 | processing_started_at: int = None 28 | processing_completed_at: int = None 29 | uploaded_by: str = None 30 | uploaded_at: int = None 31 | upload_details: UploadDetailResponse = None 32 | 33 | 34 | @dataclass 35 | class UploadResponse(Response): 36 | is_idempotency_replayed: bool 37 | usage_file: UsageFileResponse 38 | 39 | 40 | @dataclass 41 | class StatusResponse(Response): 42 | 43 | usage_file: UsageFileResponse 44 | -------------------------------------------------------------------------------- /chargebee/models/virtual_bank_account/__init__.py: -------------------------------------------------------------------------------- 1 | from .operations import VirtualBankAccount 2 | from .responses import VirtualBankAccountResponse 3 | -------------------------------------------------------------------------------- /chargebee/models/virtual_bank_account/responses.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from chargebee.model import Model 3 | from typing import Dict, List, Any 4 | from chargebee.response import Response 5 | from chargebee.models import customer, transaction 6 | 7 | 8 | @dataclass 9 | class VirtualBankAccountResponse(Model): 10 | raw_data: Dict[Any, Any] = None 11 | id: str = None 12 | customer_id: str = None 13 | email: str = None 14 | scheme: str = None 15 | bank_name: str = None 16 | account_number: str = None 17 | routing_number: str = None 18 | swift_code: str = None 19 | gateway: str = None 20 | gateway_account_id: str = None 21 | resource_version: int = None 22 | updated_at: int = None 23 | created_at: int = None 24 | reference_id: str = None 25 | deleted: bool = None 26 | 27 | 28 | @dataclass 29 | class CreateUsingPermanentTokenResponse(Response): 30 | is_idempotency_replayed: bool 31 | virtual_bank_account: VirtualBankAccountResponse 32 | customer: "customer.CustomerResponse" = None 33 | 34 | 35 | @dataclass 36 | class CreateResponse(Response): 37 | is_idempotency_replayed: bool 38 | virtual_bank_account: VirtualBankAccountResponse 39 | customer: "customer.CustomerResponse" = None 40 | 41 | 42 | @dataclass 43 | class RetrieveResponse(Response): 44 | 45 | virtual_bank_account: VirtualBankAccountResponse 46 | 47 | 48 | @dataclass 49 | class ListVirtualBankAccountResponse: 50 | virtual_bank_account: VirtualBankAccountResponse 51 | 52 | 53 | @dataclass 54 | class ListResponse(Response): 55 | 56 | list: List[ListVirtualBankAccountResponse] 57 | next_offset: str = None 58 | 59 | 60 | @dataclass 61 | class DeleteResponse(Response): 62 | is_idempotency_replayed: bool 63 | virtual_bank_account: VirtualBankAccountResponse 64 | 65 | 66 | @dataclass 67 | class DeleteLocalResponse(Response): 68 | is_idempotency_replayed: bool 69 | virtual_bank_account: VirtualBankAccountResponse 70 | -------------------------------------------------------------------------------- /chargebee/request.py: -------------------------------------------------------------------------------- 1 | import json 2 | import urllib 3 | 4 | from chargebee import compat 5 | from chargebee import util, http_request 6 | 7 | 8 | def lowercase_keys(data): 9 | if isinstance(data, dict): 10 | return {k.lower(): lowercase_keys(v) for k, v in data.items()} 11 | elif isinstance(data, list): 12 | return [lowercase_keys(item) for item in data] 13 | else: 14 | return data 15 | 16 | 17 | def send_list_request( 18 | method, 19 | url, 20 | env=None, 21 | params=None, 22 | headers=None, 23 | response_type=None, 24 | subDomain=None, 25 | isJsonRequest=False, 26 | jsonKeys=None, 27 | ): 28 | serialized = {} 29 | 30 | if params is None: 31 | params = {} 32 | 33 | for k, v in list(params.items()): 34 | if isinstance(v, list): 35 | v = json.dumps(v) 36 | serialized.update({k: v}) 37 | return send( 38 | method, 39 | url, 40 | env, 41 | serialized, 42 | headers, 43 | response_type, 44 | subDomain, 45 | isJsonRequest, 46 | jsonKeys, 47 | ) 48 | 49 | 50 | def send( 51 | method, 52 | url, 53 | env, 54 | params=None, 55 | headers=None, 56 | response_type=None, 57 | subDomain=None, 58 | isJsonRequest=False, 59 | jsonKeys=None, 60 | ): 61 | params = lowercase_keys(params) 62 | 63 | if params is None: 64 | params = {} 65 | 66 | ser_params = ( 67 | json.dumps(params) 68 | if isJsonRequest 69 | else util.serialize(params, None, None, jsonKeys) 70 | ) 71 | 72 | response, response_headers, http_code = http_request.request( 73 | method, url, env, ser_params, headers, subDomain, isJsonRequest 74 | ) 75 | 76 | from chargebee.responses import Response 77 | 78 | if "list" in response: 79 | return Response( 80 | response_type, response, response_headers, http_code 81 | ).parse_list_response() 82 | return Response( 83 | response_type, response, response_headers, http_code 84 | ).parse_response() 85 | 86 | 87 | def uri_path(*paths): 88 | url = "" 89 | for path in paths: 90 | if path is None or len(str(path).strip()) < 1: 91 | raise Exception("Id is None or empty") 92 | if compat.py_major_v >= 3: 93 | url = url + "/" + urllib.parse.quote(str(path).strip()) 94 | else: 95 | url = url + "/" + urllib.quote(str(util.get_val(path))) 96 | return url 97 | -------------------------------------------------------------------------------- /chargebee/response.py: -------------------------------------------------------------------------------- 1 | from dataclasses import dataclass 2 | from typing import Dict 3 | 4 | 5 | @dataclass 6 | class Response: 7 | http_status_code: int 8 | headers: Dict[str, str] 9 | -------------------------------------------------------------------------------- /chargebee/util.py: -------------------------------------------------------------------------------- 1 | from chargebee import compat 2 | from collections import OrderedDict 3 | from enum import Enum 4 | 5 | 6 | def serialize(value, prefix=None, idx=None, jsonKeys=None, level=0): 7 | if level is None: 8 | level = 0 9 | 10 | if jsonKeys is None: 11 | jsonKeys = {} 12 | 13 | serialized = OrderedDict() 14 | 15 | if isinstance(value, dict): 16 | for k, v in list(value.items()): 17 | should_json_encode = k in jsonKeys and jsonKeys[k] == level 18 | if should_json_encode: 19 | key = f"{prefix or ''}{f'[{k}]' if prefix else k}{f'[{idx}]' if idx is not None else ''}" 20 | serialized.update({key: v}) 21 | elif k in ("in", "not_in", "between") and isinstance(v, list): 22 | v = [str(i) for i in v] 23 | key = "".join( 24 | [ 25 | prefix or "", 26 | "[%s]" % k if prefix is not None else k, 27 | "[%s]" % idx if idx is not None else "", 28 | ] 29 | ) 30 | serialized.update({key: str(v)}) 31 | elif isinstance(v, (dict, list, tuple)): 32 | temp_prefix = f"{prefix}[{k}]" if prefix is not None else k 33 | serialized.update(serialize(v, temp_prefix, None, jsonKeys, level + 1)) 34 | else: 35 | if isinstance(v, Enum): 36 | v = str(v) 37 | key = "".join( 38 | [ 39 | prefix or "", 40 | "[%s]" % k if prefix is not None else k, 41 | "[%s]" % idx if idx is not None else "", 42 | ] 43 | ) 44 | serialized.update({key: get_val(v)}) 45 | 46 | elif isinstance(value, (list, tuple)): 47 | for i, v in enumerate(value): 48 | serialized.update(serialize(v, prefix, i, jsonKeys, level)) 49 | 50 | else: 51 | if prefix is not None and idx is not None: 52 | key = prefix + "[" + str(idx) + "]" 53 | serialized.update({key: get_val(value)}) 54 | else: 55 | raise TypeError("only hash or arrays are allowed as value") 56 | 57 | return serialized 58 | 59 | 60 | def get_val(val): 61 | if val is None: 62 | return "" 63 | elif isinstance(val, bool): 64 | return str(val).lower() 65 | else: 66 | return val 67 | -------------------------------------------------------------------------------- /chargebee/version.py: -------------------------------------------------------------------------------- 1 | VERSION = "3.4.0" 2 | -------------------------------------------------------------------------------- /pyproject.toml: -------------------------------------------------------------------------------- 1 | [build-system] 2 | requires = ["setuptools>=66", "wheel", "requests>=2.29.0"] 3 | build-backend = "setuptools.build_meta" 4 | -------------------------------------------------------------------------------- /setup.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | from setuptools import setup, find_packages 4 | import sys 5 | import os 6 | 7 | sys.path.insert(0, os.path.join(os.path.dirname(__file__), "chargebee")) 8 | if sys.version_info < (3, 11): 9 | sys.exit("Sorry, Python < 3.11 is not supported") 10 | import version 11 | 12 | with open("README.md", "r") as file: 13 | description = file.read() 14 | 15 | requires = ["requests"] 16 | 17 | setup( 18 | name="chargebee", 19 | version=version.VERSION, 20 | author="Chargebee", 21 | author_email="dx@chargebee.com", 22 | url="https://apidocs.chargebee.com/docs/api?lang=python", 23 | description="Python wrapper for the Chargebee Subscription Billing API", 24 | packages=find_packages(exclude=["tests"]), 25 | package_data={"chargebee": ["ssl/*.crt"]}, 26 | python_requires=">=3.11", 27 | install_requires=requires, 28 | test_suite="tests", 29 | long_description=description, 30 | long_description_content_type="text/markdown", 31 | ) 32 | -------------------------------------------------------------------------------- /tests/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chargebee/chargebee-python/ef03e127d8e2b81fdec368650e326b0a2fc05044/tests/__init__.py -------------------------------------------------------------------------------- /tests/util.py: -------------------------------------------------------------------------------- 1 | import unittest 2 | 3 | from chargebee import util 4 | 5 | 6 | class UtilTest(unittest.TestCase): 7 | 8 | def test_serialize(self): 9 | before = { 10 | "id": "sub_KyVq7DNSNM7CSD", 11 | "plan_id": "free", 12 | "addons": ( 13 | { 14 | "id": "monitor", 15 | "quantity": 2, 16 | }, 17 | { 18 | "id": "ssl", 19 | }, 20 | ), 21 | "card": { 22 | "first_name": "Rajaraman", 23 | "last_name": "Santhanam", 24 | "number": "4111111111111111", 25 | "expiry_month": "1", 26 | "expiry_year": "2024", 27 | "cvv": "007", 28 | }, 29 | } 30 | 31 | after = { 32 | "id": "sub_KyVq7DNSNM7CSD", 33 | "plan_id": "free", 34 | "addons[id][0]": "monitor", 35 | "addons[quantity][0]": 2, 36 | "addons[id][1]": "ssl", 37 | "card[first_name]": "Rajaraman", 38 | "card[last_name]": "Santhanam", 39 | "card[number]": "4111111111111111", 40 | "card[expiry_month]": "1", 41 | "card[expiry_year]": "2024", 42 | "card[cvv]": "007", 43 | } 44 | 45 | self.assertEqual(after, util.serialize(before)) 46 | --------------------------------------------------------------------------------