paid-python 0.5.0__py3-none-any.whl → 1.0.0a0__py3-none-any.whl

paid/plans/client.py

@@ -6,6 +6,8 @@ import typing
 from ..core.client_wrapper import AsyncClientWrapper, SyncClientWrapper
 from ..core.request_options import RequestOptions
 from ..types.plan import Plan
+from ..types.plan_group import PlanGroup
+from ..types.plan_with_features import PlanWithFeatures
 from ..types.usage_summaries_response import UsageSummariesResponse
 from .raw_client import AsyncRawPlansClient, RawPlansClient
 
@@ -127,6 +129,68 @@ class PlansClient:
         )
         return _response.data
 
+    def get_group_by_id(
+        self, plan_group_id: str, *, request_options: typing.Optional[RequestOptions] = None
+    ) -> PlanGroup:
+        """
+        Parameters
+        ----------
+        plan_group_id : str
+            The ID of the plan group
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        PlanGroup
+            Success response
+
+        Examples
+        --------
+        from paid import Paid
+
+        client = Paid(
+            token="YOUR_TOKEN",
+        )
+        client.plans.get_group_by_id(
+            plan_group_id="planGroupId",
+        )
+        """
+        _response = self._raw_client.get_group_by_id(plan_group_id, request_options=request_options)
+        return _response.data
+
+    def get_group_plans(
+        self, plan_group_id: str, *, request_options: typing.Optional[RequestOptions] = None
+    ) -> typing.List[PlanWithFeatures]:
+        """
+        Parameters
+        ----------
+        plan_group_id : str
+            The ID of the plan group
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        typing.List[PlanWithFeatures]
+            Success response
+
+        Examples
+        --------
+        from paid import Paid
+
+        client = Paid(
+            token="YOUR_TOKEN",
+        )
+        client.plans.get_group_plans(
+            plan_group_id="planGroupId",
+        )
+        """
+        _response = self._raw_client.get_group_plans(plan_group_id, request_options=request_options)
+        return _response.data
+
 
 class AsyncPlansClient:
     def __init__(self, *, client_wrapper: AsyncClientWrapper):
@@ -259,3 +323,81 @@ class AsyncPlansClient:
             request_options=request_options,
         )
         return _response.data
+
+    async def get_group_by_id(
+        self, plan_group_id: str, *, request_options: typing.Optional[RequestOptions] = None
+    ) -> PlanGroup:
+        """
+        Parameters
+        ----------
+        plan_group_id : str
+            The ID of the plan group
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        PlanGroup
+            Success response
+
+        Examples
+        --------
+        import asyncio
+
+        from paid import AsyncPaid
+
+        client = AsyncPaid(
+            token="YOUR_TOKEN",
+        )
+
+
+        async def main() -> None:
+            await client.plans.get_group_by_id(
+                plan_group_id="planGroupId",
+            )
+
+
+        asyncio.run(main())
+        """
+        _response = await self._raw_client.get_group_by_id(plan_group_id, request_options=request_options)
+        return _response.data
+
+    async def get_group_plans(
+        self, plan_group_id: str, *, request_options: typing.Optional[RequestOptions] = None
+    ) -> typing.List[PlanWithFeatures]:
+        """
+        Parameters
+        ----------
+        plan_group_id : str
+            The ID of the plan group
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        typing.List[PlanWithFeatures]
+            Success response
+
+        Examples
+        --------
+        import asyncio
+
+        from paid import AsyncPaid
+
+        client = AsyncPaid(
+            token="YOUR_TOKEN",
+        )
+
+
+        async def main() -> None:
+            await client.plans.get_group_plans(
+                plan_group_id="planGroupId",
+            )
+
+
+        asyncio.run(main())
+        """
+        _response = await self._raw_client.get_group_plans(plan_group_id, request_options=request_options)
+        return _response.data

paid/plans/raw_client.py

@@ -16,6 +16,8 @@ from ..errors.forbidden_error import ForbiddenError
 from ..errors.not_found_error import NotFoundError
 from ..types.error import Error
 from ..types.plan import Plan
+from ..types.plan_group import PlanGroup
+from ..types.plan_with_features import PlanWithFeatures
 from ..types.usage_summaries_response import UsageSummariesResponse
 
 
