diff --git a/.stats.yml b/.stats.yml index c397995164b..a5a069377cc 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,2 +1,2 @@ -configured_endpoints: 1435 +configured_endpoints: 1449 openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/cloudflare%2Fcloudflare-829ade7062fed63a30accc2a5e1a14c6c26fd4dc003d300d1b25a5416b8b8727.yml diff --git a/api.md b/api.md index a44181e0287..56b3b3898c0 100644 --- a/api.md +++ b/api.md @@ -544,7 +544,7 @@ Methods: Types: ```python -from cloudflare.types.load_balancers import Pool, PoolDeleteResponse +from cloudflare.types.load_balancers import Pool, PoolDeleteResponse, PoolBulkEditResponse ``` Methods: @@ -553,6 +553,7 @@ Methods: - client.load_balancers.pools.update(pool_id, \*, account_id, \*\*params) -> Pool - client.load_balancers.pools.list(\*, account_id, \*\*params) -> SyncSinglePage[Pool] - client.load_balancers.pools.delete(pool_id, \*, account_id) -> PoolDeleteResponse +- client.load_balancers.pools.bulk_edit(\*, account_id, \*\*params) -> PoolBulkEditResponse - client.load_balancers.pools.edit(pool_id, \*, account_id, \*\*params) -> Pool - client.load_balancers.pools.get(pool_id, \*, account_id) -> Pool @@ -1322,6 +1323,7 @@ Types: from cloudflare.types.email_security.settings import ( DomainListResponse, DomainDeleteResponse, + DomainBulkDeleteResponse, DomainEditResponse, DomainGetResponse, ) @@ -1331,6 +1333,7 @@ Methods: - client.email_security.settings.domains.list(\*, account_id, \*\*params) -> SyncV4PagePaginationArray[DomainListResponse] - client.email_security.settings.domains.delete(domain_id, \*, account_id) -> DomainDeleteResponse +- client.email_security.settings.domains.bulk_delete(\*, account_id) -> DomainBulkDeleteResponse - client.email_security.settings.domains.edit(domain_id, \*, account_id, \*\*params) -> DomainEditResponse - client.email_security.settings.domains.get(domain_id, \*, account_id) -> DomainGetResponse @@ -1473,7 +1476,12 @@ Methods: Types: ```python -from cloudflare.types.filters import FirewallFilter, FilterCreateResponse +from cloudflare.types.filters import ( + FirewallFilter, + FilterCreateResponse, + FilterBulkDeleteResponse, + FilterBulkUpdateResponse, +) ``` Methods: @@ -1482,6 +1490,8 @@ Methods: - client.filters.update(filter_id, \*, zone_id, \*\*params) -> FirewallFilter - client.filters.list(\*, zone_id, \*\*params) -> SyncV4PagePaginationArray[FirewallFilter] - client.filters.delete(filter_id, \*, zone_id) -> FirewallFilter +- client.filters.bulk_delete(\*, zone_id) -> Optional +- client.filters.bulk_update(\*, zone_id) -> Optional - client.filters.get(filter_id, \*, zone_id) -> FirewallFilter # Firewall @@ -1519,6 +1529,9 @@ from cloudflare.types.firewall import ( Product, DeletedFilter, RuleCreateResponse, + RuleBulkDeleteResponse, + RuleBulkEditResponse, + RuleBulkUpdateResponse, RuleEditResponse, ) ``` @@ -1529,6 +1542,9 @@ Methods: - client.firewall.rules.update(rule_id, \*, zone_id, \*\*params) -> FirewallRule - client.firewall.rules.list(\*, zone_id, \*\*params) -> SyncV4PagePaginationArray[FirewallRule] - client.firewall.rules.delete(rule_id, \*, zone_id) -> FirewallRule +- client.firewall.rules.bulk_delete(\*, zone_id) -> Optional +- client.firewall.rules.bulk_edit(\*, zone_id, \*\*params) -> Optional +- client.firewall.rules.bulk_update(\*, zone_id, \*\*params) -> Optional - client.firewall.rules.edit(rule_id, \*, zone_id) -> Optional - client.firewall.rules.get(rule_id, \*, zone_id, \*\*params) -> FirewallRule @@ -2499,7 +2515,13 @@ Methods: Types: ```python -from cloudflare.types.kv import Namespace, NamespaceUpdateResponse, NamespaceDeleteResponse +from cloudflare.types.kv import ( + Namespace, + NamespaceUpdateResponse, + NamespaceDeleteResponse, + NamespaceBulkDeleteResponse, + NamespaceBulkUpdateResponse, +) ``` Methods: @@ -2508,21 +2530,10 @@ Methods: - client.kv.namespaces.update(namespace_id, \*, account_id, \*\*params) -> Optional - client.kv.namespaces.list(\*, account_id, \*\*params) -> SyncV4PagePaginationArray[Namespace] - client.kv.namespaces.delete(namespace_id, \*, account_id) -> Optional +- client.kv.namespaces.bulk_delete(namespace_id, \*, account_id, \*\*params) -> Optional +- client.kv.namespaces.bulk_update(namespace_id, \*, account_id, \*\*params) -> Optional - client.kv.namespaces.get(namespace_id, \*, account_id) -> Optional -### Bulk - -Types: - -```python -from cloudflare.types.kv.namespaces import BulkUpdateResponse, BulkDeleteResponse -``` - -Methods: - -- client.kv.namespaces.bulk.update(namespace_id, \*, account_id, \*\*params) -> Optional -- client.kv.namespaces.bulk.delete(namespace_id, \*, account_id) -> Optional - ### Keys Types: @@ -2669,12 +2680,13 @@ Methods: Types: ```python -from cloudflare.types.api_gateway.discovery import OperationEditResponse +from cloudflare.types.api_gateway.discovery import OperationBulkEditResponse, OperationEditResponse ``` Methods: - client.api_gateway.discovery.operations.list(\*, zone_id, \*\*params) -> SyncV4PagePaginationArray[DiscoveryOperation] +- client.api_gateway.discovery.operations.bulk_edit(\*, zone_id, \*\*params) -> OperationBulkEditResponse - client.api_gateway.discovery.operations.edit(operation_id, \*, zone_id, \*\*params) -> OperationEditResponse ## Operations @@ -2687,6 +2699,7 @@ from cloudflare.types.api_gateway import ( OperationCreateResponse, OperationListResponse, OperationDeleteResponse, + OperationBulkDeleteResponse, OperationGetResponse, ) ``` @@ -2696,6 +2709,7 @@ Methods: - client.api_gateway.operations.create(\*, zone_id, \*\*params) -> OperationCreateResponse - client.api_gateway.operations.list(\*, zone_id, \*\*params) -> SyncV4PagePaginationArray[OperationListResponse] - client.api_gateway.operations.delete(operation_id, \*, zone_id) -> OperationDeleteResponse +- client.api_gateway.operations.bulk_delete(\*, zone_id) -> OperationBulkDeleteResponse - client.api_gateway.operations.get(operation_id, \*, zone_id, \*\*params) -> OperationGetResponse ### SchemaValidation @@ -3705,6 +3719,7 @@ Types: from cloudflare.types.magic_transit import ( CfInterconnectUpdateResponse, CfInterconnectListResponse, + CfInterconnectBulkUpdateResponse, CfInterconnectGetResponse, ) ``` @@ -3713,6 +3728,7 @@ Methods: - client.magic_transit.cf_interconnects.update(cf_interconnect_id, \*, account_id, \*\*params) -> CfInterconnectUpdateResponse - client.magic_transit.cf_interconnects.list(\*, account_id) -> CfInterconnectListResponse +- client.magic_transit.cf_interconnects.bulk_update(\*, account_id, \*\*params) -> CfInterconnectBulkUpdateResponse - client.magic_transit.cf_interconnects.get(cf_interconnect_id, \*, account_id) -> CfInterconnectGetResponse ## GRETunnels @@ -3725,6 +3741,7 @@ from cloudflare.types.magic_transit import ( GRETunnelUpdateResponse, GRETunnelListResponse, GRETunnelDeleteResponse, + GRETunnelBulkUpdateResponse, GRETunnelGetResponse, ) ``` @@ -3735,6 +3752,7 @@ Methods: - client.magic_transit.gre_tunnels.update(gre_tunnel_id, \*, account_id, \*\*params) -> GRETunnelUpdateResponse - client.magic_transit.gre_tunnels.list(\*, account_id) -> GRETunnelListResponse - client.magic_transit.gre_tunnels.delete(gre_tunnel_id, \*, account_id) -> GRETunnelDeleteResponse +- client.magic_transit.gre_tunnels.bulk_update(\*, account_id, \*\*params) -> GRETunnelBulkUpdateResponse - client.magic_transit.gre_tunnels.get(gre_tunnel_id, \*, account_id) -> GRETunnelGetResponse ## IPSECTunnels @@ -3748,6 +3766,7 @@ from cloudflare.types.magic_transit import ( IPSECTunnelUpdateResponse, IPSECTunnelListResponse, IPSECTunnelDeleteResponse, + IPSECTunnelBulkUpdateResponse, IPSECTunnelGetResponse, IPSECTunnelPSKGenerateResponse, ) @@ -3759,6 +3778,7 @@ Methods: - client.magic_transit.ipsec_tunnels.update(ipsec_tunnel_id, \*, account_id, \*\*params) -> IPSECTunnelUpdateResponse - client.magic_transit.ipsec_tunnels.list(\*, account_id) -> IPSECTunnelListResponse - client.magic_transit.ipsec_tunnels.delete(ipsec_tunnel_id, \*, account_id) -> IPSECTunnelDeleteResponse +- client.magic_transit.ipsec_tunnels.bulk_update(\*, account_id, \*\*params) -> IPSECTunnelBulkUpdateResponse - client.magic_transit.ipsec_tunnels.get(ipsec_tunnel_id, \*, account_id) -> IPSECTunnelGetResponse - client.magic_transit.ipsec_tunnels.psk_generate(ipsec_tunnel_id, \*, account_id, \*\*params) -> IPSECTunnelPSKGenerateResponse @@ -3773,6 +3793,7 @@ from cloudflare.types.magic_transit import ( RouteUpdateResponse, RouteListResponse, RouteDeleteResponse, + RouteBulkUpdateResponse, RouteEmptyResponse, RouteGetResponse, ) @@ -3784,6 +3805,7 @@ Methods: - client.magic_transit.routes.update(route_id, \*, account_id, \*\*params) -> RouteUpdateResponse - client.magic_transit.routes.list(\*, account_id) -> RouteListResponse - client.magic_transit.routes.delete(route_id, \*, account_id) -> RouteDeleteResponse +- client.magic_transit.routes.bulk_update(\*, account_id, \*\*params) -> RouteBulkUpdateResponse - client.magic_transit.routes.empty(\*, account_id) -> RouteEmptyResponse - client.magic_transit.routes.get(route_id, \*, account_id) -> RouteGetResponse @@ -6403,7 +6425,12 @@ Methods: Types: ```python -from cloudflare.types.rum import RUMRule, RuleListResponse, RuleDeleteResponse +from cloudflare.types.rum import ( + RUMRule, + RuleListResponse, + RuleDeleteResponse, + RuleBulkCreateResponse, +) ``` Methods: @@ -6412,6 +6439,7 @@ Methods: - client.rum.rules.update(rule_id, \*, account_id, ruleset_id, \*\*params) -> Optional - client.rum.rules.list(ruleset_id, \*, account_id) -> Optional - client.rum.rules.delete(rule_id, \*, account_id, ruleset_id) -> Optional +- client.rum.rules.bulk_create(ruleset_id, \*, account_id, \*\*params) -> Optional # Vectorize diff --git a/src/cloudflare/resources/api_gateway/discovery/operations.py b/src/cloudflare/resources/api_gateway/discovery/operations.py index ba21c48267f..1994f365d02 100644 --- a/src/cloudflare/resources/api_gateway/discovery/operations.py +++ b/src/cloudflare/resources/api_gateway/discovery/operations.py @@ -2,7 +2,7 @@ from __future__ import annotations -from typing import List, Type, cast +from typing import Dict, List, Type, cast from typing_extensions import Literal import httpx @@ -23,9 +23,10 @@ from ...._wrappers import ResultWrapper from ....pagination import SyncV4PagePaginationArray, AsyncV4PagePaginationArray from ...._base_client import AsyncPaginator, make_request_options -from ....types.api_gateway.discovery import operation_edit_params, operation_list_params +from ....types.api_gateway.discovery import operation_edit_params, operation_list_params, operation_bulk_edit_params from ....types.api_gateway.discovery_operation import DiscoveryOperation from ....types.api_gateway.discovery.operation_edit_response import OperationEditResponse +from ....types.api_gateway.discovery.operation_bulk_edit_response import OperationBulkEditResponse __all__ = ["OperationsResource", "AsyncOperationsResource"] @@ -148,6 +149,47 @@ def list( model=DiscoveryOperation, ) + def bulk_edit( + self, + *, + zone_id: str, + body: Dict[str, operation_bulk_edit_params.Body], + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + ) -> OperationBulkEditResponse: + """ + Update the `state` on one or more discovered operations + + Args: + zone_id: Identifier + + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + if not zone_id: + raise ValueError(f"Expected a non-empty value for `zone_id` but received {zone_id!r}") + return self._patch( + f"/zones/{zone_id}/api_gateway/discovery/operations", + body=maybe_transform(body, operation_bulk_edit_params.OperationBulkEditParams), + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + post_parser=ResultWrapper[OperationBulkEditResponse]._unwrapper, + ), + cast_to=cast(Type[OperationBulkEditResponse], ResultWrapper[OperationBulkEditResponse]), + ) + def edit( self, operation_id: str, @@ -318,6 +360,47 @@ def list( model=DiscoveryOperation, ) + async def bulk_edit( + self, + *, + zone_id: str, + body: Dict[str, operation_bulk_edit_params.Body], + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + ) -> OperationBulkEditResponse: + """ + Update the `state` on one or more discovered operations + + Args: + zone_id: Identifier + + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + if not zone_id: + raise ValueError(f"Expected a non-empty value for `zone_id` but received {zone_id!r}") + return await self._patch( + f"/zones/{zone_id}/api_gateway/discovery/operations", + body=await async_maybe_transform(body, operation_bulk_edit_params.OperationBulkEditParams), + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + post_parser=ResultWrapper[OperationBulkEditResponse]._unwrapper, + ), + cast_to=cast(Type[OperationBulkEditResponse], ResultWrapper[OperationBulkEditResponse]), + ) + async def edit( self, operation_id: str, @@ -377,6 +460,9 @@ def __init__(self, operations: OperationsResource) -> None: self.list = to_raw_response_wrapper( operations.list, ) + self.bulk_edit = to_raw_response_wrapper( + operations.bulk_edit, + ) self.edit = to_raw_response_wrapper( operations.edit, ) @@ -389,6 +475,9 @@ def __init__(self, operations: AsyncOperationsResource) -> None: self.list = async_to_raw_response_wrapper( operations.list, ) + self.bulk_edit = async_to_raw_response_wrapper( + operations.bulk_edit, + ) self.edit = async_to_raw_response_wrapper( operations.edit, ) @@ -401,6 +490,9 @@ def __init__(self, operations: OperationsResource) -> None: self.list = to_streamed_response_wrapper( operations.list, ) + self.bulk_edit = to_streamed_response_wrapper( + operations.bulk_edit, + ) self.edit = to_streamed_response_wrapper( operations.edit, ) @@ -413,6 +505,9 @@ def __init__(self, operations: AsyncOperationsResource) -> None: self.list = async_to_streamed_response_wrapper( operations.list, ) + self.bulk_edit = async_to_streamed_response_wrapper( + operations.bulk_edit, + ) self.edit = async_to_streamed_response_wrapper( operations.edit, ) diff --git a/src/cloudflare/resources/api_gateway/operations/operations.py b/src/cloudflare/resources/api_gateway/operations/operations.py index cab1bd954c9..4e2c044805e 100644 --- a/src/cloudflare/resources/api_gateway/operations/operations.py +++ b/src/cloudflare/resources/api_gateway/operations/operations.py @@ -36,6 +36,7 @@ from ....types.api_gateway.operation_list_response import OperationListResponse from ....types.api_gateway.operation_create_response import OperationCreateResponse from ....types.api_gateway.operation_delete_response import OperationDeleteResponse +from ....types.api_gateway.operation_bulk_delete_response import OperationBulkDeleteResponse __all__ = ["OperationsResource", "AsyncOperationsResource"] @@ -229,6 +230,41 @@ def delete( cast_to=OperationDeleteResponse, ) + def bulk_delete( + self, + *, + zone_id: str, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + ) -> OperationBulkDeleteResponse: + """ + Delete multiple operations + + Args: + zone_id: Identifier + + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + if not zone_id: + raise ValueError(f"Expected a non-empty value for `zone_id` but received {zone_id!r}") + return self._delete( + f"/zones/{zone_id}/api_gateway/operations", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=OperationBulkDeleteResponse, + ) + def get( self, operation_id: str, @@ -469,6 +505,41 @@ async def delete( cast_to=OperationDeleteResponse, ) + async def bulk_delete( + self, + *, + zone_id: str, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + ) -> OperationBulkDeleteResponse: + """ + Delete multiple operations + + Args: + zone_id: Identifier + + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + if not zone_id: + raise ValueError(f"Expected a non-empty value for `zone_id` but received {zone_id!r}") + return await self._delete( + f"/zones/{zone_id}/api_gateway/operations", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=OperationBulkDeleteResponse, + ) + async def get( self, operation_id: str, @@ -533,6 +604,9 @@ def __init__(self, operations: OperationsResource) -> None: self.delete = to_raw_response_wrapper( operations.delete, ) + self.bulk_delete = to_raw_response_wrapper( + operations.bulk_delete, + ) self.get = to_raw_response_wrapper( operations.get, ) @@ -555,6 +629,9 @@ def __init__(self, operations: AsyncOperationsResource) -> None: self.delete = async_to_raw_response_wrapper( operations.delete, ) + self.bulk_delete = async_to_raw_response_wrapper( + operations.bulk_delete, + ) self.get = async_to_raw_response_wrapper( operations.get, ) @@ -577,6 +654,9 @@ def __init__(self, operations: OperationsResource) -> None: self.delete = to_streamed_response_wrapper( operations.delete, ) + self.bulk_delete = to_streamed_response_wrapper( + operations.bulk_delete, + ) self.get = to_streamed_response_wrapper( operations.get, ) @@ -599,6 +679,9 @@ def __init__(self, operations: AsyncOperationsResource) -> None: self.delete = async_to_streamed_response_wrapper( operations.delete, ) + self.bulk_delete = async_to_streamed_response_wrapper( + operations.bulk_delete, + ) self.get = async_to_streamed_response_wrapper( operations.get, ) diff --git a/src/cloudflare/resources/email_security/settings/domains.py b/src/cloudflare/resources/email_security/settings/domains.py index 2fa9d8ec5bf..d0587f9f3f8 100644 --- a/src/cloudflare/resources/email_security/settings/domains.py +++ b/src/cloudflare/resources/email_security/settings/domains.py @@ -28,6 +28,7 @@ from ....types.email_security.settings.domain_edit_response import DomainEditResponse from ....types.email_security.settings.domain_list_response import DomainListResponse from ....types.email_security.settings.domain_delete_response import DomainDeleteResponse +from ....types.email_security.settings.domain_bulk_delete_response import DomainBulkDeleteResponse __all__ = ["DomainsResource", "AsyncDomainsResource"] @@ -168,6 +169,45 @@ def delete( cast_to=cast(Type[DomainDeleteResponse], ResultWrapper[DomainDeleteResponse]), ) + def bulk_delete( + self, + *, + account_id: str, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + ) -> DomainBulkDeleteResponse: + """ + Unprotect multiple email domains + + Args: + account_id: Account Identifier + + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + if not account_id: + raise ValueError(f"Expected a non-empty value for `account_id` but received {account_id!r}") + return self._delete( + f"/accounts/{account_id}/email-security/settings/domains", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + post_parser=ResultWrapper[DomainBulkDeleteResponse]._unwrapper, + ), + cast_to=cast(Type[DomainBulkDeleteResponse], ResultWrapper[DomainBulkDeleteResponse]), + ) + def edit( self, domain_id: int, @@ -402,6 +442,45 @@ async def delete( cast_to=cast(Type[DomainDeleteResponse], ResultWrapper[DomainDeleteResponse]), ) + async def bulk_delete( + self, + *, + account_id: str, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + ) -> DomainBulkDeleteResponse: + """ + Unprotect multiple email domains + + Args: + account_id: Account Identifier + + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + if not account_id: + raise ValueError(f"Expected a non-empty value for `account_id` but received {account_id!r}") + return await self._delete( + f"/accounts/{account_id}/email-security/settings/domains", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + post_parser=ResultWrapper[DomainBulkDeleteResponse]._unwrapper, + ), + cast_to=cast(Type[DomainBulkDeleteResponse], ResultWrapper[DomainBulkDeleteResponse]), + ) + async def edit( self, domain_id: int, @@ -510,6 +589,9 @@ def __init__(self, domains: DomainsResource) -> None: self.delete = to_raw_response_wrapper( domains.delete, ) + self.bulk_delete = to_raw_response_wrapper( + domains.bulk_delete, + ) self.edit = to_raw_response_wrapper( domains.edit, ) @@ -528,6 +610,9 @@ def __init__(self, domains: AsyncDomainsResource) -> None: self.delete = async_to_raw_response_wrapper( domains.delete, ) + self.bulk_delete = async_to_raw_response_wrapper( + domains.bulk_delete, + ) self.edit = async_to_raw_response_wrapper( domains.edit, ) @@ -546,6 +631,9 @@ def __init__(self, domains: DomainsResource) -> None: self.delete = to_streamed_response_wrapper( domains.delete, ) + self.bulk_delete = to_streamed_response_wrapper( + domains.bulk_delete, + ) self.edit = to_streamed_response_wrapper( domains.edit, ) @@ -564,6 +652,9 @@ def __init__(self, domains: AsyncDomainsResource) -> None: self.delete = async_to_streamed_response_wrapper( domains.delete, ) + self.bulk_delete = async_to_streamed_response_wrapper( + domains.bulk_delete, + ) self.edit = async_to_streamed_response_wrapper( domains.edit, ) diff --git a/src/cloudflare/resources/filters.py b/src/cloudflare/resources/filters.py index 4e696d2c05f..bda722a9a26 100644 --- a/src/cloudflare/resources/filters.py +++ b/src/cloudflare/resources/filters.py @@ -26,6 +26,8 @@ from ..types.filters import filter_list_params, filter_create_params, filter_update_params from ..types.filters.firewall_filter import FirewallFilter from ..types.filters.filter_create_response import FilterCreateResponse +from ..types.filters.filter_bulk_delete_response import FilterBulkDeleteResponse +from ..types.filters.filter_bulk_update_response import FilterBulkUpdateResponse __all__ = ["FiltersResource", "AsyncFiltersResource"] @@ -270,6 +272,90 @@ def delete( cast_to=cast(Type[FirewallFilter], ResultWrapper[FirewallFilter]), ) + @typing_extensions.deprecated( + "The Filters API is deprecated in favour of using the Ruleset Engine. See https://developers.cloudflare.com/fundamentals/api/reference/deprecations/#firewall-rules-api-and-filters-api for full details." + ) + def bulk_delete( + self, + *, + zone_id: str, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + ) -> Optional[FilterBulkDeleteResponse]: + """ + Deletes one or more existing filters. + + Args: + zone_id: Identifier + + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + if not zone_id: + raise ValueError(f"Expected a non-empty value for `zone_id` but received {zone_id!r}") + return self._delete( + f"/zones/{zone_id}/filters", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + post_parser=ResultWrapper[Optional[FilterBulkDeleteResponse]]._unwrapper, + ), + cast_to=cast(Type[Optional[FilterBulkDeleteResponse]], ResultWrapper[FilterBulkDeleteResponse]), + ) + + @typing_extensions.deprecated( + "The Filters API is deprecated in favour of using the Ruleset Engine. See https://developers.cloudflare.com/fundamentals/api/reference/deprecations/#firewall-rules-api-and-filters-api for full details." + ) + def bulk_update( + self, + *, + zone_id: str, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + ) -> Optional[FilterBulkUpdateResponse]: + """ + Updates one or more existing filters. + + Args: + zone_id: Identifier + + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + if not zone_id: + raise ValueError(f"Expected a non-empty value for `zone_id` but received {zone_id!r}") + return self._put( + f"/zones/{zone_id}/filters", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + post_parser=ResultWrapper[Optional[FilterBulkUpdateResponse]]._unwrapper, + ), + cast_to=cast(Type[Optional[FilterBulkUpdateResponse]], ResultWrapper[FilterBulkUpdateResponse]), + ) + @typing_extensions.deprecated( "The Filters API is deprecated in favour of using the Ruleset Engine. See https://developers.cloudflare.com/fundamentals/api/reference/deprecations/#firewall-rules-api-and-filters-api for full details." ) @@ -558,6 +644,90 @@ async def delete( cast_to=cast(Type[FirewallFilter], ResultWrapper[FirewallFilter]), ) + @typing_extensions.deprecated( + "The Filters API is deprecated in favour of using the Ruleset Engine. See https://developers.cloudflare.com/fundamentals/api/reference/deprecations/#firewall-rules-api-and-filters-api for full details." + ) + async def bulk_delete( + self, + *, + zone_id: str, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + ) -> Optional[FilterBulkDeleteResponse]: + """ + Deletes one or more existing filters. + + Args: + zone_id: Identifier + + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + if not zone_id: + raise ValueError(f"Expected a non-empty value for `zone_id` but received {zone_id!r}") + return await self._delete( + f"/zones/{zone_id}/filters", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + post_parser=ResultWrapper[Optional[FilterBulkDeleteResponse]]._unwrapper, + ), + cast_to=cast(Type[Optional[FilterBulkDeleteResponse]], ResultWrapper[FilterBulkDeleteResponse]), + ) + + @typing_extensions.deprecated( + "The Filters API is deprecated in favour of using the Ruleset Engine. See https://developers.cloudflare.com/fundamentals/api/reference/deprecations/#firewall-rules-api-and-filters-api for full details." + ) + async def bulk_update( + self, + *, + zone_id: str, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + ) -> Optional[FilterBulkUpdateResponse]: + """ + Updates one or more existing filters. + + Args: + zone_id: Identifier + + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + if not zone_id: + raise ValueError(f"Expected a non-empty value for `zone_id` but received {zone_id!r}") + return await self._put( + f"/zones/{zone_id}/filters", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + post_parser=ResultWrapper[Optional[FilterBulkUpdateResponse]]._unwrapper, + ), + cast_to=cast(Type[Optional[FilterBulkUpdateResponse]], ResultWrapper[FilterBulkUpdateResponse]), + ) + @typing_extensions.deprecated( "The Filters API is deprecated in favour of using the Ruleset Engine. See https://developers.cloudflare.com/fundamentals/api/reference/deprecations/#firewall-rules-api-and-filters-api for full details." ) @@ -630,6 +800,16 @@ def __init__(self, filters: FiltersResource) -> None: filters.delete # pyright: ignore[reportDeprecated], ) ) + self.bulk_delete = ( # pyright: ignore[reportDeprecated] + to_raw_response_wrapper( + filters.bulk_delete # pyright: ignore[reportDeprecated], + ) + ) + self.bulk_update = ( # pyright: ignore[reportDeprecated] + to_raw_response_wrapper( + filters.bulk_update # pyright: ignore[reportDeprecated], + ) + ) self.get = ( # pyright: ignore[reportDeprecated] to_raw_response_wrapper( filters.get # pyright: ignore[reportDeprecated], @@ -661,6 +841,16 @@ def __init__(self, filters: AsyncFiltersResource) -> None: filters.delete # pyright: ignore[reportDeprecated], ) ) + self.bulk_delete = ( # pyright: ignore[reportDeprecated] + async_to_raw_response_wrapper( + filters.bulk_delete # pyright: ignore[reportDeprecated], + ) + ) + self.bulk_update = ( # pyright: ignore[reportDeprecated] + async_to_raw_response_wrapper( + filters.bulk_update # pyright: ignore[reportDeprecated], + ) + ) self.get = ( # pyright: ignore[reportDeprecated] async_to_raw_response_wrapper( filters.get # pyright: ignore[reportDeprecated], @@ -692,6 +882,16 @@ def __init__(self, filters: FiltersResource) -> None: filters.delete # pyright: ignore[reportDeprecated], ) ) + self.bulk_delete = ( # pyright: ignore[reportDeprecated] + to_streamed_response_wrapper( + filters.bulk_delete # pyright: ignore[reportDeprecated], + ) + ) + self.bulk_update = ( # pyright: ignore[reportDeprecated] + to_streamed_response_wrapper( + filters.bulk_update # pyright: ignore[reportDeprecated], + ) + ) self.get = ( # pyright: ignore[reportDeprecated] to_streamed_response_wrapper( filters.get # pyright: ignore[reportDeprecated], @@ -723,6 +923,16 @@ def __init__(self, filters: AsyncFiltersResource) -> None: filters.delete # pyright: ignore[reportDeprecated], ) ) + self.bulk_delete = ( # pyright: ignore[reportDeprecated] + async_to_streamed_response_wrapper( + filters.bulk_delete # pyright: ignore[reportDeprecated], + ) + ) + self.bulk_update = ( # pyright: ignore[reportDeprecated] + async_to_streamed_response_wrapper( + filters.bulk_update # pyright: ignore[reportDeprecated], + ) + ) self.get = ( # pyright: ignore[reportDeprecated] async_to_streamed_response_wrapper( filters.get # pyright: ignore[reportDeprecated], diff --git a/src/cloudflare/resources/firewall/rules.py b/src/cloudflare/resources/firewall/rules.py index b760b0f9128..0fec41375bd 100644 --- a/src/cloudflare/resources/firewall/rules.py +++ b/src/cloudflare/resources/firewall/rules.py @@ -23,11 +23,21 @@ from ..._wrappers import ResultWrapper from ...pagination import SyncV4PagePaginationArray, AsyncV4PagePaginationArray from ..._base_client import AsyncPaginator, make_request_options -from ...types.firewall import rule_get_params, rule_list_params, rule_create_params, rule_update_params +from ...types.firewall import ( + rule_get_params, + rule_list_params, + rule_create_params, + rule_update_params, + rule_bulk_edit_params, + rule_bulk_update_params, +) from ...types.firewall.firewall_rule import FirewallRule from ...types.firewall.rule_edit_response import RuleEditResponse from ...types.filters.firewall_filter_param import FirewallFilterParam from ...types.firewall.rule_create_response import RuleCreateResponse +from ...types.firewall.rule_bulk_edit_response import RuleBulkEditResponse +from ...types.firewall.rule_bulk_delete_response import RuleBulkDeleteResponse +from ...types.firewall.rule_bulk_update_response import RuleBulkUpdateResponse __all__ = ["RulesResource", "AsyncRulesResource"] @@ -285,6 +295,136 @@ def delete( cast_to=cast(Type[FirewallRule], ResultWrapper[FirewallRule]), ) + @typing_extensions.deprecated( + "The Firewall Rules API is deprecated in favour of using the Ruleset Engine. See https://developers.cloudflare.com/fundamentals/api/reference/deprecations/#firewall-rules-api-and-filters-api for full details." + ) + def bulk_delete( + self, + *, + zone_id: str, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + ) -> Optional[RuleBulkDeleteResponse]: + """ + Deletes existing firewall rules. + + Args: + zone_id: Identifier + + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + if not zone_id: + raise ValueError(f"Expected a non-empty value for `zone_id` but received {zone_id!r}") + return self._delete( + f"/zones/{zone_id}/firewall/rules", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + post_parser=ResultWrapper[Optional[RuleBulkDeleteResponse]]._unwrapper, + ), + cast_to=cast(Type[Optional[RuleBulkDeleteResponse]], ResultWrapper[RuleBulkDeleteResponse]), + ) + + @typing_extensions.deprecated( + "The Firewall Rules API is deprecated in favour of using the Ruleset Engine. See https://developers.cloudflare.com/fundamentals/api/reference/deprecations/#firewall-rules-api-and-filters-api for full details." + ) + def bulk_edit( + self, + *, + zone_id: str, + body: object, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + ) -> Optional[RuleBulkEditResponse]: + """ + Updates the priority of existing firewall rules. + + Args: + zone_id: Identifier + + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + if not zone_id: + raise ValueError(f"Expected a non-empty value for `zone_id` but received {zone_id!r}") + return self._patch( + f"/zones/{zone_id}/firewall/rules", + body=maybe_transform(body, rule_bulk_edit_params.RuleBulkEditParams), + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + post_parser=ResultWrapper[Optional[RuleBulkEditResponse]]._unwrapper, + ), + cast_to=cast(Type[Optional[RuleBulkEditResponse]], ResultWrapper[RuleBulkEditResponse]), + ) + + @typing_extensions.deprecated( + "The Firewall Rules API is deprecated in favour of using the Ruleset Engine. See https://developers.cloudflare.com/fundamentals/api/reference/deprecations/#firewall-rules-api-and-filters-api for full details." + ) + def bulk_update( + self, + *, + zone_id: str, + body: object, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + ) -> Optional[RuleBulkUpdateResponse]: + """ + Updates one or more existing firewall rules. + + Args: + zone_id: Identifier + + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + if not zone_id: + raise ValueError(f"Expected a non-empty value for `zone_id` but received {zone_id!r}") + return self._put( + f"/zones/{zone_id}/firewall/rules", + body=maybe_transform(body, rule_bulk_update_params.RuleBulkUpdateParams), + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + post_parser=ResultWrapper[Optional[RuleBulkUpdateResponse]]._unwrapper, + ), + cast_to=cast(Type[Optional[RuleBulkUpdateResponse]], ResultWrapper[RuleBulkUpdateResponse]), + ) + @typing_extensions.deprecated( "The Firewall Rules API is deprecated in favour of using the Ruleset Engine. See https://developers.cloudflare.com/fundamentals/api/reference/deprecations/#firewall-rules-api-and-filters-api for full details." ) @@ -637,6 +777,136 @@ async def delete( cast_to=cast(Type[FirewallRule], ResultWrapper[FirewallRule]), ) + @typing_extensions.deprecated( + "The Firewall Rules API is deprecated in favour of using the Ruleset Engine. See https://developers.cloudflare.com/fundamentals/api/reference/deprecations/#firewall-rules-api-and-filters-api for full details." + ) + async def bulk_delete( + self, + *, + zone_id: str, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + ) -> Optional[RuleBulkDeleteResponse]: + """ + Deletes existing firewall rules. + + Args: + zone_id: Identifier + + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + if not zone_id: + raise ValueError(f"Expected a non-empty value for `zone_id` but received {zone_id!r}") + return await self._delete( + f"/zones/{zone_id}/firewall/rules", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + post_parser=ResultWrapper[Optional[RuleBulkDeleteResponse]]._unwrapper, + ), + cast_to=cast(Type[Optional[RuleBulkDeleteResponse]], ResultWrapper[RuleBulkDeleteResponse]), + ) + + @typing_extensions.deprecated( + "The Firewall Rules API is deprecated in favour of using the Ruleset Engine. See https://developers.cloudflare.com/fundamentals/api/reference/deprecations/#firewall-rules-api-and-filters-api for full details." + ) + async def bulk_edit( + self, + *, + zone_id: str, + body: object, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + ) -> Optional[RuleBulkEditResponse]: + """ + Updates the priority of existing firewall rules. + + Args: + zone_id: Identifier + + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + if not zone_id: + raise ValueError(f"Expected a non-empty value for `zone_id` but received {zone_id!r}") + return await self._patch( + f"/zones/{zone_id}/firewall/rules", + body=await async_maybe_transform(body, rule_bulk_edit_params.RuleBulkEditParams), + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + post_parser=ResultWrapper[Optional[RuleBulkEditResponse]]._unwrapper, + ), + cast_to=cast(Type[Optional[RuleBulkEditResponse]], ResultWrapper[RuleBulkEditResponse]), + ) + + @typing_extensions.deprecated( + "The Firewall Rules API is deprecated in favour of using the Ruleset Engine. See https://developers.cloudflare.com/fundamentals/api/reference/deprecations/#firewall-rules-api-and-filters-api for full details." + ) + async def bulk_update( + self, + *, + zone_id: str, + body: object, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + ) -> Optional[RuleBulkUpdateResponse]: + """ + Updates one or more existing firewall rules. + + Args: + zone_id: Identifier + + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + if not zone_id: + raise ValueError(f"Expected a non-empty value for `zone_id` but received {zone_id!r}") + return await self._put( + f"/zones/{zone_id}/firewall/rules", + body=await async_maybe_transform(body, rule_bulk_update_params.RuleBulkUpdateParams), + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + post_parser=ResultWrapper[Optional[RuleBulkUpdateResponse]]._unwrapper, + ), + cast_to=cast(Type[Optional[RuleBulkUpdateResponse]], ResultWrapper[RuleBulkUpdateResponse]), + ) + @typing_extensions.deprecated( "The Firewall Rules API is deprecated in favour of using the Ruleset Engine. See https://developers.cloudflare.com/fundamentals/api/reference/deprecations/#firewall-rules-api-and-filters-api for full details." ) @@ -760,6 +1030,21 @@ def __init__(self, rules: RulesResource) -> None: rules.delete # pyright: ignore[reportDeprecated], ) ) + self.bulk_delete = ( # pyright: ignore[reportDeprecated] + to_raw_response_wrapper( + rules.bulk_delete # pyright: ignore[reportDeprecated], + ) + ) + self.bulk_edit = ( # pyright: ignore[reportDeprecated] + to_raw_response_wrapper( + rules.bulk_edit # pyright: ignore[reportDeprecated], + ) + ) + self.bulk_update = ( # pyright: ignore[reportDeprecated] + to_raw_response_wrapper( + rules.bulk_update # pyright: ignore[reportDeprecated], + ) + ) self.edit = ( # pyright: ignore[reportDeprecated] to_raw_response_wrapper( rules.edit # pyright: ignore[reportDeprecated], @@ -796,6 +1081,21 @@ def __init__(self, rules: AsyncRulesResource) -> None: rules.delete # pyright: ignore[reportDeprecated], ) ) + self.bulk_delete = ( # pyright: ignore[reportDeprecated] + async_to_raw_response_wrapper( + rules.bulk_delete # pyright: ignore[reportDeprecated], + ) + ) + self.bulk_edit = ( # pyright: ignore[reportDeprecated] + async_to_raw_response_wrapper( + rules.bulk_edit # pyright: ignore[reportDeprecated], + ) + ) + self.bulk_update = ( # pyright: ignore[reportDeprecated] + async_to_raw_response_wrapper( + rules.bulk_update # pyright: ignore[reportDeprecated], + ) + ) self.edit = ( # pyright: ignore[reportDeprecated] async_to_raw_response_wrapper( rules.edit # pyright: ignore[reportDeprecated], @@ -832,6 +1132,21 @@ def __init__(self, rules: RulesResource) -> None: rules.delete # pyright: ignore[reportDeprecated], ) ) + self.bulk_delete = ( # pyright: ignore[reportDeprecated] + to_streamed_response_wrapper( + rules.bulk_delete # pyright: ignore[reportDeprecated], + ) + ) + self.bulk_edit = ( # pyright: ignore[reportDeprecated] + to_streamed_response_wrapper( + rules.bulk_edit # pyright: ignore[reportDeprecated], + ) + ) + self.bulk_update = ( # pyright: ignore[reportDeprecated] + to_streamed_response_wrapper( + rules.bulk_update # pyright: ignore[reportDeprecated], + ) + ) self.edit = ( # pyright: ignore[reportDeprecated] to_streamed_response_wrapper( rules.edit # pyright: ignore[reportDeprecated], @@ -868,6 +1183,21 @@ def __init__(self, rules: AsyncRulesResource) -> None: rules.delete # pyright: ignore[reportDeprecated], ) ) + self.bulk_delete = ( # pyright: ignore[reportDeprecated] + async_to_streamed_response_wrapper( + rules.bulk_delete # pyright: ignore[reportDeprecated], + ) + ) + self.bulk_edit = ( # pyright: ignore[reportDeprecated] + async_to_streamed_response_wrapper( + rules.bulk_edit # pyright: ignore[reportDeprecated], + ) + ) + self.bulk_update = ( # pyright: ignore[reportDeprecated] + async_to_streamed_response_wrapper( + rules.bulk_update # pyright: ignore[reportDeprecated], + ) + ) self.edit = ( # pyright: ignore[reportDeprecated] async_to_streamed_response_wrapper( rules.edit # pyright: ignore[reportDeprecated], diff --git a/src/cloudflare/resources/kv/namespaces/__init__.py b/src/cloudflare/resources/kv/namespaces/__init__.py index 0784dbb3103..eaf6f601cea 100644 --- a/src/cloudflare/resources/kv/namespaces/__init__.py +++ b/src/cloudflare/resources/kv/namespaces/__init__.py @@ -1,13 +1,5 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -from .bulk import ( - BulkResource, - AsyncBulkResource, - BulkResourceWithRawResponse, - AsyncBulkResourceWithRawResponse, - BulkResourceWithStreamingResponse, - AsyncBulkResourceWithStreamingResponse, -) from .keys import ( KeysResource, AsyncKeysResource, @@ -42,12 +34,6 @@ ) __all__ = [ - "BulkResource", - "AsyncBulkResource", - "BulkResourceWithRawResponse", - "AsyncBulkResourceWithRawResponse", - "BulkResourceWithStreamingResponse", - "AsyncBulkResourceWithStreamingResponse", "KeysResource", "AsyncKeysResource", "KeysResourceWithRawResponse", diff --git a/src/cloudflare/resources/kv/namespaces/bulk.py b/src/cloudflare/resources/kv/namespaces/bulk.py deleted file mode 100644 index 8fb4ed0f906..00000000000 --- a/src/cloudflare/resources/kv/namespaces/bulk.py +++ /dev/null @@ -1,314 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from __future__ import annotations - -from typing import Type, Iterable, Optional, cast - -import httpx - -from ...._types import NOT_GIVEN, Body, Query, Headers, NotGiven -from ...._utils import ( - maybe_transform, - async_maybe_transform, -) -from ...._compat import cached_property -from ...._resource import SyncAPIResource, AsyncAPIResource -from ...._response import ( - to_raw_response_wrapper, - to_streamed_response_wrapper, - async_to_raw_response_wrapper, - async_to_streamed_response_wrapper, -) -from ...._wrappers import ResultWrapper -from ...._base_client import make_request_options -from ....types.kv.namespaces import bulk_update_params -from ....types.kv.namespaces.bulk_delete_response import BulkDeleteResponse -from ....types.kv.namespaces.bulk_update_response import BulkUpdateResponse - -__all__ = ["BulkResource", "AsyncBulkResource"] - - -class BulkResource(SyncAPIResource): - @cached_property - def with_raw_response(self) -> BulkResourceWithRawResponse: - """ - This property can be used as a prefix for any HTTP method call to return the - the raw response object instead of the parsed content. - - For more information, see https://www.github.com/cloudflare/cloudflare-python#accessing-raw-response-data-eg-headers - """ - return BulkResourceWithRawResponse(self) - - @cached_property - def with_streaming_response(self) -> BulkResourceWithStreamingResponse: - """ - An alternative to `.with_raw_response` that doesn't eagerly read the response body. - - For more information, see https://www.github.com/cloudflare/cloudflare-python#with_streaming_response - """ - return BulkResourceWithStreamingResponse(self) - - def update( - self, - namespace_id: str, - *, - account_id: str, - body: Iterable[bulk_update_params.Body], - # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. - # The extra values given here take precedence over values defined on the client or passed to this method. - extra_headers: Headers | None = None, - extra_query: Query | None = None, - extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[BulkUpdateResponse]: - """Write multiple keys and values at once. - - Body should be an array of up to 10,000 - key-value pairs to be stored, along with optional expiration information. - Existing values and expirations will be overwritten. If neither `expiration` nor - `expiration_ttl` is specified, the key-value pair will never expire. If both are - set, `expiration_ttl` is used and `expiration` is ignored. The entire request - size must be 100 megabytes or less. - - Args: - account_id: Identifier - - namespace_id: Namespace identifier tag. - - extra_headers: Send extra headers - - extra_query: Add additional query parameters to the request - - extra_body: Add additional JSON properties to the request - - timeout: Override the client-level default timeout for this request, in seconds - """ - if not account_id: - raise ValueError(f"Expected a non-empty value for `account_id` but received {account_id!r}") - if not namespace_id: - raise ValueError(f"Expected a non-empty value for `namespace_id` but received {namespace_id!r}") - return self._put( - f"/accounts/{account_id}/storage/kv/namespaces/{namespace_id}/bulk", - body=maybe_transform(body, Iterable[bulk_update_params.Body]), - options=make_request_options( - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, - post_parser=ResultWrapper[Optional[BulkUpdateResponse]]._unwrapper, - ), - cast_to=cast(Type[Optional[BulkUpdateResponse]], ResultWrapper[BulkUpdateResponse]), - ) - - def delete( - self, - namespace_id: str, - *, - account_id: str, - # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. - # The extra values given here take precedence over values defined on the client or passed to this method. - extra_headers: Headers | None = None, - extra_query: Query | None = None, - extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[BulkDeleteResponse]: - """Remove multiple KV pairs from the namespace. - - Body should be an array of up to - 10,000 keys to be removed. - - Args: - account_id: Identifier - - namespace_id: Namespace identifier tag. - - extra_headers: Send extra headers - - extra_query: Add additional query parameters to the request - - extra_body: Add additional JSON properties to the request - - timeout: Override the client-level default timeout for this request, in seconds - """ - if not account_id: - raise ValueError(f"Expected a non-empty value for `account_id` but received {account_id!r}") - if not namespace_id: - raise ValueError(f"Expected a non-empty value for `namespace_id` but received {namespace_id!r}") - return self._delete( - f"/accounts/{account_id}/storage/kv/namespaces/{namespace_id}/bulk", - options=make_request_options( - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, - post_parser=ResultWrapper[Optional[BulkDeleteResponse]]._unwrapper, - ), - cast_to=cast(Type[Optional[BulkDeleteResponse]], ResultWrapper[BulkDeleteResponse]), - ) - - -class AsyncBulkResource(AsyncAPIResource): - @cached_property - def with_raw_response(self) -> AsyncBulkResourceWithRawResponse: - """ - This property can be used as a prefix for any HTTP method call to return the - the raw response object instead of the parsed content. - - For more information, see https://www.github.com/cloudflare/cloudflare-python#accessing-raw-response-data-eg-headers - """ - return AsyncBulkResourceWithRawResponse(self) - - @cached_property - def with_streaming_response(self) -> AsyncBulkResourceWithStreamingResponse: - """ - An alternative to `.with_raw_response` that doesn't eagerly read the response body. - - For more information, see https://www.github.com/cloudflare/cloudflare-python#with_streaming_response - """ - return AsyncBulkResourceWithStreamingResponse(self) - - async def update( - self, - namespace_id: str, - *, - account_id: str, - body: Iterable[bulk_update_params.Body], - # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. - # The extra values given here take precedence over values defined on the client or passed to this method. - extra_headers: Headers | None = None, - extra_query: Query | None = None, - extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[BulkUpdateResponse]: - """Write multiple keys and values at once. - - Body should be an array of up to 10,000 - key-value pairs to be stored, along with optional expiration information. - Existing values and expirations will be overwritten. If neither `expiration` nor - `expiration_ttl` is specified, the key-value pair will never expire. If both are - set, `expiration_ttl` is used and `expiration` is ignored. The entire request - size must be 100 megabytes or less. - - Args: - account_id: Identifier - - namespace_id: Namespace identifier tag. - - extra_headers: Send extra headers - - extra_query: Add additional query parameters to the request - - extra_body: Add additional JSON properties to the request - - timeout: Override the client-level default timeout for this request, in seconds - """ - if not account_id: - raise ValueError(f"Expected a non-empty value for `account_id` but received {account_id!r}") - if not namespace_id: - raise ValueError(f"Expected a non-empty value for `namespace_id` but received {namespace_id!r}") - return await self._put( - f"/accounts/{account_id}/storage/kv/namespaces/{namespace_id}/bulk", - body=await async_maybe_transform(body, Iterable[bulk_update_params.Body]), - options=make_request_options( - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, - post_parser=ResultWrapper[Optional[BulkUpdateResponse]]._unwrapper, - ), - cast_to=cast(Type[Optional[BulkUpdateResponse]], ResultWrapper[BulkUpdateResponse]), - ) - - async def delete( - self, - namespace_id: str, - *, - account_id: str, - # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. - # The extra values given here take precedence over values defined on the client or passed to this method. - extra_headers: Headers | None = None, - extra_query: Query | None = None, - extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[BulkDeleteResponse]: - """Remove multiple KV pairs from the namespace. - - Body should be an array of up to - 10,000 keys to be removed. - - Args: - account_id: Identifier - - namespace_id: Namespace identifier tag. - - extra_headers: Send extra headers - - extra_query: Add additional query parameters to the request - - extra_body: Add additional JSON properties to the request - - timeout: Override the client-level default timeout for this request, in seconds - """ - if not account_id: - raise ValueError(f"Expected a non-empty value for `account_id` but received {account_id!r}") - if not namespace_id: - raise ValueError(f"Expected a non-empty value for `namespace_id` but received {namespace_id!r}") - return await self._delete( - f"/accounts/{account_id}/storage/kv/namespaces/{namespace_id}/bulk", - options=make_request_options( - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, - post_parser=ResultWrapper[Optional[BulkDeleteResponse]]._unwrapper, - ), - cast_to=cast(Type[Optional[BulkDeleteResponse]], ResultWrapper[BulkDeleteResponse]), - ) - - -class BulkResourceWithRawResponse: - def __init__(self, bulk: BulkResource) -> None: - self._bulk = bulk - - self.update = to_raw_response_wrapper( - bulk.update, - ) - self.delete = to_raw_response_wrapper( - bulk.delete, - ) - - -class AsyncBulkResourceWithRawResponse: - def __init__(self, bulk: AsyncBulkResource) -> None: - self._bulk = bulk - - self.update = async_to_raw_response_wrapper( - bulk.update, - ) - self.delete = async_to_raw_response_wrapper( - bulk.delete, - ) - - -class BulkResourceWithStreamingResponse: - def __init__(self, bulk: BulkResource) -> None: - self._bulk = bulk - - self.update = to_streamed_response_wrapper( - bulk.update, - ) - self.delete = to_streamed_response_wrapper( - bulk.delete, - ) - - -class AsyncBulkResourceWithStreamingResponse: - def __init__(self, bulk: AsyncBulkResource) -> None: - self._bulk = bulk - - self.update = async_to_streamed_response_wrapper( - bulk.update, - ) - self.delete = async_to_streamed_response_wrapper( - bulk.delete, - ) diff --git a/src/cloudflare/resources/kv/namespaces/namespaces.py b/src/cloudflare/resources/kv/namespaces/namespaces.py index 95fea898307..3f47127b147 100644 --- a/src/cloudflare/resources/kv/namespaces/namespaces.py +++ b/src/cloudflare/resources/kv/namespaces/namespaces.py @@ -2,19 +2,11 @@ from __future__ import annotations -from typing import Type, Optional, cast +from typing import List, Type, Iterable, Optional, cast from typing_extensions import Literal import httpx -from .bulk import ( - BulkResource, - AsyncBulkResource, - BulkResourceWithRawResponse, - AsyncBulkResourceWithRawResponse, - BulkResourceWithStreamingResponse, - AsyncBulkResourceWithStreamingResponse, -) from .keys import ( KeysResource, AsyncKeysResource, @@ -45,7 +37,12 @@ async_maybe_transform, ) from ...._compat import cached_property -from ....types.kv import namespace_list_params, namespace_create_params, namespace_update_params +from ....types.kv import ( + namespace_list_params, + namespace_create_params, + namespace_update_params, + namespace_bulk_update_params, +) from ...._resource import SyncAPIResource, AsyncAPIResource from ...._response import ( to_raw_response_wrapper, @@ -59,15 +56,13 @@ from ....types.kv.namespace import Namespace from ....types.kv.namespace_delete_response import NamespaceDeleteResponse from ....types.kv.namespace_update_response import NamespaceUpdateResponse +from ....types.kv.namespace_bulk_delete_response import NamespaceBulkDeleteResponse +from ....types.kv.namespace_bulk_update_response import NamespaceBulkUpdateResponse __all__ = ["NamespacesResource", "AsyncNamespacesResource"] class NamespacesResource(SyncAPIResource): - @cached_property - def bulk(self) -> BulkResource: - return BulkResource(self._client) - @cached_property def keys(self) -> KeysResource: return KeysResource(self._client) @@ -297,6 +292,106 @@ def delete( cast_to=cast(Type[Optional[NamespaceDeleteResponse]], ResultWrapper[NamespaceDeleteResponse]), ) + def bulk_delete( + self, + namespace_id: str, + *, + account_id: str, + body: List[str], + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + ) -> Optional[NamespaceBulkDeleteResponse]: + """Remove multiple KV pairs from the namespace. + + Body should be an array of up to + 10,000 keys to be removed. + + Args: + account_id: Identifier + + namespace_id: Namespace identifier tag. + + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + if not account_id: + raise ValueError(f"Expected a non-empty value for `account_id` but received {account_id!r}") + if not namespace_id: + raise ValueError(f"Expected a non-empty value for `namespace_id` but received {namespace_id!r}") + return self._post( + f"/accounts/{account_id}/storage/kv/namespaces/{namespace_id}/bulk/delete", + body=maybe_transform(body, List[str]), + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + post_parser=ResultWrapper[Optional[NamespaceBulkDeleteResponse]]._unwrapper, + ), + cast_to=cast(Type[Optional[NamespaceBulkDeleteResponse]], ResultWrapper[NamespaceBulkDeleteResponse]), + ) + + def bulk_update( + self, + namespace_id: str, + *, + account_id: str, + body: Iterable[namespace_bulk_update_params.Body], + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + ) -> Optional[NamespaceBulkUpdateResponse]: + """Write multiple keys and values at once. + + Body should be an array of up to 10,000 + key-value pairs to be stored, along with optional expiration information. + Existing values and expirations will be overwritten. If neither `expiration` nor + `expiration_ttl` is specified, the key-value pair will never expire. If both are + set, `expiration_ttl` is used and `expiration` is ignored. The entire request + size must be 100 megabytes or less. + + Args: + account_id: Identifier + + namespace_id: Namespace identifier tag. + + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + if not account_id: + raise ValueError(f"Expected a non-empty value for `account_id` but received {account_id!r}") + if not namespace_id: + raise ValueError(f"Expected a non-empty value for `namespace_id` but received {namespace_id!r}") + return self._put( + f"/accounts/{account_id}/storage/kv/namespaces/{namespace_id}/bulk", + body=maybe_transform(body, Iterable[namespace_bulk_update_params.Body]), + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + post_parser=ResultWrapper[Optional[NamespaceBulkUpdateResponse]]._unwrapper, + ), + cast_to=cast(Type[Optional[NamespaceBulkUpdateResponse]], ResultWrapper[NamespaceBulkUpdateResponse]), + ) + def get( self, namespace_id: str, @@ -343,10 +438,6 @@ def get( class AsyncNamespacesResource(AsyncAPIResource): - @cached_property - def bulk(self) -> AsyncBulkResource: - return AsyncBulkResource(self._client) - @cached_property def keys(self) -> AsyncKeysResource: return AsyncKeysResource(self._client) @@ -576,6 +667,106 @@ async def delete( cast_to=cast(Type[Optional[NamespaceDeleteResponse]], ResultWrapper[NamespaceDeleteResponse]), ) + async def bulk_delete( + self, + namespace_id: str, + *, + account_id: str, + body: List[str], + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + ) -> Optional[NamespaceBulkDeleteResponse]: + """Remove multiple KV pairs from the namespace. + + Body should be an array of up to + 10,000 keys to be removed. + + Args: + account_id: Identifier + + namespace_id: Namespace identifier tag. + + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + if not account_id: + raise ValueError(f"Expected a non-empty value for `account_id` but received {account_id!r}") + if not namespace_id: + raise ValueError(f"Expected a non-empty value for `namespace_id` but received {namespace_id!r}") + return await self._post( + f"/accounts/{account_id}/storage/kv/namespaces/{namespace_id}/bulk/delete", + body=await async_maybe_transform(body, List[str]), + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + post_parser=ResultWrapper[Optional[NamespaceBulkDeleteResponse]]._unwrapper, + ), + cast_to=cast(Type[Optional[NamespaceBulkDeleteResponse]], ResultWrapper[NamespaceBulkDeleteResponse]), + ) + + async def bulk_update( + self, + namespace_id: str, + *, + account_id: str, + body: Iterable[namespace_bulk_update_params.Body], + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + ) -> Optional[NamespaceBulkUpdateResponse]: + """Write multiple keys and values at once. + + Body should be an array of up to 10,000 + key-value pairs to be stored, along with optional expiration information. + Existing values and expirations will be overwritten. If neither `expiration` nor + `expiration_ttl` is specified, the key-value pair will never expire. If both are + set, `expiration_ttl` is used and `expiration` is ignored. The entire request + size must be 100 megabytes or less. + + Args: + account_id: Identifier + + namespace_id: Namespace identifier tag. + + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + if not account_id: + raise ValueError(f"Expected a non-empty value for `account_id` but received {account_id!r}") + if not namespace_id: + raise ValueError(f"Expected a non-empty value for `namespace_id` but received {namespace_id!r}") + return await self._put( + f"/accounts/{account_id}/storage/kv/namespaces/{namespace_id}/bulk", + body=await async_maybe_transform(body, Iterable[namespace_bulk_update_params.Body]), + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + post_parser=ResultWrapper[Optional[NamespaceBulkUpdateResponse]]._unwrapper, + ), + cast_to=cast(Type[Optional[NamespaceBulkUpdateResponse]], ResultWrapper[NamespaceBulkUpdateResponse]), + ) + async def get( self, namespace_id: str, @@ -637,14 +828,16 @@ def __init__(self, namespaces: NamespacesResource) -> None: self.delete = to_raw_response_wrapper( namespaces.delete, ) + self.bulk_delete = to_raw_response_wrapper( + namespaces.bulk_delete, + ) + self.bulk_update = to_raw_response_wrapper( + namespaces.bulk_update, + ) self.get = to_raw_response_wrapper( namespaces.get, ) - @cached_property - def bulk(self) -> BulkResourceWithRawResponse: - return BulkResourceWithRawResponse(self._namespaces.bulk) - @cached_property def keys(self) -> KeysResourceWithRawResponse: return KeysResourceWithRawResponse(self._namespaces.keys) @@ -674,14 +867,16 @@ def __init__(self, namespaces: AsyncNamespacesResource) -> None: self.delete = async_to_raw_response_wrapper( namespaces.delete, ) + self.bulk_delete = async_to_raw_response_wrapper( + namespaces.bulk_delete, + ) + self.bulk_update = async_to_raw_response_wrapper( + namespaces.bulk_update, + ) self.get = async_to_raw_response_wrapper( namespaces.get, ) - @cached_property - def bulk(self) -> AsyncBulkResourceWithRawResponse: - return AsyncBulkResourceWithRawResponse(self._namespaces.bulk) - @cached_property def keys(self) -> AsyncKeysResourceWithRawResponse: return AsyncKeysResourceWithRawResponse(self._namespaces.keys) @@ -711,14 +906,16 @@ def __init__(self, namespaces: NamespacesResource) -> None: self.delete = to_streamed_response_wrapper( namespaces.delete, ) + self.bulk_delete = to_streamed_response_wrapper( + namespaces.bulk_delete, + ) + self.bulk_update = to_streamed_response_wrapper( + namespaces.bulk_update, + ) self.get = to_streamed_response_wrapper( namespaces.get, ) - @cached_property - def bulk(self) -> BulkResourceWithStreamingResponse: - return BulkResourceWithStreamingResponse(self._namespaces.bulk) - @cached_property def keys(self) -> KeysResourceWithStreamingResponse: return KeysResourceWithStreamingResponse(self._namespaces.keys) @@ -748,14 +945,16 @@ def __init__(self, namespaces: AsyncNamespacesResource) -> None: self.delete = async_to_streamed_response_wrapper( namespaces.delete, ) + self.bulk_delete = async_to_streamed_response_wrapper( + namespaces.bulk_delete, + ) + self.bulk_update = async_to_streamed_response_wrapper( + namespaces.bulk_update, + ) self.get = async_to_streamed_response_wrapper( namespaces.get, ) - @cached_property - def bulk(self) -> AsyncBulkResourceWithStreamingResponse: - return AsyncBulkResourceWithStreamingResponse(self._namespaces.bulk) - @cached_property def keys(self) -> AsyncKeysResourceWithStreamingResponse: return AsyncKeysResourceWithStreamingResponse(self._namespaces.keys) diff --git a/src/cloudflare/resources/load_balancers/pools/pools.py b/src/cloudflare/resources/load_balancers/pools/pools.py index 3efd17bda34..db842db77eb 100644 --- a/src/cloudflare/resources/load_balancers/pools/pools.py +++ b/src/cloudflare/resources/load_balancers/pools/pools.py @@ -3,6 +3,7 @@ from __future__ import annotations from typing import List, Type, Iterable, Optional, cast +from typing_extensions import Literal import httpx @@ -43,6 +44,7 @@ pool_list_params, pool_create_params, pool_update_params, + pool_bulk_edit_params, ) from ....types.load_balancers.pool import Pool from ....types.load_balancers.check_region import CheckRegion @@ -50,6 +52,7 @@ from ....types.load_balancers.load_shedding_param import LoadSheddingParam from ....types.load_balancers.pool_delete_response import PoolDeleteResponse from ....types.load_balancers.origin_steering_param import OriginSteeringParam +from ....types.load_balancers.pool_bulk_edit_response import PoolBulkEditResponse from ....types.load_balancers.notification_filter_param import NotificationFilterParam __all__ = ["PoolsResource", "AsyncPoolsResource"] @@ -391,6 +394,55 @@ def delete( cast_to=cast(Type[PoolDeleteResponse], ResultWrapper[PoolDeleteResponse]), ) + def bulk_edit( + self, + *, + account_id: str, + notification_email: Literal[""] | NotGiven = NOT_GIVEN, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + ) -> PoolBulkEditResponse: + """Apply changes to a number of existing pools, overwriting the supplied + properties. + + Pools are ordered by ascending `name`. Returns the list of affected + pools. Supports the standard pagination query parameters, either + `limit`/`offset` or `per_page`/`page`. + + Args: + account_id: Identifier + + notification_email: The email address to send health status notifications to. This field is now + deprecated in favor of Cloudflare Notifications for Load Balancing, so only + resetting this field with an empty string `""` is accepted. + + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + if not account_id: + raise ValueError(f"Expected a non-empty value for `account_id` but received {account_id!r}") + return self._patch( + f"/accounts/{account_id}/load_balancers/pools", + body=maybe_transform({"notification_email": notification_email}, pool_bulk_edit_params.PoolBulkEditParams), + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + post_parser=ResultWrapper[PoolBulkEditResponse]._unwrapper, + ), + cast_to=cast(Type[PoolBulkEditResponse], ResultWrapper[PoolBulkEditResponse]), + ) + def edit( self, pool_id: str, @@ -885,6 +937,57 @@ async def delete( cast_to=cast(Type[PoolDeleteResponse], ResultWrapper[PoolDeleteResponse]), ) + async def bulk_edit( + self, + *, + account_id: str, + notification_email: Literal[""] | NotGiven = NOT_GIVEN, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + ) -> PoolBulkEditResponse: + """Apply changes to a number of existing pools, overwriting the supplied + properties. + + Pools are ordered by ascending `name`. Returns the list of affected + pools. Supports the standard pagination query parameters, either + `limit`/`offset` or `per_page`/`page`. + + Args: + account_id: Identifier + + notification_email: The email address to send health status notifications to. This field is now + deprecated in favor of Cloudflare Notifications for Load Balancing, so only + resetting this field with an empty string `""` is accepted. + + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + if not account_id: + raise ValueError(f"Expected a non-empty value for `account_id` but received {account_id!r}") + return await self._patch( + f"/accounts/{account_id}/load_balancers/pools", + body=await async_maybe_transform( + {"notification_email": notification_email}, pool_bulk_edit_params.PoolBulkEditParams + ), + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + post_parser=ResultWrapper[PoolBulkEditResponse]._unwrapper, + ), + cast_to=cast(Type[PoolBulkEditResponse], ResultWrapper[PoolBulkEditResponse]), + ) + async def edit( self, pool_id: str, @@ -1059,6 +1162,9 @@ def __init__(self, pools: PoolsResource) -> None: self.delete = to_raw_response_wrapper( pools.delete, ) + self.bulk_edit = to_raw_response_wrapper( + pools.bulk_edit, + ) self.edit = to_raw_response_wrapper( pools.edit, ) @@ -1091,6 +1197,9 @@ def __init__(self, pools: AsyncPoolsResource) -> None: self.delete = async_to_raw_response_wrapper( pools.delete, ) + self.bulk_edit = async_to_raw_response_wrapper( + pools.bulk_edit, + ) self.edit = async_to_raw_response_wrapper( pools.edit, ) @@ -1123,6 +1232,9 @@ def __init__(self, pools: PoolsResource) -> None: self.delete = to_streamed_response_wrapper( pools.delete, ) + self.bulk_edit = to_streamed_response_wrapper( + pools.bulk_edit, + ) self.edit = to_streamed_response_wrapper( pools.edit, ) @@ -1155,6 +1267,9 @@ def __init__(self, pools: AsyncPoolsResource) -> None: self.delete = async_to_streamed_response_wrapper( pools.delete, ) + self.bulk_edit = async_to_streamed_response_wrapper( + pools.bulk_edit, + ) self.edit = async_to_streamed_response_wrapper( pools.edit, ) diff --git a/src/cloudflare/resources/magic_transit/cf_interconnects.py b/src/cloudflare/resources/magic_transit/cf_interconnects.py index 843fb30c559..a7d54b6c147 100644 --- a/src/cloudflare/resources/magic_transit/cf_interconnects.py +++ b/src/cloudflare/resources/magic_transit/cf_interconnects.py @@ -23,11 +23,12 @@ ) from ..._wrappers import ResultWrapper from ..._base_client import make_request_options -from ...types.magic_transit import cf_interconnect_update_params +from ...types.magic_transit import cf_interconnect_update_params, cf_interconnect_bulk_update_params from ...types.magic_transit.health_check_param import HealthCheckParam from ...types.magic_transit.cf_interconnect_get_response import CfInterconnectGetResponse from ...types.magic_transit.cf_interconnect_list_response import CfInterconnectListResponse from ...types.magic_transit.cf_interconnect_update_response import CfInterconnectUpdateResponse +from ...types.magic_transit.cf_interconnect_bulk_update_response import CfInterconnectBulkUpdateResponse __all__ = ["CfInterconnectsResource", "AsyncCfInterconnectsResource"] @@ -186,6 +187,61 @@ def list( cast_to=cast(Type[CfInterconnectListResponse], ResultWrapper[CfInterconnectListResponse]), ) + def bulk_update( + self, + *, + account_id: str, + body: object, + x_magic_new_hc_target: bool | NotGiven = NOT_GIVEN, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + ) -> CfInterconnectBulkUpdateResponse: + """Updates multiple interconnects associated with an account. + + Use + `?validate_only=true` as an optional query parameter to only run validation + without persisting changes. + + Args: + account_id: Identifier + + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + if not account_id: + raise ValueError(f"Expected a non-empty value for `account_id` but received {account_id!r}") + extra_headers = { + **strip_not_given( + { + "x-magic-new-hc-target": ("true" if x_magic_new_hc_target else "false") + if is_given(x_magic_new_hc_target) + else NOT_GIVEN + } + ), + **(extra_headers or {}), + } + return self._put( + f"/accounts/{account_id}/magic/cf_interconnects", + body=maybe_transform(body, cf_interconnect_bulk_update_params.CfInterconnectBulkUpdateParams), + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + post_parser=ResultWrapper[CfInterconnectBulkUpdateResponse]._unwrapper, + ), + cast_to=cast(Type[CfInterconnectBulkUpdateResponse], ResultWrapper[CfInterconnectBulkUpdateResponse]), + ) + def get( self, cf_interconnect_id: str, @@ -396,6 +452,61 @@ async def list( cast_to=cast(Type[CfInterconnectListResponse], ResultWrapper[CfInterconnectListResponse]), ) + async def bulk_update( + self, + *, + account_id: str, + body: object, + x_magic_new_hc_target: bool | NotGiven = NOT_GIVEN, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + ) -> CfInterconnectBulkUpdateResponse: + """Updates multiple interconnects associated with an account. + + Use + `?validate_only=true` as an optional query parameter to only run validation + without persisting changes. + + Args: + account_id: Identifier + + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + if not account_id: + raise ValueError(f"Expected a non-empty value for `account_id` but received {account_id!r}") + extra_headers = { + **strip_not_given( + { + "x-magic-new-hc-target": ("true" if x_magic_new_hc_target else "false") + if is_given(x_magic_new_hc_target) + else NOT_GIVEN + } + ), + **(extra_headers or {}), + } + return await self._put( + f"/accounts/{account_id}/magic/cf_interconnects", + body=await async_maybe_transform(body, cf_interconnect_bulk_update_params.CfInterconnectBulkUpdateParams), + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + post_parser=ResultWrapper[CfInterconnectBulkUpdateResponse]._unwrapper, + ), + cast_to=cast(Type[CfInterconnectBulkUpdateResponse], ResultWrapper[CfInterconnectBulkUpdateResponse]), + ) + async def get( self, cf_interconnect_id: str, @@ -462,6 +573,9 @@ def __init__(self, cf_interconnects: CfInterconnectsResource) -> None: self.list = to_raw_response_wrapper( cf_interconnects.list, ) + self.bulk_update = to_raw_response_wrapper( + cf_interconnects.bulk_update, + ) self.get = to_raw_response_wrapper( cf_interconnects.get, ) @@ -477,6 +591,9 @@ def __init__(self, cf_interconnects: AsyncCfInterconnectsResource) -> None: self.list = async_to_raw_response_wrapper( cf_interconnects.list, ) + self.bulk_update = async_to_raw_response_wrapper( + cf_interconnects.bulk_update, + ) self.get = async_to_raw_response_wrapper( cf_interconnects.get, ) @@ -492,6 +609,9 @@ def __init__(self, cf_interconnects: CfInterconnectsResource) -> None: self.list = to_streamed_response_wrapper( cf_interconnects.list, ) + self.bulk_update = to_streamed_response_wrapper( + cf_interconnects.bulk_update, + ) self.get = to_streamed_response_wrapper( cf_interconnects.get, ) @@ -507,6 +627,9 @@ def __init__(self, cf_interconnects: AsyncCfInterconnectsResource) -> None: self.list = async_to_streamed_response_wrapper( cf_interconnects.list, ) + self.bulk_update = async_to_streamed_response_wrapper( + cf_interconnects.bulk_update, + ) self.get = async_to_streamed_response_wrapper( cf_interconnects.get, ) diff --git a/src/cloudflare/resources/magic_transit/gre_tunnels.py b/src/cloudflare/resources/magic_transit/gre_tunnels.py index 60b2dbc9fcc..1d5a624258c 100644 --- a/src/cloudflare/resources/magic_transit/gre_tunnels.py +++ b/src/cloudflare/resources/magic_transit/gre_tunnels.py @@ -23,12 +23,13 @@ ) from ..._wrappers import ResultWrapper from ..._base_client import make_request_options -from ...types.magic_transit import gre_tunnel_create_params, gre_tunnel_update_params +from ...types.magic_transit import gre_tunnel_create_params, gre_tunnel_update_params, gre_tunnel_bulk_update_params from ...types.magic_transit.gre_tunnel_get_response import GRETunnelGetResponse from ...types.magic_transit.gre_tunnel_list_response import GRETunnelListResponse from ...types.magic_transit.gre_tunnel_create_response import GRETunnelCreateResponse from ...types.magic_transit.gre_tunnel_delete_response import GRETunnelDeleteResponse from ...types.magic_transit.gre_tunnel_update_response import GRETunnelUpdateResponse +from ...types.magic_transit.gre_tunnel_bulk_update_response import GRETunnelBulkUpdateResponse __all__ = ["GRETunnelsResource", "AsyncGRETunnelsResource"] @@ -310,6 +311,60 @@ def delete( cast_to=cast(Type[GRETunnelDeleteResponse], ResultWrapper[GRETunnelDeleteResponse]), ) + def bulk_update( + self, + *, + account_id: str, + body: object, + x_magic_new_hc_target: bool | NotGiven = NOT_GIVEN, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + ) -> GRETunnelBulkUpdateResponse: + """Updates multiple GRE tunnels. + + Use `?validate_only=true` as an optional query + parameter to only run validation without persisting changes. + + Args: + account_id: Identifier + + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + if not account_id: + raise ValueError(f"Expected a non-empty value for `account_id` but received {account_id!r}") + extra_headers = { + **strip_not_given( + { + "x-magic-new-hc-target": ("true" if x_magic_new_hc_target else "false") + if is_given(x_magic_new_hc_target) + else NOT_GIVEN + } + ), + **(extra_headers or {}), + } + return self._put( + f"/accounts/{account_id}/magic/gre_tunnels", + body=maybe_transform(body, gre_tunnel_bulk_update_params.GRETunnelBulkUpdateParams), + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + post_parser=ResultWrapper[GRETunnelBulkUpdateResponse]._unwrapper, + ), + cast_to=cast(Type[GRETunnelBulkUpdateResponse], ResultWrapper[GRETunnelBulkUpdateResponse]), + ) + def get( self, gre_tunnel_id: str, @@ -643,6 +698,60 @@ async def delete( cast_to=cast(Type[GRETunnelDeleteResponse], ResultWrapper[GRETunnelDeleteResponse]), ) + async def bulk_update( + self, + *, + account_id: str, + body: object, + x_magic_new_hc_target: bool | NotGiven = NOT_GIVEN, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + ) -> GRETunnelBulkUpdateResponse: + """Updates multiple GRE tunnels. + + Use `?validate_only=true` as an optional query + parameter to only run validation without persisting changes. + + Args: + account_id: Identifier + + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + if not account_id: + raise ValueError(f"Expected a non-empty value for `account_id` but received {account_id!r}") + extra_headers = { + **strip_not_given( + { + "x-magic-new-hc-target": ("true" if x_magic_new_hc_target else "false") + if is_given(x_magic_new_hc_target) + else NOT_GIVEN + } + ), + **(extra_headers or {}), + } + return await self._put( + f"/accounts/{account_id}/magic/gre_tunnels", + body=await async_maybe_transform(body, gre_tunnel_bulk_update_params.GRETunnelBulkUpdateParams), + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + post_parser=ResultWrapper[GRETunnelBulkUpdateResponse]._unwrapper, + ), + cast_to=cast(Type[GRETunnelBulkUpdateResponse], ResultWrapper[GRETunnelBulkUpdateResponse]), + ) + async def get( self, gre_tunnel_id: str, @@ -715,6 +824,9 @@ def __init__(self, gre_tunnels: GRETunnelsResource) -> None: self.delete = to_raw_response_wrapper( gre_tunnels.delete, ) + self.bulk_update = to_raw_response_wrapper( + gre_tunnels.bulk_update, + ) self.get = to_raw_response_wrapper( gre_tunnels.get, ) @@ -736,6 +848,9 @@ def __init__(self, gre_tunnels: AsyncGRETunnelsResource) -> None: self.delete = async_to_raw_response_wrapper( gre_tunnels.delete, ) + self.bulk_update = async_to_raw_response_wrapper( + gre_tunnels.bulk_update, + ) self.get = async_to_raw_response_wrapper( gre_tunnels.get, ) @@ -757,6 +872,9 @@ def __init__(self, gre_tunnels: GRETunnelsResource) -> None: self.delete = to_streamed_response_wrapper( gre_tunnels.delete, ) + self.bulk_update = to_streamed_response_wrapper( + gre_tunnels.bulk_update, + ) self.get = to_streamed_response_wrapper( gre_tunnels.get, ) @@ -778,6 +896,9 @@ def __init__(self, gre_tunnels: AsyncGRETunnelsResource) -> None: self.delete = async_to_streamed_response_wrapper( gre_tunnels.delete, ) + self.bulk_update = async_to_streamed_response_wrapper( + gre_tunnels.bulk_update, + ) self.get = async_to_streamed_response_wrapper( gre_tunnels.get, ) diff --git a/src/cloudflare/resources/magic_transit/ipsec_tunnels.py b/src/cloudflare/resources/magic_transit/ipsec_tunnels.py index d0ff7696e03..e59ba9a890a 100644 --- a/src/cloudflare/resources/magic_transit/ipsec_tunnels.py +++ b/src/cloudflare/resources/magic_transit/ipsec_tunnels.py @@ -26,6 +26,7 @@ from ...types.magic_transit import ( ipsec_tunnel_create_params, ipsec_tunnel_update_params, + ipsec_tunnel_bulk_update_params, ipsec_tunnel_psk_generate_params, ) from ...types.magic_transit.ipsec_tunnel_get_response import IPSECTunnelGetResponse @@ -33,6 +34,7 @@ from ...types.magic_transit.ipsec_tunnel_create_response import IPSECTunnelCreateResponse from ...types.magic_transit.ipsec_tunnel_delete_response import IPSECTunnelDeleteResponse from ...types.magic_transit.ipsec_tunnel_update_response import IPSECTunnelUpdateResponse +from ...types.magic_transit.ipsec_tunnel_bulk_update_response import IPSECTunnelBulkUpdateResponse from ...types.magic_transit.ipsec_tunnel_psk_generate_response import IPSECTunnelPSKGenerateResponse __all__ = ["IPSECTunnelsResource", "AsyncIPSECTunnelsResource"] @@ -354,6 +356,61 @@ def delete( cast_to=cast(Type[IPSECTunnelDeleteResponse], ResultWrapper[IPSECTunnelDeleteResponse]), ) + def bulk_update( + self, + *, + account_id: str, + body: object, + x_magic_new_hc_target: bool | NotGiven = NOT_GIVEN, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + ) -> IPSECTunnelBulkUpdateResponse: + """Update multiple IPsec tunnels associated with an account. + + Use + `?validate_only=true` as an optional query parameter to only run validation + without persisting changes. + + Args: + account_id: Identifier + + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + if not account_id: + raise ValueError(f"Expected a non-empty value for `account_id` but received {account_id!r}") + extra_headers = { + **strip_not_given( + { + "x-magic-new-hc-target": ("true" if x_magic_new_hc_target else "false") + if is_given(x_magic_new_hc_target) + else NOT_GIVEN + } + ), + **(extra_headers or {}), + } + return self._put( + f"/accounts/{account_id}/magic/ipsec_tunnels", + body=maybe_transform(body, ipsec_tunnel_bulk_update_params.IPSECTunnelBulkUpdateParams), + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + post_parser=ResultWrapper[IPSECTunnelBulkUpdateResponse]._unwrapper, + ), + cast_to=cast(Type[IPSECTunnelBulkUpdateResponse], ResultWrapper[IPSECTunnelBulkUpdateResponse]), + ) + def get( self, ipsec_tunnel_id: str, @@ -776,6 +833,61 @@ async def delete( cast_to=cast(Type[IPSECTunnelDeleteResponse], ResultWrapper[IPSECTunnelDeleteResponse]), ) + async def bulk_update( + self, + *, + account_id: str, + body: object, + x_magic_new_hc_target: bool | NotGiven = NOT_GIVEN, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + ) -> IPSECTunnelBulkUpdateResponse: + """Update multiple IPsec tunnels associated with an account. + + Use + `?validate_only=true` as an optional query parameter to only run validation + without persisting changes. + + Args: + account_id: Identifier + + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + if not account_id: + raise ValueError(f"Expected a non-empty value for `account_id` but received {account_id!r}") + extra_headers = { + **strip_not_given( + { + "x-magic-new-hc-target": ("true" if x_magic_new_hc_target else "false") + if is_given(x_magic_new_hc_target) + else NOT_GIVEN + } + ), + **(extra_headers or {}), + } + return await self._put( + f"/accounts/{account_id}/magic/ipsec_tunnels", + body=await async_maybe_transform(body, ipsec_tunnel_bulk_update_params.IPSECTunnelBulkUpdateParams), + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + post_parser=ResultWrapper[IPSECTunnelBulkUpdateResponse]._unwrapper, + ), + cast_to=cast(Type[IPSECTunnelBulkUpdateResponse], ResultWrapper[IPSECTunnelBulkUpdateResponse]), + ) + async def get( self, ipsec_tunnel_id: str, @@ -898,6 +1010,9 @@ def __init__(self, ipsec_tunnels: IPSECTunnelsResource) -> None: self.delete = to_raw_response_wrapper( ipsec_tunnels.delete, ) + self.bulk_update = to_raw_response_wrapper( + ipsec_tunnels.bulk_update, + ) self.get = to_raw_response_wrapper( ipsec_tunnels.get, ) @@ -922,6 +1037,9 @@ def __init__(self, ipsec_tunnels: AsyncIPSECTunnelsResource) -> None: self.delete = async_to_raw_response_wrapper( ipsec_tunnels.delete, ) + self.bulk_update = async_to_raw_response_wrapper( + ipsec_tunnels.bulk_update, + ) self.get = async_to_raw_response_wrapper( ipsec_tunnels.get, ) @@ -946,6 +1064,9 @@ def __init__(self, ipsec_tunnels: IPSECTunnelsResource) -> None: self.delete = to_streamed_response_wrapper( ipsec_tunnels.delete, ) + self.bulk_update = to_streamed_response_wrapper( + ipsec_tunnels.bulk_update, + ) self.get = to_streamed_response_wrapper( ipsec_tunnels.get, ) @@ -970,6 +1091,9 @@ def __init__(self, ipsec_tunnels: AsyncIPSECTunnelsResource) -> None: self.delete = async_to_streamed_response_wrapper( ipsec_tunnels.delete, ) + self.bulk_update = async_to_streamed_response_wrapper( + ipsec_tunnels.bulk_update, + ) self.get = async_to_streamed_response_wrapper( ipsec_tunnels.get, ) diff --git a/src/cloudflare/resources/magic_transit/routes.py b/src/cloudflare/resources/magic_transit/routes.py index ec525c9aa78..c8de89a8570 100644 --- a/src/cloudflare/resources/magic_transit/routes.py +++ b/src/cloudflare/resources/magic_transit/routes.py @@ -2,7 +2,7 @@ from __future__ import annotations -from typing import Type, cast +from typing import Type, Iterable, cast import httpx @@ -21,7 +21,7 @@ ) from ..._wrappers import ResultWrapper from ..._base_client import make_request_options -from ...types.magic_transit import route_create_params, route_update_params +from ...types.magic_transit import route_create_params, route_update_params, route_bulk_update_params from ...types.magic_transit.scope_param import ScopeParam from ...types.magic_transit.route_get_response import RouteGetResponse from ...types.magic_transit.route_list_response import RouteListResponse @@ -29,6 +29,7 @@ from ...types.magic_transit.route_create_response import RouteCreateResponse from ...types.magic_transit.route_delete_response import RouteDeleteResponse from ...types.magic_transit.route_update_response import RouteUpdateResponse +from ...types.magic_transit.route_bulk_update_response import RouteBulkUpdateResponse __all__ = ["RoutesResource", "AsyncRoutesResource"] @@ -254,6 +255,50 @@ def delete( cast_to=cast(Type[RouteDeleteResponse], ResultWrapper[RouteDeleteResponse]), ) + def bulk_update( + self, + *, + account_id: str, + routes: Iterable[route_bulk_update_params.Route], + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + ) -> RouteBulkUpdateResponse: + """Update multiple Magic static routes. + + Use `?validate_only=true` as an optional + query parameter to run validation only without persisting changes. Only fields + for a route that need to be changed need be provided. + + Args: + account_id: Identifier + + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + if not account_id: + raise ValueError(f"Expected a non-empty value for `account_id` but received {account_id!r}") + return self._put( + f"/accounts/{account_id}/magic/routes", + body=maybe_transform({"routes": routes}, route_bulk_update_params.RouteBulkUpdateParams), + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + post_parser=ResultWrapper[RouteBulkUpdateResponse]._unwrapper, + ), + cast_to=cast(Type[RouteBulkUpdateResponse], ResultWrapper[RouteBulkUpdateResponse]), + ) + def empty( self, *, @@ -559,6 +604,50 @@ async def delete( cast_to=cast(Type[RouteDeleteResponse], ResultWrapper[RouteDeleteResponse]), ) + async def bulk_update( + self, + *, + account_id: str, + routes: Iterable[route_bulk_update_params.Route], + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + ) -> RouteBulkUpdateResponse: + """Update multiple Magic static routes. + + Use `?validate_only=true` as an optional + query parameter to run validation only without persisting changes. Only fields + for a route that need to be changed need be provided. + + Args: + account_id: Identifier + + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + if not account_id: + raise ValueError(f"Expected a non-empty value for `account_id` but received {account_id!r}") + return await self._put( + f"/accounts/{account_id}/magic/routes", + body=await async_maybe_transform({"routes": routes}, route_bulk_update_params.RouteBulkUpdateParams), + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + post_parser=ResultWrapper[RouteBulkUpdateResponse]._unwrapper, + ), + cast_to=cast(Type[RouteBulkUpdateResponse], ResultWrapper[RouteBulkUpdateResponse]), + ) + async def empty( self, *, @@ -659,6 +748,9 @@ def __init__(self, routes: RoutesResource) -> None: self.delete = to_raw_response_wrapper( routes.delete, ) + self.bulk_update = to_raw_response_wrapper( + routes.bulk_update, + ) self.empty = to_raw_response_wrapper( routes.empty, ) @@ -683,6 +775,9 @@ def __init__(self, routes: AsyncRoutesResource) -> None: self.delete = async_to_raw_response_wrapper( routes.delete, ) + self.bulk_update = async_to_raw_response_wrapper( + routes.bulk_update, + ) self.empty = async_to_raw_response_wrapper( routes.empty, ) @@ -707,6 +802,9 @@ def __init__(self, routes: RoutesResource) -> None: self.delete = to_streamed_response_wrapper( routes.delete, ) + self.bulk_update = to_streamed_response_wrapper( + routes.bulk_update, + ) self.empty = to_streamed_response_wrapper( routes.empty, ) @@ -731,6 +829,9 @@ def __init__(self, routes: AsyncRoutesResource) -> None: self.delete = async_to_streamed_response_wrapper( routes.delete, ) + self.bulk_update = async_to_streamed_response_wrapper( + routes.bulk_update, + ) self.empty = async_to_streamed_response_wrapper( routes.empty, ) diff --git a/src/cloudflare/resources/rum/rules.py b/src/cloudflare/resources/rum/rules.py index 9dd639c610a..4f81b98d586 100644 --- a/src/cloudflare/resources/rum/rules.py +++ b/src/cloudflare/resources/rum/rules.py @@ -2,7 +2,7 @@ from __future__ import annotations -from typing import List, Type, Optional, cast +from typing import List, Type, Iterable, Optional, cast import httpx @@ -20,11 +20,12 @@ async_to_streamed_response_wrapper, ) from ..._wrappers import ResultWrapper -from ...types.rum import rule_create_params, rule_update_params +from ...types.rum import rule_create_params, rule_update_params, rule_bulk_create_params from ..._base_client import make_request_options from ...types.rum.rum_rule import RUMRule from ...types.rum.rule_list_response import RuleListResponse from ...types.rum.rule_delete_response import RuleDeleteResponse +from ...types.rum.rule_bulk_create_response import RuleBulkCreateResponse __all__ = ["RulesResource", "AsyncRulesResource"] @@ -269,6 +270,63 @@ def delete( cast_to=cast(Type[Optional[RuleDeleteResponse]], ResultWrapper[RuleDeleteResponse]), ) + def bulk_create( + self, + ruleset_id: str, + *, + account_id: str, + delete_rules: List[str] | NotGiven = NOT_GIVEN, + rules: Iterable[rule_bulk_create_params.Rule] | NotGiven = NOT_GIVEN, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + ) -> Optional[RuleBulkCreateResponse]: + """ + Modifies one or more rules in a Web Analytics ruleset with a single request. + + Args: + account_id: Identifier + + ruleset_id: The Web Analytics ruleset identifier. + + delete_rules: A list of rule identifiers to delete. + + rules: A list of rules to create or update. + + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + if not account_id: + raise ValueError(f"Expected a non-empty value for `account_id` but received {account_id!r}") + if not ruleset_id: + raise ValueError(f"Expected a non-empty value for `ruleset_id` but received {ruleset_id!r}") + return self._post( + f"/accounts/{account_id}/rum/v2/{ruleset_id}/rules", + body=maybe_transform( + { + "delete_rules": delete_rules, + "rules": rules, + }, + rule_bulk_create_params.RuleBulkCreateParams, + ), + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + post_parser=ResultWrapper[Optional[RuleBulkCreateResponse]]._unwrapper, + ), + cast_to=cast(Type[Optional[RuleBulkCreateResponse]], ResultWrapper[RuleBulkCreateResponse]), + ) + class AsyncRulesResource(AsyncAPIResource): @cached_property @@ -510,6 +568,63 @@ async def delete( cast_to=cast(Type[Optional[RuleDeleteResponse]], ResultWrapper[RuleDeleteResponse]), ) + async def bulk_create( + self, + ruleset_id: str, + *, + account_id: str, + delete_rules: List[str] | NotGiven = NOT_GIVEN, + rules: Iterable[rule_bulk_create_params.Rule] | NotGiven = NOT_GIVEN, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + ) -> Optional[RuleBulkCreateResponse]: + """ + Modifies one or more rules in a Web Analytics ruleset with a single request. + + Args: + account_id: Identifier + + ruleset_id: The Web Analytics ruleset identifier. + + delete_rules: A list of rule identifiers to delete. + + rules: A list of rules to create or update. + + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + if not account_id: + raise ValueError(f"Expected a non-empty value for `account_id` but received {account_id!r}") + if not ruleset_id: + raise ValueError(f"Expected a non-empty value for `ruleset_id` but received {ruleset_id!r}") + return await self._post( + f"/accounts/{account_id}/rum/v2/{ruleset_id}/rules", + body=await async_maybe_transform( + { + "delete_rules": delete_rules, + "rules": rules, + }, + rule_bulk_create_params.RuleBulkCreateParams, + ), + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + post_parser=ResultWrapper[Optional[RuleBulkCreateResponse]]._unwrapper, + ), + cast_to=cast(Type[Optional[RuleBulkCreateResponse]], ResultWrapper[RuleBulkCreateResponse]), + ) + class RulesResourceWithRawResponse: def __init__(self, rules: RulesResource) -> None: @@ -527,6 +642,9 @@ def __init__(self, rules: RulesResource) -> None: self.delete = to_raw_response_wrapper( rules.delete, ) + self.bulk_create = to_raw_response_wrapper( + rules.bulk_create, + ) class AsyncRulesResourceWithRawResponse: @@ -545,6 +663,9 @@ def __init__(self, rules: AsyncRulesResource) -> None: self.delete = async_to_raw_response_wrapper( rules.delete, ) + self.bulk_create = async_to_raw_response_wrapper( + rules.bulk_create, + ) class RulesResourceWithStreamingResponse: @@ -563,6 +684,9 @@ def __init__(self, rules: RulesResource) -> None: self.delete = to_streamed_response_wrapper( rules.delete, ) + self.bulk_create = to_streamed_response_wrapper( + rules.bulk_create, + ) class AsyncRulesResourceWithStreamingResponse: @@ -581,3 +705,6 @@ def __init__(self, rules: AsyncRulesResource) -> None: self.delete = async_to_streamed_response_wrapper( rules.delete, ) + self.bulk_create = async_to_streamed_response_wrapper( + rules.bulk_create, + ) diff --git a/src/cloudflare/types/api_gateway/__init__.py b/src/cloudflare/types/api_gateway/__init__.py index 15d29b9c6f3..272e71c2b78 100644 --- a/src/cloudflare/types/api_gateway/__init__.py +++ b/src/cloudflare/types/api_gateway/__init__.py @@ -27,3 +27,4 @@ from .configuration_update_params import ConfigurationUpdateParams as ConfigurationUpdateParams from .user_schema_delete_response import UserSchemaDeleteResponse as UserSchemaDeleteResponse from .configuration_update_response import ConfigurationUpdateResponse as ConfigurationUpdateResponse +from .operation_bulk_delete_response import OperationBulkDeleteResponse as OperationBulkDeleteResponse diff --git a/src/cloudflare/types/api_gateway/discovery/__init__.py b/src/cloudflare/types/api_gateway/discovery/__init__.py index 91d80c2cedc..40378bcab0c 100644 --- a/src/cloudflare/types/api_gateway/discovery/__init__.py +++ b/src/cloudflare/types/api_gateway/discovery/__init__.py @@ -5,3 +5,5 @@ from .operation_edit_params import OperationEditParams as OperationEditParams from .operation_list_params import OperationListParams as OperationListParams from .operation_edit_response import OperationEditResponse as OperationEditResponse +from .operation_bulk_edit_params import OperationBulkEditParams as OperationBulkEditParams +from .operation_bulk_edit_response import OperationBulkEditResponse as OperationBulkEditResponse diff --git a/src/cloudflare/types/api_gateway/discovery/operation_bulk_edit_params.py b/src/cloudflare/types/api_gateway/discovery/operation_bulk_edit_params.py new file mode 100644 index 00000000000..db2119fa7b6 --- /dev/null +++ b/src/cloudflare/types/api_gateway/discovery/operation_bulk_edit_params.py @@ -0,0 +1,24 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Dict +from typing_extensions import Literal, Required, TypedDict + +__all__ = ["OperationBulkEditParams", "Body"] + + +class OperationBulkEditParams(TypedDict, total=False): + zone_id: Required[str] + """Identifier""" + + body: Required[Dict[str, Body]] + + +class Body(TypedDict, total=False): + state: Literal["review", "ignored"] + """Mark state of operation in API Discovery + + - `review` - Mark operation as for review + - `ignored` - Mark operation as ignored + """ diff --git a/src/cloudflare/types/api_gateway/discovery/operation_bulk_edit_response.py b/src/cloudflare/types/api_gateway/discovery/operation_bulk_edit_response.py new file mode 100644 index 00000000000..cd0e5264150 --- /dev/null +++ b/src/cloudflare/types/api_gateway/discovery/operation_bulk_edit_response.py @@ -0,0 +1,20 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import Dict, Optional +from typing_extensions import Literal, TypeAlias + +from ...._models import BaseModel + +__all__ = ["OperationBulkEditResponse", "OperationBulkEditResponseItem"] + + +class OperationBulkEditResponseItem(BaseModel): + state: Optional[Literal["review", "ignored"]] = None + """Mark state of operation in API Discovery + + - `review` - Mark operation as for review + - `ignored` - Mark operation as ignored + """ + + +OperationBulkEditResponse: TypeAlias = Dict[str, OperationBulkEditResponseItem] diff --git a/src/cloudflare/types/api_gateway/operation_bulk_delete_response.py b/src/cloudflare/types/api_gateway/operation_bulk_delete_response.py new file mode 100644 index 00000000000..fa2db0d647c --- /dev/null +++ b/src/cloudflare/types/api_gateway/operation_bulk_delete_response.py @@ -0,0 +1,17 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing_extensions import Literal + +from .message import Message +from ..._models import BaseModel + +__all__ = ["OperationBulkDeleteResponse"] + + +class OperationBulkDeleteResponse(BaseModel): + errors: Message + + messages: Message + + success: Literal[True] + """Whether the API call was successful""" diff --git a/src/cloudflare/types/email_security/settings/__init__.py b/src/cloudflare/types/email_security/settings/__init__.py index 3cdacd3f71b..26c5fc41f06 100644 --- a/src/cloudflare/types/email_security/settings/__init__.py +++ b/src/cloudflare/types/email_security/settings/__init__.py @@ -22,6 +22,7 @@ from .block_sender_list_response import BlockSenderListResponse as BlockSenderListResponse from .trusted_domain_edit_params import TrustedDomainEditParams as TrustedDomainEditParams from .trusted_domain_list_params import TrustedDomainListParams as TrustedDomainListParams +from .domain_bulk_delete_response import DomainBulkDeleteResponse as DomainBulkDeleteResponse from .trusted_domain_get_response import TrustedDomainGetResponse as TrustedDomainGetResponse from .allow_policy_create_response import AllowPolicyCreateResponse as AllowPolicyCreateResponse from .allow_policy_delete_response import AllowPolicyDeleteResponse as AllowPolicyDeleteResponse diff --git a/src/cloudflare/types/email_security/settings/domain_bulk_delete_response.py b/src/cloudflare/types/email_security/settings/domain_bulk_delete_response.py new file mode 100644 index 00000000000..bf90cf2a6ed --- /dev/null +++ b/src/cloudflare/types/email_security/settings/domain_bulk_delete_response.py @@ -0,0 +1,16 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List +from typing_extensions import TypeAlias + +from ...._models import BaseModel + +__all__ = ["DomainBulkDeleteResponse", "DomainBulkDeleteResponseItem"] + + +class DomainBulkDeleteResponseItem(BaseModel): + id: int + """The unique identifier for the domain.""" + + +DomainBulkDeleteResponse: TypeAlias = List[DomainBulkDeleteResponseItem] diff --git a/src/cloudflare/types/filters/__init__.py b/src/cloudflare/types/filters/__init__.py index 84b9f911178..be5345ef460 100644 --- a/src/cloudflare/types/filters/__init__.py +++ b/src/cloudflare/types/filters/__init__.py @@ -8,3 +8,5 @@ from .filter_update_params import FilterUpdateParams as FilterUpdateParams from .firewall_filter_param import FirewallFilterParam as FirewallFilterParam from .filter_create_response import FilterCreateResponse as FilterCreateResponse +from .filter_bulk_delete_response import FilterBulkDeleteResponse as FilterBulkDeleteResponse +from .filter_bulk_update_response import FilterBulkUpdateResponse as FilterBulkUpdateResponse diff --git a/src/cloudflare/types/filters/filter_bulk_delete_response.py b/src/cloudflare/types/filters/filter_bulk_delete_response.py new file mode 100644 index 00000000000..7a37b1b4cbd --- /dev/null +++ b/src/cloudflare/types/filters/filter_bulk_delete_response.py @@ -0,0 +1,10 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List +from typing_extensions import TypeAlias + +from .firewall_filter import FirewallFilter + +__all__ = ["FilterBulkDeleteResponse"] + +FilterBulkDeleteResponse: TypeAlias = List[FirewallFilter] diff --git a/src/cloudflare/types/filters/filter_bulk_update_response.py b/src/cloudflare/types/filters/filter_bulk_update_response.py new file mode 100644 index 00000000000..48059fa12a6 --- /dev/null +++ b/src/cloudflare/types/filters/filter_bulk_update_response.py @@ -0,0 +1,10 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List +from typing_extensions import TypeAlias + +from .firewall_filter import FirewallFilter + +__all__ = ["FilterBulkUpdateResponse"] + +FilterBulkUpdateResponse: TypeAlias = List[FirewallFilter] diff --git a/src/cloudflare/types/firewall/__init__.py b/src/cloudflare/types/firewall/__init__.py index 9e3458a7b6d..0b12a89c62b 100644 --- a/src/cloudflare/types/firewall/__init__.py +++ b/src/cloudflare/types/firewall/__init__.py @@ -21,6 +21,7 @@ from .rule_create_response import RuleCreateResponse as RuleCreateResponse from .ua_rule_get_response import UARuleGetResponse as UARuleGetResponse from .country_configuration import CountryConfiguration as CountryConfiguration +from .rule_bulk_edit_params import RuleBulkEditParams as RuleBulkEditParams from .ua_rule_create_params import UARuleCreateParams as UARuleCreateParams from .ua_rule_list_response import UARuleListResponse as UARuleListResponse from .ua_rule_update_params import UARuleUpdateParams as UARuleUpdateParams @@ -29,6 +30,8 @@ from .access_rule_edit_params import AccessRuleEditParams as AccessRuleEditParams from .access_rule_list_params import AccessRuleListParams as AccessRuleListParams from .asn_configuration_param import ASNConfigurationParam as ASNConfigurationParam +from .rule_bulk_edit_response import RuleBulkEditResponse as RuleBulkEditResponse +from .rule_bulk_update_params import RuleBulkUpdateParams as RuleBulkUpdateParams from .ua_rule_create_response import UARuleCreateResponse as UARuleCreateResponse from .ua_rule_delete_response import UARuleDeleteResponse as UARuleDeleteResponse from .ua_rule_update_response import UARuleUpdateResponse as UARuleUpdateResponse @@ -39,6 +42,8 @@ from .access_rule_edit_response import AccessRuleEditResponse as AccessRuleEditResponse from .access_rule_list_response import AccessRuleListResponse as AccessRuleListResponse from .lockdown_ip_configuration import LockdownIPConfiguration as LockdownIPConfiguration +from .rule_bulk_delete_response import RuleBulkDeleteResponse as RuleBulkDeleteResponse +from .rule_bulk_update_response import RuleBulkUpdateResponse as RuleBulkUpdateResponse from .access_rule_create_response import AccessRuleCreateResponse as AccessRuleCreateResponse from .access_rule_delete_response import AccessRuleDeleteResponse as AccessRuleDeleteResponse from .country_configuration_param import CountryConfigurationParam as CountryConfigurationParam diff --git a/src/cloudflare/types/firewall/rule_bulk_delete_response.py b/src/cloudflare/types/firewall/rule_bulk_delete_response.py new file mode 100644 index 00000000000..535192b8afb --- /dev/null +++ b/src/cloudflare/types/firewall/rule_bulk_delete_response.py @@ -0,0 +1,10 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List +from typing_extensions import TypeAlias + +from .firewall_rule import FirewallRule + +__all__ = ["RuleBulkDeleteResponse"] + +RuleBulkDeleteResponse: TypeAlias = List[FirewallRule] diff --git a/src/cloudflare/types/firewall/rule_bulk_edit_params.py b/src/cloudflare/types/firewall/rule_bulk_edit_params.py new file mode 100644 index 00000000000..f47f108569c --- /dev/null +++ b/src/cloudflare/types/firewall/rule_bulk_edit_params.py @@ -0,0 +1,14 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing_extensions import Required, TypedDict + +__all__ = ["RuleBulkEditParams"] + + +class RuleBulkEditParams(TypedDict, total=False): + zone_id: Required[str] + """Identifier""" + + body: Required[object] diff --git a/src/cloudflare/types/firewall/rule_bulk_edit_response.py b/src/cloudflare/types/firewall/rule_bulk_edit_response.py new file mode 100644 index 00000000000..f6d4fdaf7f2 --- /dev/null +++ b/src/cloudflare/types/firewall/rule_bulk_edit_response.py @@ -0,0 +1,10 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List +from typing_extensions import TypeAlias + +from .firewall_rule import FirewallRule + +__all__ = ["RuleBulkEditResponse"] + +RuleBulkEditResponse: TypeAlias = List[FirewallRule] diff --git a/src/cloudflare/types/firewall/rule_bulk_update_params.py b/src/cloudflare/types/firewall/rule_bulk_update_params.py new file mode 100644 index 00000000000..97016b19207 --- /dev/null +++ b/src/cloudflare/types/firewall/rule_bulk_update_params.py @@ -0,0 +1,14 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing_extensions import Required, TypedDict + +__all__ = ["RuleBulkUpdateParams"] + + +class RuleBulkUpdateParams(TypedDict, total=False): + zone_id: Required[str] + """Identifier""" + + body: Required[object] diff --git a/src/cloudflare/types/firewall/rule_bulk_update_response.py b/src/cloudflare/types/firewall/rule_bulk_update_response.py new file mode 100644 index 00000000000..d8bacf8ab0e --- /dev/null +++ b/src/cloudflare/types/firewall/rule_bulk_update_response.py @@ -0,0 +1,10 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List +from typing_extensions import TypeAlias + +from .firewall_rule import FirewallRule + +__all__ = ["RuleBulkUpdateResponse"] + +RuleBulkUpdateResponse: TypeAlias = List[FirewallRule] diff --git a/src/cloudflare/types/kv/__init__.py b/src/cloudflare/types/kv/__init__.py index e345eaf540a..afaccc1c1e0 100644 --- a/src/cloudflare/types/kv/__init__.py +++ b/src/cloudflare/types/kv/__init__.py @@ -8,3 +8,7 @@ from .namespace_update_params import NamespaceUpdateParams as NamespaceUpdateParams from .namespace_delete_response import NamespaceDeleteResponse as NamespaceDeleteResponse from .namespace_update_response import NamespaceUpdateResponse as NamespaceUpdateResponse +from .namespace_bulk_delete_params import NamespaceBulkDeleteParams as NamespaceBulkDeleteParams +from .namespace_bulk_update_params import NamespaceBulkUpdateParams as NamespaceBulkUpdateParams +from .namespace_bulk_delete_response import NamespaceBulkDeleteResponse as NamespaceBulkDeleteResponse +from .namespace_bulk_update_response import NamespaceBulkUpdateResponse as NamespaceBulkUpdateResponse diff --git a/src/cloudflare/types/kv/namespace_bulk_delete_params.py b/src/cloudflare/types/kv/namespace_bulk_delete_params.py new file mode 100644 index 00000000000..1de9c109a16 --- /dev/null +++ b/src/cloudflare/types/kv/namespace_bulk_delete_params.py @@ -0,0 +1,15 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import List +from typing_extensions import Required, TypedDict + +__all__ = ["NamespaceBulkDeleteParams"] + + +class NamespaceBulkDeleteParams(TypedDict, total=False): + account_id: Required[str] + """Identifier""" + + body: Required[List[str]] diff --git a/src/cloudflare/types/kv/namespaces/bulk_delete_response.py b/src/cloudflare/types/kv/namespace_bulk_delete_response.py similarity index 74% rename from src/cloudflare/types/kv/namespaces/bulk_delete_response.py rename to src/cloudflare/types/kv/namespace_bulk_delete_response.py index d0ff56c5e18..5cf86953b96 100644 --- a/src/cloudflare/types/kv/namespaces/bulk_delete_response.py +++ b/src/cloudflare/types/kv/namespace_bulk_delete_response.py @@ -2,12 +2,12 @@ from typing import List, Optional -from ...._models import BaseModel +from ..._models import BaseModel -__all__ = ["BulkDeleteResponse"] +__all__ = ["NamespaceBulkDeleteResponse"] -class BulkDeleteResponse(BaseModel): +class NamespaceBulkDeleteResponse(BaseModel): successful_key_count: Optional[float] = None """Number of keys successfully updated""" diff --git a/src/cloudflare/types/kv/namespaces/bulk_update_params.py b/src/cloudflare/types/kv/namespace_bulk_update_params.py similarity index 91% rename from src/cloudflare/types/kv/namespaces/bulk_update_params.py rename to src/cloudflare/types/kv/namespace_bulk_update_params.py index 6cb8d8702c8..e1ce68a86b6 100644 --- a/src/cloudflare/types/kv/namespaces/bulk_update_params.py +++ b/src/cloudflare/types/kv/namespace_bulk_update_params.py @@ -5,10 +5,10 @@ from typing import Dict, Iterable from typing_extensions import Required, TypedDict -__all__ = ["BulkUpdateParams", "Body"] +__all__ = ["NamespaceBulkUpdateParams", "Body"] -class BulkUpdateParams(TypedDict, total=False): +class NamespaceBulkUpdateParams(TypedDict, total=False): account_id: Required[str] """Identifier""" diff --git a/src/cloudflare/types/kv/namespaces/bulk_update_response.py b/src/cloudflare/types/kv/namespace_bulk_update_response.py similarity index 74% rename from src/cloudflare/types/kv/namespaces/bulk_update_response.py rename to src/cloudflare/types/kv/namespace_bulk_update_response.py index 083a81a27f8..6076c1444f5 100644 --- a/src/cloudflare/types/kv/namespaces/bulk_update_response.py +++ b/src/cloudflare/types/kv/namespace_bulk_update_response.py @@ -2,12 +2,12 @@ from typing import List, Optional -from ...._models import BaseModel +from ..._models import BaseModel -__all__ = ["BulkUpdateResponse"] +__all__ = ["NamespaceBulkUpdateResponse"] -class BulkUpdateResponse(BaseModel): +class NamespaceBulkUpdateResponse(BaseModel): successful_key_count: Optional[float] = None """Number of keys successfully updated""" diff --git a/src/cloudflare/types/kv/namespaces/__init__.py b/src/cloudflare/types/kv/namespaces/__init__.py index 69632f0965e..49140e07efe 100644 --- a/src/cloudflare/types/kv/namespaces/__init__.py +++ b/src/cloudflare/types/kv/namespaces/__init__.py @@ -4,10 +4,7 @@ from .key import Key as Key from .key_list_params import KeyListParams as KeyListParams -from .bulk_update_params import BulkUpdateParams as BulkUpdateParams from .value_update_params import ValueUpdateParams as ValueUpdateParams -from .bulk_delete_response import BulkDeleteResponse as BulkDeleteResponse -from .bulk_update_response import BulkUpdateResponse as BulkUpdateResponse from .metadata_get_response import MetadataGetResponse as MetadataGetResponse from .value_delete_response import ValueDeleteResponse as ValueDeleteResponse from .value_update_response import ValueUpdateResponse as ValueUpdateResponse diff --git a/src/cloudflare/types/load_balancers/__init__.py b/src/cloudflare/types/load_balancers/__init__.py index 46d78e92ec5..c6035687d61 100644 --- a/src/cloudflare/types/load_balancers/__init__.py +++ b/src/cloudflare/types/load_balancers/__init__.py @@ -40,10 +40,12 @@ from .monitor_create_params import MonitorCreateParams as MonitorCreateParams from .monitor_update_params import MonitorUpdateParams as MonitorUpdateParams from .origin_steering_param import OriginSteeringParam as OriginSteeringParam +from .pool_bulk_edit_params import PoolBulkEditParams as PoolBulkEditParams from .random_steering_param import RandomSteeringParam as RandomSteeringParam from .adaptive_routing_param import AdaptiveRoutingParam as AdaptiveRoutingParam from .location_strategy_param import LocationStrategyParam as LocationStrategyParam from .monitor_delete_response import MonitorDeleteResponse as MonitorDeleteResponse +from .pool_bulk_edit_response import PoolBulkEditResponse as PoolBulkEditResponse from .load_balancer_edit_params import LoadBalancerEditParams as LoadBalancerEditParams from .notification_filter_param import NotificationFilterParam as NotificationFilterParam from .load_balancer_create_params import LoadBalancerCreateParams as LoadBalancerCreateParams diff --git a/src/cloudflare/types/load_balancers/pool_bulk_edit_params.py b/src/cloudflare/types/load_balancers/pool_bulk_edit_params.py new file mode 100644 index 00000000000..4e1d26424e0 --- /dev/null +++ b/src/cloudflare/types/load_balancers/pool_bulk_edit_params.py @@ -0,0 +1,19 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing_extensions import Literal, Required, TypedDict + +__all__ = ["PoolBulkEditParams"] + + +class PoolBulkEditParams(TypedDict, total=False): + account_id: Required[str] + """Identifier""" + + notification_email: Literal[""] + """The email address to send health status notifications to. + + This field is now deprecated in favor of Cloudflare Notifications for Load + Balancing, so only resetting this field with an empty string `""` is accepted. + """ diff --git a/src/cloudflare/types/load_balancers/pool_bulk_edit_response.py b/src/cloudflare/types/load_balancers/pool_bulk_edit_response.py new file mode 100644 index 00000000000..068a163bed5 --- /dev/null +++ b/src/cloudflare/types/load_balancers/pool_bulk_edit_response.py @@ -0,0 +1,10 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List +from typing_extensions import TypeAlias + +from .pool import Pool + +__all__ = ["PoolBulkEditResponse"] + +PoolBulkEditResponse: TypeAlias = List[Pool] diff --git a/src/cloudflare/types/magic_transit/__init__.py b/src/cloudflare/types/magic_transit/__init__.py index 099059832ec..26a12934156 100644 --- a/src/cloudflare/types/magic_transit/__init__.py +++ b/src/cloudflare/types/magic_transit/__init__.py @@ -46,6 +46,7 @@ from .gre_tunnel_create_params import GRETunnelCreateParams as GRETunnelCreateParams from .gre_tunnel_list_response import GRETunnelListResponse as GRETunnelListResponse from .gre_tunnel_update_params import GRETunnelUpdateParams as GRETunnelUpdateParams +from .route_bulk_update_params import RouteBulkUpdateParams as RouteBulkUpdateParams from .connector_update_response import ConnectorUpdateResponse as ConnectorUpdateResponse from .ipsec_tunnel_get_response import IPSECTunnelGetResponse as IPSECTunnelGetResponse from .gre_tunnel_create_response import GRETunnelCreateResponse as GRETunnelCreateResponse @@ -54,12 +55,19 @@ from .ipsec_tunnel_create_params import IPSECTunnelCreateParams as IPSECTunnelCreateParams from .ipsec_tunnel_list_response import IPSECTunnelListResponse as IPSECTunnelListResponse from .ipsec_tunnel_update_params import IPSECTunnelUpdateParams as IPSECTunnelUpdateParams +from .route_bulk_update_response import RouteBulkUpdateResponse as RouteBulkUpdateResponse from .cf_interconnect_get_response import CfInterconnectGetResponse as CfInterconnectGetResponse from .ipsec_tunnel_create_response import IPSECTunnelCreateResponse as IPSECTunnelCreateResponse from .ipsec_tunnel_delete_response import IPSECTunnelDeleteResponse as IPSECTunnelDeleteResponse from .ipsec_tunnel_update_response import IPSECTunnelUpdateResponse as IPSECTunnelUpdateResponse from .cf_interconnect_list_response import CfInterconnectListResponse as CfInterconnectListResponse from .cf_interconnect_update_params import CfInterconnectUpdateParams as CfInterconnectUpdateParams +from .gre_tunnel_bulk_update_params import GRETunnelBulkUpdateParams as GRETunnelBulkUpdateParams from .cf_interconnect_update_response import CfInterconnectUpdateResponse as CfInterconnectUpdateResponse +from .gre_tunnel_bulk_update_response import GRETunnelBulkUpdateResponse as GRETunnelBulkUpdateResponse +from .ipsec_tunnel_bulk_update_params import IPSECTunnelBulkUpdateParams as IPSECTunnelBulkUpdateParams from .ipsec_tunnel_psk_generate_params import IPSECTunnelPSKGenerateParams as IPSECTunnelPSKGenerateParams +from .ipsec_tunnel_bulk_update_response import IPSECTunnelBulkUpdateResponse as IPSECTunnelBulkUpdateResponse +from .cf_interconnect_bulk_update_params import CfInterconnectBulkUpdateParams as CfInterconnectBulkUpdateParams from .ipsec_tunnel_psk_generate_response import IPSECTunnelPSKGenerateResponse as IPSECTunnelPSKGenerateResponse +from .cf_interconnect_bulk_update_response import CfInterconnectBulkUpdateResponse as CfInterconnectBulkUpdateResponse diff --git a/src/cloudflare/types/magic_transit/cf_interconnect_bulk_update_params.py b/src/cloudflare/types/magic_transit/cf_interconnect_bulk_update_params.py new file mode 100644 index 00000000000..ab9e94f12de --- /dev/null +++ b/src/cloudflare/types/magic_transit/cf_interconnect_bulk_update_params.py @@ -0,0 +1,18 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing_extensions import Required, Annotated, TypedDict + +from ..._utils import PropertyInfo + +__all__ = ["CfInterconnectBulkUpdateParams"] + + +class CfInterconnectBulkUpdateParams(TypedDict, total=False): + account_id: Required[str] + """Identifier""" + + body: Required[object] + + x_magic_new_hc_target: Annotated[bool, PropertyInfo(alias="x-magic-new-hc-target")] diff --git a/src/cloudflare/types/magic_transit/cf_interconnect_bulk_update_response.py b/src/cloudflare/types/magic_transit/cf_interconnect_bulk_update_response.py new file mode 100644 index 00000000000..958181967d4 --- /dev/null +++ b/src/cloudflare/types/magic_transit/cf_interconnect_bulk_update_response.py @@ -0,0 +1,61 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List, Optional +from datetime import datetime + +from ..._models import BaseModel +from .health_check import HealthCheck + +__all__ = ["CfInterconnectBulkUpdateResponse", "ModifiedInterconnect", "ModifiedInterconnectGRE"] + + +class ModifiedInterconnectGRE(BaseModel): + cloudflare_endpoint: Optional[str] = None + """ + The IP address assigned to the Cloudflare side of the GRE tunnel created as part + of the Interconnect. + """ + + +class ModifiedInterconnect(BaseModel): + id: Optional[str] = None + """Tunnel identifier tag.""" + + colo_name: Optional[str] = None + """The name of the interconnect. The name cannot share a name with other tunnels.""" + + created_on: Optional[datetime] = None + """The date and time the tunnel was created.""" + + description: Optional[str] = None + """An optional description of the interconnect.""" + + gre: Optional[ModifiedInterconnectGRE] = None + """The configuration specific to GRE interconnects.""" + + health_check: Optional[HealthCheck] = None + + interface_address: Optional[str] = None + """ + A 31-bit prefix (/31 in CIDR notation) supporting two hosts, one for each side + of the tunnel. Select the subnet from the following private IP space: + 10.0.0.0–10.255.255.255, 172.16.0.0–172.31.255.255, 192.168.0.0–192.168.255.255. + """ + + modified_on: Optional[datetime] = None + """The date and time the tunnel was last modified.""" + + mtu: Optional[int] = None + """The Maximum Transmission Unit (MTU) in bytes for the interconnect. + + The minimum value is 576. + """ + + name: Optional[str] = None + """The name of the interconnect. The name cannot share a name with other tunnels.""" + + +class CfInterconnectBulkUpdateResponse(BaseModel): + modified: Optional[bool] = None + + modified_interconnects: Optional[List[ModifiedInterconnect]] = None diff --git a/src/cloudflare/types/magic_transit/gre_tunnel_bulk_update_params.py b/src/cloudflare/types/magic_transit/gre_tunnel_bulk_update_params.py new file mode 100644 index 00000000000..652e4f41702 --- /dev/null +++ b/src/cloudflare/types/magic_transit/gre_tunnel_bulk_update_params.py @@ -0,0 +1,18 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing_extensions import Required, Annotated, TypedDict + +from ..._utils import PropertyInfo + +__all__ = ["GRETunnelBulkUpdateParams"] + + +class GRETunnelBulkUpdateParams(TypedDict, total=False): + account_id: Required[str] + """Identifier""" + + body: Required[object] + + x_magic_new_hc_target: Annotated[bool, PropertyInfo(alias="x-magic-new-hc-target")] diff --git a/src/cloudflare/types/magic_transit/gre_tunnel_bulk_update_response.py b/src/cloudflare/types/magic_transit/gre_tunnel_bulk_update_response.py new file mode 100644 index 00000000000..5ee74bdd932 --- /dev/null +++ b/src/cloudflare/types/magic_transit/gre_tunnel_bulk_update_response.py @@ -0,0 +1,118 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List, Union, Optional +from datetime import datetime +from typing_extensions import Literal, TypeAlias + +from ..._models import BaseModel +from .health_check_rate import HealthCheckRate +from .health_check_type import HealthCheckType + +__all__ = [ + "GRETunnelBulkUpdateResponse", + "ModifiedGRETunnel", + "ModifiedGRETunnelHealthCheck", + "ModifiedGRETunnelHealthCheckTarget", + "ModifiedGRETunnelHealthCheckTargetMagicHealthCheckTarget", +] + + +class ModifiedGRETunnelHealthCheckTargetMagicHealthCheckTarget(BaseModel): + effective: Optional[str] = None + """The effective health check target. + + If 'saved' is empty, then this field will be populated with the calculated + default value on GET requests. Ignored in POST, PUT, and PATCH requests. + """ + + saved: Optional[str] = None + """The saved health check target. + + Setting the value to the empty string indicates that the calculated default + value will be used. + """ + + +ModifiedGRETunnelHealthCheckTarget: TypeAlias = Union[ModifiedGRETunnelHealthCheckTargetMagicHealthCheckTarget, str] + + +class ModifiedGRETunnelHealthCheck(BaseModel): + direction: Optional[Literal["unidirectional", "bidirectional"]] = None + """The direction of the flow of the healthcheck. + + Either unidirectional, where the probe comes to you via the tunnel and the + result comes back to Cloudflare via the open Internet, or bidirectional where + both the probe and result come and go via the tunnel. + """ + + enabled: Optional[bool] = None + """Determines whether to run healthchecks for a tunnel.""" + + rate: Optional[HealthCheckRate] = None + """How frequent the health check is run. The default value is `mid`.""" + + target: Optional[ModifiedGRETunnelHealthCheckTarget] = None + """The destination address in a request type health check. + + After the healthcheck is decapsulated at the customer end of the tunnel, the + ICMP echo will be forwarded to this address. This field defaults to + `customer_gre_endpoint address`. This field is ignored for bidirectional + healthchecks as the interface_address (not assigned to the Cloudflare side of + the tunnel) is used as the target. Must be in object form if the + x-magic-new-hc-target header is set to true and string form if + x-magic-new-hc-target is absent or set to false. + """ + + type: Optional[HealthCheckType] = None + """The type of healthcheck to run, reply or request. The default value is `reply`.""" + + +class ModifiedGRETunnel(BaseModel): + cloudflare_gre_endpoint: str + """The IP address assigned to the Cloudflare side of the GRE tunnel.""" + + customer_gre_endpoint: str + """The IP address assigned to the customer side of the GRE tunnel.""" + + interface_address: str + """ + A 31-bit prefix (/31 in CIDR notation) supporting two hosts, one for each side + of the tunnel. Select the subnet from the following private IP space: + 10.0.0.0–10.255.255.255, 172.16.0.0–172.31.255.255, 192.168.0.0–192.168.255.255. + """ + + name: str + """The name of the tunnel. + + The name cannot contain spaces or special characters, must be 15 characters or + less, and cannot share a name with another GRE tunnel. + """ + + id: Optional[str] = None + """Tunnel identifier tag.""" + + created_on: Optional[datetime] = None + """The date and time the tunnel was created.""" + + description: Optional[str] = None + """An optional description of the GRE tunnel.""" + + health_check: Optional[ModifiedGRETunnelHealthCheck] = None + + modified_on: Optional[datetime] = None + """The date and time the tunnel was last modified.""" + + mtu: Optional[int] = None + """Maximum Transmission Unit (MTU) in bytes for the GRE tunnel. + + The minimum value is 576. + """ + + ttl: Optional[int] = None + """Time To Live (TTL) in number of hops of the GRE tunnel.""" + + +class GRETunnelBulkUpdateResponse(BaseModel): + modified: Optional[bool] = None + + modified_gre_tunnels: Optional[List[ModifiedGRETunnel]] = None diff --git a/src/cloudflare/types/magic_transit/ipsec_tunnel_bulk_update_params.py b/src/cloudflare/types/magic_transit/ipsec_tunnel_bulk_update_params.py new file mode 100644 index 00000000000..c35b7181e30 --- /dev/null +++ b/src/cloudflare/types/magic_transit/ipsec_tunnel_bulk_update_params.py @@ -0,0 +1,18 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing_extensions import Required, Annotated, TypedDict + +from ..._utils import PropertyInfo + +__all__ = ["IPSECTunnelBulkUpdateParams"] + + +class IPSECTunnelBulkUpdateParams(TypedDict, total=False): + account_id: Required[str] + """Identifier""" + + body: Required[object] + + x_magic_new_hc_target: Annotated[bool, PropertyInfo(alias="x-magic-new-hc-target")] diff --git a/src/cloudflare/types/magic_transit/ipsec_tunnel_bulk_update_response.py b/src/cloudflare/types/magic_transit/ipsec_tunnel_bulk_update_response.py new file mode 100644 index 00000000000..107d0ce5fa5 --- /dev/null +++ b/src/cloudflare/types/magic_transit/ipsec_tunnel_bulk_update_response.py @@ -0,0 +1,124 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List, Union, Optional +from datetime import datetime +from typing_extensions import Literal, TypeAlias + +from ..._models import BaseModel +from .psk_metadata import PSKMetadata +from .health_check_rate import HealthCheckRate +from .health_check_type import HealthCheckType + +__all__ = [ + "IPSECTunnelBulkUpdateResponse", + "ModifiedIPSECTunnel", + "ModifiedIPSECTunnelHealthCheck", + "ModifiedIPSECTunnelHealthCheckTarget", + "ModifiedIPSECTunnelHealthCheckTargetMagicHealthCheckTarget", +] + + +class ModifiedIPSECTunnelHealthCheckTargetMagicHealthCheckTarget(BaseModel): + effective: Optional[str] = None + """The effective health check target. + + If 'saved' is empty, then this field will be populated with the calculated + default value on GET requests. Ignored in POST, PUT, and PATCH requests. + """ + + saved: Optional[str] = None + """The saved health check target. + + Setting the value to the empty string indicates that the calculated default + value will be used. + """ + + +ModifiedIPSECTunnelHealthCheckTarget: TypeAlias = Union[ModifiedIPSECTunnelHealthCheckTargetMagicHealthCheckTarget, str] + + +class ModifiedIPSECTunnelHealthCheck(BaseModel): + direction: Optional[Literal["unidirectional", "bidirectional"]] = None + """The direction of the flow of the healthcheck. + + Either unidirectional, where the probe comes to you via the tunnel and the + result comes back to Cloudflare via the open Internet, or bidirectional where + both the probe and result come and go via the tunnel. + """ + + enabled: Optional[bool] = None + """Determines whether to run healthchecks for a tunnel.""" + + rate: Optional[HealthCheckRate] = None + """How frequent the health check is run. The default value is `mid`.""" + + target: Optional[ModifiedIPSECTunnelHealthCheckTarget] = None + """The destination address in a request type health check. + + After the healthcheck is decapsulated at the customer end of the tunnel, the + ICMP echo will be forwarded to this address. This field defaults to + `customer_gre_endpoint address`. This field is ignored for bidirectional + healthchecks as the interface_address (not assigned to the Cloudflare side of + the tunnel) is used as the target. Must be in object form if the + x-magic-new-hc-target header is set to true and string form if + x-magic-new-hc-target is absent or set to false. + """ + + type: Optional[HealthCheckType] = None + """The type of healthcheck to run, reply or request. The default value is `reply`.""" + + +class ModifiedIPSECTunnel(BaseModel): + cloudflare_endpoint: str + """The IP address assigned to the Cloudflare side of the IPsec tunnel.""" + + interface_address: str + """ + A 31-bit prefix (/31 in CIDR notation) supporting two hosts, one for each side + of the tunnel. Select the subnet from the following private IP space: + 10.0.0.0–10.255.255.255, 172.16.0.0–172.31.255.255, 192.168.0.0–192.168.255.255. + """ + + name: str + """The name of the IPsec tunnel. The name cannot share a name with other tunnels.""" + + id: Optional[str] = None + """Tunnel identifier tag.""" + + allow_null_cipher: Optional[bool] = None + """ + When `true`, the tunnel can use a null-cipher (`ENCR_NULL`) in the ESP tunnel + (Phase 2). + """ + + created_on: Optional[datetime] = None + """The date and time the tunnel was created.""" + + customer_endpoint: Optional[str] = None + """The IP address assigned to the customer side of the IPsec tunnel. + + Not required, but must be set for proactive traceroutes to work. + """ + + description: Optional[str] = None + """An optional description forthe IPsec tunnel.""" + + health_check: Optional[ModifiedIPSECTunnelHealthCheck] = None + + modified_on: Optional[datetime] = None + """The date and time the tunnel was last modified.""" + + psk_metadata: Optional[PSKMetadata] = None + """The PSK metadata that includes when the PSK was generated.""" + + replay_protection: Optional[bool] = None + """ + If `true`, then IPsec replay protection will be supported in the + Cloudflare-to-customer direction. + """ + + +class IPSECTunnelBulkUpdateResponse(BaseModel): + modified: Optional[bool] = None + + modified_ipsec_tunnels: Optional[List[ModifiedIPSECTunnel]] = None diff --git a/src/cloudflare/types/magic_transit/route_bulk_update_params.py b/src/cloudflare/types/magic_transit/route_bulk_update_params.py new file mode 100644 index 00000000000..9fe9f18041d --- /dev/null +++ b/src/cloudflare/types/magic_transit/route_bulk_update_params.py @@ -0,0 +1,40 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Iterable +from typing_extensions import Required, TypedDict + +from .scope_param import ScopeParam + +__all__ = ["RouteBulkUpdateParams", "Route"] + + +class RouteBulkUpdateParams(TypedDict, total=False): + account_id: Required[str] + """Identifier""" + + routes: Required[Iterable[Route]] + + +class Route(TypedDict, total=False): + id: Required[str] + """Identifier""" + + nexthop: Required[str] + """The next-hop IP Address for the static route.""" + + prefix: Required[str] + """IP Prefix in Classless Inter-Domain Routing format.""" + + priority: Required[int] + """Priority of the static route.""" + + description: str + """An optional human provided description of the static route.""" + + scope: ScopeParam + """Used only for ECMP routes.""" + + weight: int + """Optional weight of the ECMP scope - if provided.""" diff --git a/src/cloudflare/types/magic_transit/route_bulk_update_response.py b/src/cloudflare/types/magic_transit/route_bulk_update_response.py new file mode 100644 index 00000000000..6c675c3587c --- /dev/null +++ b/src/cloudflare/types/magic_transit/route_bulk_update_response.py @@ -0,0 +1,44 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List, Optional +from datetime import datetime + +from .scope import Scope +from ..._models import BaseModel + +__all__ = ["RouteBulkUpdateResponse", "ModifiedRoute"] + + +class ModifiedRoute(BaseModel): + nexthop: str + """The next-hop IP Address for the static route.""" + + prefix: str + """IP Prefix in Classless Inter-Domain Routing format.""" + + priority: int + """Priority of the static route.""" + + id: Optional[str] = None + """Identifier""" + + created_on: Optional[datetime] = None + """When the route was created.""" + + description: Optional[str] = None + """An optional human provided description of the static route.""" + + modified_on: Optional[datetime] = None + """When the route was last modified.""" + + scope: Optional[Scope] = None + """Used only for ECMP routes.""" + + weight: Optional[int] = None + """Optional weight of the ECMP scope - if provided.""" + + +class RouteBulkUpdateResponse(BaseModel): + modified: Optional[bool] = None + + modified_routes: Optional[List[ModifiedRoute]] = None diff --git a/src/cloudflare/types/rum/__init__.py b/src/cloudflare/types/rum/__init__.py index 870d7373122..31efc427c14 100644 --- a/src/cloudflare/types/rum/__init__.py +++ b/src/cloudflare/types/rum/__init__.py @@ -9,6 +9,8 @@ from .rule_update_params import RuleUpdateParams as RuleUpdateParams from .rule_delete_response import RuleDeleteResponse as RuleDeleteResponse from .site_info_list_params import SiteInfoListParams as SiteInfoListParams +from .rule_bulk_create_params import RuleBulkCreateParams as RuleBulkCreateParams from .site_info_create_params import SiteInfoCreateParams as SiteInfoCreateParams from .site_info_update_params import SiteInfoUpdateParams as SiteInfoUpdateParams +from .rule_bulk_create_response import RuleBulkCreateResponse as RuleBulkCreateResponse from .site_info_delete_response import SiteInfoDeleteResponse as SiteInfoDeleteResponse diff --git a/src/cloudflare/types/rum/rule_bulk_create_params.py b/src/cloudflare/types/rum/rule_bulk_create_params.py new file mode 100644 index 00000000000..c99c444584e --- /dev/null +++ b/src/cloudflare/types/rum/rule_bulk_create_params.py @@ -0,0 +1,32 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import List, Iterable +from typing_extensions import Required, TypedDict + +__all__ = ["RuleBulkCreateParams", "Rule"] + + +class RuleBulkCreateParams(TypedDict, total=False): + account_id: Required[str] + """Identifier""" + + delete_rules: List[str] + """A list of rule identifiers to delete.""" + + rules: Iterable[Rule] + """A list of rules to create or update.""" + + +class Rule(TypedDict, total=False): + id: str + """The Web Analytics rule identifier.""" + + host: str + + inclusive: bool + + is_paused: bool + + paths: List[str] diff --git a/src/cloudflare/types/rum/rule_bulk_create_response.py b/src/cloudflare/types/rum/rule_bulk_create_response.py new file mode 100644 index 00000000000..7370f98b684 --- /dev/null +++ b/src/cloudflare/types/rum/rule_bulk_create_response.py @@ -0,0 +1,28 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List, Optional + +from .rum_rule import RUMRule +from ..._models import BaseModel + +__all__ = ["RuleBulkCreateResponse", "Ruleset"] + + +class Ruleset(BaseModel): + id: Optional[str] = None + """The Web Analytics ruleset identifier.""" + + enabled: Optional[bool] = None + """Whether the ruleset is enabled.""" + + zone_name: Optional[str] = None + + zone_tag: Optional[str] = None + """The zone identifier.""" + + +class RuleBulkCreateResponse(BaseModel): + rules: Optional[List[RUMRule]] = None + """A list of rules.""" + + ruleset: Optional[Ruleset] = None diff --git a/tests/api_resources/api_gateway/discovery/test_operations.py b/tests/api_resources/api_gateway/discovery/test_operations.py index 021c6643c93..01e6ba3122e 100644 --- a/tests/api_resources/api_gateway/discovery/test_operations.py +++ b/tests/api_resources/api_gateway/discovery/test_operations.py @@ -11,7 +11,10 @@ from tests.utils import assert_matches_type from cloudflare.pagination import SyncV4PagePaginationArray, AsyncV4PagePaginationArray from cloudflare.types.api_gateway import DiscoveryOperation -from cloudflare.types.api_gateway.discovery import OperationEditResponse +from cloudflare.types.api_gateway.discovery import ( + OperationEditResponse, + OperationBulkEditResponse, +) base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -74,6 +77,60 @@ def test_path_params_list(self, client: Cloudflare) -> None: zone_id="", ) + @parametrize + def test_method_bulk_edit(self, client: Cloudflare) -> None: + operation = client.api_gateway.discovery.operations.bulk_edit( + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + body={ + "3818d821-5901-4147-a474-f5f5aec1d54e": {}, + "b17c8043-99a0-4202-b7d9-8f7cdbee02cd": {}, + }, + ) + assert_matches_type(OperationBulkEditResponse, operation, path=["response"]) + + @parametrize + def test_raw_response_bulk_edit(self, client: Cloudflare) -> None: + response = client.api_gateway.discovery.operations.with_raw_response.bulk_edit( + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + body={ + "3818d821-5901-4147-a474-f5f5aec1d54e": {}, + "b17c8043-99a0-4202-b7d9-8f7cdbee02cd": {}, + }, + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + operation = response.parse() + assert_matches_type(OperationBulkEditResponse, operation, path=["response"]) + + @parametrize + def test_streaming_response_bulk_edit(self, client: Cloudflare) -> None: + with client.api_gateway.discovery.operations.with_streaming_response.bulk_edit( + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + body={ + "3818d821-5901-4147-a474-f5f5aec1d54e": {}, + "b17c8043-99a0-4202-b7d9-8f7cdbee02cd": {}, + }, + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + operation = response.parse() + assert_matches_type(OperationBulkEditResponse, operation, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_path_params_bulk_edit(self, client: Cloudflare) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `zone_id` but received ''"): + client.api_gateway.discovery.operations.with_raw_response.bulk_edit( + zone_id="", + body={ + "3818d821-5901-4147-a474-f5f5aec1d54e": {}, + "b17c8043-99a0-4202-b7d9-8f7cdbee02cd": {}, + }, + ) + @parametrize def test_method_edit(self, client: Cloudflare) -> None: operation = client.api_gateway.discovery.operations.edit( @@ -190,6 +247,60 @@ async def test_path_params_list(self, async_client: AsyncCloudflare) -> None: zone_id="", ) + @parametrize + async def test_method_bulk_edit(self, async_client: AsyncCloudflare) -> None: + operation = await async_client.api_gateway.discovery.operations.bulk_edit( + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + body={ + "3818d821-5901-4147-a474-f5f5aec1d54e": {}, + "b17c8043-99a0-4202-b7d9-8f7cdbee02cd": {}, + }, + ) + assert_matches_type(OperationBulkEditResponse, operation, path=["response"]) + + @parametrize + async def test_raw_response_bulk_edit(self, async_client: AsyncCloudflare) -> None: + response = await async_client.api_gateway.discovery.operations.with_raw_response.bulk_edit( + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + body={ + "3818d821-5901-4147-a474-f5f5aec1d54e": {}, + "b17c8043-99a0-4202-b7d9-8f7cdbee02cd": {}, + }, + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + operation = await response.parse() + assert_matches_type(OperationBulkEditResponse, operation, path=["response"]) + + @parametrize + async def test_streaming_response_bulk_edit(self, async_client: AsyncCloudflare) -> None: + async with async_client.api_gateway.discovery.operations.with_streaming_response.bulk_edit( + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + body={ + "3818d821-5901-4147-a474-f5f5aec1d54e": {}, + "b17c8043-99a0-4202-b7d9-8f7cdbee02cd": {}, + }, + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + operation = await response.parse() + assert_matches_type(OperationBulkEditResponse, operation, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_path_params_bulk_edit(self, async_client: AsyncCloudflare) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `zone_id` but received ''"): + await async_client.api_gateway.discovery.operations.with_raw_response.bulk_edit( + zone_id="", + body={ + "3818d821-5901-4147-a474-f5f5aec1d54e": {}, + "b17c8043-99a0-4202-b7d9-8f7cdbee02cd": {}, + }, + ) + @parametrize async def test_method_edit(self, async_client: AsyncCloudflare) -> None: operation = await async_client.api_gateway.discovery.operations.edit( diff --git a/tests/api_resources/api_gateway/test_operations.py b/tests/api_resources/api_gateway/test_operations.py index 255418352e0..2be09e57fa3 100644 --- a/tests/api_resources/api_gateway/test_operations.py +++ b/tests/api_resources/api_gateway/test_operations.py @@ -15,6 +15,7 @@ OperationListResponse, OperationCreateResponse, OperationDeleteResponse, + OperationBulkDeleteResponse, ) base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -190,6 +191,44 @@ def test_path_params_delete(self, client: Cloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) + @parametrize + def test_method_bulk_delete(self, client: Cloudflare) -> None: + operation = client.api_gateway.operations.bulk_delete( + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + ) + assert_matches_type(OperationBulkDeleteResponse, operation, path=["response"]) + + @parametrize + def test_raw_response_bulk_delete(self, client: Cloudflare) -> None: + response = client.api_gateway.operations.with_raw_response.bulk_delete( + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + operation = response.parse() + assert_matches_type(OperationBulkDeleteResponse, operation, path=["response"]) + + @parametrize + def test_streaming_response_bulk_delete(self, client: Cloudflare) -> None: + with client.api_gateway.operations.with_streaming_response.bulk_delete( + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + operation = response.parse() + assert_matches_type(OperationBulkDeleteResponse, operation, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_path_params_bulk_delete(self, client: Cloudflare) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `zone_id` but received ''"): + client.api_gateway.operations.with_raw_response.bulk_delete( + zone_id="", + ) + @parametrize def test_method_get(self, client: Cloudflare) -> None: operation = client.api_gateway.operations.get( @@ -418,6 +457,44 @@ async def test_path_params_delete(self, async_client: AsyncCloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) + @parametrize + async def test_method_bulk_delete(self, async_client: AsyncCloudflare) -> None: + operation = await async_client.api_gateway.operations.bulk_delete( + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + ) + assert_matches_type(OperationBulkDeleteResponse, operation, path=["response"]) + + @parametrize + async def test_raw_response_bulk_delete(self, async_client: AsyncCloudflare) -> None: + response = await async_client.api_gateway.operations.with_raw_response.bulk_delete( + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + operation = await response.parse() + assert_matches_type(OperationBulkDeleteResponse, operation, path=["response"]) + + @parametrize + async def test_streaming_response_bulk_delete(self, async_client: AsyncCloudflare) -> None: + async with async_client.api_gateway.operations.with_streaming_response.bulk_delete( + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + operation = await response.parse() + assert_matches_type(OperationBulkDeleteResponse, operation, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_path_params_bulk_delete(self, async_client: AsyncCloudflare) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `zone_id` but received ''"): + await async_client.api_gateway.operations.with_raw_response.bulk_delete( + zone_id="", + ) + @parametrize async def test_method_get(self, async_client: AsyncCloudflare) -> None: operation = await async_client.api_gateway.operations.get( diff --git a/tests/api_resources/email_security/settings/test_domains.py b/tests/api_resources/email_security/settings/test_domains.py index 462d209c780..f2ee13c6fbb 100644 --- a/tests/api_resources/email_security/settings/test_domains.py +++ b/tests/api_resources/email_security/settings/test_domains.py @@ -15,6 +15,7 @@ DomainEditResponse, DomainListResponse, DomainDeleteResponse, + DomainBulkDeleteResponse, ) base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -117,6 +118,44 @@ def test_path_params_delete(self, client: Cloudflare) -> None: account_id="", ) + @parametrize + def test_method_bulk_delete(self, client: Cloudflare) -> None: + domain = client.email_security.settings.domains.bulk_delete( + account_id="023e105f4ecef8ad9ca31a8372d0c353", + ) + assert_matches_type(DomainBulkDeleteResponse, domain, path=["response"]) + + @parametrize + def test_raw_response_bulk_delete(self, client: Cloudflare) -> None: + response = client.email_security.settings.domains.with_raw_response.bulk_delete( + account_id="023e105f4ecef8ad9ca31a8372d0c353", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + domain = response.parse() + assert_matches_type(DomainBulkDeleteResponse, domain, path=["response"]) + + @parametrize + def test_streaming_response_bulk_delete(self, client: Cloudflare) -> None: + with client.email_security.settings.domains.with_streaming_response.bulk_delete( + account_id="023e105f4ecef8ad9ca31a8372d0c353", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + domain = response.parse() + assert_matches_type(DomainBulkDeleteResponse, domain, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_path_params_bulk_delete(self, client: Cloudflare) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `account_id` but received ''"): + client.email_security.settings.domains.with_raw_response.bulk_delete( + account_id="", + ) + @parametrize def test_method_edit(self, client: Cloudflare) -> None: domain = client.email_security.settings.domains.edit( @@ -311,6 +350,44 @@ async def test_path_params_delete(self, async_client: AsyncCloudflare) -> None: account_id="", ) + @parametrize + async def test_method_bulk_delete(self, async_client: AsyncCloudflare) -> None: + domain = await async_client.email_security.settings.domains.bulk_delete( + account_id="023e105f4ecef8ad9ca31a8372d0c353", + ) + assert_matches_type(DomainBulkDeleteResponse, domain, path=["response"]) + + @parametrize + async def test_raw_response_bulk_delete(self, async_client: AsyncCloudflare) -> None: + response = await async_client.email_security.settings.domains.with_raw_response.bulk_delete( + account_id="023e105f4ecef8ad9ca31a8372d0c353", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + domain = await response.parse() + assert_matches_type(DomainBulkDeleteResponse, domain, path=["response"]) + + @parametrize + async def test_streaming_response_bulk_delete(self, async_client: AsyncCloudflare) -> None: + async with async_client.email_security.settings.domains.with_streaming_response.bulk_delete( + account_id="023e105f4ecef8ad9ca31a8372d0c353", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + domain = await response.parse() + assert_matches_type(DomainBulkDeleteResponse, domain, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_path_params_bulk_delete(self, async_client: AsyncCloudflare) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `account_id` but received ''"): + await async_client.email_security.settings.domains.with_raw_response.bulk_delete( + account_id="", + ) + @parametrize async def test_method_edit(self, async_client: AsyncCloudflare) -> None: domain = await async_client.email_security.settings.domains.edit( diff --git a/tests/api_resources/firewall/test_rules.py b/tests/api_resources/firewall/test_rules.py index 8f4c18bf1e2..62388686851 100644 --- a/tests/api_resources/firewall/test_rules.py +++ b/tests/api_resources/firewall/test_rules.py @@ -14,6 +14,9 @@ FirewallRule, RuleEditResponse, RuleCreateResponse, + RuleBulkEditResponse, + RuleBulkDeleteResponse, + RuleBulkUpdateResponse, ) # pyright: reportDeprecated=false @@ -306,6 +309,143 @@ def test_path_params_delete(self, client: Cloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) + @parametrize + def test_method_bulk_delete(self, client: Cloudflare) -> None: + with pytest.warns(DeprecationWarning): + rule = client.firewall.rules.bulk_delete( + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + ) + + assert_matches_type(Optional[RuleBulkDeleteResponse], rule, path=["response"]) + + @parametrize + def test_raw_response_bulk_delete(self, client: Cloudflare) -> None: + with pytest.warns(DeprecationWarning): + response = client.firewall.rules.with_raw_response.bulk_delete( + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + rule = response.parse() + assert_matches_type(Optional[RuleBulkDeleteResponse], rule, path=["response"]) + + @parametrize + def test_streaming_response_bulk_delete(self, client: Cloudflare) -> None: + with pytest.warns(DeprecationWarning): + with client.firewall.rules.with_streaming_response.bulk_delete( + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + rule = response.parse() + assert_matches_type(Optional[RuleBulkDeleteResponse], rule, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_path_params_bulk_delete(self, client: Cloudflare) -> None: + with pytest.warns(DeprecationWarning): + with pytest.raises(ValueError, match=r"Expected a non-empty value for `zone_id` but received ''"): + client.firewall.rules.with_raw_response.bulk_delete( + zone_id="", + ) + + @parametrize + def test_method_bulk_edit(self, client: Cloudflare) -> None: + with pytest.warns(DeprecationWarning): + rule = client.firewall.rules.bulk_edit( + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + body={}, + ) + + assert_matches_type(Optional[RuleBulkEditResponse], rule, path=["response"]) + + @parametrize + def test_raw_response_bulk_edit(self, client: Cloudflare) -> None: + with pytest.warns(DeprecationWarning): + response = client.firewall.rules.with_raw_response.bulk_edit( + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + body={}, + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + rule = response.parse() + assert_matches_type(Optional[RuleBulkEditResponse], rule, path=["response"]) + + @parametrize + def test_streaming_response_bulk_edit(self, client: Cloudflare) -> None: + with pytest.warns(DeprecationWarning): + with client.firewall.rules.with_streaming_response.bulk_edit( + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + body={}, + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + rule = response.parse() + assert_matches_type(Optional[RuleBulkEditResponse], rule, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_path_params_bulk_edit(self, client: Cloudflare) -> None: + with pytest.warns(DeprecationWarning): + with pytest.raises(ValueError, match=r"Expected a non-empty value for `zone_id` but received ''"): + client.firewall.rules.with_raw_response.bulk_edit( + zone_id="", + body={}, + ) + + @parametrize + def test_method_bulk_update(self, client: Cloudflare) -> None: + with pytest.warns(DeprecationWarning): + rule = client.firewall.rules.bulk_update( + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + body={}, + ) + + assert_matches_type(Optional[RuleBulkUpdateResponse], rule, path=["response"]) + + @parametrize + def test_raw_response_bulk_update(self, client: Cloudflare) -> None: + with pytest.warns(DeprecationWarning): + response = client.firewall.rules.with_raw_response.bulk_update( + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + body={}, + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + rule = response.parse() + assert_matches_type(Optional[RuleBulkUpdateResponse], rule, path=["response"]) + + @parametrize + def test_streaming_response_bulk_update(self, client: Cloudflare) -> None: + with pytest.warns(DeprecationWarning): + with client.firewall.rules.with_streaming_response.bulk_update( + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + body={}, + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + rule = response.parse() + assert_matches_type(Optional[RuleBulkUpdateResponse], rule, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_path_params_bulk_update(self, client: Cloudflare) -> None: + with pytest.warns(DeprecationWarning): + with pytest.raises(ValueError, match=r"Expected a non-empty value for `zone_id` but received ''"): + client.firewall.rules.with_raw_response.bulk_update( + zone_id="", + body={}, + ) + @pytest.mark.skip(reason="TODO: investigate broken test") @parametrize def test_method_edit(self, client: Cloudflare) -> None: @@ -713,6 +853,143 @@ async def test_path_params_delete(self, async_client: AsyncCloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) + @parametrize + async def test_method_bulk_delete(self, async_client: AsyncCloudflare) -> None: + with pytest.warns(DeprecationWarning): + rule = await async_client.firewall.rules.bulk_delete( + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + ) + + assert_matches_type(Optional[RuleBulkDeleteResponse], rule, path=["response"]) + + @parametrize + async def test_raw_response_bulk_delete(self, async_client: AsyncCloudflare) -> None: + with pytest.warns(DeprecationWarning): + response = await async_client.firewall.rules.with_raw_response.bulk_delete( + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + rule = await response.parse() + assert_matches_type(Optional[RuleBulkDeleteResponse], rule, path=["response"]) + + @parametrize + async def test_streaming_response_bulk_delete(self, async_client: AsyncCloudflare) -> None: + with pytest.warns(DeprecationWarning): + async with async_client.firewall.rules.with_streaming_response.bulk_delete( + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + rule = await response.parse() + assert_matches_type(Optional[RuleBulkDeleteResponse], rule, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_path_params_bulk_delete(self, async_client: AsyncCloudflare) -> None: + with pytest.warns(DeprecationWarning): + with pytest.raises(ValueError, match=r"Expected a non-empty value for `zone_id` but received ''"): + await async_client.firewall.rules.with_raw_response.bulk_delete( + zone_id="", + ) + + @parametrize + async def test_method_bulk_edit(self, async_client: AsyncCloudflare) -> None: + with pytest.warns(DeprecationWarning): + rule = await async_client.firewall.rules.bulk_edit( + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + body={}, + ) + + assert_matches_type(Optional[RuleBulkEditResponse], rule, path=["response"]) + + @parametrize + async def test_raw_response_bulk_edit(self, async_client: AsyncCloudflare) -> None: + with pytest.warns(DeprecationWarning): + response = await async_client.firewall.rules.with_raw_response.bulk_edit( + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + body={}, + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + rule = await response.parse() + assert_matches_type(Optional[RuleBulkEditResponse], rule, path=["response"]) + + @parametrize + async def test_streaming_response_bulk_edit(self, async_client: AsyncCloudflare) -> None: + with pytest.warns(DeprecationWarning): + async with async_client.firewall.rules.with_streaming_response.bulk_edit( + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + body={}, + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + rule = await response.parse() + assert_matches_type(Optional[RuleBulkEditResponse], rule, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_path_params_bulk_edit(self, async_client: AsyncCloudflare) -> None: + with pytest.warns(DeprecationWarning): + with pytest.raises(ValueError, match=r"Expected a non-empty value for `zone_id` but received ''"): + await async_client.firewall.rules.with_raw_response.bulk_edit( + zone_id="", + body={}, + ) + + @parametrize + async def test_method_bulk_update(self, async_client: AsyncCloudflare) -> None: + with pytest.warns(DeprecationWarning): + rule = await async_client.firewall.rules.bulk_update( + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + body={}, + ) + + assert_matches_type(Optional[RuleBulkUpdateResponse], rule, path=["response"]) + + @parametrize + async def test_raw_response_bulk_update(self, async_client: AsyncCloudflare) -> None: + with pytest.warns(DeprecationWarning): + response = await async_client.firewall.rules.with_raw_response.bulk_update( + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + body={}, + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + rule = await response.parse() + assert_matches_type(Optional[RuleBulkUpdateResponse], rule, path=["response"]) + + @parametrize + async def test_streaming_response_bulk_update(self, async_client: AsyncCloudflare) -> None: + with pytest.warns(DeprecationWarning): + async with async_client.firewall.rules.with_streaming_response.bulk_update( + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + body={}, + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + rule = await response.parse() + assert_matches_type(Optional[RuleBulkUpdateResponse], rule, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_path_params_bulk_update(self, async_client: AsyncCloudflare) -> None: + with pytest.warns(DeprecationWarning): + with pytest.raises(ValueError, match=r"Expected a non-empty value for `zone_id` but received ''"): + await async_client.firewall.rules.with_raw_response.bulk_update( + zone_id="", + body={}, + ) + @pytest.mark.skip(reason="TODO: investigate broken test") @parametrize async def test_method_edit(self, async_client: AsyncCloudflare) -> None: diff --git a/tests/api_resources/kv/namespaces/test_bulk.py b/tests/api_resources/kv/namespaces/test_bulk.py deleted file mode 100644 index 57f87368451..00000000000 --- a/tests/api_resources/kv/namespaces/test_bulk.py +++ /dev/null @@ -1,224 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from __future__ import annotations - -import os -from typing import Any, Optional, cast - -import pytest - -from cloudflare import Cloudflare, AsyncCloudflare -from tests.utils import assert_matches_type -from cloudflare.types.kv.namespaces import BulkDeleteResponse, BulkUpdateResponse - -base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") - - -class TestBulk: - parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) - - @parametrize - def test_method_update(self, client: Cloudflare) -> None: - bulk = client.kv.namespaces.bulk.update( - namespace_id="0f2ac74b498b48028cb68387c421e279", - account_id="023e105f4ecef8ad9ca31a8372d0c353", - body=[{}], - ) - assert_matches_type(Optional[BulkUpdateResponse], bulk, path=["response"]) - - @parametrize - def test_raw_response_update(self, client: Cloudflare) -> None: - response = client.kv.namespaces.bulk.with_raw_response.update( - namespace_id="0f2ac74b498b48028cb68387c421e279", - account_id="023e105f4ecef8ad9ca31a8372d0c353", - body=[{}], - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - bulk = response.parse() - assert_matches_type(Optional[BulkUpdateResponse], bulk, path=["response"]) - - @parametrize - def test_streaming_response_update(self, client: Cloudflare) -> None: - with client.kv.namespaces.bulk.with_streaming_response.update( - namespace_id="0f2ac74b498b48028cb68387c421e279", - account_id="023e105f4ecef8ad9ca31a8372d0c353", - body=[{}], - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - bulk = response.parse() - assert_matches_type(Optional[BulkUpdateResponse], bulk, path=["response"]) - - assert cast(Any, response.is_closed) is True - - @parametrize - def test_path_params_update(self, client: Cloudflare) -> None: - with pytest.raises(ValueError, match=r"Expected a non-empty value for `account_id` but received ''"): - client.kv.namespaces.bulk.with_raw_response.update( - namespace_id="0f2ac74b498b48028cb68387c421e279", - account_id="", - body=[{}], - ) - - with pytest.raises(ValueError, match=r"Expected a non-empty value for `namespace_id` but received ''"): - client.kv.namespaces.bulk.with_raw_response.update( - namespace_id="", - account_id="023e105f4ecef8ad9ca31a8372d0c353", - body=[{}], - ) - - @parametrize - def test_method_delete(self, client: Cloudflare) -> None: - bulk = client.kv.namespaces.bulk.delete( - namespace_id="0f2ac74b498b48028cb68387c421e279", - account_id="023e105f4ecef8ad9ca31a8372d0c353", - ) - assert_matches_type(Optional[BulkDeleteResponse], bulk, path=["response"]) - - @parametrize - def test_raw_response_delete(self, client: Cloudflare) -> None: - response = client.kv.namespaces.bulk.with_raw_response.delete( - namespace_id="0f2ac74b498b48028cb68387c421e279", - account_id="023e105f4ecef8ad9ca31a8372d0c353", - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - bulk = response.parse() - assert_matches_type(Optional[BulkDeleteResponse], bulk, path=["response"]) - - @parametrize - def test_streaming_response_delete(self, client: Cloudflare) -> None: - with client.kv.namespaces.bulk.with_streaming_response.delete( - namespace_id="0f2ac74b498b48028cb68387c421e279", - account_id="023e105f4ecef8ad9ca31a8372d0c353", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - bulk = response.parse() - assert_matches_type(Optional[BulkDeleteResponse], bulk, path=["response"]) - - assert cast(Any, response.is_closed) is True - - @parametrize - def test_path_params_delete(self, client: Cloudflare) -> None: - with pytest.raises(ValueError, match=r"Expected a non-empty value for `account_id` but received ''"): - client.kv.namespaces.bulk.with_raw_response.delete( - namespace_id="0f2ac74b498b48028cb68387c421e279", - account_id="", - ) - - with pytest.raises(ValueError, match=r"Expected a non-empty value for `namespace_id` but received ''"): - client.kv.namespaces.bulk.with_raw_response.delete( - namespace_id="", - account_id="023e105f4ecef8ad9ca31a8372d0c353", - ) - - -class TestAsyncBulk: - parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"]) - - @parametrize - async def test_method_update(self, async_client: AsyncCloudflare) -> None: - bulk = await async_client.kv.namespaces.bulk.update( - namespace_id="0f2ac74b498b48028cb68387c421e279", - account_id="023e105f4ecef8ad9ca31a8372d0c353", - body=[{}], - ) - assert_matches_type(Optional[BulkUpdateResponse], bulk, path=["response"]) - - @parametrize - async def test_raw_response_update(self, async_client: AsyncCloudflare) -> None: - response = await async_client.kv.namespaces.bulk.with_raw_response.update( - namespace_id="0f2ac74b498b48028cb68387c421e279", - account_id="023e105f4ecef8ad9ca31a8372d0c353", - body=[{}], - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - bulk = await response.parse() - assert_matches_type(Optional[BulkUpdateResponse], bulk, path=["response"]) - - @parametrize - async def test_streaming_response_update(self, async_client: AsyncCloudflare) -> None: - async with async_client.kv.namespaces.bulk.with_streaming_response.update( - namespace_id="0f2ac74b498b48028cb68387c421e279", - account_id="023e105f4ecef8ad9ca31a8372d0c353", - body=[{}], - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - bulk = await response.parse() - assert_matches_type(Optional[BulkUpdateResponse], bulk, path=["response"]) - - assert cast(Any, response.is_closed) is True - - @parametrize - async def test_path_params_update(self, async_client: AsyncCloudflare) -> None: - with pytest.raises(ValueError, match=r"Expected a non-empty value for `account_id` but received ''"): - await async_client.kv.namespaces.bulk.with_raw_response.update( - namespace_id="0f2ac74b498b48028cb68387c421e279", - account_id="", - body=[{}], - ) - - with pytest.raises(ValueError, match=r"Expected a non-empty value for `namespace_id` but received ''"): - await async_client.kv.namespaces.bulk.with_raw_response.update( - namespace_id="", - account_id="023e105f4ecef8ad9ca31a8372d0c353", - body=[{}], - ) - - @parametrize - async def test_method_delete(self, async_client: AsyncCloudflare) -> None: - bulk = await async_client.kv.namespaces.bulk.delete( - namespace_id="0f2ac74b498b48028cb68387c421e279", - account_id="023e105f4ecef8ad9ca31a8372d0c353", - ) - assert_matches_type(Optional[BulkDeleteResponse], bulk, path=["response"]) - - @parametrize - async def test_raw_response_delete(self, async_client: AsyncCloudflare) -> None: - response = await async_client.kv.namespaces.bulk.with_raw_response.delete( - namespace_id="0f2ac74b498b48028cb68387c421e279", - account_id="023e105f4ecef8ad9ca31a8372d0c353", - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - bulk = await response.parse() - assert_matches_type(Optional[BulkDeleteResponse], bulk, path=["response"]) - - @parametrize - async def test_streaming_response_delete(self, async_client: AsyncCloudflare) -> None: - async with async_client.kv.namespaces.bulk.with_streaming_response.delete( - namespace_id="0f2ac74b498b48028cb68387c421e279", - account_id="023e105f4ecef8ad9ca31a8372d0c353", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - bulk = await response.parse() - assert_matches_type(Optional[BulkDeleteResponse], bulk, path=["response"]) - - assert cast(Any, response.is_closed) is True - - @parametrize - async def test_path_params_delete(self, async_client: AsyncCloudflare) -> None: - with pytest.raises(ValueError, match=r"Expected a non-empty value for `account_id` but received ''"): - await async_client.kv.namespaces.bulk.with_raw_response.delete( - namespace_id="0f2ac74b498b48028cb68387c421e279", - account_id="", - ) - - with pytest.raises(ValueError, match=r"Expected a non-empty value for `namespace_id` but received ''"): - await async_client.kv.namespaces.bulk.with_raw_response.delete( - namespace_id="", - account_id="023e105f4ecef8ad9ca31a8372d0c353", - ) diff --git a/tests/api_resources/kv/test_namespaces.py b/tests/api_resources/kv/test_namespaces.py index aa2e9589dfe..7f288603c1d 100644 --- a/tests/api_resources/kv/test_namespaces.py +++ b/tests/api_resources/kv/test_namespaces.py @@ -13,6 +13,8 @@ Namespace, NamespaceDeleteResponse, NamespaceUpdateResponse, + NamespaceBulkDeleteResponse, + NamespaceBulkUpdateResponse, ) from cloudflare.pagination import SyncV4PagePaginationArray, AsyncV4PagePaginationArray @@ -214,6 +216,112 @@ def test_path_params_delete(self, client: Cloudflare) -> None: account_id="023e105f4ecef8ad9ca31a8372d0c353", ) + @parametrize + def test_method_bulk_delete(self, client: Cloudflare) -> None: + namespace = client.kv.namespaces.bulk_delete( + namespace_id="0f2ac74b498b48028cb68387c421e279", + account_id="023e105f4ecef8ad9ca31a8372d0c353", + body=["My-Key"], + ) + assert_matches_type(Optional[NamespaceBulkDeleteResponse], namespace, path=["response"]) + + @parametrize + def test_raw_response_bulk_delete(self, client: Cloudflare) -> None: + response = client.kv.namespaces.with_raw_response.bulk_delete( + namespace_id="0f2ac74b498b48028cb68387c421e279", + account_id="023e105f4ecef8ad9ca31a8372d0c353", + body=["My-Key"], + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + namespace = response.parse() + assert_matches_type(Optional[NamespaceBulkDeleteResponse], namespace, path=["response"]) + + @parametrize + def test_streaming_response_bulk_delete(self, client: Cloudflare) -> None: + with client.kv.namespaces.with_streaming_response.bulk_delete( + namespace_id="0f2ac74b498b48028cb68387c421e279", + account_id="023e105f4ecef8ad9ca31a8372d0c353", + body=["My-Key"], + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + namespace = response.parse() + assert_matches_type(Optional[NamespaceBulkDeleteResponse], namespace, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_path_params_bulk_delete(self, client: Cloudflare) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `account_id` but received ''"): + client.kv.namespaces.with_raw_response.bulk_delete( + namespace_id="0f2ac74b498b48028cb68387c421e279", + account_id="", + body=["My-Key"], + ) + + with pytest.raises(ValueError, match=r"Expected a non-empty value for `namespace_id` but received ''"): + client.kv.namespaces.with_raw_response.bulk_delete( + namespace_id="", + account_id="023e105f4ecef8ad9ca31a8372d0c353", + body=["My-Key"], + ) + + @parametrize + def test_method_bulk_update(self, client: Cloudflare) -> None: + namespace = client.kv.namespaces.bulk_update( + namespace_id="0f2ac74b498b48028cb68387c421e279", + account_id="023e105f4ecef8ad9ca31a8372d0c353", + body=[{}], + ) + assert_matches_type(Optional[NamespaceBulkUpdateResponse], namespace, path=["response"]) + + @parametrize + def test_raw_response_bulk_update(self, client: Cloudflare) -> None: + response = client.kv.namespaces.with_raw_response.bulk_update( + namespace_id="0f2ac74b498b48028cb68387c421e279", + account_id="023e105f4ecef8ad9ca31a8372d0c353", + body=[{}], + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + namespace = response.parse() + assert_matches_type(Optional[NamespaceBulkUpdateResponse], namespace, path=["response"]) + + @parametrize + def test_streaming_response_bulk_update(self, client: Cloudflare) -> None: + with client.kv.namespaces.with_streaming_response.bulk_update( + namespace_id="0f2ac74b498b48028cb68387c421e279", + account_id="023e105f4ecef8ad9ca31a8372d0c353", + body=[{}], + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + namespace = response.parse() + assert_matches_type(Optional[NamespaceBulkUpdateResponse], namespace, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_path_params_bulk_update(self, client: Cloudflare) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `account_id` but received ''"): + client.kv.namespaces.with_raw_response.bulk_update( + namespace_id="0f2ac74b498b48028cb68387c421e279", + account_id="", + body=[{}], + ) + + with pytest.raises(ValueError, match=r"Expected a non-empty value for `namespace_id` but received ''"): + client.kv.namespaces.with_raw_response.bulk_update( + namespace_id="", + account_id="023e105f4ecef8ad9ca31a8372d0c353", + body=[{}], + ) + @parametrize def test_method_get(self, client: Cloudflare) -> None: namespace = client.kv.namespaces.get( @@ -458,6 +566,112 @@ async def test_path_params_delete(self, async_client: AsyncCloudflare) -> None: account_id="023e105f4ecef8ad9ca31a8372d0c353", ) + @parametrize + async def test_method_bulk_delete(self, async_client: AsyncCloudflare) -> None: + namespace = await async_client.kv.namespaces.bulk_delete( + namespace_id="0f2ac74b498b48028cb68387c421e279", + account_id="023e105f4ecef8ad9ca31a8372d0c353", + body=["My-Key"], + ) + assert_matches_type(Optional[NamespaceBulkDeleteResponse], namespace, path=["response"]) + + @parametrize + async def test_raw_response_bulk_delete(self, async_client: AsyncCloudflare) -> None: + response = await async_client.kv.namespaces.with_raw_response.bulk_delete( + namespace_id="0f2ac74b498b48028cb68387c421e279", + account_id="023e105f4ecef8ad9ca31a8372d0c353", + body=["My-Key"], + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + namespace = await response.parse() + assert_matches_type(Optional[NamespaceBulkDeleteResponse], namespace, path=["response"]) + + @parametrize + async def test_streaming_response_bulk_delete(self, async_client: AsyncCloudflare) -> None: + async with async_client.kv.namespaces.with_streaming_response.bulk_delete( + namespace_id="0f2ac74b498b48028cb68387c421e279", + account_id="023e105f4ecef8ad9ca31a8372d0c353", + body=["My-Key"], + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + namespace = await response.parse() + assert_matches_type(Optional[NamespaceBulkDeleteResponse], namespace, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_path_params_bulk_delete(self, async_client: AsyncCloudflare) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `account_id` but received ''"): + await async_client.kv.namespaces.with_raw_response.bulk_delete( + namespace_id="0f2ac74b498b48028cb68387c421e279", + account_id="", + body=["My-Key"], + ) + + with pytest.raises(ValueError, match=r"Expected a non-empty value for `namespace_id` but received ''"): + await async_client.kv.namespaces.with_raw_response.bulk_delete( + namespace_id="", + account_id="023e105f4ecef8ad9ca31a8372d0c353", + body=["My-Key"], + ) + + @parametrize + async def test_method_bulk_update(self, async_client: AsyncCloudflare) -> None: + namespace = await async_client.kv.namespaces.bulk_update( + namespace_id="0f2ac74b498b48028cb68387c421e279", + account_id="023e105f4ecef8ad9ca31a8372d0c353", + body=[{}], + ) + assert_matches_type(Optional[NamespaceBulkUpdateResponse], namespace, path=["response"]) + + @parametrize + async def test_raw_response_bulk_update(self, async_client: AsyncCloudflare) -> None: + response = await async_client.kv.namespaces.with_raw_response.bulk_update( + namespace_id="0f2ac74b498b48028cb68387c421e279", + account_id="023e105f4ecef8ad9ca31a8372d0c353", + body=[{}], + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + namespace = await response.parse() + assert_matches_type(Optional[NamespaceBulkUpdateResponse], namespace, path=["response"]) + + @parametrize + async def test_streaming_response_bulk_update(self, async_client: AsyncCloudflare) -> None: + async with async_client.kv.namespaces.with_streaming_response.bulk_update( + namespace_id="0f2ac74b498b48028cb68387c421e279", + account_id="023e105f4ecef8ad9ca31a8372d0c353", + body=[{}], + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + namespace = await response.parse() + assert_matches_type(Optional[NamespaceBulkUpdateResponse], namespace, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_path_params_bulk_update(self, async_client: AsyncCloudflare) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `account_id` but received ''"): + await async_client.kv.namespaces.with_raw_response.bulk_update( + namespace_id="0f2ac74b498b48028cb68387c421e279", + account_id="", + body=[{}], + ) + + with pytest.raises(ValueError, match=r"Expected a non-empty value for `namespace_id` but received ''"): + await async_client.kv.namespaces.with_raw_response.bulk_update( + namespace_id="", + account_id="023e105f4ecef8ad9ca31a8372d0c353", + body=[{}], + ) + @parametrize async def test_method_get(self, async_client: AsyncCloudflare) -> None: namespace = await async_client.kv.namespaces.get( diff --git a/tests/api_resources/load_balancers/test_pools.py b/tests/api_resources/load_balancers/test_pools.py index fd1432ad458..3808356bd7f 100644 --- a/tests/api_resources/load_balancers/test_pools.py +++ b/tests/api_resources/load_balancers/test_pools.py @@ -13,6 +13,7 @@ from cloudflare.types.load_balancers import ( Pool, PoolDeleteResponse, + PoolBulkEditResponse, ) base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -305,6 +306,52 @@ def test_path_params_delete(self, client: Cloudflare) -> None: account_id="023e105f4ecef8ad9ca31a8372d0c353", ) + @parametrize + def test_method_bulk_edit(self, client: Cloudflare) -> None: + pool = client.load_balancers.pools.bulk_edit( + account_id="023e105f4ecef8ad9ca31a8372d0c353", + ) + assert_matches_type(PoolBulkEditResponse, pool, path=["response"]) + + @parametrize + def test_method_bulk_edit_with_all_params(self, client: Cloudflare) -> None: + pool = client.load_balancers.pools.bulk_edit( + account_id="023e105f4ecef8ad9ca31a8372d0c353", + notification_email="", + ) + assert_matches_type(PoolBulkEditResponse, pool, path=["response"]) + + @parametrize + def test_raw_response_bulk_edit(self, client: Cloudflare) -> None: + response = client.load_balancers.pools.with_raw_response.bulk_edit( + account_id="023e105f4ecef8ad9ca31a8372d0c353", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + pool = response.parse() + assert_matches_type(PoolBulkEditResponse, pool, path=["response"]) + + @parametrize + def test_streaming_response_bulk_edit(self, client: Cloudflare) -> None: + with client.load_balancers.pools.with_streaming_response.bulk_edit( + account_id="023e105f4ecef8ad9ca31a8372d0c353", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + pool = response.parse() + assert_matches_type(PoolBulkEditResponse, pool, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_path_params_bulk_edit(self, client: Cloudflare) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `account_id` but received ''"): + client.load_balancers.pools.with_raw_response.bulk_edit( + account_id="", + ) + @parametrize def test_method_edit(self, client: Cloudflare) -> None: pool = client.load_balancers.pools.edit( @@ -733,6 +780,52 @@ async def test_path_params_delete(self, async_client: AsyncCloudflare) -> None: account_id="023e105f4ecef8ad9ca31a8372d0c353", ) + @parametrize + async def test_method_bulk_edit(self, async_client: AsyncCloudflare) -> None: + pool = await async_client.load_balancers.pools.bulk_edit( + account_id="023e105f4ecef8ad9ca31a8372d0c353", + ) + assert_matches_type(PoolBulkEditResponse, pool, path=["response"]) + + @parametrize + async def test_method_bulk_edit_with_all_params(self, async_client: AsyncCloudflare) -> None: + pool = await async_client.load_balancers.pools.bulk_edit( + account_id="023e105f4ecef8ad9ca31a8372d0c353", + notification_email="", + ) + assert_matches_type(PoolBulkEditResponse, pool, path=["response"]) + + @parametrize + async def test_raw_response_bulk_edit(self, async_client: AsyncCloudflare) -> None: + response = await async_client.load_balancers.pools.with_raw_response.bulk_edit( + account_id="023e105f4ecef8ad9ca31a8372d0c353", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + pool = await response.parse() + assert_matches_type(PoolBulkEditResponse, pool, path=["response"]) + + @parametrize + async def test_streaming_response_bulk_edit(self, async_client: AsyncCloudflare) -> None: + async with async_client.load_balancers.pools.with_streaming_response.bulk_edit( + account_id="023e105f4ecef8ad9ca31a8372d0c353", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + pool = await response.parse() + assert_matches_type(PoolBulkEditResponse, pool, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_path_params_bulk_edit(self, async_client: AsyncCloudflare) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `account_id` but received ''"): + await async_client.load_balancers.pools.with_raw_response.bulk_edit( + account_id="", + ) + @parametrize async def test_method_edit(self, async_client: AsyncCloudflare) -> None: pool = await async_client.load_balancers.pools.edit( diff --git a/tests/api_resources/magic_transit/test_cf_interconnects.py b/tests/api_resources/magic_transit/test_cf_interconnects.py index 57ed25ea535..8c66eb4f777 100644 --- a/tests/api_resources/magic_transit/test_cf_interconnects.py +++ b/tests/api_resources/magic_transit/test_cf_interconnects.py @@ -13,6 +13,7 @@ CfInterconnectGetResponse, CfInterconnectListResponse, CfInterconnectUpdateResponse, + CfInterconnectBulkUpdateResponse, ) base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -134,6 +135,57 @@ def test_path_params_list(self, client: Cloudflare) -> None: account_id="", ) + @parametrize + def test_method_bulk_update(self, client: Cloudflare) -> None: + cf_interconnect = client.magic_transit.cf_interconnects.bulk_update( + account_id="023e105f4ecef8ad9ca31a8372d0c353", + body={}, + ) + assert_matches_type(CfInterconnectBulkUpdateResponse, cf_interconnect, path=["response"]) + + @parametrize + def test_method_bulk_update_with_all_params(self, client: Cloudflare) -> None: + cf_interconnect = client.magic_transit.cf_interconnects.bulk_update( + account_id="023e105f4ecef8ad9ca31a8372d0c353", + body={}, + x_magic_new_hc_target=True, + ) + assert_matches_type(CfInterconnectBulkUpdateResponse, cf_interconnect, path=["response"]) + + @parametrize + def test_raw_response_bulk_update(self, client: Cloudflare) -> None: + response = client.magic_transit.cf_interconnects.with_raw_response.bulk_update( + account_id="023e105f4ecef8ad9ca31a8372d0c353", + body={}, + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + cf_interconnect = response.parse() + assert_matches_type(CfInterconnectBulkUpdateResponse, cf_interconnect, path=["response"]) + + @parametrize + def test_streaming_response_bulk_update(self, client: Cloudflare) -> None: + with client.magic_transit.cf_interconnects.with_streaming_response.bulk_update( + account_id="023e105f4ecef8ad9ca31a8372d0c353", + body={}, + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + cf_interconnect = response.parse() + assert_matches_type(CfInterconnectBulkUpdateResponse, cf_interconnect, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_path_params_bulk_update(self, client: Cloudflare) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `account_id` but received ''"): + client.magic_transit.cf_interconnects.with_raw_response.bulk_update( + account_id="", + body={}, + ) + @parametrize def test_method_get(self, client: Cloudflare) -> None: cf_interconnect = client.magic_transit.cf_interconnects.get( @@ -308,6 +360,57 @@ async def test_path_params_list(self, async_client: AsyncCloudflare) -> None: account_id="", ) + @parametrize + async def test_method_bulk_update(self, async_client: AsyncCloudflare) -> None: + cf_interconnect = await async_client.magic_transit.cf_interconnects.bulk_update( + account_id="023e105f4ecef8ad9ca31a8372d0c353", + body={}, + ) + assert_matches_type(CfInterconnectBulkUpdateResponse, cf_interconnect, path=["response"]) + + @parametrize + async def test_method_bulk_update_with_all_params(self, async_client: AsyncCloudflare) -> None: + cf_interconnect = await async_client.magic_transit.cf_interconnects.bulk_update( + account_id="023e105f4ecef8ad9ca31a8372d0c353", + body={}, + x_magic_new_hc_target=True, + ) + assert_matches_type(CfInterconnectBulkUpdateResponse, cf_interconnect, path=["response"]) + + @parametrize + async def test_raw_response_bulk_update(self, async_client: AsyncCloudflare) -> None: + response = await async_client.magic_transit.cf_interconnects.with_raw_response.bulk_update( + account_id="023e105f4ecef8ad9ca31a8372d0c353", + body={}, + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + cf_interconnect = await response.parse() + assert_matches_type(CfInterconnectBulkUpdateResponse, cf_interconnect, path=["response"]) + + @parametrize + async def test_streaming_response_bulk_update(self, async_client: AsyncCloudflare) -> None: + async with async_client.magic_transit.cf_interconnects.with_streaming_response.bulk_update( + account_id="023e105f4ecef8ad9ca31a8372d0c353", + body={}, + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + cf_interconnect = await response.parse() + assert_matches_type(CfInterconnectBulkUpdateResponse, cf_interconnect, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_path_params_bulk_update(self, async_client: AsyncCloudflare) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `account_id` but received ''"): + await async_client.magic_transit.cf_interconnects.with_raw_response.bulk_update( + account_id="", + body={}, + ) + @parametrize async def test_method_get(self, async_client: AsyncCloudflare) -> None: cf_interconnect = await async_client.magic_transit.cf_interconnects.get( diff --git a/tests/api_resources/magic_transit/test_gre_tunnels.py b/tests/api_resources/magic_transit/test_gre_tunnels.py index 286e971795d..ad8f9e60f61 100644 --- a/tests/api_resources/magic_transit/test_gre_tunnels.py +++ b/tests/api_resources/magic_transit/test_gre_tunnels.py @@ -15,6 +15,7 @@ GRETunnelCreateResponse, GRETunnelDeleteResponse, GRETunnelUpdateResponse, + GRETunnelBulkUpdateResponse, ) base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -273,6 +274,57 @@ def test_path_params_delete(self, client: Cloudflare) -> None: account_id="023e105f4ecef8ad9ca31a8372d0c353", ) + @parametrize + def test_method_bulk_update(self, client: Cloudflare) -> None: + gre_tunnel = client.magic_transit.gre_tunnels.bulk_update( + account_id="023e105f4ecef8ad9ca31a8372d0c353", + body={}, + ) + assert_matches_type(GRETunnelBulkUpdateResponse, gre_tunnel, path=["response"]) + + @parametrize + def test_method_bulk_update_with_all_params(self, client: Cloudflare) -> None: + gre_tunnel = client.magic_transit.gre_tunnels.bulk_update( + account_id="023e105f4ecef8ad9ca31a8372d0c353", + body={}, + x_magic_new_hc_target=True, + ) + assert_matches_type(GRETunnelBulkUpdateResponse, gre_tunnel, path=["response"]) + + @parametrize + def test_raw_response_bulk_update(self, client: Cloudflare) -> None: + response = client.magic_transit.gre_tunnels.with_raw_response.bulk_update( + account_id="023e105f4ecef8ad9ca31a8372d0c353", + body={}, + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + gre_tunnel = response.parse() + assert_matches_type(GRETunnelBulkUpdateResponse, gre_tunnel, path=["response"]) + + @parametrize + def test_streaming_response_bulk_update(self, client: Cloudflare) -> None: + with client.magic_transit.gre_tunnels.with_streaming_response.bulk_update( + account_id="023e105f4ecef8ad9ca31a8372d0c353", + body={}, + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + gre_tunnel = response.parse() + assert_matches_type(GRETunnelBulkUpdateResponse, gre_tunnel, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_path_params_bulk_update(self, client: Cloudflare) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `account_id` but received ''"): + client.magic_transit.gre_tunnels.with_raw_response.bulk_update( + account_id="", + body={}, + ) + @parametrize def test_method_get(self, client: Cloudflare) -> None: gre_tunnel = client.magic_transit.gre_tunnels.get( @@ -584,6 +636,57 @@ async def test_path_params_delete(self, async_client: AsyncCloudflare) -> None: account_id="023e105f4ecef8ad9ca31a8372d0c353", ) + @parametrize + async def test_method_bulk_update(self, async_client: AsyncCloudflare) -> None: + gre_tunnel = await async_client.magic_transit.gre_tunnels.bulk_update( + account_id="023e105f4ecef8ad9ca31a8372d0c353", + body={}, + ) + assert_matches_type(GRETunnelBulkUpdateResponse, gre_tunnel, path=["response"]) + + @parametrize + async def test_method_bulk_update_with_all_params(self, async_client: AsyncCloudflare) -> None: + gre_tunnel = await async_client.magic_transit.gre_tunnels.bulk_update( + account_id="023e105f4ecef8ad9ca31a8372d0c353", + body={}, + x_magic_new_hc_target=True, + ) + assert_matches_type(GRETunnelBulkUpdateResponse, gre_tunnel, path=["response"]) + + @parametrize + async def test_raw_response_bulk_update(self, async_client: AsyncCloudflare) -> None: + response = await async_client.magic_transit.gre_tunnels.with_raw_response.bulk_update( + account_id="023e105f4ecef8ad9ca31a8372d0c353", + body={}, + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + gre_tunnel = await response.parse() + assert_matches_type(GRETunnelBulkUpdateResponse, gre_tunnel, path=["response"]) + + @parametrize + async def test_streaming_response_bulk_update(self, async_client: AsyncCloudflare) -> None: + async with async_client.magic_transit.gre_tunnels.with_streaming_response.bulk_update( + account_id="023e105f4ecef8ad9ca31a8372d0c353", + body={}, + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + gre_tunnel = await response.parse() + assert_matches_type(GRETunnelBulkUpdateResponse, gre_tunnel, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_path_params_bulk_update(self, async_client: AsyncCloudflare) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `account_id` but received ''"): + await async_client.magic_transit.gre_tunnels.with_raw_response.bulk_update( + account_id="", + body={}, + ) + @parametrize async def test_method_get(self, async_client: AsyncCloudflare) -> None: gre_tunnel = await async_client.magic_transit.gre_tunnels.get( diff --git a/tests/api_resources/magic_transit/test_ipsec_tunnels.py b/tests/api_resources/magic_transit/test_ipsec_tunnels.py index 00aaa8d4ba8..483c4d4d1b8 100644 --- a/tests/api_resources/magic_transit/test_ipsec_tunnels.py +++ b/tests/api_resources/magic_transit/test_ipsec_tunnels.py @@ -15,6 +15,7 @@ IPSECTunnelCreateResponse, IPSECTunnelDeleteResponse, IPSECTunnelUpdateResponse, + IPSECTunnelBulkUpdateResponse, IPSECTunnelPSKGenerateResponse, ) @@ -285,6 +286,57 @@ def test_path_params_delete(self, client: Cloudflare) -> None: account_id="023e105f4ecef8ad9ca31a8372d0c353", ) + @parametrize + def test_method_bulk_update(self, client: Cloudflare) -> None: + ipsec_tunnel = client.magic_transit.ipsec_tunnels.bulk_update( + account_id="023e105f4ecef8ad9ca31a8372d0c353", + body={}, + ) + assert_matches_type(IPSECTunnelBulkUpdateResponse, ipsec_tunnel, path=["response"]) + + @parametrize + def test_method_bulk_update_with_all_params(self, client: Cloudflare) -> None: + ipsec_tunnel = client.magic_transit.ipsec_tunnels.bulk_update( + account_id="023e105f4ecef8ad9ca31a8372d0c353", + body={}, + x_magic_new_hc_target=True, + ) + assert_matches_type(IPSECTunnelBulkUpdateResponse, ipsec_tunnel, path=["response"]) + + @parametrize + def test_raw_response_bulk_update(self, client: Cloudflare) -> None: + response = client.magic_transit.ipsec_tunnels.with_raw_response.bulk_update( + account_id="023e105f4ecef8ad9ca31a8372d0c353", + body={}, + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + ipsec_tunnel = response.parse() + assert_matches_type(IPSECTunnelBulkUpdateResponse, ipsec_tunnel, path=["response"]) + + @parametrize + def test_streaming_response_bulk_update(self, client: Cloudflare) -> None: + with client.magic_transit.ipsec_tunnels.with_streaming_response.bulk_update( + account_id="023e105f4ecef8ad9ca31a8372d0c353", + body={}, + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + ipsec_tunnel = response.parse() + assert_matches_type(IPSECTunnelBulkUpdateResponse, ipsec_tunnel, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_path_params_bulk_update(self, client: Cloudflare) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `account_id` but received ''"): + client.magic_transit.ipsec_tunnels.with_raw_response.bulk_update( + account_id="", + body={}, + ) + @parametrize def test_method_get(self, client: Cloudflare) -> None: ipsec_tunnel = client.magic_transit.ipsec_tunnels.get( @@ -660,6 +712,57 @@ async def test_path_params_delete(self, async_client: AsyncCloudflare) -> None: account_id="023e105f4ecef8ad9ca31a8372d0c353", ) + @parametrize + async def test_method_bulk_update(self, async_client: AsyncCloudflare) -> None: + ipsec_tunnel = await async_client.magic_transit.ipsec_tunnels.bulk_update( + account_id="023e105f4ecef8ad9ca31a8372d0c353", + body={}, + ) + assert_matches_type(IPSECTunnelBulkUpdateResponse, ipsec_tunnel, path=["response"]) + + @parametrize + async def test_method_bulk_update_with_all_params(self, async_client: AsyncCloudflare) -> None: + ipsec_tunnel = await async_client.magic_transit.ipsec_tunnels.bulk_update( + account_id="023e105f4ecef8ad9ca31a8372d0c353", + body={}, + x_magic_new_hc_target=True, + ) + assert_matches_type(IPSECTunnelBulkUpdateResponse, ipsec_tunnel, path=["response"]) + + @parametrize + async def test_raw_response_bulk_update(self, async_client: AsyncCloudflare) -> None: + response = await async_client.magic_transit.ipsec_tunnels.with_raw_response.bulk_update( + account_id="023e105f4ecef8ad9ca31a8372d0c353", + body={}, + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + ipsec_tunnel = await response.parse() + assert_matches_type(IPSECTunnelBulkUpdateResponse, ipsec_tunnel, path=["response"]) + + @parametrize + async def test_streaming_response_bulk_update(self, async_client: AsyncCloudflare) -> None: + async with async_client.magic_transit.ipsec_tunnels.with_streaming_response.bulk_update( + account_id="023e105f4ecef8ad9ca31a8372d0c353", + body={}, + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + ipsec_tunnel = await response.parse() + assert_matches_type(IPSECTunnelBulkUpdateResponse, ipsec_tunnel, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_path_params_bulk_update(self, async_client: AsyncCloudflare) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `account_id` but received ''"): + await async_client.magic_transit.ipsec_tunnels.with_raw_response.bulk_update( + account_id="", + body={}, + ) + @parametrize async def test_method_get(self, async_client: AsyncCloudflare) -> None: ipsec_tunnel = await async_client.magic_transit.ipsec_tunnels.get( diff --git a/tests/api_resources/magic_transit/test_routes.py b/tests/api_resources/magic_transit/test_routes.py index 0344c8e2a13..607186daf23 100644 --- a/tests/api_resources/magic_transit/test_routes.py +++ b/tests/api_resources/magic_transit/test_routes.py @@ -16,6 +16,7 @@ RouteCreateResponse, RouteDeleteResponse, RouteUpdateResponse, + RouteBulkUpdateResponse, ) base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -236,6 +237,76 @@ def test_path_params_delete(self, client: Cloudflare) -> None: account_id="023e105f4ecef8ad9ca31a8372d0c353", ) + @parametrize + def test_method_bulk_update(self, client: Cloudflare) -> None: + route = client.magic_transit.routes.bulk_update( + account_id="023e105f4ecef8ad9ca31a8372d0c353", + routes=[ + { + "id": "023e105f4ecef8ad9ca31a8372d0c353", + "nexthop": "203.0.113.1", + "prefix": "192.0.2.0/24", + "priority": 0, + } + ], + ) + assert_matches_type(RouteBulkUpdateResponse, route, path=["response"]) + + @parametrize + def test_raw_response_bulk_update(self, client: Cloudflare) -> None: + response = client.magic_transit.routes.with_raw_response.bulk_update( + account_id="023e105f4ecef8ad9ca31a8372d0c353", + routes=[ + { + "id": "023e105f4ecef8ad9ca31a8372d0c353", + "nexthop": "203.0.113.1", + "prefix": "192.0.2.0/24", + "priority": 0, + } + ], + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + route = response.parse() + assert_matches_type(RouteBulkUpdateResponse, route, path=["response"]) + + @parametrize + def test_streaming_response_bulk_update(self, client: Cloudflare) -> None: + with client.magic_transit.routes.with_streaming_response.bulk_update( + account_id="023e105f4ecef8ad9ca31a8372d0c353", + routes=[ + { + "id": "023e105f4ecef8ad9ca31a8372d0c353", + "nexthop": "203.0.113.1", + "prefix": "192.0.2.0/24", + "priority": 0, + } + ], + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + route = response.parse() + assert_matches_type(RouteBulkUpdateResponse, route, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_path_params_bulk_update(self, client: Cloudflare) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `account_id` but received ''"): + client.magic_transit.routes.with_raw_response.bulk_update( + account_id="", + routes=[ + { + "id": "023e105f4ecef8ad9ca31a8372d0c353", + "nexthop": "203.0.113.1", + "prefix": "192.0.2.0/24", + "priority": 0, + } + ], + ) + @parametrize def test_method_empty(self, client: Cloudflare) -> None: route = client.magic_transit.routes.empty( @@ -538,6 +609,76 @@ async def test_path_params_delete(self, async_client: AsyncCloudflare) -> None: account_id="023e105f4ecef8ad9ca31a8372d0c353", ) + @parametrize + async def test_method_bulk_update(self, async_client: AsyncCloudflare) -> None: + route = await async_client.magic_transit.routes.bulk_update( + account_id="023e105f4ecef8ad9ca31a8372d0c353", + routes=[ + { + "id": "023e105f4ecef8ad9ca31a8372d0c353", + "nexthop": "203.0.113.1", + "prefix": "192.0.2.0/24", + "priority": 0, + } + ], + ) + assert_matches_type(RouteBulkUpdateResponse, route, path=["response"]) + + @parametrize + async def test_raw_response_bulk_update(self, async_client: AsyncCloudflare) -> None: + response = await async_client.magic_transit.routes.with_raw_response.bulk_update( + account_id="023e105f4ecef8ad9ca31a8372d0c353", + routes=[ + { + "id": "023e105f4ecef8ad9ca31a8372d0c353", + "nexthop": "203.0.113.1", + "prefix": "192.0.2.0/24", + "priority": 0, + } + ], + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + route = await response.parse() + assert_matches_type(RouteBulkUpdateResponse, route, path=["response"]) + + @parametrize + async def test_streaming_response_bulk_update(self, async_client: AsyncCloudflare) -> None: + async with async_client.magic_transit.routes.with_streaming_response.bulk_update( + account_id="023e105f4ecef8ad9ca31a8372d0c353", + routes=[ + { + "id": "023e105f4ecef8ad9ca31a8372d0c353", + "nexthop": "203.0.113.1", + "prefix": "192.0.2.0/24", + "priority": 0, + } + ], + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + route = await response.parse() + assert_matches_type(RouteBulkUpdateResponse, route, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_path_params_bulk_update(self, async_client: AsyncCloudflare) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `account_id` but received ''"): + await async_client.magic_transit.routes.with_raw_response.bulk_update( + account_id="", + routes=[ + { + "id": "023e105f4ecef8ad9ca31a8372d0c353", + "nexthop": "203.0.113.1", + "prefix": "192.0.2.0/24", + "priority": 0, + } + ], + ) + @parametrize async def test_method_empty(self, async_client: AsyncCloudflare) -> None: route = await async_client.magic_transit.routes.empty( diff --git a/tests/api_resources/rum/test_rules.py b/tests/api_resources/rum/test_rules.py index 6cdb5f5db36..5ab034386be 100644 --- a/tests/api_resources/rum/test_rules.py +++ b/tests/api_resources/rum/test_rules.py @@ -9,7 +9,12 @@ from cloudflare import Cloudflare, AsyncCloudflare from tests.utils import assert_matches_type -from cloudflare.types.rum import RUMRule, RuleListResponse, RuleDeleteResponse +from cloudflare.types.rum import ( + RUMRule, + RuleListResponse, + RuleDeleteResponse, + RuleBulkCreateResponse, +) base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -258,6 +263,72 @@ def test_path_params_delete(self, client: Cloudflare) -> None: ruleset_id="f174e90a-fafe-4643-bbbc-4a0ed4fc8415", ) + @parametrize + def test_method_bulk_create(self, client: Cloudflare) -> None: + rule = client.rum.rules.bulk_create( + ruleset_id="f174e90a-fafe-4643-bbbc-4a0ed4fc8415", + account_id="023e105f4ecef8ad9ca31a8372d0c353", + ) + assert_matches_type(Optional[RuleBulkCreateResponse], rule, path=["response"]) + + @parametrize + def test_method_bulk_create_with_all_params(self, client: Cloudflare) -> None: + rule = client.rum.rules.bulk_create( + ruleset_id="f174e90a-fafe-4643-bbbc-4a0ed4fc8415", + account_id="023e105f4ecef8ad9ca31a8372d0c353", + delete_rules=["f174e90a-fafe-4643-bbbc-4a0ed4fc8415"], + rules=[ + { + "id": "f174e90a-fafe-4643-bbbc-4a0ed4fc8415", + "host": "example.com", + "inclusive": True, + "is_paused": False, + "paths": ["*"], + } + ], + ) + assert_matches_type(Optional[RuleBulkCreateResponse], rule, path=["response"]) + + @parametrize + def test_raw_response_bulk_create(self, client: Cloudflare) -> None: + response = client.rum.rules.with_raw_response.bulk_create( + ruleset_id="f174e90a-fafe-4643-bbbc-4a0ed4fc8415", + account_id="023e105f4ecef8ad9ca31a8372d0c353", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + rule = response.parse() + assert_matches_type(Optional[RuleBulkCreateResponse], rule, path=["response"]) + + @parametrize + def test_streaming_response_bulk_create(self, client: Cloudflare) -> None: + with client.rum.rules.with_streaming_response.bulk_create( + ruleset_id="f174e90a-fafe-4643-bbbc-4a0ed4fc8415", + account_id="023e105f4ecef8ad9ca31a8372d0c353", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + rule = response.parse() + assert_matches_type(Optional[RuleBulkCreateResponse], rule, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_path_params_bulk_create(self, client: Cloudflare) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `account_id` but received ''"): + client.rum.rules.with_raw_response.bulk_create( + ruleset_id="f174e90a-fafe-4643-bbbc-4a0ed4fc8415", + account_id="", + ) + + with pytest.raises(ValueError, match=r"Expected a non-empty value for `ruleset_id` but received ''"): + client.rum.rules.with_raw_response.bulk_create( + ruleset_id="", + account_id="023e105f4ecef8ad9ca31a8372d0c353", + ) + class TestAsyncRules: parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"]) @@ -502,3 +573,69 @@ async def test_path_params_delete(self, async_client: AsyncCloudflare) -> None: account_id="023e105f4ecef8ad9ca31a8372d0c353", ruleset_id="f174e90a-fafe-4643-bbbc-4a0ed4fc8415", ) + + @parametrize + async def test_method_bulk_create(self, async_client: AsyncCloudflare) -> None: + rule = await async_client.rum.rules.bulk_create( + ruleset_id="f174e90a-fafe-4643-bbbc-4a0ed4fc8415", + account_id="023e105f4ecef8ad9ca31a8372d0c353", + ) + assert_matches_type(Optional[RuleBulkCreateResponse], rule, path=["response"]) + + @parametrize + async def test_method_bulk_create_with_all_params(self, async_client: AsyncCloudflare) -> None: + rule = await async_client.rum.rules.bulk_create( + ruleset_id="f174e90a-fafe-4643-bbbc-4a0ed4fc8415", + account_id="023e105f4ecef8ad9ca31a8372d0c353", + delete_rules=["f174e90a-fafe-4643-bbbc-4a0ed4fc8415"], + rules=[ + { + "id": "f174e90a-fafe-4643-bbbc-4a0ed4fc8415", + "host": "example.com", + "inclusive": True, + "is_paused": False, + "paths": ["*"], + } + ], + ) + assert_matches_type(Optional[RuleBulkCreateResponse], rule, path=["response"]) + + @parametrize + async def test_raw_response_bulk_create(self, async_client: AsyncCloudflare) -> None: + response = await async_client.rum.rules.with_raw_response.bulk_create( + ruleset_id="f174e90a-fafe-4643-bbbc-4a0ed4fc8415", + account_id="023e105f4ecef8ad9ca31a8372d0c353", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + rule = await response.parse() + assert_matches_type(Optional[RuleBulkCreateResponse], rule, path=["response"]) + + @parametrize + async def test_streaming_response_bulk_create(self, async_client: AsyncCloudflare) -> None: + async with async_client.rum.rules.with_streaming_response.bulk_create( + ruleset_id="f174e90a-fafe-4643-bbbc-4a0ed4fc8415", + account_id="023e105f4ecef8ad9ca31a8372d0c353", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + rule = await response.parse() + assert_matches_type(Optional[RuleBulkCreateResponse], rule, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_path_params_bulk_create(self, async_client: AsyncCloudflare) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `account_id` but received ''"): + await async_client.rum.rules.with_raw_response.bulk_create( + ruleset_id="f174e90a-fafe-4643-bbbc-4a0ed4fc8415", + account_id="", + ) + + with pytest.raises(ValueError, match=r"Expected a non-empty value for `ruleset_id` but received ''"): + await async_client.rum.rules.with_raw_response.bulk_create( + ruleset_id="", + account_id="023e105f4ecef8ad9ca31a8372d0c353", + ) diff --git a/tests/api_resources/test_filters.py b/tests/api_resources/test_filters.py index 683f923ca5a..eb126fb8162 100644 --- a/tests/api_resources/test_filters.py +++ b/tests/api_resources/test_filters.py @@ -13,6 +13,8 @@ from cloudflare.types.filters import ( FirewallFilter, FilterCreateResponse, + FilterBulkDeleteResponse, + FilterBulkUpdateResponse, ) # pyright: reportDeprecated=false @@ -248,6 +250,92 @@ def test_path_params_delete(self, client: Cloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) + @parametrize + def test_method_bulk_delete(self, client: Cloudflare) -> None: + with pytest.warns(DeprecationWarning): + filter = client.filters.bulk_delete( + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + ) + + assert_matches_type(Optional[FilterBulkDeleteResponse], filter, path=["response"]) + + @parametrize + def test_raw_response_bulk_delete(self, client: Cloudflare) -> None: + with pytest.warns(DeprecationWarning): + response = client.filters.with_raw_response.bulk_delete( + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + filter = response.parse() + assert_matches_type(Optional[FilterBulkDeleteResponse], filter, path=["response"]) + + @parametrize + def test_streaming_response_bulk_delete(self, client: Cloudflare) -> None: + with pytest.warns(DeprecationWarning): + with client.filters.with_streaming_response.bulk_delete( + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + filter = response.parse() + assert_matches_type(Optional[FilterBulkDeleteResponse], filter, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_path_params_bulk_delete(self, client: Cloudflare) -> None: + with pytest.warns(DeprecationWarning): + with pytest.raises(ValueError, match=r"Expected a non-empty value for `zone_id` but received ''"): + client.filters.with_raw_response.bulk_delete( + zone_id="", + ) + + @parametrize + def test_method_bulk_update(self, client: Cloudflare) -> None: + with pytest.warns(DeprecationWarning): + filter = client.filters.bulk_update( + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + ) + + assert_matches_type(Optional[FilterBulkUpdateResponse], filter, path=["response"]) + + @parametrize + def test_raw_response_bulk_update(self, client: Cloudflare) -> None: + with pytest.warns(DeprecationWarning): + response = client.filters.with_raw_response.bulk_update( + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + filter = response.parse() + assert_matches_type(Optional[FilterBulkUpdateResponse], filter, path=["response"]) + + @parametrize + def test_streaming_response_bulk_update(self, client: Cloudflare) -> None: + with pytest.warns(DeprecationWarning): + with client.filters.with_streaming_response.bulk_update( + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + filter = response.parse() + assert_matches_type(Optional[FilterBulkUpdateResponse], filter, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_path_params_bulk_update(self, client: Cloudflare) -> None: + with pytest.warns(DeprecationWarning): + with pytest.raises(ValueError, match=r"Expected a non-empty value for `zone_id` but received ''"): + client.filters.with_raw_response.bulk_update( + zone_id="", + ) + @parametrize def test_method_get(self, client: Cloudflare) -> None: with pytest.warns(DeprecationWarning): @@ -530,6 +618,92 @@ async def test_path_params_delete(self, async_client: AsyncCloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) + @parametrize + async def test_method_bulk_delete(self, async_client: AsyncCloudflare) -> None: + with pytest.warns(DeprecationWarning): + filter = await async_client.filters.bulk_delete( + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + ) + + assert_matches_type(Optional[FilterBulkDeleteResponse], filter, path=["response"]) + + @parametrize + async def test_raw_response_bulk_delete(self, async_client: AsyncCloudflare) -> None: + with pytest.warns(DeprecationWarning): + response = await async_client.filters.with_raw_response.bulk_delete( + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + filter = await response.parse() + assert_matches_type(Optional[FilterBulkDeleteResponse], filter, path=["response"]) + + @parametrize + async def test_streaming_response_bulk_delete(self, async_client: AsyncCloudflare) -> None: + with pytest.warns(DeprecationWarning): + async with async_client.filters.with_streaming_response.bulk_delete( + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + filter = await response.parse() + assert_matches_type(Optional[FilterBulkDeleteResponse], filter, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_path_params_bulk_delete(self, async_client: AsyncCloudflare) -> None: + with pytest.warns(DeprecationWarning): + with pytest.raises(ValueError, match=r"Expected a non-empty value for `zone_id` but received ''"): + await async_client.filters.with_raw_response.bulk_delete( + zone_id="", + ) + + @parametrize + async def test_method_bulk_update(self, async_client: AsyncCloudflare) -> None: + with pytest.warns(DeprecationWarning): + filter = await async_client.filters.bulk_update( + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + ) + + assert_matches_type(Optional[FilterBulkUpdateResponse], filter, path=["response"]) + + @parametrize + async def test_raw_response_bulk_update(self, async_client: AsyncCloudflare) -> None: + with pytest.warns(DeprecationWarning): + response = await async_client.filters.with_raw_response.bulk_update( + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + filter = await response.parse() + assert_matches_type(Optional[FilterBulkUpdateResponse], filter, path=["response"]) + + @parametrize + async def test_streaming_response_bulk_update(self, async_client: AsyncCloudflare) -> None: + with pytest.warns(DeprecationWarning): + async with async_client.filters.with_streaming_response.bulk_update( + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + filter = await response.parse() + assert_matches_type(Optional[FilterBulkUpdateResponse], filter, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_path_params_bulk_update(self, async_client: AsyncCloudflare) -> None: + with pytest.warns(DeprecationWarning): + with pytest.raises(ValueError, match=r"Expected a non-empty value for `zone_id` but received ''"): + await async_client.filters.with_raw_response.bulk_update( + zone_id="", + ) + @parametrize async def test_method_get(self, async_client: AsyncCloudflare) -> None: with pytest.warns(DeprecationWarning):