9088651600

Committed 15 May 2024 01:36AM UTC coverage: 96.387% (+0.01%) from 96.375%

Build # 9088651600

Build Type

Pull #1328

github

Committed by

web-flow

Commit Message

Merge 2da841cab into 46edbe3eb

Pull Request Pull Request #1328: Update generated code

Run Details

1288 of 1901 branches covered (67.75%)

Branch coverage included in aggregate %.

114 of 115 new or added lines in 16 files covered. (99.13%)

804 existing lines in 92 files now uncovered.

64320 of 66166 relevant lines covered (97.21%)

0.97 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

80.61

/stripe/_payment_method_domain.py

# -*- coding: utf-8 -*-
# File generated from our OpenAPI spec
from stripe._createable_api_resource import CreateableAPIResource
from stripe._list_object import ListObject
from stripe._listable_api_resource import ListableAPIResource
from stripe._request_options import RequestOptions
from stripe._stripe_object import StripeObject
from stripe._updateable_api_resource import UpdateableAPIResource
from stripe._util import class_method_variant, sanitize_id
from typing import ClassVar, List, Optional, cast, overload
from typing_extensions import Literal, NotRequired, Unpack


class PaymentMethodDomain(
    CreateableAPIResource["PaymentMethodDomain"],
    ListableAPIResource["PaymentMethodDomain"],
    UpdateableAPIResource["PaymentMethodDomain"],
):
    """
    A payment method domain represents a web domain that you have registered with Stripe.
    Stripe Elements use registered payment method domains to control where certain payment methods are shown.

    Related guides: [Payment method domains](https://stripe.com/docs/payments/payment-methods/pmd-registration).
    """

    OBJECT_NAME: ClassVar[Literal["payment_method_domain"]] = (
        "payment_method_domain"
    )

    class ApplePay(StripeObject):
        class StatusDetails(StripeObject):
            error_message: str
            """
            The error message associated with the status of the payment method on the domain.
            """

        status: Literal["active", "inactive"]
        """
        The status of the payment method on the domain.
        """
        status_details: Optional[StatusDetails]
        """
        Contains additional details about the status of a payment method for a specific payment method domain.
        """
        _inner_class_types = {"status_details": StatusDetails}

    class GooglePay(StripeObject):
        class StatusDetails(StripeObject):
            error_message: str
            """
            The error message associated with the status of the payment method on the domain.
            """

        status: Literal["active", "inactive"]
        """
        The status of the payment method on the domain.
        """
        status_details: Optional[StatusDetails]
        """
        Contains additional details about the status of a payment method for a specific payment method domain.
        """
        _inner_class_types = {"status_details": StatusDetails}

    class Link(StripeObject):
        class StatusDetails(StripeObject):
            error_message: str
            """
            The error message associated with the status of the payment method on the domain.
            """

        status: Literal["active", "inactive"]
        """
        The status of the payment method on the domain.
        """
        status_details: Optional[StatusDetails]
        """
        Contains additional details about the status of a payment method for a specific payment method domain.
        """
        _inner_class_types = {"status_details": StatusDetails}

    class Paypal(StripeObject):
        class StatusDetails(StripeObject):
            error_message: str
            """
            The error message associated with the status of the payment method on the domain.
            """

        status: Literal["active", "inactive"]
        """
        The status of the payment method on the domain.
        """
        status_details: Optional[StatusDetails]
        """
        Contains additional details about the status of a payment method for a specific payment method domain.
        """
        _inner_class_types = {"status_details": StatusDetails}

    class CreateParams(RequestOptions):
        domain_name: str
        """
        The domain name that this payment method domain object represents.
        """
        enabled: NotRequired[bool]
        """
        Whether this payment method domain is enabled. If the domain is not enabled, payment methods that require a payment method domain will not appear in Elements.
        """
        expand: NotRequired[List[str]]
        """
        Specifies which fields in the response should be expanded.
        """

    class ListParams(RequestOptions):
        domain_name: NotRequired[str]
        """
        The domain name that this payment method domain object represents.
        """
        enabled: NotRequired[bool]
        """
        Whether this payment method domain is enabled. If the domain is not enabled, payment methods will not appear in Elements
        """
        ending_before: NotRequired[str]
        """
        A cursor for use in pagination. `ending_before` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, starting with `obj_bar`, your subsequent call can include `ending_before=obj_bar` in order to fetch the previous page of the list.
        """
        expand: NotRequired[List[str]]
        """
        Specifies which fields in the response should be expanded.
        """
        limit: NotRequired[int]
        """
        A limit on the number of objects to be returned. Limit can range between 1 and 100, and the default is 10.
        """
        starting_after: NotRequired[str]
        """
        A cursor for use in pagination. `starting_after` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, ending with `obj_foo`, your subsequent call can include `starting_after=obj_foo` in order to fetch the next page of the list.
        """

    class ModifyParams(RequestOptions):
        enabled: NotRequired[bool]
        """
        Whether this payment method domain is enabled. If the domain is not enabled, payment methods that require a payment method domain will not appear in Elements.
        """
        expand: NotRequired[List[str]]
        """
        Specifies which fields in the response should be expanded.
        """

    class RetrieveParams(RequestOptions):
        expand: NotRequired[List[str]]
        """
        Specifies which fields in the response should be expanded.
        """

    class ValidateParams(RequestOptions):
        expand: NotRequired[List[str]]
        """
        Specifies which fields in the response should be expanded.
        """

    apple_pay: ApplePay
    """
    Indicates the status of a specific payment method on a payment method domain.
    """
    created: int
    """
    Time at which the object was created. Measured in seconds since the Unix epoch.
    """
    domain_name: str
    """
    The domain name that this payment method domain object represents.
    """
    enabled: bool
    """
    Whether this payment method domain is enabled. If the domain is not enabled, payment methods that require a payment method domain will not appear in Elements.
    """
    google_pay: GooglePay
    """
    Indicates the status of a specific payment method on a payment method domain.
    """
    id: str
    """
    Unique identifier for the object.
    """
    link: Link
    """
    Indicates the status of a specific payment method on a payment method domain.
    """
    livemode: bool
    """
    Has the value `true` if the object exists in live mode or the value `false` if the object exists in test mode.
    """
    object: Literal["payment_method_domain"]
    """
    String representing the object's type. Objects of the same type share the same value.
    """
    paypal: Paypal
    """
    Indicates the status of a specific payment method on a payment method domain.
    """

    @classmethod
    def create(
        cls, **params: Unpack["PaymentMethodDomain.CreateParams"]
    ) -> "PaymentMethodDomain":
        """
        Creates a payment method domain.
        """
        return cast(
            "PaymentMethodDomain",
            cls._static_request(
                "post",
                cls.class_url(),
                params=params,
            ),
        )

    @classmethod
    async def create_async(
        cls, **params: Unpack["PaymentMethodDomain.CreateParams"]
    ) -> "PaymentMethodDomain":
        """
        Creates a payment method domain.
        """
        return cast(
            "PaymentMethodDomain",
            await cls._static_request_async(
                "post",
                cls.class_url(),
                params=params,
            ),
        )

    @classmethod
    def list(
        cls, **params: Unpack["PaymentMethodDomain.ListParams"]
    ) -> ListObject["PaymentMethodDomain"]:
        """
        Lists the details of existing payment method domains.
        """
        result = cls._static_request(
            "get",
            cls.class_url(),
            params=params,
        )
        if not isinstance(result, ListObject):
            raise TypeError(
                "Expected list object from API, got %s"
                % (type(result).__name__)
            )

        return result

    @classmethod
    async def list_async(
        cls, **params: Unpack["PaymentMethodDomain.ListParams"]
    ) -> ListObject["PaymentMethodDomain"]:
        """
        Lists the details of existing payment method domains.
        """
        result = await cls._static_request_async(
            "get",
            cls.class_url(),
            params=params,
        )
        if not isinstance(result, ListObject):
            raise TypeError(
                "Expected list object from API, got %s"
                % (type(result).__name__)
            )

        return result

    @classmethod
    def modify(
        cls, id: str, **params: Unpack["PaymentMethodDomain.ModifyParams"]
    ) -> "PaymentMethodDomain":
        """
        Updates an existing payment method domain.
        """
        url = "%s/%s" % (cls.class_url(), sanitize_id(id))
        return cast(
            "PaymentMethodDomain",
            cls._static_request(
                "post",
                url,
                params=params,
            ),
        )

    @classmethod
    async def modify_async(
        cls, id: str, **params: Unpack["PaymentMethodDomain.ModifyParams"]
    ) -> "PaymentMethodDomain":
        """
        Updates an existing payment method domain.
        """
        url = "%s/%s" % (cls.class_url(), sanitize_id(id))
        return cast(
            "PaymentMethodDomain",
            await cls._static_request_async(
                "post",
                url,
                params=params,
            ),
        )

    @classmethod
    def retrieve(
        cls, id: str, **params: Unpack["PaymentMethodDomain.RetrieveParams"]
    ) -> "PaymentMethodDomain":
        """
        Retrieves the details of an existing payment method domain.
        """
        instance = cls(id, **params)
        instance.refresh()
        return instance

    @classmethod
    async def retrieve_async(
        cls, id: str, **params: Unpack["PaymentMethodDomain.RetrieveParams"]
    ) -> "PaymentMethodDomain":
        """
        Retrieves the details of an existing payment method domain.
        """
        instance = cls(id, **params)
        await instance.refresh_async()
        return instance

    @classmethod
    def _cls_validate(
        cls,
        payment_method_domain: str,
        **params: Unpack["PaymentMethodDomain.ValidateParams"],
    ) -> "PaymentMethodDomain":
        """
        Some payment methods such as Apple Pay require additional steps to verify a domain. If the requirements weren't satisfied when the domain was created, the payment method will be inactive on the domain.
        The payment method doesn't appear in Elements for this domain until it is active.

        To activate a payment method on an existing payment method domain, complete the required validation steps specific to the payment method, and then validate the payment method domain with this endpoint.

        Related guides: [Payment method domains](https://stripe.com/docs/payments/payment-methods/pmd-registration).
        """
        return cast(
            "PaymentMethodDomain",
            cls._static_request(
                "post",
                "/v1/payment_method_domains/{payment_method_domain}/validate".format(
                    payment_method_domain=sanitize_id(payment_method_domain)
                ),
                params=params,
            ),
        )

    @overload
    @staticmethod
    def validate(
        payment_method_domain: str,
        **params: Unpack["PaymentMethodDomain.ValidateParams"],
    ) -> "PaymentMethodDomain":
        """
        Some payment methods such as Apple Pay require additional steps to verify a domain. If the requirements weren't satisfied when the domain was created, the payment method will be inactive on the domain.
        The payment method doesn't appear in Elements for this domain until it is active.

        To activate a payment method on an existing payment method domain, complete the required validation steps specific to the payment method, and then validate the payment method domain with this endpoint.

        Related guides: [Payment method domains](https://stripe.com/docs/payments/payment-methods/pmd-registration).
        """
        ...

    @overload
    def validate(
        self, **params: Unpack["PaymentMethodDomain.ValidateParams"]
    ) -> "PaymentMethodDomain":
        """
        Some payment methods such as Apple Pay require additional steps to verify a domain. If the requirements weren't satisfied when the domain was created, the payment method will be inactive on the domain.
        The payment method doesn't appear in Elements for this domain until it is active.

        To activate a payment method on an existing payment method domain, complete the required validation steps specific to the payment method, and then validate the payment method domain with this endpoint.

        Related guides: [Payment method domains](https://stripe.com/docs/payments/payment-methods/pmd-registration).
        """
        ...

    @class_method_variant("_cls_validate")
    def validate(  # pyright: ignore[reportGeneralTypeIssues]
        self, **params: Unpack["PaymentMethodDomain.ValidateParams"]
    ) -> "PaymentMethodDomain":
        """
        Some payment methods such as Apple Pay require additional steps to verify a domain. If the requirements weren't satisfied when the domain was created, the payment method will be inactive on the domain.
        The payment method doesn't appear in Elements for this domain until it is active.

        To activate a payment method on an existing payment method domain, complete the required validation steps specific to the payment method, and then validate the payment method domain with this endpoint.

        Related guides: [Payment method domains](https://stripe.com/docs/payments/payment-methods/pmd-registration).
        """
        return cast(
            "PaymentMethodDomain",
            self._request(
                "post",
                "/v1/payment_method_domains/{payment_method_domain}/validate".format(
                    payment_method_domain=sanitize_id(self.get("id"))
                ),
                params=params,
            ),
        )

    @classmethod
    async def _cls_validate_async(
        cls,
        payment_method_domain: str,
        **params: Unpack["PaymentMethodDomain.ValidateParams"],
    ) -> "PaymentMethodDomain":
        """
        Some payment methods such as Apple Pay require additional steps to verify a domain. If the requirements weren't satisfied when the domain was created, the payment method will be inactive on the domain.
        The payment method doesn't appear in Elements for this domain until it is active.

        To activate a payment method on an existing payment method domain, complete the required validation steps specific to the payment method, and then validate the payment method domain with this endpoint.

        Related guides: [Payment method domains](https://stripe.com/docs/payments/payment-methods/pmd-registration).
        """
        return cast(
            "PaymentMethodDomain",
            await cls._static_request_async(
                "post",
                "/v1/payment_method_domains/{payment_method_domain}/validate".format(
                    payment_method_domain=sanitize_id(payment_method_domain)
                ),
                params=params,
            ),
        )

    @overload
    @staticmethod
    async def validate_async(
        payment_method_domain: str,
        **params: Unpack["PaymentMethodDomain.ValidateParams"],
    ) -> "PaymentMethodDomain":
        """
        Some payment methods such as Apple Pay require additional steps to verify a domain. If the requirements weren't satisfied when the domain was created, the payment method will be inactive on the domain.
        The payment method doesn't appear in Elements for this domain until it is active.

        To activate a payment method on an existing payment method domain, complete the required validation steps specific to the payment method, and then validate the payment method domain with this endpoint.

        Related guides: [Payment method domains](https://stripe.com/docs/payments/payment-methods/pmd-registration).
        """
        ...

    @overload
    async def validate_async(
        self, **params: Unpack["PaymentMethodDomain.ValidateParams"]
    ) -> "PaymentMethodDomain":
        """
        Some payment methods such as Apple Pay require additional steps to verify a domain. If the requirements weren't satisfied when the domain was created, the payment method will be inactive on the domain.
        The payment method doesn't appear in Elements for this domain until it is active.

        To activate a payment method on an existing payment method domain, complete the required validation steps specific to the payment method, and then validate the payment method domain with this endpoint.

        Related guides: [Payment method domains](https://stripe.com/docs/payments/payment-methods/pmd-registration).
        """
        ...

    @class_method_variant("_cls_validate_async")
    async def validate_async(  # pyright: ignore[reportGeneralTypeIssues]
        self, **params: Unpack["PaymentMethodDomain.ValidateParams"]
    ) -> "PaymentMethodDomain":
        """
        Some payment methods such as Apple Pay require additional steps to verify a domain. If the requirements weren't satisfied when the domain was created, the payment method will be inactive on the domain.
        The payment method doesn't appear in Elements for this domain until it is active.

        To activate a payment method on an existing payment method domain, complete the required validation steps specific to the payment method, and then validate the payment method domain with this endpoint.

        Related guides: [Payment method domains](https://stripe.com/docs/payments/payment-methods/pmd-registration).
        """
        return cast(
            "PaymentMethodDomain",
            await self._request_async(
                "post",
                "/v1/payment_method_domains/{payment_method_domain}/validate".format(
                    payment_method_domain=sanitize_id(self.get("id"))
                ),
                params=params,
            ),
        )

    _inner_class_types = {
        "apple_pay": ApplePay,
        "google_pay": GooglePay,
        "link": Link,
        "paypal": Paypal,
    }