@@ -180,6 +182,124 @@ class RawPlansClient:
             raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
         raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
 
+    def get_group_by_id(
+        self, plan_group_id: str, *, request_options: typing.Optional[RequestOptions] = None
+    ) -> HttpResponse[PlanGroup]:
+        """
+        Parameters
+        ----------
+        plan_group_id : str
+            The ID of the plan group
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        HttpResponse[PlanGroup]
+            Success response
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            f"plans/planGroup/{jsonable_encoder(plan_group_id)}",
+            method="GET",
+            request_options=request_options,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    PlanGroup,
+                    parse_obj_as(
+                        type_=PlanGroup,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return HttpResponse(response=_response, data=_data)
+            if _response.status_code == 403:
+                raise ForbiddenError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        Error,
+                        parse_obj_as(
+                            type_=Error,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 404:
+                raise NotFoundError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        Error,
+                        parse_obj_as(
+                            type_=Error,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
+    def get_group_plans(
+        self, plan_group_id: str, *, request_options: typing.Optional[RequestOptions] = None
+    ) -> HttpResponse[typing.List[PlanWithFeatures]]:
+        """
+        Parameters
+        ----------
+        plan_group_id : str
+            The ID of the plan group
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        HttpResponse[typing.List[PlanWithFeatures]]
+            Success response
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            f"plans/planGroup/{jsonable_encoder(plan_group_id)}/plans",
+            method="GET",
+            request_options=request_options,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    typing.List[PlanWithFeatures],
+                    parse_obj_as(
+                        type_=typing.List[PlanWithFeatures],  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return HttpResponse(response=_response, data=_data)
+            if _response.status_code == 403:
+                raise ForbiddenError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        Error,
+                        parse_obj_as(
+                            type_=Error,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 404:
+                raise NotFoundError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        Error,
+                        parse_obj_as(
+                            type_=Error,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
 
 class AsyncRawPlansClient:
     def __init__(self, *, client_wrapper: AsyncClientWrapper):
@@ -343,3 +463,121 @@ class AsyncRawPlansClient:
         except JSONDecodeError:
             raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
         raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
+    async def get_group_by_id(
+        self, plan_group_id: str, *, request_options: typing.Optional[RequestOptions] = None
+    ) -> AsyncHttpResponse[PlanGroup]:
+        """
+        Parameters
+        ----------
+        plan_group_id : str
+            The ID of the plan group
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        AsyncHttpResponse[PlanGroup]
+            Success response
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            f"plans/planGroup/{jsonable_encoder(plan_group_id)}",
+            method="GET",
+            request_options=request_options,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    PlanGroup,
+                    parse_obj_as(
+                        type_=PlanGroup,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return AsyncHttpResponse(response=_response, data=_data)
+            if _response.status_code == 403:
+                raise ForbiddenError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        Error,
+                        parse_obj_as(
+                            type_=Error,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 404:
+                raise NotFoundError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        Error,
+                        parse_obj_as(
+                            type_=Error,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
+    async def get_group_plans(
+        self, plan_group_id: str, *, request_options: typing.Optional[RequestOptions] = None
+    ) -> AsyncHttpResponse[typing.List[PlanWithFeatures]]:
+        """
+        Parameters
+        ----------
+        plan_group_id : str
+            The ID of the plan group
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        AsyncHttpResponse[typing.List[PlanWithFeatures]]
+            Success response
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            f"plans/planGroup/{jsonable_encoder(plan_group_id)}/plans",
+            method="GET",
+            request_options=request_options,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    typing.List[PlanWithFeatures],
+                    parse_obj_as(
+                        type_=typing.List[PlanWithFeatures],  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return AsyncHttpResponse(response=_response, data=_data)
+            if _response.status_code == 403:
+                raise ForbiddenError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        Error,
+                        parse_obj_as(
+                            type_=Error,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 404:
+                raise NotFoundError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        Error,
+                        parse_obj_as(
+                            type_=Error,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)

paid/types/__init__.py

@@ -10,8 +10,10 @@ from .agent_price_point_tiers import AgentPricePointTiers
 from .agent_update import AgentUpdate
 from .api_error import ApiError
 from .billing_frequency import BillingFrequency
+from .cancel_renewal_response import CancelRenewalResponse
 from .charge_type import ChargeType
 from .contact import Contact
+from .contact_create_for_customer import ContactCreateForCustomer
 from .cost_amount import CostAmount
 from .cost_trace import CostTrace
 from .cost_traces_response import CostTracesResponse
@@ -21,6 +23,8 @@ from .customer import Customer
 from .customer_update import CustomerUpdate
 from .entitlement_usage import EntitlementUsage
 from .error import Error
+from .invoice import Invoice
+from .invoice_status import InvoiceStatus
 from .order import Order
 from .order_line import OrderLine
 from .order_line_attribute import OrderLineAttribute
@@ -28,9 +32,17 @@ from .order_line_attribute_create_one import OrderLineAttributeCreateOne
 from .order_line_attribute_pricing import OrderLineAttributePricing
 from .order_line_create import OrderLineCreate
 from .pagination_meta import PaginationMeta
+from .payment_method import PaymentMethod
+from .payment_method_card import PaymentMethodCard
+from .payment_method_type import PaymentMethodType
+from .payment_method_us_bank_account import PaymentMethodUsBankAccount
+from .payment_method_us_bank_account_account_type import PaymentMethodUsBankAccountAccountType
 from .plan import Plan
+from .plan_group import PlanGroup
 from .plan_plan_products_item import PlanPlanProductsItem
 from .plan_plan_products_item_plan_product_attribute_item import PlanPlanProductsItemPlanProductAttributeItem
+from .plan_with_features import PlanWithFeatures
+from .plan_with_features_features_item import PlanWithFeaturesFeaturesItem
 from .price_point import PricePoint
 from .pricing import Pricing
 from .pricing_model_type import PricingModelType
@@ -38,6 +50,9 @@ from .product import Product
 from .product_type import ProductType
 from .product_update import ProductUpdate
 from .product_update_type import ProductUpdateType
+from .proration_attribute_update import ProrationAttributeUpdate
+from .proration_detail import ProrationDetail
+from .proration_upgrade_response import ProrationUpgradeResponse
 from .salutation import Salutation
 from .signal import Signal
 from .signal_v_2 import SignalV2
@@ -60,8 +75,10 @@ __all__ = [
     "AgentUpdate",
     "ApiError",
     "BillingFrequency",
+    "CancelRenewalResponse",
     "ChargeType",
     "Contact",
+    "ContactCreateForCustomer",
     "CostAmount",
     "CostTrace",
     "CostTracesResponse",
@@ -71,6 +88,8 @@ __all__ = [
     "CustomerUpdate",
     "EntitlementUsage",
     "Error",
+    "Invoice",
+    "InvoiceStatus",
     "Order",
     "OrderLine",
     "OrderLineAttribute",
@@ -78,9 +97,17 @@ __all__ = [
     "OrderLineAttributePricing",
     "OrderLineCreate",
     "PaginationMeta",
+    "PaymentMethod",
+    "PaymentMethodCard",
+    "PaymentMethodType",
+    "PaymentMethodUsBankAccount",
+    "PaymentMethodUsBankAccountAccountType",
     "Plan",
+    "PlanGroup",
     "PlanPlanProductsItem",
     "PlanPlanProductsItemPlanProductAttributeItem",
+    "PlanWithFeatures",
+    "PlanWithFeaturesFeaturesItem",
     "PricePoint",
     "Pricing",
     "PricingModelType",
@@ -88,6 +115,9 @@ __all__ = [
     "ProductType",
     "ProductUpdate",
     "ProductUpdateType",
+    "ProrationAttributeUpdate",
+    "ProrationDetail",
+    "ProrationUpgradeResponse",
     "Salutation",
     "Signal",
     "SignalV2",

paid/types/cancel_renewal_response.py

@@ -0,0 +1,49 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import datetime as dt
+import typing
+
+import pydantic
+import typing_extensions
+from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel
+from ..core.serialization import FieldMetadata
+
+
+class CancelRenewalResponse(UniversalBaseModel):
+    """
+    Response after successfully cancelling an order's renewal
+    """
+
+    order_id: typing_extensions.Annotated[str, FieldMetadata(alias="orderId")] = pydantic.Field()
+    """
+    The ID of the order
+    """
+
+    amendment_id: typing_extensions.Annotated[str, FieldMetadata(alias="amendmentId")] = pydantic.Field()
+    """
+    The ID of the amendment record
+    """
+
+    version: int = pydantic.Field()
+    """
+    The new version of the order after the amendment
+    """
+
+    end_date: typing_extensions.Annotated[dt.datetime, FieldMetadata(alias="endDate")] = pydantic.Field()
+    """
+    The new end date of the order
+    """
+
+    effective_date: typing_extensions.Annotated[dt.datetime, FieldMetadata(alias="effectiveDate")] = pydantic.Field()
+    """
+    The effective date of the cancellation
+    """
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

paid/types/contact_create_for_customer.py

@@ -0,0 +1,37 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+import pydantic
+import typing_extensions
+from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel
+from ..core.serialization import FieldMetadata
+from .salutation import Salutation
+
+
+class ContactCreateForCustomer(UniversalBaseModel):
+    external_id: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="externalId")] = None
+    salutation: Salutation
+    first_name: typing_extensions.Annotated[str, FieldMetadata(alias="firstName")]
+    last_name: typing_extensions.Annotated[str, FieldMetadata(alias="lastName")]
+    account_name: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="accountName")] = None
+    email: str
+    phone: typing.Optional[str] = None
+    billing_street: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="billingStreet")] = None
+    billing_city: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="billingCity")] = None
+    billing_state_province: typing_extensions.Annotated[
+        typing.Optional[str], FieldMetadata(alias="billingStateProvince")
+    ] = None
+    billing_country: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="billingCountry")] = None
+    billing_postal_code: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="billingPostalCode")] = (
+        None
+    )
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

paid/types/invoice.py

@@ -0,0 +1,75 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import datetime as dt
+import typing
+
+import pydantic
+import typing_extensions
+from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel
+from ..core.serialization import FieldMetadata
+from .customer import Customer
+from .invoice_status import InvoiceStatus
+
+
+class Invoice(UniversalBaseModel):
+    """
+    An invoice for an order
+    """
+
+    id: typing.Optional[str] = None
+    display_id: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="displayId")] = pydantic.Field(
+        default=None
+    )
+    """
+    Human-readable invoice number
+    """
+
+    organization_id: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="organizationId")] = None
+    customer_id: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="customerId")] = None
+    order_id: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="orderId")] = None
+    status: typing.Optional[InvoiceStatus] = None
+    currency: typing.Optional[str] = None
+    subtotal: typing.Optional[float] = pydantic.Field(default=None)
+    """
+    Total before tax (in smallest currency unit)
+    """
+
+    tax: typing.Optional[float] = pydantic.Field(default=None)
+    """
+    Tax amount (in smallest currency unit)
+    """
+
+    total: typing.Optional[float] = pydantic.Field(default=None)
+    """
+    Total amount including tax (in smallest currency unit)
+    """
+
+    amount_paid: typing_extensions.Annotated[typing.Optional[float], FieldMetadata(alias="amountPaid")] = (
+        pydantic.Field(default=None)
+    )
+    """
+    Amount already paid (in smallest currency unit)
+    """
+
+    amount_due: typing_extensions.Annotated[typing.Optional[float], FieldMetadata(alias="amountDue")] = pydantic.Field(
+        default=None
+    )
+    """
+    Amount still due (in smallest currency unit)
+    """
+
+    due_date: typing_extensions.Annotated[typing.Optional[dt.datetime], FieldMetadata(alias="dueDate")] = None
+    paid_at: typing_extensions.Annotated[typing.Optional[dt.datetime], FieldMetadata(alias="paidAt")] = None
+    voided_at: typing_extensions.Annotated[typing.Optional[dt.datetime], FieldMetadata(alias="voidedAt")] = None
+    created_at: typing_extensions.Annotated[typing.Optional[dt.datetime], FieldMetadata(alias="createdAt")] = None
+    updated_at: typing_extensions.Annotated[typing.Optional[dt.datetime], FieldMetadata(alias="updatedAt")] = None
+    customer: typing.Optional[Customer] = None
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

paid/types/invoice_status.py

@@ -0,0 +1,5 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+InvoiceStatus = typing.Union[typing.Literal["draft", "open", "paid", "void", "uncollectible"], typing.Any]