1	# -- coding: utf-8 --
2	# File generated from our OpenAPI spec
3	from stripe._createable_api_resource import CreateableAPIResource	1✔
4	from stripe._list_object import ListObject	1✔
5	from stripe._listable_api_resource import ListableAPIResource	1✔
6	from stripe._request_options import RequestOptions	1✔
7	from stripe._stripe_object import StripeObject	1✔
8	from stripe._updateable_api_resource import UpdateableAPIResource	1✔
9	from stripe._util import class_method_variant, sanitize_id	1✔
10	from typing import ClassVar, List, Optional, cast, overload	1✔
11	from typing_extensions import Literal, NotRequired, Unpack	1✔
12
13
14	class PaymentMethodDomain(	1✔
15	CreateableAPIResource["PaymentMethodDomain"],
16	ListableAPIResource["PaymentMethodDomain"],
17	UpdateableAPIResource["PaymentMethodDomain"],
18	):
19	"""
20	A payment method domain represents a web domain that you have registered with Stripe.
21	Stripe Elements use registered payment method domains to control where certain payment methods are shown.
22
23	Related guides: [Payment method domains](https://stripe.com/docs/payments/payment-methods/pmd-registration).
24	"""
25
26	OBJECT_NAME: ClassVar[Literal["payment_method_domain"]] = (	1✔
27	"payment_method_domain"
28	)
29
30	class ApplePay(StripeObject):	1✔
31	class StatusDetails(StripeObject):	1✔
32	error_message: str	1✔
33	"""	1✔
34	The error message associated with the status of the payment method on the domain.
35	"""
36
37	status: Literal["active", "inactive"]	1✔
38	"""	1✔
39	The status of the payment method on the domain.
40	"""
41	status_details: Optional[StatusDetails]	1✔
42	"""	1✔
43	Contains additional details about the status of a payment method for a specific payment method domain.
44	"""
45	_inner_class_types = {"status_details": StatusDetails}	1✔
46
47	class GooglePay(StripeObject):	1✔
48	class StatusDetails(StripeObject):	1✔
49	error_message: str	1✔
50	"""	1✔
51	The error message associated with the status of the payment method on the domain.
52	"""
53
54	status: Literal["active", "inactive"]	1✔
55	"""	1✔
56	The status of the payment method on the domain.
57	"""
58	status_details: Optional[StatusDetails]	1✔
59	"""	1✔
60	Contains additional details about the status of a payment method for a specific payment method domain.
61	"""
62	_inner_class_types = {"status_details": StatusDetails}	1✔
63
64	class Link(StripeObject):	1✔
65	class StatusDetails(StripeObject):	1✔
66	error_message: str	1✔
67	"""	1✔
68	The error message associated with the status of the payment method on the domain.
69	"""
70
71	status: Literal["active", "inactive"]	1✔
72	"""	1✔
73	The status of the payment method on the domain.
74	"""
75	status_details: Optional[StatusDetails]	1✔
76	"""	1✔
77	Contains additional details about the status of a payment method for a specific payment method domain.
78	"""
79	_inner_class_types = {"status_details": StatusDetails}	1✔
80
81	class Paypal(StripeObject):	1✔
82	class StatusDetails(StripeObject):	1✔
83	error_message: str	1✔
84	"""	1✔
85	The error message associated with the status of the payment method on the domain.
86	"""
87
88	status: Literal["active", "inactive"]	1✔
89	"""	1✔
90	The status of the payment method on the domain.
91	"""
92	status_details: Optional[StatusDetails]	1✔
93	"""	1✔
94	Contains additional details about the status of a payment method for a specific payment method domain.
95	"""
96	_inner_class_types = {"status_details": StatusDetails}	1✔
97
98	class CreateParams(RequestOptions):	1✔
99	domain_name: str	1✔
100	"""	1✔
101	The domain name that this payment method domain object represents.
102	"""
103	enabled: NotRequired[bool]	1✔
104	"""	1✔
105	Whether this payment method domain is enabled. If the domain is not enabled, payment methods that require a payment method domain will not appear in Elements.
106	"""
107	expand: NotRequired[List[str]]	1✔
108	"""	1✔
109	Specifies which fields in the response should be expanded.
110	"""
111
112	class ListParams(RequestOptions):	1✔
113	domain_name: NotRequired[str]	1✔
114	"""	1✔
115	The domain name that this payment method domain object represents.
116	"""
117	enabled: NotRequired[bool]	1✔
118	"""	1✔
119	Whether this payment method domain is enabled. If the domain is not enabled, payment methods will not appear in Elements
120	"""
121	ending_before: NotRequired[str]	1✔
122	"""	1✔
123	A cursor for use in pagination. `ending_before` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, starting with `obj_bar`, your subsequent call can include `ending_before=obj_bar` in order to fetch the previous page of the list.
124	"""
125	expand: NotRequired[List[str]]	1✔
126	"""	1✔
127	Specifies which fields in the response should be expanded.
128	"""
129	limit: NotRequired[int]	1✔
130	"""	1✔
131	A limit on the number of objects to be returned. Limit can range between 1 and 100, and the default is 10.
132	"""
133	starting_after: NotRequired[str]	1✔
134	"""	1✔
135	A cursor for use in pagination. `starting_after` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, ending with `obj_foo`, your subsequent call can include `starting_after=obj_foo` in order to fetch the next page of the list.
136	"""
137
138	class ModifyParams(RequestOptions):	1✔
139	enabled: NotRequired[bool]	1✔
140	"""	1✔
141	Whether this payment method domain is enabled. If the domain is not enabled, payment methods that require a payment method domain will not appear in Elements.
142	"""
143	expand: NotRequired[List[str]]	1✔
144	"""	1✔
145	Specifies which fields in the response should be expanded.
146	"""
147
148	class RetrieveParams(RequestOptions):	1✔
149	expand: NotRequired[List[str]]	1✔
150	"""	1✔
151	Specifies which fields in the response should be expanded.
152	"""
153
154	class ValidateParams(RequestOptions):	1✔
155	expand: NotRequired[List[str]]	1✔
156	"""	1✔
157	Specifies which fields in the response should be expanded.
158	"""
159
160	apple_pay: ApplePay	1✔
161	"""	1✔
162	Indicates the status of a specific payment method on a payment method domain.
163	"""
164	created: int	1✔
165	"""	1✔
166	Time at which the object was created. Measured in seconds since the Unix epoch.
167	"""
168	domain_name: str	1✔
169	"""	1✔
170	The domain name that this payment method domain object represents.
171	"""
172	enabled: bool	1✔
173	"""	1✔
174	Whether this payment method domain is enabled. If the domain is not enabled, payment methods that require a payment method domain will not appear in Elements.
175	"""
176	google_pay: GooglePay	1✔
177	"""	1✔
178	Indicates the status of a specific payment method on a payment method domain.
179	"""
180	id: str	1✔
181	"""	1✔
182	Unique identifier for the object.
183	"""
184	link: Link	1✔
185	"""	1✔
186	Indicates the status of a specific payment method on a payment method domain.
187	"""
188	livemode: bool	1✔
189	"""	1✔
190	Has the value `true` if the object exists in live mode or the value `false` if the object exists in test mode.
191	"""
192	object: Literal["payment_method_domain"]	1✔
193	"""	1✔
194	String representing the object's type. Objects of the same type share the same value.
195	"""
196	paypal: Paypal	1✔
197	"""	1✔
198	Indicates the status of a specific payment method on a payment method domain.
199	"""
200
201	@classmethod	1✔
202	def create(	1✔
203	cls, **params: Unpack["PaymentMethodDomain.CreateParams"]
204	) -> "PaymentMethodDomain":
205	"""
206	Creates a payment method domain.
207	"""
208	return cast(	×
209	"PaymentMethodDomain",
210	cls._static_request(
211	"post",
212	cls.class_url(),
213	params=params,
214	),
215	)
216
217	@classmethod	1✔
218	async def create_async(	1✔
219	cls, **params: Unpack["PaymentMethodDomain.CreateParams"]
220	) -> "PaymentMethodDomain":
221	"""
222	Creates a payment method domain.
223	"""
224	return cast(	×
225	"PaymentMethodDomain",
226	await cls._static_request_async(
227	"post",
228	cls.class_url(),
229	params=params,
230	),
231	)
232
233	@classmethod	1✔
234	def list(	1✔
235	cls, **params: Unpack["PaymentMethodDomain.ListParams"]
236	) -> ListObject["PaymentMethodDomain"]:
237	"""
238	Lists the details of existing payment method domains.
239	"""
240	result = cls._static_request(	×
241	"get",
242	cls.class_url(),
243	params=params,
244	)
245	if not isinstance(result, ListObject):	×
UNCOV 246	raise TypeError(	×
247	"Expected list object from API, got %s"
248	% (type(result).__name__)
249	)
250
UNCOV 251	return result	×
252
253	@classmethod	1✔
254	async def list_async(	1✔
255	cls, **params: Unpack["PaymentMethodDomain.ListParams"]
256	) -> ListObject["PaymentMethodDomain"]:
257	"""
258	Lists the details of existing payment method domains.
259	"""
UNCOV 260	result = await cls._static_request_async(	×
261	"get",
262	cls.class_url(),
263	params=params,
264	)
UNCOV 265	if not isinstance(result, ListObject):	×
266	raise TypeError(	×
267	"Expected list object from API, got %s"
268	% (type(result).__name__)
269	)
270
UNCOV 271	return result	×
272
273	@classmethod	1✔
274	def modify(	1✔
275	cls, id: str, **params: Unpack["PaymentMethodDomain.ModifyParams"]
276	) -> "PaymentMethodDomain":
277	"""
278	Updates an existing payment method domain.
279	"""
UNCOV 280	url = "%s/%s" % (cls.class_url(), sanitize_id(id))	×
UNCOV 281	return cast(	×
282	"PaymentMethodDomain",
283	cls._static_request(
284	"post",
285	url,
286	params=params,
287	),
288	)
289
290	@classmethod	1✔
291	async def modify_async(	1✔
292	cls, id: str, **params: Unpack["PaymentMethodDomain.ModifyParams"]
293	) -> "PaymentMethodDomain":
294	"""
295	Updates an existing payment method domain.
296	"""
UNCOV 297	url = "%s/%s" % (cls.class_url(), sanitize_id(id))	×
UNCOV 298	return cast(	×
299	"PaymentMethodDomain",
300	await cls._static_request_async(
301	"post",
302	url,
303	params=params,
304	),
305	)
306
307	@classmethod	1✔
308	def retrieve(	1✔
309	cls, id: str, **params: Unpack["PaymentMethodDomain.RetrieveParams"]
310	) -> "PaymentMethodDomain":
311	"""
312	Retrieves the details of an existing payment method domain.
313	"""
UNCOV 314	instance = cls(id, **params)	×
UNCOV 315	instance.refresh()	×
316	return instance	×
317
318	@classmethod	1✔
319	async def retrieve_async(	1✔
320	cls, id: str, **params: Unpack["PaymentMethodDomain.RetrieveParams"]
321	) -> "PaymentMethodDomain":
322	"""
323	Retrieves the details of an existing payment method domain.
324	"""
UNCOV 325	instance = cls(id, **params)	×
UNCOV 326	await instance.refresh_async()	×
327	return instance	×
328
329	@classmethod	1✔
330	def _cls_validate(	1✔
331	cls,
332	payment_method_domain: str,
333	**params: Unpack["PaymentMethodDomain.ValidateParams"],
334	) -> "PaymentMethodDomain":
335	"""
336	Some payment methods such as Apple Pay require additional steps to verify a domain. If the requirements weren't satisfied when the domain was created, the payment method will be inactive on the domain.
337	The payment method doesn't appear in Elements for this domain until it is active.
338
339	To activate a payment method on an existing payment method domain, complete the required validation steps specific to the payment method, and then validate the payment method domain with this endpoint.
340
341	Related guides: [Payment method domains](https://stripe.com/docs/payments/payment-methods/pmd-registration).
342	"""
UNCOV 343	return cast(	×
344	"PaymentMethodDomain",
345	cls._static_request(
346	"post",
347	"/v1/payment_method_domains/{payment_method_domain}/validate".format(
348	payment_method_domain=sanitize_id(payment_method_domain)
349	),
350	params=params,
351	),
352	)
353
354	@overload	1✔
355	@staticmethod	1✔
356	def validate(	1✔
357	payment_method_domain: str,
358	**params: Unpack["PaymentMethodDomain.ValidateParams"],
359	) -> "PaymentMethodDomain":
360	"""
361	Some payment methods such as Apple Pay require additional steps to verify a domain. If the requirements weren't satisfied when the domain was created, the payment method will be inactive on the domain.
362	The payment method doesn't appear in Elements for this domain until it is active.
363
364	To activate a payment method on an existing payment method domain, complete the required validation steps specific to the payment method, and then validate the payment method domain with this endpoint.
365
366	Related guides: [Payment method domains](https://stripe.com/docs/payments/payment-methods/pmd-registration).
367	"""
UNCOV 368	...	×
369
370	@overload	1✔
371	def validate(	1✔
372	self, **params: Unpack["PaymentMethodDomain.ValidateParams"]
373	) -> "PaymentMethodDomain":
374	"""
375	Some payment methods such as Apple Pay require additional steps to verify a domain. If the requirements weren't satisfied when the domain was created, the payment method will be inactive on the domain.
376	The payment method doesn't appear in Elements for this domain until it is active.
377
378	To activate a payment method on an existing payment method domain, complete the required validation steps specific to the payment method, and then validate the payment method domain with this endpoint.
379
380	Related guides: [Payment method domains](https://stripe.com/docs/payments/payment-methods/pmd-registration).
381	"""
UNCOV 382	...	×
383
384	@class_method_variant("_cls_validate")	1✔
385	def validate( # pyright: ignore[reportGeneralTypeIssues]	1✔
386	self, **params: Unpack["PaymentMethodDomain.ValidateParams"]
387	) -> "PaymentMethodDomain":
388	"""
389	Some payment methods such as Apple Pay require additional steps to verify a domain. If the requirements weren't satisfied when the domain was created, the payment method will be inactive on the domain.
390	The payment method doesn't appear in Elements for this domain until it is active.
391
392	To activate a payment method on an existing payment method domain, complete the required validation steps specific to the payment method, and then validate the payment method domain with this endpoint.
393
394	Related guides: [Payment method domains](https://stripe.com/docs/payments/payment-methods/pmd-registration).
395	"""
UNCOV 396	return cast(	×
397	"PaymentMethodDomain",
398	self._request(
399	"post",
400	"/v1/payment_method_domains/{payment_method_domain}/validate".format(
401	payment_method_domain=sanitize_id(self.get("id"))
402	),
403	params=params,
404	),
405	)
406
407	@classmethod	1✔
408	async def _cls_validate_async(	1✔
409	cls,
410	payment_method_domain: str,
411	**params: Unpack["PaymentMethodDomain.ValidateParams"],
412	) -> "PaymentMethodDomain":
413	"""
414	Some payment methods such as Apple Pay require additional steps to verify a domain. If the requirements weren't satisfied when the domain was created, the payment method will be inactive on the domain.
415	The payment method doesn't appear in Elements for this domain until it is active.
416
417	To activate a payment method on an existing payment method domain, complete the required validation steps specific to the payment method, and then validate the payment method domain with this endpoint.
418
419	Related guides: [Payment method domains](https://stripe.com/docs/payments/payment-methods/pmd-registration).
420	"""
UNCOV 421	return cast(	×
422	"PaymentMethodDomain",
423	await cls._static_request_async(
424	"post",
425	"/v1/payment_method_domains/{payment_method_domain}/validate".format(
426	payment_method_domain=sanitize_id(payment_method_domain)
427	),
428	params=params,
429	),
430	)
431
432	@overload	1✔
433	@staticmethod	1✔
434	async def validate_async(	1✔
435	payment_method_domain: str,
436	**params: Unpack["PaymentMethodDomain.ValidateParams"],
437	) -> "PaymentMethodDomain":
438	"""
439	Some payment methods such as Apple Pay require additional steps to verify a domain. If the requirements weren't satisfied when the domain was created, the payment method will be inactive on the domain.
440	The payment method doesn't appear in Elements for this domain until it is active.
441
442	To activate a payment method on an existing payment method domain, complete the required validation steps specific to the payment method, and then validate the payment method domain with this endpoint.
443
444	Related guides: [Payment method domains](https://stripe.com/docs/payments/payment-methods/pmd-registration).
445	"""
UNCOV 446	...	×
447
448	@overload	1✔
449	async def validate_async(	1✔
450	self, **params: Unpack["PaymentMethodDomain.ValidateParams"]
451	) -> "PaymentMethodDomain":
452	"""
453	Some payment methods such as Apple Pay require additional steps to verify a domain. If the requirements weren't satisfied when the domain was created, the payment method will be inactive on the domain.
454	The payment method doesn't appear in Elements for this domain until it is active.
455
456	To activate a payment method on an existing payment method domain, complete the required validation steps specific to the payment method, and then validate the payment method domain with this endpoint.
457
458	Related guides: [Payment method domains](https://stripe.com/docs/payments/payment-methods/pmd-registration).
459	"""
UNCOV 460	...	×
461
462	@class_method_variant("_cls_validate_async")	1✔
463	async def validate_async( # pyright: ignore[reportGeneralTypeIssues]	1✔
464	self, **params: Unpack["PaymentMethodDomain.ValidateParams"]
465	) -> "PaymentMethodDomain":
466	"""
467	Some payment methods such as Apple Pay require additional steps to verify a domain. If the requirements weren't satisfied when the domain was created, the payment method will be inactive on the domain.
468	The payment method doesn't appear in Elements for this domain until it is active.
469
470	To activate a payment method on an existing payment method domain, complete the required validation steps specific to the payment method, and then validate the payment method domain with this endpoint.
471
472	Related guides: [Payment method domains](https://stripe.com/docs/payments/payment-methods/pmd-registration).
473	"""
UNCOV 474	return cast(	×
475	"PaymentMethodDomain",
476	await self._request_async(
477	"post",
478	"/v1/payment_method_domains/{payment_method_domain}/validate".format(
479	payment_method_domain=sanitize_id(self.get("id"))
480	),
481	params=params,
482	),
483	)
484
485	_inner_class_types = {	1✔
486	"apple_pay": ApplePay,
487	"google_pay": GooglePay,
488	"link": Link,
489	"paypal": Paypal,
490	}

stripe / stripe-python / 9088651600

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous