From feb296571927e5c0a1c8f55eab22efd7255f20e8 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 4 Apr 2024 21:33:35 +0000 Subject: [PATCH] feat(api): update via SDK Studio (#225) --- api.md | 382 ++--- .../resources/zones/settings/__init__.py | 1008 +++++------ .../resources/zones/settings/advanced_ddos.py | 10 +- .../resources/zones/settings/always_online.py | 56 +- .../zones/settings/always_use_https.py | 26 +- .../settings/automatic_https_rewrites.py | 22 +- .../automatic_platform_optimization.py | 74 +- .../resources/zones/settings/brotli.py | 56 +- .../zones/settings/browser_cache_ttl.py | 56 +- .../resources/zones/settings/browser_check.py | 56 +- .../resources/zones/settings/cache_level.py | 56 +- .../resources/zones/settings/challenge_ttl.py | 56 +- .../resources/zones/settings/ciphers.py | 18 +- .../zones/settings/development_mode.py | 56 +- .../resources/zones/settings/early_hints.py | 18 +- .../zones/settings/email_obfuscation.py | 56 +- .../resources/zones/settings/font_settings.py | 18 +- .../zones/settings/h2_prioritization.py | 64 +- .../zones/settings/hotlink_protection.py | 56 +- .../resources/zones/settings/http2.py | 56 +- .../resources/zones/settings/http3.py | 56 +- .../zones/settings/image_resizing.py | 60 +- .../zones/settings/ip_geolocation.py | 56 +- .../resources/zones/settings/ipv6.py | 56 +- .../zones/settings/min_tls_version.py | 56 +- .../resources/zones/settings/minify.py | 56 +- .../resources/zones/settings/mirage.py | 56 +- .../zones/settings/mobile_redirect.py | 56 +- .../resources/zones/settings/nel.py | 60 +- .../settings/opportunistic_encryption.py | 64 +- .../zones/settings/opportunistic_onion.py | 56 +- .../zones/settings/orange_to_orange.py | 64 +- .../settings/origin_error_page_pass_thru.py | 64 +- .../resources/zones/settings/polish.py | 60 +- .../zones/settings/prefetch_preload.py | 56 +- .../zones/settings/proxy_read_timeout.py | 64 +- .../resources/zones/settings/pseudo_ipv4.py | 56 +- .../zones/settings/response_buffering.py | 56 +- .../resources/zones/settings/rocket_loader.py | 60 +- .../zones/settings/security_headers.py | 26 +- .../zones/settings/security_level.py | 56 +- .../zones/settings/server_side_excludes.py | 30 +- .../resources/zones/settings/settings.py | 1516 +++++++++-------- .../settings/sort_query_string_for_cache.py | 64 +- .../resources/zones/settings/ssl.py | 56 +- .../zones/settings/ssl_recommender.py | 64 +- .../resources/zones/settings/tls_1_3.py | 56 +- .../zones/settings/tls_client_auth.py | 56 +- .../zones/settings/true_client_ip_header.py | 56 +- .../resources/zones/settings/waf.py | 56 +- .../resources/zones/settings/webp.py | 56 +- .../resources/zones/settings/websocket.py | 56 +- .../resources/zones/settings/zero_rtt.py | 56 +- .../types/zones/settings/__init__.py | 132 +- ...ting_advanced_ddos.py => advanced_ddos.py} | 4 +- ...ting_always_online.py => always_online.py} | 4 +- ...lways_use_https.py => always_use_https.py} | 4 +- ...ewrites.py => automatic_https_rewrites.py} | 4 +- ....py => automatic_platform_optimization.py} | 4 +- ...matic_platform_optimization_edit_params.py | 4 +- ... automatic_platform_optimization_param.py} | 4 +- .../{zone_setting_brotli.py => brotli.py} | 4 +- ...wser_cache_ttl.py => browser_cache_ttl.py} | 4 +- ...ting_browser_check.py => browser_check.py} | 4 +- ..._setting_cache_level.py => cache_level.py} | 4 +- ...ting_challenge_ttl.py => challenge_ttl.py} | 4 +- .../{zone_setting_ciphers.py => ciphers.py} | 4 +- ...evelopment_mode.py => development_mode.py} | 4 +- ..._setting_early_hints.py => early_hints.py} | 4 +- ...il_obfuscation.py => email_obfuscation.py} | 4 +- ...zone_setting_fonts.py => font_settings.py} | 4 +- ...prioritization.py => h2_prioritization.py} | 4 +- .../settings/h2_prioritization_edit_params.py | 4 +- ...on_param.py => h2_prioritization_param.py} | 4 +- ...nk_protection.py => hotlink_protection.py} | 4 +- .../{zone_setting_http2.py => http2.py} | 4 +- .../{zone_setting_http3.py => http3.py} | 4 +- ...ng_image_resizing.py => image_resizing.py} | 4 +- .../settings/image_resizing_edit_params.py | 4 +- ...izing_param.py => image_resizing_param.py} | 4 +- ...ng_ip_geolocation.py => ip_geolocation.py} | 4 +- .../{zone_setting_ipv6.py => ipv6.py} | 4 +- ..._min_tls_version.py => min_tls_version.py} | 4 +- .../{zone_setting_minify.py => minify.py} | 4 +- .../{zone_setting_mirage.py => mirage.py} | 4 +- ..._mobile_redirect.py => mobile_redirect.py} | 4 +- .../settings/{zone_setting_nel.py => nel.py} | 4 +- .../types/zones/settings/nel_edit_params.py | 4 +- ...zone_setting_nel_param.py => nel_param.py} | 4 +- ...ryption.py => opportunistic_encryption.py} | 4 +- ...nistic_onion.py => opportunistic_onion.py} | 4 +- ...range_to_orange.py => orange_to_orange.py} | 4 +- .../settings/orange_to_orange_edit_params.py | 4 +- ...nge_param.py => orange_to_orange_param.py} | 4 +- ...thru.py => origin_error_page_pass_thru.py} | 4 +- .../{zone_setting_polish.py => polish.py} | 4 +- .../zones/settings/polish_edit_params.py | 4 +- ...etting_polish_param.py => polish_param.py} | 4 +- ...refetch_preload.py => prefetch_preload.py} | 4 +- ..._read_timeout.py => proxy_read_timeout.py} | 4 +- .../proxy_read_timeout_edit_params.py | 4 +- ...t_param.py => proxy_read_timeout_param.py} | 4 +- ..._setting_pseudo_ipv4.py => pseudo_ipv4.py} | 4 +- ...ing_buffering.py => response_buffering.py} | 4 +- ...ting_rocket_loader.py => rocket_loader.py} | 4 +- .../settings/rocket_loader_edit_params.py | 4 +- ...loader_param.py => rocket_loader_param.py} | 4 +- ...security_header.py => security_headers.py} | 4 +- ...ng_security_level.py => security_level.py} | 4 +- ...ide_exclude.py => server_side_excludes.py} | 4 +- ...ache.py => sort_query_string_for_cache.py} | 4 +- .../settings/{zone_setting_ssl.py => ssl.py} | 4 +- ..._ssl_recommender.py => ssl_recommender.py} | 4 +- .../settings/ssl_recommender_edit_params.py | 4 +- ...nder_param.py => ssl_recommender_param.py} | 4 +- .../{zone_setting_tls_1_3.py => tls_1_3.py} | 4 +- ..._tls_client_auth.py => tls_client_auth.py} | 4 +- ..._ip_header.py => true_client_ip_header.py} | 4 +- .../settings/{zone_setting_waf.py => waf.py} | 4 +- .../{zone_setting_webp.py => webp.py} | 4 +- ...one_setting_websockets.py => websocket.py} | 4 +- .../{zone_setting_0rtt.py => zero_rtt.py} | 4 +- .../zones/settings/test_advanced_ddos.py | 14 +- .../zones/settings/test_always_online.py | 26 +- .../zones/settings/test_always_use_https.py | 26 +- .../settings/test_automatic_https_rewrites.py | 26 +- .../test_automatic_platform_optimization.py | 44 +- .../zones/settings/test_brotli.py | 26 +- .../zones/settings/test_browser_cache_ttl.py | 26 +- .../zones/settings/test_browser_check.py | 26 +- .../zones/settings/test_cache_level.py | 26 +- .../zones/settings/test_challenge_ttl.py | 26 +- .../zones/settings/test_ciphers.py | 26 +- .../zones/settings/test_development_mode.py | 26 +- .../zones/settings/test_early_hints.py | 26 +- .../zones/settings/test_email_obfuscation.py | 26 +- .../zones/settings/test_font_settings.py | 26 +- .../zones/settings/test_h2_prioritization.py | 30 +- .../zones/settings/test_hotlink_protection.py | 26 +- .../zones/settings/test_http2.py | 26 +- .../zones/settings/test_http3.py | 26 +- .../zones/settings/test_image_resizing.py | 30 +- .../zones/settings/test_ip_geolocation.py | 26 +- .../api_resources/zones/settings/test_ipv6.py | 26 +- .../zones/settings/test_min_tls_version.py | 26 +- .../zones/settings/test_minify.py | 30 +- .../zones/settings/test_mirage.py | 26 +- .../zones/settings/test_mobile_redirect.py | 30 +- .../api_resources/zones/settings/test_nel.py | 30 +- .../settings/test_opportunistic_encryption.py | 34 +- .../settings/test_opportunistic_onion.py | 26 +- .../zones/settings/test_orange_to_orange.py | 30 +- .../test_origin_error_page_pass_thru.py | 50 +- .../zones/settings/test_polish.py | 30 +- .../zones/settings/test_prefetch_preload.py | 26 +- .../zones/settings/test_proxy_read_timeout.py | 30 +- .../zones/settings/test_pseudo_ipv4.py | 26 +- .../zones/settings/test_response_buffering.py | 26 +- .../zones/settings/test_rocket_loader.py | 30 +- .../zones/settings/test_security_headers.py | 30 +- .../zones/settings/test_security_level.py | 26 +- .../settings/test_server_side_excludes.py | 26 +- .../test_sort_query_string_for_cache.py | 50 +- .../api_resources/zones/settings/test_ssl.py | 26 +- .../zones/settings/test_ssl_recommender.py | 30 +- .../zones/settings/test_tls_1_3.py | 26 +- .../zones/settings/test_tls_client_auth.py | 26 +- .../settings/test_true_client_ip_header.py | 26 +- .../api_resources/zones/settings/test_waf.py | 26 +- .../api_resources/zones/settings/test_webp.py | 26 +- .../zones/settings/test_websocket.py | 26 +- .../zones/settings/test_zero_rtt.py | 26 +- 172 files changed, 3613 insertions(+), 3713 deletions(-) rename src/cloudflare/types/zones/settings/{zone_setting_advanced_ddos.py => advanced_ddos.py} (88%) rename src/cloudflare/types/zones/settings/{zone_setting_always_online.py => always_online.py} (88%) rename src/cloudflare/types/zones/settings/{zone_setting_always_use_https.py => always_use_https.py} (88%) rename src/cloudflare/types/zones/settings/{zone_setting_automatic_https_rewrites.py => automatic_https_rewrites.py} (86%) rename src/cloudflare/types/zones/settings/{zone_setting_automatic_platform_optimization.py => automatic_platform_optimization.py} (89%) rename src/cloudflare/types/zones/settings/{zone_setting_automatic_platform_optimization_param.py => automatic_platform_optimization_param.py} (88%) rename src/cloudflare/types/zones/settings/{zone_setting_brotli.py => brotli.py} (90%) rename src/cloudflare/types/zones/settings/{zone_setting_browser_cache_ttl.py => browser_cache_ttl.py} (92%) rename src/cloudflare/types/zones/settings/{zone_setting_browser_check.py => browser_check.py} (88%) rename src/cloudflare/types/zones/settings/{zone_setting_cache_level.py => cache_level.py} (89%) rename src/cloudflare/types/zones/settings/{zone_setting_challenge_ttl.py => challenge_ttl.py} (89%) rename src/cloudflare/types/zones/settings/{zone_setting_ciphers.py => ciphers.py} (89%) rename src/cloudflare/types/zones/settings/{zone_setting_development_mode.py => development_mode.py} (91%) rename src/cloudflare/types/zones/settings/{zone_setting_early_hints.py => early_hints.py} (89%) rename src/cloudflare/types/zones/settings/{zone_setting_email_obfuscation.py => email_obfuscation.py} (87%) rename src/cloudflare/types/zones/settings/{zone_setting_fonts.py => font_settings.py} (90%) rename src/cloudflare/types/zones/settings/{zone_setting_h2_prioritization.py => h2_prioritization.py} (87%) rename src/cloudflare/types/zones/settings/{zone_setting_h2_prioritization_param.py => h2_prioritization_param.py} (76%) rename src/cloudflare/types/zones/settings/{zone_setting_hotlink_protection.py => hotlink_protection.py} (87%) rename src/cloudflare/types/zones/settings/{zone_setting_http2.py => http2.py} (90%) rename src/cloudflare/types/zones/settings/{zone_setting_http3.py => http3.py} (90%) rename src/cloudflare/types/zones/settings/{zone_setting_image_resizing.py => image_resizing.py} (88%) rename src/cloudflare/types/zones/settings/{zone_setting_image_resizing_param.py => image_resizing_param.py} (77%) rename src/cloudflare/types/zones/settings/{zone_setting_ip_geolocation.py => ip_geolocation.py} (88%) rename src/cloudflare/types/zones/settings/{zone_setting_ipv6.py => ipv6.py} (90%) rename src/cloudflare/types/zones/settings/{zone_setting_min_tls_version.py => min_tls_version.py} (88%) rename src/cloudflare/types/zones/settings/{zone_setting_minify.py => minify.py} (92%) rename src/cloudflare/types/zones/settings/{zone_setting_mirage.py => mirage.py} (90%) rename src/cloudflare/types/zones/settings/{zone_setting_mobile_redirect.py => mobile_redirect.py} (92%) rename src/cloudflare/types/zones/settings/{zone_setting_nel.py => nel.py} (90%) rename src/cloudflare/types/zones/settings/{zone_setting_nel_param.py => nel_param.py} (80%) rename src/cloudflare/types/zones/settings/{zone_setting_opportunistic_encryption.py => opportunistic_encryption.py} (86%) rename src/cloudflare/types/zones/settings/{zone_setting_opportunistic_onion.py => opportunistic_onion.py} (87%) rename src/cloudflare/types/zones/settings/{zone_setting_orange_to_orange.py => orange_to_orange.py} (88%) rename src/cloudflare/types/zones/settings/{zone_setting_orange_to_orange_param.py => orange_to_orange_param.py} (76%) rename src/cloudflare/types/zones/settings/{zone_setting_origin_error_page_pass_thru.py => origin_error_page_pass_thru.py} (86%) rename src/cloudflare/types/zones/settings/{zone_setting_polish.py => polish.py} (90%) rename src/cloudflare/types/zones/settings/{zone_setting_polish_param.py => polish_param.py} (79%) rename src/cloudflare/types/zones/settings/{zone_setting_prefetch_preload.py => prefetch_preload.py} (88%) rename src/cloudflare/types/zones/settings/{zone_setting_proxy_read_timeout.py => proxy_read_timeout.py} (87%) rename src/cloudflare/types/zones/settings/{zone_setting_proxy_read_timeout_param.py => proxy_read_timeout_param.py} (75%) rename src/cloudflare/types/zones/settings/{zone_setting_pseudo_ipv4.py => pseudo_ipv4.py} (89%) rename src/cloudflare/types/zones/settings/{zone_setting_buffering.py => response_buffering.py} (89%) rename src/cloudflare/types/zones/settings/{zone_setting_rocket_loader.py => rocket_loader.py} (88%) rename src/cloudflare/types/zones/settings/{zone_setting_rocket_loader_param.py => rocket_loader_param.py} (77%) rename src/cloudflare/types/zones/settings/{zone_setting_security_header.py => security_headers.py} (90%) rename src/cloudflare/types/zones/settings/{zone_setting_security_level.py => security_level.py} (89%) rename src/cloudflare/types/zones/settings/{zone_setting_server_side_exclude.py => server_side_excludes.py} (87%) rename src/cloudflare/types/zones/settings/{zone_setting_sort_query_string_for_cache.py => sort_query_string_for_cache.py} (86%) rename src/cloudflare/types/zones/settings/{zone_setting_ssl.py => ssl.py} (91%) rename src/cloudflare/types/zones/settings/{zone_setting_ssl_recommender.py => ssl_recommender.py} (81%) rename src/cloudflare/types/zones/settings/{zone_setting_ssl_recommender_param.py => ssl_recommender_param.py} (75%) rename src/cloudflare/types/zones/settings/{zone_setting_tls_1_3.py => tls_1_3.py} (90%) rename src/cloudflare/types/zones/settings/{zone_setting_tls_client_auth.py => tls_client_auth.py} (88%) rename src/cloudflare/types/zones/settings/{zone_setting_true_client_ip_header.py => true_client_ip_header.py} (87%) rename src/cloudflare/types/zones/settings/{zone_setting_waf.py => waf.py} (90%) rename src/cloudflare/types/zones/settings/{zone_setting_webp.py => webp.py} (90%) rename src/cloudflare/types/zones/settings/{zone_setting_websockets.py => websocket.py} (89%) rename src/cloudflare/types/zones/settings/{zone_setting_0rtt.py => zero_rtt.py} (90%) diff --git a/api.md b/api.md index 28804129a473..4de6b6789960 100644 --- a/api.md +++ b/api.md @@ -394,407 +394,407 @@ Methods: ## Settings -### ZeroRTT +### ZeroRTTResource Types: ```python -from cloudflare.types.zones.settings import ZoneSetting0rtt +from cloudflare.types.zones.settings import ZeroRTT ``` Methods: -- client.zones.settings.zero_rtt.edit(\*, zone_id, \*\*params) -> Optional -- client.zones.settings.zero_rtt.get(\*, zone_id) -> Optional +- client.zones.settings.zero_rtt.edit(\*, zone_id, \*\*params) -> Optional +- client.zones.settings.zero_rtt.get(\*, zone_id) -> Optional ### AdvancedDDoS Types: ```python -from cloudflare.types.zones.settings import ZoneSettingAdvancedDDoS +from cloudflare.types.zones.settings import AdvancedDDoS ``` Methods: -- client.zones.settings.advanced_ddos.get(\*, zone_id) -> Optional +- client.zones.settings.advanced_ddos.get(\*, zone_id) -> Optional -### AlwaysOnline +### AlwaysOnlineResource Types: ```python -from cloudflare.types.zones.settings import ZoneSettingAlwaysOnline +from cloudflare.types.zones.settings import AlwaysOnline ``` Methods: -- client.zones.settings.always_online.edit(\*, zone_id, \*\*params) -> Optional -- client.zones.settings.always_online.get(\*, zone_id) -> Optional +- client.zones.settings.always_online.edit(\*, zone_id, \*\*params) -> Optional +- client.zones.settings.always_online.get(\*, zone_id) -> Optional ### AlwaysUseHTTPS Types: ```python -from cloudflare.types.zones.settings import ZoneSettingAlwaysUseHTTPS +from cloudflare.types.zones.settings import AlwaysUseHTTPS ``` Methods: -- client.zones.settings.always_use_https.edit(\*, zone_id, \*\*params) -> Optional -- client.zones.settings.always_use_https.get(\*, zone_id) -> Optional +- client.zones.settings.always_use_https.edit(\*, zone_id, \*\*params) -> Optional +- client.zones.settings.always_use_https.get(\*, zone_id) -> Optional ### AutomaticHTTPSRewrites Types: ```python -from cloudflare.types.zones.settings import ZoneSettingAutomaticHTTPSRewrites +from cloudflare.types.zones.settings import AutomaticHTTPSRewrites ``` Methods: -- client.zones.settings.automatic_https_rewrites.edit(\*, zone_id, \*\*params) -> Optional -- client.zones.settings.automatic_https_rewrites.get(\*, zone_id) -> Optional +- client.zones.settings.automatic_https_rewrites.edit(\*, zone_id, \*\*params) -> Optional +- client.zones.settings.automatic_https_rewrites.get(\*, zone_id) -> Optional -### AutomaticPlatformOptimization +### AutomaticPlatformOptimizationResource Types: ```python -from cloudflare.types.zones.settings import ZoneSettingAutomaticPlatformOptimization +from cloudflare.types.zones.settings import AutomaticPlatformOptimization ``` Methods: -- client.zones.settings.automatic_platform_optimization.edit(\*, zone_id, \*\*params) -> Optional -- client.zones.settings.automatic_platform_optimization.get(\*, zone_id) -> Optional +- client.zones.settings.automatic_platform_optimization.edit(\*, zone_id, \*\*params) -> Optional +- client.zones.settings.automatic_platform_optimization.get(\*, zone_id) -> Optional -### Brotli +### BrotliResource Types: ```python -from cloudflare.types.zones.settings import ZoneSettingBrotli +from cloudflare.types.zones.settings import Brotli ``` Methods: -- client.zones.settings.brotli.edit(\*, zone_id, \*\*params) -> Optional -- client.zones.settings.brotli.get(\*, zone_id) -> Optional +- client.zones.settings.brotli.edit(\*, zone_id, \*\*params) -> Optional +- client.zones.settings.brotli.get(\*, zone_id) -> Optional -### BrowserCacheTTL +### BrowserCacheTTLResource Types: ```python -from cloudflare.types.zones.settings import ZoneSettingBrowserCacheTTL +from cloudflare.types.zones.settings import BrowserCacheTTL ``` Methods: -- client.zones.settings.browser_cache_ttl.edit(\*, zone_id, \*\*params) -> Optional -- client.zones.settings.browser_cache_ttl.get(\*, zone_id) -> Optional +- client.zones.settings.browser_cache_ttl.edit(\*, zone_id, \*\*params) -> Optional +- client.zones.settings.browser_cache_ttl.get(\*, zone_id) -> Optional -### BrowserCheck +### BrowserCheckResource Types: ```python -from cloudflare.types.zones.settings import ZoneSettingBrowserCheck +from cloudflare.types.zones.settings import BrowserCheck ``` Methods: -- client.zones.settings.browser_check.edit(\*, zone_id, \*\*params) -> Optional -- client.zones.settings.browser_check.get(\*, zone_id) -> Optional +- client.zones.settings.browser_check.edit(\*, zone_id, \*\*params) -> Optional +- client.zones.settings.browser_check.get(\*, zone_id) -> Optional -### CacheLevel +### CacheLevelResource Types: ```python -from cloudflare.types.zones.settings import ZoneSettingCacheLevel +from cloudflare.types.zones.settings import CacheLevel ``` Methods: -- client.zones.settings.cache_level.edit(\*, zone_id, \*\*params) -> Optional -- client.zones.settings.cache_level.get(\*, zone_id) -> Optional +- client.zones.settings.cache_level.edit(\*, zone_id, \*\*params) -> Optional +- client.zones.settings.cache_level.get(\*, zone_id) -> Optional -### ChallengeTTL +### ChallengeTTLResource Types: ```python -from cloudflare.types.zones.settings import ZoneSettingChallengeTTL +from cloudflare.types.zones.settings import ChallengeTTL ``` Methods: -- client.zones.settings.challenge_ttl.edit(\*, zone_id, \*\*params) -> Optional -- client.zones.settings.challenge_ttl.get(\*, zone_id) -> Optional +- client.zones.settings.challenge_ttl.edit(\*, zone_id, \*\*params) -> Optional +- client.zones.settings.challenge_ttl.get(\*, zone_id) -> Optional ### Ciphers Types: ```python -from cloudflare.types.zones.settings import ZoneSettingCiphers +from cloudflare.types.zones.settings import Ciphers ``` Methods: -- client.zones.settings.ciphers.edit(\*, zone_id, \*\*params) -> Optional -- client.zones.settings.ciphers.get(\*, zone_id) -> Optional +- client.zones.settings.ciphers.edit(\*, zone_id, \*\*params) -> Optional +- client.zones.settings.ciphers.get(\*, zone_id) -> Optional -### DevelopmentMode +### DevelopmentModeResource Types: ```python -from cloudflare.types.zones.settings import ZoneSettingDevelopmentMode +from cloudflare.types.zones.settings import DevelopmentMode ``` Methods: -- client.zones.settings.development_mode.edit(\*, zone_id, \*\*params) -> Optional -- client.zones.settings.development_mode.get(\*, zone_id) -> Optional +- client.zones.settings.development_mode.edit(\*, zone_id, \*\*params) -> Optional +- client.zones.settings.development_mode.get(\*, zone_id) -> Optional ### EarlyHints Types: ```python -from cloudflare.types.zones.settings import ZoneSettingEarlyHints +from cloudflare.types.zones.settings import EarlyHints ``` Methods: -- client.zones.settings.early_hints.edit(\*, zone_id, \*\*params) -> Optional -- client.zones.settings.early_hints.get(\*, zone_id) -> Optional +- client.zones.settings.early_hints.edit(\*, zone_id, \*\*params) -> Optional +- client.zones.settings.early_hints.get(\*, zone_id) -> Optional -### EmailObfuscation +### EmailObfuscationResource Types: ```python -from cloudflare.types.zones.settings import ZoneSettingEmailObfuscation +from cloudflare.types.zones.settings import EmailObfuscation ``` Methods: -- client.zones.settings.email_obfuscation.edit(\*, zone_id, \*\*params) -> Optional -- client.zones.settings.email_obfuscation.get(\*, zone_id) -> Optional +- client.zones.settings.email_obfuscation.edit(\*, zone_id, \*\*params) -> Optional +- client.zones.settings.email_obfuscation.get(\*, zone_id) -> Optional -### H2Prioritization +### H2PrioritizationResource Types: ```python -from cloudflare.types.zones.settings import ZoneSettingH2Prioritization +from cloudflare.types.zones.settings import H2Prioritization ``` Methods: -- client.zones.settings.h2_prioritization.edit(\*, zone_id, \*\*params) -> Optional -- client.zones.settings.h2_prioritization.get(\*, zone_id) -> Optional +- client.zones.settings.h2_prioritization.edit(\*, zone_id, \*\*params) -> Optional +- client.zones.settings.h2_prioritization.get(\*, zone_id) -> Optional -### HotlinkProtection +### HotlinkProtectionResource Types: ```python -from cloudflare.types.zones.settings import ZoneSettingHotlinkProtection +from cloudflare.types.zones.settings import HotlinkProtection ``` Methods: -- client.zones.settings.hotlink_protection.edit(\*, zone_id, \*\*params) -> Optional -- client.zones.settings.hotlink_protection.get(\*, zone_id) -> Optional +- client.zones.settings.hotlink_protection.edit(\*, zone_id, \*\*params) -> Optional +- client.zones.settings.hotlink_protection.get(\*, zone_id) -> Optional -### HTTP2 +### HTTP2Resource Types: ```python -from cloudflare.types.zones.settings import ZoneSettingHTTP2 +from cloudflare.types.zones.settings import HTTP2 ``` Methods: -- client.zones.settings.http2.edit(\*, zone_id, \*\*params) -> Optional -- client.zones.settings.http2.get(\*, zone_id) -> Optional +- client.zones.settings.http2.edit(\*, zone_id, \*\*params) -> Optional +- client.zones.settings.http2.get(\*, zone_id) -> Optional -### HTTP3 +### HTTP3Resource Types: ```python -from cloudflare.types.zones.settings import ZoneSettingHTTP3 +from cloudflare.types.zones.settings import HTTP3 ``` Methods: -- client.zones.settings.http3.edit(\*, zone_id, \*\*params) -> Optional -- client.zones.settings.http3.get(\*, zone_id) -> Optional +- client.zones.settings.http3.edit(\*, zone_id, \*\*params) -> Optional +- client.zones.settings.http3.get(\*, zone_id) -> Optional -### ImageResizing +### ImageResizingResource Types: ```python -from cloudflare.types.zones.settings import ZoneSettingImageResizing +from cloudflare.types.zones.settings import ImageResizing ``` Methods: -- client.zones.settings.image_resizing.edit(\*, zone_id, \*\*params) -> Optional -- client.zones.settings.image_resizing.get(\*, zone_id) -> Optional +- client.zones.settings.image_resizing.edit(\*, zone_id, \*\*params) -> Optional +- client.zones.settings.image_resizing.get(\*, zone_id) -> Optional -### IPGeolocation +### IPGeolocationResource Types: ```python -from cloudflare.types.zones.settings import ZoneSettingIPGeolocation +from cloudflare.types.zones.settings import IPGeolocation ``` Methods: -- client.zones.settings.ip_geolocation.edit(\*, zone_id, \*\*params) -> Optional -- client.zones.settings.ip_geolocation.get(\*, zone_id) -> Optional +- client.zones.settings.ip_geolocation.edit(\*, zone_id, \*\*params) -> Optional +- client.zones.settings.ip_geolocation.get(\*, zone_id) -> Optional -### IPV6 +### IPV6Resource Types: ```python -from cloudflare.types.zones.settings import ZoneSettingIPV6 +from cloudflare.types.zones.settings import IPV6 ``` Methods: -- client.zones.settings.ipv6.edit(\*, zone_id, \*\*params) -> Optional -- client.zones.settings.ipv6.get(\*, zone_id) -> Optional +- client.zones.settings.ipv6.edit(\*, zone_id, \*\*params) -> Optional +- client.zones.settings.ipv6.get(\*, zone_id) -> Optional -### MinTLSVersion +### MinTLSVersionResource Types: ```python -from cloudflare.types.zones.settings import ZoneSettingMinTLSVersion +from cloudflare.types.zones.settings import MinTLSVersion ``` Methods: -- client.zones.settings.min_tls_version.edit(\*, zone_id, \*\*params) -> Optional -- client.zones.settings.min_tls_version.get(\*, zone_id) -> Optional +- client.zones.settings.min_tls_version.edit(\*, zone_id, \*\*params) -> Optional +- client.zones.settings.min_tls_version.get(\*, zone_id) -> Optional -### Minify +### MinifyResource Types: ```python -from cloudflare.types.zones.settings import ZoneSettingMinify +from cloudflare.types.zones.settings import Minify ``` Methods: -- client.zones.settings.minify.edit(\*, zone_id, \*\*params) -> Optional -- client.zones.settings.minify.get(\*, zone_id) -> Optional +- client.zones.settings.minify.edit(\*, zone_id, \*\*params) -> Optional +- client.zones.settings.minify.get(\*, zone_id) -> Optional -### Mirage +### MirageResource Types: ```python -from cloudflare.types.zones.settings import ZoneSettingMirage +from cloudflare.types.zones.settings import Mirage ``` Methods: -- client.zones.settings.mirage.edit(\*, zone_id, \*\*params) -> Optional -- client.zones.settings.mirage.get(\*, zone_id) -> Optional +- client.zones.settings.mirage.edit(\*, zone_id, \*\*params) -> Optional +- client.zones.settings.mirage.get(\*, zone_id) -> Optional -### MobileRedirect +### MobileRedirectResource Types: ```python -from cloudflare.types.zones.settings import ZoneSettingMobileRedirect +from cloudflare.types.zones.settings import MobileRedirect ``` Methods: -- client.zones.settings.mobile_redirect.edit(\*, zone_id, \*\*params) -> Optional -- client.zones.settings.mobile_redirect.get(\*, zone_id) -> Optional +- client.zones.settings.mobile_redirect.edit(\*, zone_id, \*\*params) -> Optional +- client.zones.settings.mobile_redirect.get(\*, zone_id) -> Optional -### NEL +### NELResource Types: ```python -from cloudflare.types.zones.settings import ZoneSettingNEL +from cloudflare.types.zones.settings import NEL ``` Methods: -- client.zones.settings.nel.edit(\*, zone_id, \*\*params) -> Optional -- client.zones.settings.nel.get(\*, zone_id) -> Optional +- client.zones.settings.nel.edit(\*, zone_id, \*\*params) -> Optional +- client.zones.settings.nel.get(\*, zone_id) -> Optional -### OpportunisticEncryption +### OpportunisticEncryptionResource Types: ```python -from cloudflare.types.zones.settings import ZoneSettingOpportunisticEncryption +from cloudflare.types.zones.settings import OpportunisticEncryption ``` Methods: -- client.zones.settings.opportunistic_encryption.edit(\*, zone_id, \*\*params) -> Optional -- client.zones.settings.opportunistic_encryption.get(\*, zone_id) -> Optional +- client.zones.settings.opportunistic_encryption.edit(\*, zone_id, \*\*params) -> Optional +- client.zones.settings.opportunistic_encryption.get(\*, zone_id) -> Optional -### OpportunisticOnion +### OpportunisticOnionResource Types: ```python -from cloudflare.types.zones.settings import ZoneSettingOpportunisticOnion +from cloudflare.types.zones.settings import OpportunisticOnion ``` Methods: -- client.zones.settings.opportunistic_onion.edit(\*, zone_id, \*\*params) -> Optional -- client.zones.settings.opportunistic_onion.get(\*, zone_id) -> Optional +- client.zones.settings.opportunistic_onion.edit(\*, zone_id, \*\*params) -> Optional +- client.zones.settings.opportunistic_onion.get(\*, zone_id) -> Optional -### OrangeToOrange +### OrangeToOrangeResource Types: ```python -from cloudflare.types.zones.settings import ZoneSettingOrangeToOrange +from cloudflare.types.zones.settings import OrangeToOrange ``` Methods: -- client.zones.settings.orange_to_orange.edit(\*, zone_id, \*\*params) -> Optional -- client.zones.settings.orange_to_orange.get(\*, zone_id) -> Optional +- client.zones.settings.orange_to_orange.edit(\*, zone_id, \*\*params) -> Optional +- client.zones.settings.orange_to_orange.get(\*, zone_id) -> Optional -### OriginErrorPagePassThru +### OriginErrorPagePassThruResource Types: ```python -from cloudflare.types.zones.settings import ZoneSettingOriginErrorPagePassThru +from cloudflare.types.zones.settings import OriginErrorPagePassThru ``` Methods: -- client.zones.settings.origin_error_page_pass_thru.edit(\*, zone_id, \*\*params) -> Optional -- client.zones.settings.origin_error_page_pass_thru.get(\*, zone_id) -> Optional +- client.zones.settings.origin_error_page_pass_thru.edit(\*, zone_id, \*\*params) -> Optional +- client.zones.settings.origin_error_page_pass_thru.get(\*, zone_id) -> Optional ### OriginMaxHTTPVersion @@ -813,252 +813,252 @@ Methods: - client.zones.settings.origin_max_http_version.edit(\*, zone_id, \*\*params) -> OriginMaxHTTPVersionEditResponse - client.zones.settings.origin_max_http_version.get(\*, zone_id) -> OriginMaxHTTPVersionGetResponse -### Polish +### PolishResource Types: ```python -from cloudflare.types.zones.settings import ZoneSettingPolish +from cloudflare.types.zones.settings import Polish ``` Methods: -- client.zones.settings.polish.edit(\*, zone_id, \*\*params) -> Optional -- client.zones.settings.polish.get(\*, zone_id) -> Optional +- client.zones.settings.polish.edit(\*, zone_id, \*\*params) -> Optional +- client.zones.settings.polish.get(\*, zone_id) -> Optional -### PrefetchPreload +### PrefetchPreloadResource Types: ```python -from cloudflare.types.zones.settings import ZoneSettingPrefetchPreload +from cloudflare.types.zones.settings import PrefetchPreload ``` Methods: -- client.zones.settings.prefetch_preload.edit(\*, zone_id, \*\*params) -> Optional -- client.zones.settings.prefetch_preload.get(\*, zone_id) -> Optional +- client.zones.settings.prefetch_preload.edit(\*, zone_id, \*\*params) -> Optional +- client.zones.settings.prefetch_preload.get(\*, zone_id) -> Optional -### ProxyReadTimeout +### ProxyReadTimeoutResource Types: ```python -from cloudflare.types.zones.settings import ZoneSettingProxyReadTimeout +from cloudflare.types.zones.settings import ProxyReadTimeout ``` Methods: -- client.zones.settings.proxy_read_timeout.edit(\*, zone_id, \*\*params) -> Optional -- client.zones.settings.proxy_read_timeout.get(\*, zone_id) -> Optional +- client.zones.settings.proxy_read_timeout.edit(\*, zone_id, \*\*params) -> Optional +- client.zones.settings.proxy_read_timeout.get(\*, zone_id) -> Optional -### PseudoIPV4 +### PseudoIPV4Resource Types: ```python -from cloudflare.types.zones.settings import ZoneSettingPseudoIPV4 +from cloudflare.types.zones.settings import PseudoIPV4 ``` Methods: -- client.zones.settings.pseudo_ipv4.edit(\*, zone_id, \*\*params) -> Optional -- client.zones.settings.pseudo_ipv4.get(\*, zone_id) -> Optional +- client.zones.settings.pseudo_ipv4.edit(\*, zone_id, \*\*params) -> Optional +- client.zones.settings.pseudo_ipv4.get(\*, zone_id) -> Optional -### ResponseBuffering +### ResponseBufferingResource Types: ```python -from cloudflare.types.zones.settings import ZoneSettingBuffering +from cloudflare.types.zones.settings import ResponseBuffering ``` Methods: -- client.zones.settings.response_buffering.edit(\*, zone_id, \*\*params) -> Optional -- client.zones.settings.response_buffering.get(\*, zone_id) -> Optional +- client.zones.settings.response_buffering.edit(\*, zone_id, \*\*params) -> Optional +- client.zones.settings.response_buffering.get(\*, zone_id) -> Optional -### RocketLoader +### RocketLoaderResource Types: ```python -from cloudflare.types.zones.settings import ZoneSettingRocketLoader +from cloudflare.types.zones.settings import RocketLoader ``` Methods: -- client.zones.settings.rocket_loader.edit(\*, zone_id, \*\*params) -> Optional -- client.zones.settings.rocket_loader.get(\*, zone_id) -> Optional +- client.zones.settings.rocket_loader.edit(\*, zone_id, \*\*params) -> Optional +- client.zones.settings.rocket_loader.get(\*, zone_id) -> Optional ### SecurityHeaders Types: ```python -from cloudflare.types.zones.settings import ZoneSettingSecurityHeader +from cloudflare.types.zones.settings import SecurityHeaders ``` Methods: -- client.zones.settings.security_headers.edit(\*, zone_id, \*\*params) -> Optional -- client.zones.settings.security_headers.get(\*, zone_id) -> Optional +- client.zones.settings.security_headers.edit(\*, zone_id, \*\*params) -> Optional +- client.zones.settings.security_headers.get(\*, zone_id) -> Optional -### SecurityLevel +### SecurityLevelResource Types: ```python -from cloudflare.types.zones.settings import ZoneSettingSecurityLevel +from cloudflare.types.zones.settings import SecurityLevel ``` Methods: -- client.zones.settings.security_level.edit(\*, zone_id, \*\*params) -> Optional -- client.zones.settings.security_level.get(\*, zone_id) -> Optional +- client.zones.settings.security_level.edit(\*, zone_id, \*\*params) -> Optional +- client.zones.settings.security_level.get(\*, zone_id) -> Optional ### ServerSideExcludes Types: ```python -from cloudflare.types.zones.settings import ZoneSettingServerSideExclude +from cloudflare.types.zones.settings import ServerSideExcludes ``` Methods: -- client.zones.settings.server_side_excludes.edit(\*, zone_id, \*\*params) -> Optional -- client.zones.settings.server_side_excludes.get(\*, zone_id) -> Optional +- client.zones.settings.server_side_excludes.edit(\*, zone_id, \*\*params) -> Optional +- client.zones.settings.server_side_excludes.get(\*, zone_id) -> Optional -### SortQueryStringForCache +### SortQueryStringForCacheResource Types: ```python -from cloudflare.types.zones.settings import ZoneSettingSortQueryStringForCache +from cloudflare.types.zones.settings import SortQueryStringForCache ``` Methods: -- client.zones.settings.sort_query_string_for_cache.edit(\*, zone_id, \*\*params) -> Optional -- client.zones.settings.sort_query_string_for_cache.get(\*, zone_id) -> Optional +- client.zones.settings.sort_query_string_for_cache.edit(\*, zone_id, \*\*params) -> Optional +- client.zones.settings.sort_query_string_for_cache.get(\*, zone_id) -> Optional -### SSL +### SSLResource Types: ```python -from cloudflare.types.zones.settings import ZoneSettingSSL +from cloudflare.types.zones.settings import SSL ``` Methods: -- client.zones.settings.ssl.edit(\*, zone_id, \*\*params) -> Optional -- client.zones.settings.ssl.get(\*, zone_id) -> Optional +- client.zones.settings.ssl.edit(\*, zone_id, \*\*params) -> Optional +- client.zones.settings.ssl.get(\*, zone_id) -> Optional -### SSLRecommender +### SSLRecommenderResource Types: ```python -from cloudflare.types.zones.settings import ZoneSettingSSLRecommender +from cloudflare.types.zones.settings import SSLRecommender ``` Methods: -- client.zones.settings.ssl_recommender.edit(\*, zone_id, \*\*params) -> Optional -- client.zones.settings.ssl_recommender.get(\*, zone_id) -> Optional +- client.zones.settings.ssl_recommender.edit(\*, zone_id, \*\*params) -> Optional +- client.zones.settings.ssl_recommender.get(\*, zone_id) -> Optional -### TLS1_3 +### TLS1_3Resource Types: ```python -from cloudflare.types.zones.settings import ZoneSettingTLS1_3 +from cloudflare.types.zones.settings import TLS1_3 ``` Methods: -- client.zones.settings.tls_1_3.edit(\*, zone_id, \*\*params) -> Optional -- client.zones.settings.tls_1_3.get(\*, zone_id) -> Optional +- client.zones.settings.tls_1_3.edit(\*, zone_id, \*\*params) -> Optional +- client.zones.settings.tls_1_3.get(\*, zone_id) -> Optional -### TLSClientAuth +### TLSClientAuthResource Types: ```python -from cloudflare.types.zones.settings import ZoneSettingTLSClientAuth +from cloudflare.types.zones.settings import TLSClientAuth ``` Methods: -- client.zones.settings.tls_client_auth.edit(\*, zone_id, \*\*params) -> Optional -- client.zones.settings.tls_client_auth.get(\*, zone_id) -> Optional +- client.zones.settings.tls_client_auth.edit(\*, zone_id, \*\*params) -> Optional +- client.zones.settings.tls_client_auth.get(\*, zone_id) -> Optional -### TrueClientIPHeader +### TrueClientIPHeaderResource Types: ```python -from cloudflare.types.zones.settings import ZoneSettingTrueClientIPHeader +from cloudflare.types.zones.settings import TrueClientIPHeader ``` Methods: -- client.zones.settings.true_client_ip_header.edit(\*, zone_id, \*\*params) -> Optional -- client.zones.settings.true_client_ip_header.get(\*, zone_id) -> Optional +- client.zones.settings.true_client_ip_header.edit(\*, zone_id, \*\*params) -> Optional +- client.zones.settings.true_client_ip_header.get(\*, zone_id) -> Optional -### WAF +### WAFResource Types: ```python -from cloudflare.types.zones.settings import ZoneSettingWAF +from cloudflare.types.zones.settings import WAF ``` Methods: -- client.zones.settings.waf.edit(\*, zone_id, \*\*params) -> Optional -- client.zones.settings.waf.get(\*, zone_id) -> Optional +- client.zones.settings.waf.edit(\*, zone_id, \*\*params) -> Optional +- client.zones.settings.waf.get(\*, zone_id) -> Optional -### WebP +### WebPResource Types: ```python -from cloudflare.types.zones.settings import ZoneSettingWebP +from cloudflare.types.zones.settings import WebP ``` Methods: -- client.zones.settings.webp.edit(\*, zone_id, \*\*params) -> Optional -- client.zones.settings.webp.get(\*, zone_id) -> Optional +- client.zones.settings.webp.edit(\*, zone_id, \*\*params) -> Optional +- client.zones.settings.webp.get(\*, zone_id) -> Optional -### Websocket +### WebsocketResource Types: ```python -from cloudflare.types.zones.settings import ZoneSettingWebsockets +from cloudflare.types.zones.settings import Websocket ``` Methods: -- client.zones.settings.websocket.edit(\*, zone_id, \*\*params) -> Optional -- client.zones.settings.websocket.get(\*, zone_id) -> Optional +- client.zones.settings.websocket.edit(\*, zone_id, \*\*params) -> Optional +- client.zones.settings.websocket.get(\*, zone_id) -> Optional ### FontSettings Types: ```python -from cloudflare.types.zones.settings import ZoneSettingFonts +from cloudflare.types.zones.settings import FontSettings ``` Methods: -- client.zones.settings.font_settings.edit(\*, zone_id, \*\*params) -> Optional -- client.zones.settings.font_settings.get(\*, zone_id) -> Optional +- client.zones.settings.font_settings.edit(\*, zone_id, \*\*params) -> Optional +- client.zones.settings.font_settings.get(\*, zone_id) -> Optional ## CustomNameservers diff --git a/src/cloudflare/resources/zones/settings/__init__.py b/src/cloudflare/resources/zones/settings/__init__.py index 95ca89ea01b9..424ca93c194c 100644 --- a/src/cloudflare/resources/zones/settings/__init__.py +++ b/src/cloudflare/resources/zones/settings/__init__.py @@ -1,92 +1,92 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. from .nel import ( - NEL, - AsyncNEL, - NELWithRawResponse, - AsyncNELWithRawResponse, - NELWithStreamingResponse, - AsyncNELWithStreamingResponse, + NELResource, + AsyncNELResource, + NELResourceWithRawResponse, + AsyncNELResourceWithRawResponse, + NELResourceWithStreamingResponse, + AsyncNELResourceWithStreamingResponse, ) from .ssl import ( - SSL, - AsyncSSL, - SSLWithRawResponse, - AsyncSSLWithRawResponse, - SSLWithStreamingResponse, - AsyncSSLWithStreamingResponse, + SSLResource, + AsyncSSLResource, + SSLResourceWithRawResponse, + AsyncSSLResourceWithRawResponse, + SSLResourceWithStreamingResponse, + AsyncSSLResourceWithStreamingResponse, ) from .waf import ( - WAF, - AsyncWAF, - WAFWithRawResponse, - AsyncWAFWithRawResponse, - WAFWithStreamingResponse, - AsyncWAFWithStreamingResponse, + WAFResource, + AsyncWAFResource, + WAFResourceWithRawResponse, + AsyncWAFResourceWithRawResponse, + WAFResourceWithStreamingResponse, + AsyncWAFResourceWithStreamingResponse, ) from .ipv6 import ( - IPV6, - AsyncIPV6, - IPV6WithRawResponse, - AsyncIPV6WithRawResponse, - IPV6WithStreamingResponse, - AsyncIPV6WithStreamingResponse, + IPV6Resource, + AsyncIPV6Resource, + IPV6ResourceWithRawResponse, + AsyncIPV6ResourceWithRawResponse, + IPV6ResourceWithStreamingResponse, + AsyncIPV6ResourceWithStreamingResponse, ) from .webp import ( - WebP, - AsyncWebP, - WebPWithRawResponse, - AsyncWebPWithRawResponse, - WebPWithStreamingResponse, - AsyncWebPWithStreamingResponse, + WebPResource, + AsyncWebPResource, + WebPResourceWithRawResponse, + AsyncWebPResourceWithRawResponse, + WebPResourceWithStreamingResponse, + AsyncWebPResourceWithStreamingResponse, ) from .http2 import ( - HTTP2, - AsyncHTTP2, - HTTP2WithRawResponse, - AsyncHTTP2WithRawResponse, - HTTP2WithStreamingResponse, - AsyncHTTP2WithStreamingResponse, + HTTP2Resource, + AsyncHTTP2Resource, + HTTP2ResourceWithRawResponse, + AsyncHTTP2ResourceWithRawResponse, + HTTP2ResourceWithStreamingResponse, + AsyncHTTP2ResourceWithStreamingResponse, ) from .http3 import ( - HTTP3, - AsyncHTTP3, - HTTP3WithRawResponse, - AsyncHTTP3WithRawResponse, - HTTP3WithStreamingResponse, - AsyncHTTP3WithStreamingResponse, + HTTP3Resource, + AsyncHTTP3Resource, + HTTP3ResourceWithRawResponse, + AsyncHTTP3ResourceWithRawResponse, + HTTP3ResourceWithStreamingResponse, + AsyncHTTP3ResourceWithStreamingResponse, ) from .brotli import ( - Brotli, - AsyncBrotli, - BrotliWithRawResponse, - AsyncBrotliWithRawResponse, - BrotliWithStreamingResponse, - AsyncBrotliWithStreamingResponse, + BrotliResource, + AsyncBrotliResource, + BrotliResourceWithRawResponse, + AsyncBrotliResourceWithRawResponse, + BrotliResourceWithStreamingResponse, + AsyncBrotliResourceWithStreamingResponse, ) from .minify import ( - Minify, - AsyncMinify, - MinifyWithRawResponse, - AsyncMinifyWithRawResponse, - MinifyWithStreamingResponse, - AsyncMinifyWithStreamingResponse, + MinifyResource, + AsyncMinifyResource, + MinifyResourceWithRawResponse, + AsyncMinifyResourceWithRawResponse, + MinifyResourceWithStreamingResponse, + AsyncMinifyResourceWithStreamingResponse, ) from .mirage import ( - Mirage, - AsyncMirage, - MirageWithRawResponse, - AsyncMirageWithRawResponse, - MirageWithStreamingResponse, - AsyncMirageWithStreamingResponse, + MirageResource, + AsyncMirageResource, + MirageResourceWithRawResponse, + AsyncMirageResourceWithRawResponse, + MirageResourceWithStreamingResponse, + AsyncMirageResourceWithStreamingResponse, ) from .polish import ( - Polish, - AsyncPolish, - PolishWithRawResponse, - AsyncPolishWithRawResponse, - PolishWithStreamingResponse, - AsyncPolishWithStreamingResponse, + PolishResource, + AsyncPolishResource, + PolishResourceWithRawResponse, + AsyncPolishResourceWithRawResponse, + PolishResourceWithStreamingResponse, + AsyncPolishResourceWithStreamingResponse, ) from .ciphers import ( Ciphers, @@ -97,12 +97,12 @@ AsyncCiphersWithStreamingResponse, ) from .tls_1_3 import ( - TLS1_3, - AsyncTLS1_3, - TLS1_3WithRawResponse, - AsyncTLS1_3WithRawResponse, - TLS1_3WithStreamingResponse, - AsyncTLS1_3WithStreamingResponse, + TLS1_3Resource, + AsyncTLS1_3Resource, + TLS1_3ResourceWithRawResponse, + AsyncTLS1_3ResourceWithRawResponse, + TLS1_3ResourceWithStreamingResponse, + AsyncTLS1_3ResourceWithStreamingResponse, ) from .settings import ( Settings, @@ -113,28 +113,28 @@ AsyncSettingsWithStreamingResponse, ) from .zero_rtt import ( - ZeroRTT, - AsyncZeroRTT, - ZeroRTTWithRawResponse, - AsyncZeroRTTWithRawResponse, - ZeroRTTWithStreamingResponse, - AsyncZeroRTTWithStreamingResponse, + ZeroRTTResource, + AsyncZeroRTTResource, + ZeroRTTResourceWithRawResponse, + AsyncZeroRTTResourceWithRawResponse, + ZeroRTTResourceWithStreamingResponse, + AsyncZeroRTTResourceWithStreamingResponse, ) from .websocket import ( - Websocket, - AsyncWebsocket, - WebsocketWithRawResponse, - AsyncWebsocketWithRawResponse, - WebsocketWithStreamingResponse, - AsyncWebsocketWithStreamingResponse, + WebsocketResource, + AsyncWebsocketResource, + WebsocketResourceWithRawResponse, + AsyncWebsocketResourceWithRawResponse, + WebsocketResourceWithStreamingResponse, + AsyncWebsocketResourceWithStreamingResponse, ) from .cache_level import ( - CacheLevel, - AsyncCacheLevel, - CacheLevelWithRawResponse, - AsyncCacheLevelWithRawResponse, - CacheLevelWithStreamingResponse, - AsyncCacheLevelWithStreamingResponse, + CacheLevelResource, + AsyncCacheLevelResource, + CacheLevelResourceWithRawResponse, + AsyncCacheLevelResourceWithRawResponse, + CacheLevelResourceWithStreamingResponse, + AsyncCacheLevelResourceWithStreamingResponse, ) from .early_hints import ( EarlyHints, @@ -145,12 +145,12 @@ AsyncEarlyHintsWithStreamingResponse, ) from .pseudo_ipv4 import ( - PseudoIPV4, - AsyncPseudoIPV4, - PseudoIPV4WithRawResponse, - AsyncPseudoIPV4WithRawResponse, - PseudoIPV4WithStreamingResponse, - AsyncPseudoIPV4WithStreamingResponse, + PseudoIPV4Resource, + AsyncPseudoIPV4Resource, + PseudoIPV4ResourceWithRawResponse, + AsyncPseudoIPV4ResourceWithRawResponse, + PseudoIPV4ResourceWithStreamingResponse, + AsyncPseudoIPV4ResourceWithStreamingResponse, ) from .advanced_ddos import ( AdvancedDDoS, @@ -161,28 +161,28 @@ AsyncAdvancedDDoSWithStreamingResponse, ) from .always_online import ( - AlwaysOnline, - AsyncAlwaysOnline, - AlwaysOnlineWithRawResponse, - AsyncAlwaysOnlineWithRawResponse, - AlwaysOnlineWithStreamingResponse, - AsyncAlwaysOnlineWithStreamingResponse, + AlwaysOnlineResource, + AsyncAlwaysOnlineResource, + AlwaysOnlineResourceWithRawResponse, + AsyncAlwaysOnlineResourceWithRawResponse, + AlwaysOnlineResourceWithStreamingResponse, + AsyncAlwaysOnlineResourceWithStreamingResponse, ) from .browser_check import ( - BrowserCheck, - AsyncBrowserCheck, - BrowserCheckWithRawResponse, - AsyncBrowserCheckWithRawResponse, - BrowserCheckWithStreamingResponse, - AsyncBrowserCheckWithStreamingResponse, + BrowserCheckResource, + AsyncBrowserCheckResource, + BrowserCheckResourceWithRawResponse, + AsyncBrowserCheckResourceWithRawResponse, + BrowserCheckResourceWithStreamingResponse, + AsyncBrowserCheckResourceWithStreamingResponse, ) from .challenge_ttl import ( - ChallengeTTL, - AsyncChallengeTTL, - ChallengeTTLWithRawResponse, - AsyncChallengeTTLWithRawResponse, - ChallengeTTLWithStreamingResponse, - AsyncChallengeTTLWithStreamingResponse, + ChallengeTTLResource, + AsyncChallengeTTLResource, + ChallengeTTLResourceWithRawResponse, + AsyncChallengeTTLResourceWithRawResponse, + ChallengeTTLResourceWithStreamingResponse, + AsyncChallengeTTLResourceWithStreamingResponse, ) from .font_settings import ( FontSettings, @@ -193,68 +193,68 @@ AsyncFontSettingsWithStreamingResponse, ) from .rocket_loader import ( - RocketLoader, - AsyncRocketLoader, - RocketLoaderWithRawResponse, - AsyncRocketLoaderWithRawResponse, - RocketLoaderWithStreamingResponse, - AsyncRocketLoaderWithStreamingResponse, + RocketLoaderResource, + AsyncRocketLoaderResource, + RocketLoaderResourceWithRawResponse, + AsyncRocketLoaderResourceWithRawResponse, + RocketLoaderResourceWithStreamingResponse, + AsyncRocketLoaderResourceWithStreamingResponse, ) from .image_resizing import ( - ImageResizing, - AsyncImageResizing, - ImageResizingWithRawResponse, - AsyncImageResizingWithRawResponse, - ImageResizingWithStreamingResponse, - AsyncImageResizingWithStreamingResponse, + ImageResizingResource, + AsyncImageResizingResource, + ImageResizingResourceWithRawResponse, + AsyncImageResizingResourceWithRawResponse, + ImageResizingResourceWithStreamingResponse, + AsyncImageResizingResourceWithStreamingResponse, ) from .ip_geolocation import ( - IPGeolocation, - AsyncIPGeolocation, - IPGeolocationWithRawResponse, - AsyncIPGeolocationWithRawResponse, - IPGeolocationWithStreamingResponse, - AsyncIPGeolocationWithStreamingResponse, + IPGeolocationResource, + AsyncIPGeolocationResource, + IPGeolocationResourceWithRawResponse, + AsyncIPGeolocationResourceWithRawResponse, + IPGeolocationResourceWithStreamingResponse, + AsyncIPGeolocationResourceWithStreamingResponse, ) from .security_level import ( - SecurityLevel, - AsyncSecurityLevel, - SecurityLevelWithRawResponse, - AsyncSecurityLevelWithRawResponse, - SecurityLevelWithStreamingResponse, - AsyncSecurityLevelWithStreamingResponse, + SecurityLevelResource, + AsyncSecurityLevelResource, + SecurityLevelResourceWithRawResponse, + AsyncSecurityLevelResourceWithRawResponse, + SecurityLevelResourceWithStreamingResponse, + AsyncSecurityLevelResourceWithStreamingResponse, ) from .min_tls_version import ( - MinTLSVersion, - AsyncMinTLSVersion, - MinTLSVersionWithRawResponse, - AsyncMinTLSVersionWithRawResponse, - MinTLSVersionWithStreamingResponse, - AsyncMinTLSVersionWithStreamingResponse, + MinTLSVersionResource, + AsyncMinTLSVersionResource, + MinTLSVersionResourceWithRawResponse, + AsyncMinTLSVersionResourceWithRawResponse, + MinTLSVersionResourceWithStreamingResponse, + AsyncMinTLSVersionResourceWithStreamingResponse, ) from .mobile_redirect import ( - MobileRedirect, - AsyncMobileRedirect, - MobileRedirectWithRawResponse, - AsyncMobileRedirectWithRawResponse, - MobileRedirectWithStreamingResponse, - AsyncMobileRedirectWithStreamingResponse, + MobileRedirectResource, + AsyncMobileRedirectResource, + MobileRedirectResourceWithRawResponse, + AsyncMobileRedirectResourceWithRawResponse, + MobileRedirectResourceWithStreamingResponse, + AsyncMobileRedirectResourceWithStreamingResponse, ) from .ssl_recommender import ( - SSLRecommender, - AsyncSSLRecommender, - SSLRecommenderWithRawResponse, - AsyncSSLRecommenderWithRawResponse, - SSLRecommenderWithStreamingResponse, - AsyncSSLRecommenderWithStreamingResponse, + SSLRecommenderResource, + AsyncSSLRecommenderResource, + SSLRecommenderResourceWithRawResponse, + AsyncSSLRecommenderResourceWithRawResponse, + SSLRecommenderResourceWithStreamingResponse, + AsyncSSLRecommenderResourceWithStreamingResponse, ) from .tls_client_auth import ( - TLSClientAuth, - AsyncTLSClientAuth, - TLSClientAuthWithRawResponse, - AsyncTLSClientAuthWithRawResponse, - TLSClientAuthWithStreamingResponse, - AsyncTLSClientAuthWithStreamingResponse, + TLSClientAuthResource, + AsyncTLSClientAuthResource, + TLSClientAuthResourceWithRawResponse, + AsyncTLSClientAuthResourceWithRawResponse, + TLSClientAuthResourceWithStreamingResponse, + AsyncTLSClientAuthResourceWithStreamingResponse, ) from .always_use_https import ( AlwaysUseHTTPS, @@ -265,28 +265,28 @@ AsyncAlwaysUseHTTPSWithStreamingResponse, ) from .development_mode import ( - DevelopmentMode, - AsyncDevelopmentMode, - DevelopmentModeWithRawResponse, - AsyncDevelopmentModeWithRawResponse, - DevelopmentModeWithStreamingResponse, - AsyncDevelopmentModeWithStreamingResponse, + DevelopmentModeResource, + AsyncDevelopmentModeResource, + DevelopmentModeResourceWithRawResponse, + AsyncDevelopmentModeResourceWithRawResponse, + DevelopmentModeResourceWithStreamingResponse, + AsyncDevelopmentModeResourceWithStreamingResponse, ) from .orange_to_orange import ( - OrangeToOrange, - AsyncOrangeToOrange, - OrangeToOrangeWithRawResponse, - AsyncOrangeToOrangeWithRawResponse, - OrangeToOrangeWithStreamingResponse, - AsyncOrangeToOrangeWithStreamingResponse, + OrangeToOrangeResource, + AsyncOrangeToOrangeResource, + OrangeToOrangeResourceWithRawResponse, + AsyncOrangeToOrangeResourceWithRawResponse, + OrangeToOrangeResourceWithStreamingResponse, + AsyncOrangeToOrangeResourceWithStreamingResponse, ) from .prefetch_preload import ( - PrefetchPreload, - AsyncPrefetchPreload, - PrefetchPreloadWithRawResponse, - AsyncPrefetchPreloadWithRawResponse, - PrefetchPreloadWithStreamingResponse, - AsyncPrefetchPreloadWithStreamingResponse, + PrefetchPreloadResource, + AsyncPrefetchPreloadResource, + PrefetchPreloadResourceWithRawResponse, + AsyncPrefetchPreloadResourceWithRawResponse, + PrefetchPreloadResourceWithStreamingResponse, + AsyncPrefetchPreloadResourceWithStreamingResponse, ) from .security_headers import ( SecurityHeaders, @@ -297,60 +297,60 @@ AsyncSecurityHeadersWithStreamingResponse, ) from .browser_cache_ttl import ( - BrowserCacheTTL, - AsyncBrowserCacheTTL, - BrowserCacheTTLWithRawResponse, - AsyncBrowserCacheTTLWithRawResponse, - BrowserCacheTTLWithStreamingResponse, - AsyncBrowserCacheTTLWithStreamingResponse, + BrowserCacheTTLResource, + AsyncBrowserCacheTTLResource, + BrowserCacheTTLResourceWithRawResponse, + AsyncBrowserCacheTTLResourceWithRawResponse, + BrowserCacheTTLResourceWithStreamingResponse, + AsyncBrowserCacheTTLResourceWithStreamingResponse, ) from .email_obfuscation import ( - EmailObfuscation, - AsyncEmailObfuscation, - EmailObfuscationWithRawResponse, - AsyncEmailObfuscationWithRawResponse, - EmailObfuscationWithStreamingResponse, - AsyncEmailObfuscationWithStreamingResponse, + EmailObfuscationResource, + AsyncEmailObfuscationResource, + EmailObfuscationResourceWithRawResponse, + AsyncEmailObfuscationResourceWithRawResponse, + EmailObfuscationResourceWithStreamingResponse, + AsyncEmailObfuscationResourceWithStreamingResponse, ) from .h2_prioritization import ( - H2Prioritization, - AsyncH2Prioritization, - H2PrioritizationWithRawResponse, - AsyncH2PrioritizationWithRawResponse, - H2PrioritizationWithStreamingResponse, - AsyncH2PrioritizationWithStreamingResponse, + H2PrioritizationResource, + AsyncH2PrioritizationResource, + H2PrioritizationResourceWithRawResponse, + AsyncH2PrioritizationResourceWithRawResponse, + H2PrioritizationResourceWithStreamingResponse, + AsyncH2PrioritizationResourceWithStreamingResponse, ) from .hotlink_protection import ( - HotlinkProtection, - AsyncHotlinkProtection, - HotlinkProtectionWithRawResponse, - AsyncHotlinkProtectionWithRawResponse, - HotlinkProtectionWithStreamingResponse, - AsyncHotlinkProtectionWithStreamingResponse, + HotlinkProtectionResource, + AsyncHotlinkProtectionResource, + HotlinkProtectionResourceWithRawResponse, + AsyncHotlinkProtectionResourceWithRawResponse, + HotlinkProtectionResourceWithStreamingResponse, + AsyncHotlinkProtectionResourceWithStreamingResponse, ) from .proxy_read_timeout import ( - ProxyReadTimeout, - AsyncProxyReadTimeout, - ProxyReadTimeoutWithRawResponse, - AsyncProxyReadTimeoutWithRawResponse, - ProxyReadTimeoutWithStreamingResponse, - AsyncProxyReadTimeoutWithStreamingResponse, + ProxyReadTimeoutResource, + AsyncProxyReadTimeoutResource, + ProxyReadTimeoutResourceWithRawResponse, + AsyncProxyReadTimeoutResourceWithRawResponse, + ProxyReadTimeoutResourceWithStreamingResponse, + AsyncProxyReadTimeoutResourceWithStreamingResponse, ) from .response_buffering import ( - ResponseBuffering, - AsyncResponseBuffering, - ResponseBufferingWithRawResponse, - AsyncResponseBufferingWithRawResponse, - ResponseBufferingWithStreamingResponse, - AsyncResponseBufferingWithStreamingResponse, + ResponseBufferingResource, + AsyncResponseBufferingResource, + ResponseBufferingResourceWithRawResponse, + AsyncResponseBufferingResourceWithRawResponse, + ResponseBufferingResourceWithStreamingResponse, + AsyncResponseBufferingResourceWithStreamingResponse, ) from .opportunistic_onion import ( - OpportunisticOnion, - AsyncOpportunisticOnion, - OpportunisticOnionWithRawResponse, - AsyncOpportunisticOnionWithRawResponse, - OpportunisticOnionWithStreamingResponse, - AsyncOpportunisticOnionWithStreamingResponse, + OpportunisticOnionResource, + AsyncOpportunisticOnionResource, + OpportunisticOnionResourceWithRawResponse, + AsyncOpportunisticOnionResourceWithRawResponse, + OpportunisticOnionResourceWithStreamingResponse, + AsyncOpportunisticOnionResourceWithStreamingResponse, ) from .server_side_excludes import ( ServerSideExcludes, @@ -361,12 +361,12 @@ AsyncServerSideExcludesWithStreamingResponse, ) from .true_client_ip_header import ( - TrueClientIPHeader, - AsyncTrueClientIPHeader, - TrueClientIPHeaderWithRawResponse, - AsyncTrueClientIPHeaderWithRawResponse, - TrueClientIPHeaderWithStreamingResponse, - AsyncTrueClientIPHeaderWithStreamingResponse, + TrueClientIPHeaderResource, + AsyncTrueClientIPHeaderResource, + TrueClientIPHeaderResourceWithRawResponse, + AsyncTrueClientIPHeaderResourceWithRawResponse, + TrueClientIPHeaderResourceWithStreamingResponse, + AsyncTrueClientIPHeaderResourceWithStreamingResponse, ) from .origin_max_http_version import ( OriginMaxHTTPVersion, @@ -385,57 +385,57 @@ AsyncAutomaticHTTPSRewritesWithStreamingResponse, ) from .opportunistic_encryption import ( - OpportunisticEncryption, - AsyncOpportunisticEncryption, - OpportunisticEncryptionWithRawResponse, - AsyncOpportunisticEncryptionWithRawResponse, - OpportunisticEncryptionWithStreamingResponse, - AsyncOpportunisticEncryptionWithStreamingResponse, + OpportunisticEncryptionResource, + AsyncOpportunisticEncryptionResource, + OpportunisticEncryptionResourceWithRawResponse, + AsyncOpportunisticEncryptionResourceWithRawResponse, + OpportunisticEncryptionResourceWithStreamingResponse, + AsyncOpportunisticEncryptionResourceWithStreamingResponse, ) from .origin_error_page_pass_thru import ( - OriginErrorPagePassThru, - AsyncOriginErrorPagePassThru, - OriginErrorPagePassThruWithRawResponse, - AsyncOriginErrorPagePassThruWithRawResponse, - OriginErrorPagePassThruWithStreamingResponse, - AsyncOriginErrorPagePassThruWithStreamingResponse, + OriginErrorPagePassThruResource, + AsyncOriginErrorPagePassThruResource, + OriginErrorPagePassThruResourceWithRawResponse, + AsyncOriginErrorPagePassThruResourceWithRawResponse, + OriginErrorPagePassThruResourceWithStreamingResponse, + AsyncOriginErrorPagePassThruResourceWithStreamingResponse, ) from .sort_query_string_for_cache import ( - SortQueryStringForCache, - AsyncSortQueryStringForCache, - SortQueryStringForCacheWithRawResponse, - AsyncSortQueryStringForCacheWithRawResponse, - SortQueryStringForCacheWithStreamingResponse, - AsyncSortQueryStringForCacheWithStreamingResponse, + SortQueryStringForCacheResource, + AsyncSortQueryStringForCacheResource, + SortQueryStringForCacheResourceWithRawResponse, + AsyncSortQueryStringForCacheResourceWithRawResponse, + SortQueryStringForCacheResourceWithStreamingResponse, + AsyncSortQueryStringForCacheResourceWithStreamingResponse, ) from .automatic_platform_optimization import ( - AutomaticPlatformOptimization, - AsyncAutomaticPlatformOptimization, - AutomaticPlatformOptimizationWithRawResponse, - AsyncAutomaticPlatformOptimizationWithRawResponse, - AutomaticPlatformOptimizationWithStreamingResponse, - AsyncAutomaticPlatformOptimizationWithStreamingResponse, + AutomaticPlatformOptimizationResource, + AsyncAutomaticPlatformOptimizationResource, + AutomaticPlatformOptimizationResourceWithRawResponse, + AsyncAutomaticPlatformOptimizationResourceWithRawResponse, + AutomaticPlatformOptimizationResourceWithStreamingResponse, + AsyncAutomaticPlatformOptimizationResourceWithStreamingResponse, ) __all__ = [ - "ZeroRTT", - "AsyncZeroRTT", - "ZeroRTTWithRawResponse", - "AsyncZeroRTTWithRawResponse", - "ZeroRTTWithStreamingResponse", - "AsyncZeroRTTWithStreamingResponse", + "ZeroRTTResource", + "AsyncZeroRTTResource", + "ZeroRTTResourceWithRawResponse", + "AsyncZeroRTTResourceWithRawResponse", + "ZeroRTTResourceWithStreamingResponse", + "AsyncZeroRTTResourceWithStreamingResponse", "AdvancedDDoS", "AsyncAdvancedDDoS", "AdvancedDDoSWithRawResponse", "AsyncAdvancedDDoSWithRawResponse", "AdvancedDDoSWithStreamingResponse", "AsyncAdvancedDDoSWithStreamingResponse", - "AlwaysOnline", - "AsyncAlwaysOnline", - "AlwaysOnlineWithRawResponse", - "AsyncAlwaysOnlineWithRawResponse", - "AlwaysOnlineWithStreamingResponse", - "AsyncAlwaysOnlineWithStreamingResponse", + "AlwaysOnlineResource", + "AsyncAlwaysOnlineResource", + "AlwaysOnlineResourceWithRawResponse", + "AsyncAlwaysOnlineResourceWithRawResponse", + "AlwaysOnlineResourceWithStreamingResponse", + "AsyncAlwaysOnlineResourceWithStreamingResponse", "AlwaysUseHTTPS", "AsyncAlwaysUseHTTPS", "AlwaysUseHTTPSWithRawResponse", @@ -448,276 +448,276 @@ "AsyncAutomaticHTTPSRewritesWithRawResponse", "AutomaticHTTPSRewritesWithStreamingResponse", "AsyncAutomaticHTTPSRewritesWithStreamingResponse", - "AutomaticPlatformOptimization", - "AsyncAutomaticPlatformOptimization", - "AutomaticPlatformOptimizationWithRawResponse", - "AsyncAutomaticPlatformOptimizationWithRawResponse", - "AutomaticPlatformOptimizationWithStreamingResponse", - "AsyncAutomaticPlatformOptimizationWithStreamingResponse", - "Brotli", - "AsyncBrotli", - "BrotliWithRawResponse", - "AsyncBrotliWithRawResponse", - "BrotliWithStreamingResponse", - "AsyncBrotliWithStreamingResponse", - "BrowserCacheTTL", - "AsyncBrowserCacheTTL", - "BrowserCacheTTLWithRawResponse", - "AsyncBrowserCacheTTLWithRawResponse", - "BrowserCacheTTLWithStreamingResponse", - "AsyncBrowserCacheTTLWithStreamingResponse", - "BrowserCheck", - "AsyncBrowserCheck", - "BrowserCheckWithRawResponse", - "AsyncBrowserCheckWithRawResponse", - "BrowserCheckWithStreamingResponse", - "AsyncBrowserCheckWithStreamingResponse", - "CacheLevel", - "AsyncCacheLevel", - "CacheLevelWithRawResponse", - "AsyncCacheLevelWithRawResponse", - "CacheLevelWithStreamingResponse", - "AsyncCacheLevelWithStreamingResponse", - "ChallengeTTL", - "AsyncChallengeTTL", - "ChallengeTTLWithRawResponse", - "AsyncChallengeTTLWithRawResponse", - "ChallengeTTLWithStreamingResponse", - "AsyncChallengeTTLWithStreamingResponse", + "AutomaticPlatformOptimizationResource", + "AsyncAutomaticPlatformOptimizationResource", + "AutomaticPlatformOptimizationResourceWithRawResponse", + "AsyncAutomaticPlatformOptimizationResourceWithRawResponse", + "AutomaticPlatformOptimizationResourceWithStreamingResponse", + "AsyncAutomaticPlatformOptimizationResourceWithStreamingResponse", + "BrotliResource", + "AsyncBrotliResource", + "BrotliResourceWithRawResponse", + "AsyncBrotliResourceWithRawResponse", + "BrotliResourceWithStreamingResponse", + "AsyncBrotliResourceWithStreamingResponse", + "BrowserCacheTTLResource", + "AsyncBrowserCacheTTLResource", + "BrowserCacheTTLResourceWithRawResponse", + "AsyncBrowserCacheTTLResourceWithRawResponse", + "BrowserCacheTTLResourceWithStreamingResponse", + "AsyncBrowserCacheTTLResourceWithStreamingResponse", + "BrowserCheckResource", + "AsyncBrowserCheckResource", + "BrowserCheckResourceWithRawResponse", + "AsyncBrowserCheckResourceWithRawResponse", + "BrowserCheckResourceWithStreamingResponse", + "AsyncBrowserCheckResourceWithStreamingResponse", + "CacheLevelResource", + "AsyncCacheLevelResource", + "CacheLevelResourceWithRawResponse", + "AsyncCacheLevelResourceWithRawResponse", + "CacheLevelResourceWithStreamingResponse", + "AsyncCacheLevelResourceWithStreamingResponse", + "ChallengeTTLResource", + "AsyncChallengeTTLResource", + "ChallengeTTLResourceWithRawResponse", + "AsyncChallengeTTLResourceWithRawResponse", + "ChallengeTTLResourceWithStreamingResponse", + "AsyncChallengeTTLResourceWithStreamingResponse", "Ciphers", "AsyncCiphers", "CiphersWithRawResponse", "AsyncCiphersWithRawResponse", "CiphersWithStreamingResponse", "AsyncCiphersWithStreamingResponse", - "DevelopmentMode", - "AsyncDevelopmentMode", - "DevelopmentModeWithRawResponse", - "AsyncDevelopmentModeWithRawResponse", - "DevelopmentModeWithStreamingResponse", - "AsyncDevelopmentModeWithStreamingResponse", + "DevelopmentModeResource", + "AsyncDevelopmentModeResource", + "DevelopmentModeResourceWithRawResponse", + "AsyncDevelopmentModeResourceWithRawResponse", + "DevelopmentModeResourceWithStreamingResponse", + "AsyncDevelopmentModeResourceWithStreamingResponse", "EarlyHints", "AsyncEarlyHints", "EarlyHintsWithRawResponse", "AsyncEarlyHintsWithRawResponse", "EarlyHintsWithStreamingResponse", "AsyncEarlyHintsWithStreamingResponse", - "EmailObfuscation", - "AsyncEmailObfuscation", - "EmailObfuscationWithRawResponse", - "AsyncEmailObfuscationWithRawResponse", - "EmailObfuscationWithStreamingResponse", - "AsyncEmailObfuscationWithStreamingResponse", - "H2Prioritization", - "AsyncH2Prioritization", - "H2PrioritizationWithRawResponse", - "AsyncH2PrioritizationWithRawResponse", - "H2PrioritizationWithStreamingResponse", - "AsyncH2PrioritizationWithStreamingResponse", - "HotlinkProtection", - "AsyncHotlinkProtection", - "HotlinkProtectionWithRawResponse", - "AsyncHotlinkProtectionWithRawResponse", - "HotlinkProtectionWithStreamingResponse", - "AsyncHotlinkProtectionWithStreamingResponse", - "HTTP2", - "AsyncHTTP2", - "HTTP2WithRawResponse", - "AsyncHTTP2WithRawResponse", - "HTTP2WithStreamingResponse", - "AsyncHTTP2WithStreamingResponse", - "HTTP3", - "AsyncHTTP3", - "HTTP3WithRawResponse", - "AsyncHTTP3WithRawResponse", - "HTTP3WithStreamingResponse", - "AsyncHTTP3WithStreamingResponse", - "ImageResizing", - "AsyncImageResizing", - "ImageResizingWithRawResponse", - "AsyncImageResizingWithRawResponse", - "ImageResizingWithStreamingResponse", - "AsyncImageResizingWithStreamingResponse", - "IPGeolocation", - "AsyncIPGeolocation", - "IPGeolocationWithRawResponse", - "AsyncIPGeolocationWithRawResponse", - "IPGeolocationWithStreamingResponse", - "AsyncIPGeolocationWithStreamingResponse", - "IPV6", - "AsyncIPV6", - "IPV6WithRawResponse", - "AsyncIPV6WithRawResponse", - "IPV6WithStreamingResponse", - "AsyncIPV6WithStreamingResponse", - "MinTLSVersion", - "AsyncMinTLSVersion", - "MinTLSVersionWithRawResponse", - "AsyncMinTLSVersionWithRawResponse", - "MinTLSVersionWithStreamingResponse", - "AsyncMinTLSVersionWithStreamingResponse", - "Minify", - "AsyncMinify", - "MinifyWithRawResponse", - "AsyncMinifyWithRawResponse", - "MinifyWithStreamingResponse", - "AsyncMinifyWithStreamingResponse", - "Mirage", - "AsyncMirage", - "MirageWithRawResponse", - "AsyncMirageWithRawResponse", - "MirageWithStreamingResponse", - "AsyncMirageWithStreamingResponse", - "MobileRedirect", - "AsyncMobileRedirect", - "MobileRedirectWithRawResponse", - "AsyncMobileRedirectWithRawResponse", - "MobileRedirectWithStreamingResponse", - "AsyncMobileRedirectWithStreamingResponse", - "NEL", - "AsyncNEL", - "NELWithRawResponse", - "AsyncNELWithRawResponse", - "NELWithStreamingResponse", - "AsyncNELWithStreamingResponse", - "OpportunisticEncryption", - "AsyncOpportunisticEncryption", - "OpportunisticEncryptionWithRawResponse", - "AsyncOpportunisticEncryptionWithRawResponse", - "OpportunisticEncryptionWithStreamingResponse", - "AsyncOpportunisticEncryptionWithStreamingResponse", - "OpportunisticOnion", - "AsyncOpportunisticOnion", - "OpportunisticOnionWithRawResponse", - "AsyncOpportunisticOnionWithRawResponse", - "OpportunisticOnionWithStreamingResponse", - "AsyncOpportunisticOnionWithStreamingResponse", - "OrangeToOrange", - "AsyncOrangeToOrange", - "OrangeToOrangeWithRawResponse", - "AsyncOrangeToOrangeWithRawResponse", - "OrangeToOrangeWithStreamingResponse", - "AsyncOrangeToOrangeWithStreamingResponse", - "OriginErrorPagePassThru", - "AsyncOriginErrorPagePassThru", - "OriginErrorPagePassThruWithRawResponse", - "AsyncOriginErrorPagePassThruWithRawResponse", - "OriginErrorPagePassThruWithStreamingResponse", - "AsyncOriginErrorPagePassThruWithStreamingResponse", + "EmailObfuscationResource", + "AsyncEmailObfuscationResource", + "EmailObfuscationResourceWithRawResponse", + "AsyncEmailObfuscationResourceWithRawResponse", + "EmailObfuscationResourceWithStreamingResponse", + "AsyncEmailObfuscationResourceWithStreamingResponse", + "H2PrioritizationResource", + "AsyncH2PrioritizationResource", + "H2PrioritizationResourceWithRawResponse", + "AsyncH2PrioritizationResourceWithRawResponse", + "H2PrioritizationResourceWithStreamingResponse", + "AsyncH2PrioritizationResourceWithStreamingResponse", + "HotlinkProtectionResource", + "AsyncHotlinkProtectionResource", + "HotlinkProtectionResourceWithRawResponse", + "AsyncHotlinkProtectionResourceWithRawResponse", + "HotlinkProtectionResourceWithStreamingResponse", + "AsyncHotlinkProtectionResourceWithStreamingResponse", + "HTTP2Resource", + "AsyncHTTP2Resource", + "HTTP2ResourceWithRawResponse", + "AsyncHTTP2ResourceWithRawResponse", + "HTTP2ResourceWithStreamingResponse", + "AsyncHTTP2ResourceWithStreamingResponse", + "HTTP3Resource", + "AsyncHTTP3Resource", + "HTTP3ResourceWithRawResponse", + "AsyncHTTP3ResourceWithRawResponse", + "HTTP3ResourceWithStreamingResponse", + "AsyncHTTP3ResourceWithStreamingResponse", + "ImageResizingResource", + "AsyncImageResizingResource", + "ImageResizingResourceWithRawResponse", + "AsyncImageResizingResourceWithRawResponse", + "ImageResizingResourceWithStreamingResponse", + "AsyncImageResizingResourceWithStreamingResponse", + "IPGeolocationResource", + "AsyncIPGeolocationResource", + "IPGeolocationResourceWithRawResponse", + "AsyncIPGeolocationResourceWithRawResponse", + "IPGeolocationResourceWithStreamingResponse", + "AsyncIPGeolocationResourceWithStreamingResponse", + "IPV6Resource", + "AsyncIPV6Resource", + "IPV6ResourceWithRawResponse", + "AsyncIPV6ResourceWithRawResponse", + "IPV6ResourceWithStreamingResponse", + "AsyncIPV6ResourceWithStreamingResponse", + "MinTLSVersionResource", + "AsyncMinTLSVersionResource", + "MinTLSVersionResourceWithRawResponse", + "AsyncMinTLSVersionResourceWithRawResponse", + "MinTLSVersionResourceWithStreamingResponse", + "AsyncMinTLSVersionResourceWithStreamingResponse", + "MinifyResource", + "AsyncMinifyResource", + "MinifyResourceWithRawResponse", + "AsyncMinifyResourceWithRawResponse", + "MinifyResourceWithStreamingResponse", + "AsyncMinifyResourceWithStreamingResponse", + "MirageResource", + "AsyncMirageResource", + "MirageResourceWithRawResponse", + "AsyncMirageResourceWithRawResponse", + "MirageResourceWithStreamingResponse", + "AsyncMirageResourceWithStreamingResponse", + "MobileRedirectResource", + "AsyncMobileRedirectResource", + "MobileRedirectResourceWithRawResponse", + "AsyncMobileRedirectResourceWithRawResponse", + "MobileRedirectResourceWithStreamingResponse", + "AsyncMobileRedirectResourceWithStreamingResponse", + "NELResource", + "AsyncNELResource", + "NELResourceWithRawResponse", + "AsyncNELResourceWithRawResponse", + "NELResourceWithStreamingResponse", + "AsyncNELResourceWithStreamingResponse", + "OpportunisticEncryptionResource", + "AsyncOpportunisticEncryptionResource", + "OpportunisticEncryptionResourceWithRawResponse", + "AsyncOpportunisticEncryptionResourceWithRawResponse", + "OpportunisticEncryptionResourceWithStreamingResponse", + "AsyncOpportunisticEncryptionResourceWithStreamingResponse", + "OpportunisticOnionResource", + "AsyncOpportunisticOnionResource", + "OpportunisticOnionResourceWithRawResponse", + "AsyncOpportunisticOnionResourceWithRawResponse", + "OpportunisticOnionResourceWithStreamingResponse", + "AsyncOpportunisticOnionResourceWithStreamingResponse", + "OrangeToOrangeResource", + "AsyncOrangeToOrangeResource", + "OrangeToOrangeResourceWithRawResponse", + "AsyncOrangeToOrangeResourceWithRawResponse", + "OrangeToOrangeResourceWithStreamingResponse", + "AsyncOrangeToOrangeResourceWithStreamingResponse", + "OriginErrorPagePassThruResource", + "AsyncOriginErrorPagePassThruResource", + "OriginErrorPagePassThruResourceWithRawResponse", + "AsyncOriginErrorPagePassThruResourceWithRawResponse", + "OriginErrorPagePassThruResourceWithStreamingResponse", + "AsyncOriginErrorPagePassThruResourceWithStreamingResponse", "OriginMaxHTTPVersion", "AsyncOriginMaxHTTPVersion", "OriginMaxHTTPVersionWithRawResponse", "AsyncOriginMaxHTTPVersionWithRawResponse", "OriginMaxHTTPVersionWithStreamingResponse", "AsyncOriginMaxHTTPVersionWithStreamingResponse", - "Polish", - "AsyncPolish", - "PolishWithRawResponse", - "AsyncPolishWithRawResponse", - "PolishWithStreamingResponse", - "AsyncPolishWithStreamingResponse", - "PrefetchPreload", - "AsyncPrefetchPreload", - "PrefetchPreloadWithRawResponse", - "AsyncPrefetchPreloadWithRawResponse", - "PrefetchPreloadWithStreamingResponse", - "AsyncPrefetchPreloadWithStreamingResponse", - "ProxyReadTimeout", - "AsyncProxyReadTimeout", - "ProxyReadTimeoutWithRawResponse", - "AsyncProxyReadTimeoutWithRawResponse", - "ProxyReadTimeoutWithStreamingResponse", - "AsyncProxyReadTimeoutWithStreamingResponse", - "PseudoIPV4", - "AsyncPseudoIPV4", - "PseudoIPV4WithRawResponse", - "AsyncPseudoIPV4WithRawResponse", - "PseudoIPV4WithStreamingResponse", - "AsyncPseudoIPV4WithStreamingResponse", - "ResponseBuffering", - "AsyncResponseBuffering", - "ResponseBufferingWithRawResponse", - "AsyncResponseBufferingWithRawResponse", - "ResponseBufferingWithStreamingResponse", - "AsyncResponseBufferingWithStreamingResponse", - "RocketLoader", - "AsyncRocketLoader", - "RocketLoaderWithRawResponse", - "AsyncRocketLoaderWithRawResponse", - "RocketLoaderWithStreamingResponse", - "AsyncRocketLoaderWithStreamingResponse", + "PolishResource", + "AsyncPolishResource", + "PolishResourceWithRawResponse", + "AsyncPolishResourceWithRawResponse", + "PolishResourceWithStreamingResponse", + "AsyncPolishResourceWithStreamingResponse", + "PrefetchPreloadResource", + "AsyncPrefetchPreloadResource", + "PrefetchPreloadResourceWithRawResponse", + "AsyncPrefetchPreloadResourceWithRawResponse", + "PrefetchPreloadResourceWithStreamingResponse", + "AsyncPrefetchPreloadResourceWithStreamingResponse", + "ProxyReadTimeoutResource", + "AsyncProxyReadTimeoutResource", + "ProxyReadTimeoutResourceWithRawResponse", + "AsyncProxyReadTimeoutResourceWithRawResponse", + "ProxyReadTimeoutResourceWithStreamingResponse", + "AsyncProxyReadTimeoutResourceWithStreamingResponse", + "PseudoIPV4Resource", + "AsyncPseudoIPV4Resource", + "PseudoIPV4ResourceWithRawResponse", + "AsyncPseudoIPV4ResourceWithRawResponse", + "PseudoIPV4ResourceWithStreamingResponse", + "AsyncPseudoIPV4ResourceWithStreamingResponse", + "ResponseBufferingResource", + "AsyncResponseBufferingResource", + "ResponseBufferingResourceWithRawResponse", + "AsyncResponseBufferingResourceWithRawResponse", + "ResponseBufferingResourceWithStreamingResponse", + "AsyncResponseBufferingResourceWithStreamingResponse", + "RocketLoaderResource", + "AsyncRocketLoaderResource", + "RocketLoaderResourceWithRawResponse", + "AsyncRocketLoaderResourceWithRawResponse", + "RocketLoaderResourceWithStreamingResponse", + "AsyncRocketLoaderResourceWithStreamingResponse", "SecurityHeaders", "AsyncSecurityHeaders", "SecurityHeadersWithRawResponse", "AsyncSecurityHeadersWithRawResponse", "SecurityHeadersWithStreamingResponse", "AsyncSecurityHeadersWithStreamingResponse", - "SecurityLevel", - "AsyncSecurityLevel", - "SecurityLevelWithRawResponse", - "AsyncSecurityLevelWithRawResponse", - "SecurityLevelWithStreamingResponse", - "AsyncSecurityLevelWithStreamingResponse", + "SecurityLevelResource", + "AsyncSecurityLevelResource", + "SecurityLevelResourceWithRawResponse", + "AsyncSecurityLevelResourceWithRawResponse", + "SecurityLevelResourceWithStreamingResponse", + "AsyncSecurityLevelResourceWithStreamingResponse", "ServerSideExcludes", "AsyncServerSideExcludes", "ServerSideExcludesWithRawResponse", "AsyncServerSideExcludesWithRawResponse", "ServerSideExcludesWithStreamingResponse", "AsyncServerSideExcludesWithStreamingResponse", - "SortQueryStringForCache", - "AsyncSortQueryStringForCache", - "SortQueryStringForCacheWithRawResponse", - "AsyncSortQueryStringForCacheWithRawResponse", - "SortQueryStringForCacheWithStreamingResponse", - "AsyncSortQueryStringForCacheWithStreamingResponse", - "SSL", - "AsyncSSL", - "SSLWithRawResponse", - "AsyncSSLWithRawResponse", - "SSLWithStreamingResponse", - "AsyncSSLWithStreamingResponse", - "SSLRecommender", - "AsyncSSLRecommender", - "SSLRecommenderWithRawResponse", - "AsyncSSLRecommenderWithRawResponse", - "SSLRecommenderWithStreamingResponse", - "AsyncSSLRecommenderWithStreamingResponse", - "TLS1_3", - "AsyncTLS1_3", - "TLS1_3WithRawResponse", - "AsyncTLS1_3WithRawResponse", - "TLS1_3WithStreamingResponse", - "AsyncTLS1_3WithStreamingResponse", - "TLSClientAuth", - "AsyncTLSClientAuth", - "TLSClientAuthWithRawResponse", - "AsyncTLSClientAuthWithRawResponse", - "TLSClientAuthWithStreamingResponse", - "AsyncTLSClientAuthWithStreamingResponse", - "TrueClientIPHeader", - "AsyncTrueClientIPHeader", - "TrueClientIPHeaderWithRawResponse", - "AsyncTrueClientIPHeaderWithRawResponse", - "TrueClientIPHeaderWithStreamingResponse", - "AsyncTrueClientIPHeaderWithStreamingResponse", - "WAF", - "AsyncWAF", - "WAFWithRawResponse", - "AsyncWAFWithRawResponse", - "WAFWithStreamingResponse", - "AsyncWAFWithStreamingResponse", - "WebP", - "AsyncWebP", - "WebPWithRawResponse", - "AsyncWebPWithRawResponse", - "WebPWithStreamingResponse", - "AsyncWebPWithStreamingResponse", - "Websocket", - "AsyncWebsocket", - "WebsocketWithRawResponse", - "AsyncWebsocketWithRawResponse", - "WebsocketWithStreamingResponse", - "AsyncWebsocketWithStreamingResponse", + "SortQueryStringForCacheResource", + "AsyncSortQueryStringForCacheResource", + "SortQueryStringForCacheResourceWithRawResponse", + "AsyncSortQueryStringForCacheResourceWithRawResponse", + "SortQueryStringForCacheResourceWithStreamingResponse", + "AsyncSortQueryStringForCacheResourceWithStreamingResponse", + "SSLResource", + "AsyncSSLResource", + "SSLResourceWithRawResponse", + "AsyncSSLResourceWithRawResponse", + "SSLResourceWithStreamingResponse", + "AsyncSSLResourceWithStreamingResponse", + "SSLRecommenderResource", + "AsyncSSLRecommenderResource", + "SSLRecommenderResourceWithRawResponse", + "AsyncSSLRecommenderResourceWithRawResponse", + "SSLRecommenderResourceWithStreamingResponse", + "AsyncSSLRecommenderResourceWithStreamingResponse", + "TLS1_3Resource", + "AsyncTLS1_3Resource", + "TLS1_3ResourceWithRawResponse", + "AsyncTLS1_3ResourceWithRawResponse", + "TLS1_3ResourceWithStreamingResponse", + "AsyncTLS1_3ResourceWithStreamingResponse", + "TLSClientAuthResource", + "AsyncTLSClientAuthResource", + "TLSClientAuthResourceWithRawResponse", + "AsyncTLSClientAuthResourceWithRawResponse", + "TLSClientAuthResourceWithStreamingResponse", + "AsyncTLSClientAuthResourceWithStreamingResponse", + "TrueClientIPHeaderResource", + "AsyncTrueClientIPHeaderResource", + "TrueClientIPHeaderResourceWithRawResponse", + "AsyncTrueClientIPHeaderResourceWithRawResponse", + "TrueClientIPHeaderResourceWithStreamingResponse", + "AsyncTrueClientIPHeaderResourceWithStreamingResponse", + "WAFResource", + "AsyncWAFResource", + "WAFResourceWithRawResponse", + "AsyncWAFResourceWithRawResponse", + "WAFResourceWithStreamingResponse", + "AsyncWAFResourceWithStreamingResponse", + "WebPResource", + "AsyncWebPResource", + "WebPResourceWithRawResponse", + "AsyncWebPResourceWithRawResponse", + "WebPResourceWithStreamingResponse", + "AsyncWebPResourceWithStreamingResponse", + "WebsocketResource", + "AsyncWebsocketResource", + "WebsocketResourceWithRawResponse", + "AsyncWebsocketResourceWithRawResponse", + "WebsocketResourceWithStreamingResponse", + "AsyncWebsocketResourceWithStreamingResponse", "FontSettings", "AsyncFontSettings", "FontSettingsWithRawResponse", diff --git a/src/cloudflare/resources/zones/settings/advanced_ddos.py b/src/cloudflare/resources/zones/settings/advanced_ddos.py index 824148d44d0d..2cbced0345de 100644 --- a/src/cloudflare/resources/zones/settings/advanced_ddos.py +++ b/src/cloudflare/resources/zones/settings/advanced_ddos.py @@ -19,7 +19,7 @@ from ...._base_client import ( make_request_options, ) -from ....types.zones.settings import ZoneSettingAdvancedDDoS +from ....types.zones.settings import advanced_ddos __all__ = ["AdvancedDDoS", "AsyncAdvancedDDoS"] @@ -43,7 +43,7 @@ def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingAdvancedDDoS]: + ) -> Optional[advanced_ddos.AdvancedDDoS]: """ Advanced protection from Distributed Denial of Service (DDoS) attacks on your website. This is an uneditable value that is 'on' in the case of Business and @@ -71,7 +71,7 @@ def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingAdvancedDDoS]], ResultWrapper[ZoneSettingAdvancedDDoS]), + cast_to=cast(Type[Optional[advanced_ddos.AdvancedDDoS]], ResultWrapper[advanced_ddos.AdvancedDDoS]), ) @@ -94,7 +94,7 @@ async def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingAdvancedDDoS]: + ) -> Optional[advanced_ddos.AdvancedDDoS]: """ Advanced protection from Distributed Denial of Service (DDoS) attacks on your website. This is an uneditable value that is 'on' in the case of Business and @@ -122,7 +122,7 @@ async def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingAdvancedDDoS]], ResultWrapper[ZoneSettingAdvancedDDoS]), + cast_to=cast(Type[Optional[advanced_ddos.AdvancedDDoS]], ResultWrapper[advanced_ddos.AdvancedDDoS]), ) diff --git a/src/cloudflare/resources/zones/settings/always_online.py b/src/cloudflare/resources/zones/settings/always_online.py index 83205d34902c..6457dbc50c07 100644 --- a/src/cloudflare/resources/zones/settings/always_online.py +++ b/src/cloudflare/resources/zones/settings/always_online.py @@ -24,19 +24,19 @@ from ...._base_client import ( make_request_options, ) -from ....types.zones.settings import ZoneSettingAlwaysOnline, always_online_edit_params +from ....types.zones.settings import AlwaysOnline, always_online_edit_params -__all__ = ["AlwaysOnline", "AsyncAlwaysOnline"] +__all__ = ["AlwaysOnlineResource", "AsyncAlwaysOnlineResource"] -class AlwaysOnline(SyncAPIResource): +class AlwaysOnlineResource(SyncAPIResource): @cached_property - def with_raw_response(self) -> AlwaysOnlineWithRawResponse: - return AlwaysOnlineWithRawResponse(self) + def with_raw_response(self) -> AlwaysOnlineResourceWithRawResponse: + return AlwaysOnlineResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> AlwaysOnlineWithStreamingResponse: - return AlwaysOnlineWithStreamingResponse(self) + def with_streaming_response(self) -> AlwaysOnlineResourceWithStreamingResponse: + return AlwaysOnlineResourceWithStreamingResponse(self) def edit( self, @@ -49,7 +49,7 @@ def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingAlwaysOnline]: + ) -> Optional[AlwaysOnline]: """ When enabled, Cloudflare serves limited copies of web pages available from the [Internet Archive's Wayback Machine](https://archive.org/web/) if your server is @@ -82,7 +82,7 @@ def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingAlwaysOnline]], ResultWrapper[ZoneSettingAlwaysOnline]), + cast_to=cast(Type[Optional[AlwaysOnline]], ResultWrapper[AlwaysOnline]), ) def get( @@ -95,7 +95,7 @@ def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingAlwaysOnline]: + ) -> Optional[AlwaysOnline]: """ When enabled, Cloudflare serves limited copies of web pages available from the [Internet Archive's Wayback Machine](https://archive.org/web/) if your server is @@ -125,18 +125,18 @@ def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingAlwaysOnline]], ResultWrapper[ZoneSettingAlwaysOnline]), + cast_to=cast(Type[Optional[AlwaysOnline]], ResultWrapper[AlwaysOnline]), ) -class AsyncAlwaysOnline(AsyncAPIResource): +class AsyncAlwaysOnlineResource(AsyncAPIResource): @cached_property - def with_raw_response(self) -> AsyncAlwaysOnlineWithRawResponse: - return AsyncAlwaysOnlineWithRawResponse(self) + def with_raw_response(self) -> AsyncAlwaysOnlineResourceWithRawResponse: + return AsyncAlwaysOnlineResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> AsyncAlwaysOnlineWithStreamingResponse: - return AsyncAlwaysOnlineWithStreamingResponse(self) + def with_streaming_response(self) -> AsyncAlwaysOnlineResourceWithStreamingResponse: + return AsyncAlwaysOnlineResourceWithStreamingResponse(self) async def edit( self, @@ -149,7 +149,7 @@ async def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingAlwaysOnline]: + ) -> Optional[AlwaysOnline]: """ When enabled, Cloudflare serves limited copies of web pages available from the [Internet Archive's Wayback Machine](https://archive.org/web/) if your server is @@ -182,7 +182,7 @@ async def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingAlwaysOnline]], ResultWrapper[ZoneSettingAlwaysOnline]), + cast_to=cast(Type[Optional[AlwaysOnline]], ResultWrapper[AlwaysOnline]), ) async def get( @@ -195,7 +195,7 @@ async def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingAlwaysOnline]: + ) -> Optional[AlwaysOnline]: """ When enabled, Cloudflare serves limited copies of web pages available from the [Internet Archive's Wayback Machine](https://archive.org/web/) if your server is @@ -225,12 +225,12 @@ async def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingAlwaysOnline]], ResultWrapper[ZoneSettingAlwaysOnline]), + cast_to=cast(Type[Optional[AlwaysOnline]], ResultWrapper[AlwaysOnline]), ) -class AlwaysOnlineWithRawResponse: - def __init__(self, always_online: AlwaysOnline) -> None: +class AlwaysOnlineResourceWithRawResponse: + def __init__(self, always_online: AlwaysOnlineResource) -> None: self._always_online = always_online self.edit = to_raw_response_wrapper( @@ -241,8 +241,8 @@ def __init__(self, always_online: AlwaysOnline) -> None: ) -class AsyncAlwaysOnlineWithRawResponse: - def __init__(self, always_online: AsyncAlwaysOnline) -> None: +class AsyncAlwaysOnlineResourceWithRawResponse: + def __init__(self, always_online: AsyncAlwaysOnlineResource) -> None: self._always_online = always_online self.edit = async_to_raw_response_wrapper( @@ -253,8 +253,8 @@ def __init__(self, always_online: AsyncAlwaysOnline) -> None: ) -class AlwaysOnlineWithStreamingResponse: - def __init__(self, always_online: AlwaysOnline) -> None: +class AlwaysOnlineResourceWithStreamingResponse: + def __init__(self, always_online: AlwaysOnlineResource) -> None: self._always_online = always_online self.edit = to_streamed_response_wrapper( @@ -265,8 +265,8 @@ def __init__(self, always_online: AlwaysOnline) -> None: ) -class AsyncAlwaysOnlineWithStreamingResponse: - def __init__(self, always_online: AsyncAlwaysOnline) -> None: +class AsyncAlwaysOnlineResourceWithStreamingResponse: + def __init__(self, always_online: AsyncAlwaysOnlineResource) -> None: self._always_online = always_online self.edit = async_to_streamed_response_wrapper( diff --git a/src/cloudflare/resources/zones/settings/always_use_https.py b/src/cloudflare/resources/zones/settings/always_use_https.py index e0f3523f82dc..ff17569655a5 100644 --- a/src/cloudflare/resources/zones/settings/always_use_https.py +++ b/src/cloudflare/resources/zones/settings/always_use_https.py @@ -24,7 +24,7 @@ from ...._base_client import ( make_request_options, ) -from ....types.zones.settings import ZoneSettingAlwaysUseHTTPS, always_use_https_edit_params +from ....types.zones.settings import always_use_https, always_use_https_edit_params __all__ = ["AlwaysUseHTTPS", "AsyncAlwaysUseHTTPS"] @@ -49,7 +49,7 @@ def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingAlwaysUseHTTPS]: + ) -> Optional[always_use_https.AlwaysUseHTTPS]: """ Reply to all requests for URLs that use "http" with a 301 redirect to the equivalent "https" URL. If you only want to redirect for a subset of requests, @@ -80,7 +80,9 @@ def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingAlwaysUseHTTPS]], ResultWrapper[ZoneSettingAlwaysUseHTTPS]), + cast_to=cast( + Type[Optional[always_use_https.AlwaysUseHTTPS]], ResultWrapper[always_use_https.AlwaysUseHTTPS] + ), ) def get( @@ -93,7 +95,7 @@ def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingAlwaysUseHTTPS]: + ) -> Optional[always_use_https.AlwaysUseHTTPS]: """ Reply to all requests for URLs that use "http" with a 301 redirect to the equivalent "https" URL. If you only want to redirect for a subset of requests, @@ -121,7 +123,9 @@ def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingAlwaysUseHTTPS]], ResultWrapper[ZoneSettingAlwaysUseHTTPS]), + cast_to=cast( + Type[Optional[always_use_https.AlwaysUseHTTPS]], ResultWrapper[always_use_https.AlwaysUseHTTPS] + ), ) @@ -145,7 +149,7 @@ async def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingAlwaysUseHTTPS]: + ) -> Optional[always_use_https.AlwaysUseHTTPS]: """ Reply to all requests for URLs that use "http" with a 301 redirect to the equivalent "https" URL. If you only want to redirect for a subset of requests, @@ -176,7 +180,9 @@ async def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingAlwaysUseHTTPS]], ResultWrapper[ZoneSettingAlwaysUseHTTPS]), + cast_to=cast( + Type[Optional[always_use_https.AlwaysUseHTTPS]], ResultWrapper[always_use_https.AlwaysUseHTTPS] + ), ) async def get( @@ -189,7 +195,7 @@ async def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingAlwaysUseHTTPS]: + ) -> Optional[always_use_https.AlwaysUseHTTPS]: """ Reply to all requests for URLs that use "http" with a 301 redirect to the equivalent "https" URL. If you only want to redirect for a subset of requests, @@ -217,7 +223,9 @@ async def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingAlwaysUseHTTPS]], ResultWrapper[ZoneSettingAlwaysUseHTTPS]), + cast_to=cast( + Type[Optional[always_use_https.AlwaysUseHTTPS]], ResultWrapper[always_use_https.AlwaysUseHTTPS] + ), ) diff --git a/src/cloudflare/resources/zones/settings/automatic_https_rewrites.py b/src/cloudflare/resources/zones/settings/automatic_https_rewrites.py index 2950a6992434..2c9416a39fb7 100644 --- a/src/cloudflare/resources/zones/settings/automatic_https_rewrites.py +++ b/src/cloudflare/resources/zones/settings/automatic_https_rewrites.py @@ -24,7 +24,7 @@ from ...._base_client import ( make_request_options, ) -from ....types.zones.settings import ZoneSettingAutomaticHTTPSRewrites, automatic_https_rewrite_edit_params +from ....types.zones.settings import automatic_https_rewrites, automatic_https_rewrite_edit_params __all__ = ["AutomaticHTTPSRewrites", "AsyncAutomaticHTTPSRewrites"] @@ -49,7 +49,7 @@ def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingAutomaticHTTPSRewrites]: + ) -> Optional[automatic_https_rewrites.AutomaticHTTPSRewrites]: """ Enable the Automatic HTTPS Rewrites feature for this zone. @@ -80,7 +80,8 @@ def edit( post_parser=ResultWrapper._unwrapper, ), cast_to=cast( - Type[Optional[ZoneSettingAutomaticHTTPSRewrites]], ResultWrapper[ZoneSettingAutomaticHTTPSRewrites] + Type[Optional[automatic_https_rewrites.AutomaticHTTPSRewrites]], + ResultWrapper[automatic_https_rewrites.AutomaticHTTPSRewrites], ), ) @@ -94,7 +95,7 @@ def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingAutomaticHTTPSRewrites]: + ) -> Optional[automatic_https_rewrites.AutomaticHTTPSRewrites]: """ Enable the Automatic HTTPS Rewrites feature for this zone. @@ -121,7 +122,8 @@ def get( post_parser=ResultWrapper._unwrapper, ), cast_to=cast( - Type[Optional[ZoneSettingAutomaticHTTPSRewrites]], ResultWrapper[ZoneSettingAutomaticHTTPSRewrites] + Type[Optional[automatic_https_rewrites.AutomaticHTTPSRewrites]], + ResultWrapper[automatic_https_rewrites.AutomaticHTTPSRewrites], ), ) @@ -146,7 +148,7 @@ async def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingAutomaticHTTPSRewrites]: + ) -> Optional[automatic_https_rewrites.AutomaticHTTPSRewrites]: """ Enable the Automatic HTTPS Rewrites feature for this zone. @@ -179,7 +181,8 @@ async def edit( post_parser=ResultWrapper._unwrapper, ), cast_to=cast( - Type[Optional[ZoneSettingAutomaticHTTPSRewrites]], ResultWrapper[ZoneSettingAutomaticHTTPSRewrites] + Type[Optional[automatic_https_rewrites.AutomaticHTTPSRewrites]], + ResultWrapper[automatic_https_rewrites.AutomaticHTTPSRewrites], ), ) @@ -193,7 +196,7 @@ async def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingAutomaticHTTPSRewrites]: + ) -> Optional[automatic_https_rewrites.AutomaticHTTPSRewrites]: """ Enable the Automatic HTTPS Rewrites feature for this zone. @@ -220,7 +223,8 @@ async def get( post_parser=ResultWrapper._unwrapper, ), cast_to=cast( - Type[Optional[ZoneSettingAutomaticHTTPSRewrites]], ResultWrapper[ZoneSettingAutomaticHTTPSRewrites] + Type[Optional[automatic_https_rewrites.AutomaticHTTPSRewrites]], + ResultWrapper[automatic_https_rewrites.AutomaticHTTPSRewrites], ), ) diff --git a/src/cloudflare/resources/zones/settings/automatic_platform_optimization.py b/src/cloudflare/resources/zones/settings/automatic_platform_optimization.py index c8f97509389b..2ac26ec74180 100644 --- a/src/cloudflare/resources/zones/settings/automatic_platform_optimization.py +++ b/src/cloudflare/resources/zones/settings/automatic_platform_optimization.py @@ -24,35 +24,35 @@ make_request_options, ) from ....types.zones.settings import ( - ZoneSettingAutomaticPlatformOptimization, - ZoneSettingAutomaticPlatformOptimizationParam, + AutomaticPlatformOptimization, + AutomaticPlatformOptimizationParam, automatic_platform_optimization_edit_params, ) -__all__ = ["AutomaticPlatformOptimization", "AsyncAutomaticPlatformOptimization"] +__all__ = ["AutomaticPlatformOptimizationResource", "AsyncAutomaticPlatformOptimizationResource"] -class AutomaticPlatformOptimization(SyncAPIResource): +class AutomaticPlatformOptimizationResource(SyncAPIResource): @cached_property - def with_raw_response(self) -> AutomaticPlatformOptimizationWithRawResponse: - return AutomaticPlatformOptimizationWithRawResponse(self) + def with_raw_response(self) -> AutomaticPlatformOptimizationResourceWithRawResponse: + return AutomaticPlatformOptimizationResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> AutomaticPlatformOptimizationWithStreamingResponse: - return AutomaticPlatformOptimizationWithStreamingResponse(self) + def with_streaming_response(self) -> AutomaticPlatformOptimizationResourceWithStreamingResponse: + return AutomaticPlatformOptimizationResourceWithStreamingResponse(self) def edit( self, *, zone_id: str, - value: ZoneSettingAutomaticPlatformOptimizationParam, + value: AutomaticPlatformOptimizationParam, # 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[ZoneSettingAutomaticPlatformOptimization]: + ) -> Optional[AutomaticPlatformOptimization]: """ [Automatic Platform Optimization for WordPress](https://developers.cloudflare.com/automatic-platform-optimization/) serves your WordPress site from Cloudflare's edge network and caches third-party @@ -83,10 +83,7 @@ def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast( - Type[Optional[ZoneSettingAutomaticPlatformOptimization]], - ResultWrapper[ZoneSettingAutomaticPlatformOptimization], - ), + cast_to=cast(Type[Optional[AutomaticPlatformOptimization]], ResultWrapper[AutomaticPlatformOptimization]), ) def get( @@ -99,7 +96,7 @@ def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingAutomaticPlatformOptimization]: + ) -> Optional[AutomaticPlatformOptimization]: """ [Automatic Platform Optimization for WordPress](https://developers.cloudflare.com/automatic-platform-optimization/) serves your WordPress site from Cloudflare's edge network and caches third-party @@ -127,34 +124,31 @@ def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast( - Type[Optional[ZoneSettingAutomaticPlatformOptimization]], - ResultWrapper[ZoneSettingAutomaticPlatformOptimization], - ), + cast_to=cast(Type[Optional[AutomaticPlatformOptimization]], ResultWrapper[AutomaticPlatformOptimization]), ) -class AsyncAutomaticPlatformOptimization(AsyncAPIResource): +class AsyncAutomaticPlatformOptimizationResource(AsyncAPIResource): @cached_property - def with_raw_response(self) -> AsyncAutomaticPlatformOptimizationWithRawResponse: - return AsyncAutomaticPlatformOptimizationWithRawResponse(self) + def with_raw_response(self) -> AsyncAutomaticPlatformOptimizationResourceWithRawResponse: + return AsyncAutomaticPlatformOptimizationResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> AsyncAutomaticPlatformOptimizationWithStreamingResponse: - return AsyncAutomaticPlatformOptimizationWithStreamingResponse(self) + def with_streaming_response(self) -> AsyncAutomaticPlatformOptimizationResourceWithStreamingResponse: + return AsyncAutomaticPlatformOptimizationResourceWithStreamingResponse(self) async def edit( self, *, zone_id: str, - value: ZoneSettingAutomaticPlatformOptimizationParam, + value: AutomaticPlatformOptimizationParam, # 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[ZoneSettingAutomaticPlatformOptimization]: + ) -> Optional[AutomaticPlatformOptimization]: """ [Automatic Platform Optimization for WordPress](https://developers.cloudflare.com/automatic-platform-optimization/) serves your WordPress site from Cloudflare's edge network and caches third-party @@ -185,10 +179,7 @@ async def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast( - Type[Optional[ZoneSettingAutomaticPlatformOptimization]], - ResultWrapper[ZoneSettingAutomaticPlatformOptimization], - ), + cast_to=cast(Type[Optional[AutomaticPlatformOptimization]], ResultWrapper[AutomaticPlatformOptimization]), ) async def get( @@ -201,7 +192,7 @@ async def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingAutomaticPlatformOptimization]: + ) -> Optional[AutomaticPlatformOptimization]: """ [Automatic Platform Optimization for WordPress](https://developers.cloudflare.com/automatic-platform-optimization/) serves your WordPress site from Cloudflare's edge network and caches third-party @@ -229,15 +220,12 @@ async def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast( - Type[Optional[ZoneSettingAutomaticPlatformOptimization]], - ResultWrapper[ZoneSettingAutomaticPlatformOptimization], - ), + cast_to=cast(Type[Optional[AutomaticPlatformOptimization]], ResultWrapper[AutomaticPlatformOptimization]), ) -class AutomaticPlatformOptimizationWithRawResponse: - def __init__(self, automatic_platform_optimization: AutomaticPlatformOptimization) -> None: +class AutomaticPlatformOptimizationResourceWithRawResponse: + def __init__(self, automatic_platform_optimization: AutomaticPlatformOptimizationResource) -> None: self._automatic_platform_optimization = automatic_platform_optimization self.edit = to_raw_response_wrapper( @@ -248,8 +236,8 @@ def __init__(self, automatic_platform_optimization: AutomaticPlatformOptimizatio ) -class AsyncAutomaticPlatformOptimizationWithRawResponse: - def __init__(self, automatic_platform_optimization: AsyncAutomaticPlatformOptimization) -> None: +class AsyncAutomaticPlatformOptimizationResourceWithRawResponse: + def __init__(self, automatic_platform_optimization: AsyncAutomaticPlatformOptimizationResource) -> None: self._automatic_platform_optimization = automatic_platform_optimization self.edit = async_to_raw_response_wrapper( @@ -260,8 +248,8 @@ def __init__(self, automatic_platform_optimization: AsyncAutomaticPlatformOptimi ) -class AutomaticPlatformOptimizationWithStreamingResponse: - def __init__(self, automatic_platform_optimization: AutomaticPlatformOptimization) -> None: +class AutomaticPlatformOptimizationResourceWithStreamingResponse: + def __init__(self, automatic_platform_optimization: AutomaticPlatformOptimizationResource) -> None: self._automatic_platform_optimization = automatic_platform_optimization self.edit = to_streamed_response_wrapper( @@ -272,8 +260,8 @@ def __init__(self, automatic_platform_optimization: AutomaticPlatformOptimizatio ) -class AsyncAutomaticPlatformOptimizationWithStreamingResponse: - def __init__(self, automatic_platform_optimization: AsyncAutomaticPlatformOptimization) -> None: +class AsyncAutomaticPlatformOptimizationResourceWithStreamingResponse: + def __init__(self, automatic_platform_optimization: AsyncAutomaticPlatformOptimizationResource) -> None: self._automatic_platform_optimization = automatic_platform_optimization self.edit = async_to_streamed_response_wrapper( diff --git a/src/cloudflare/resources/zones/settings/brotli.py b/src/cloudflare/resources/zones/settings/brotli.py index 3c9d6bb215e9..b573db15e93f 100644 --- a/src/cloudflare/resources/zones/settings/brotli.py +++ b/src/cloudflare/resources/zones/settings/brotli.py @@ -24,19 +24,19 @@ from ...._base_client import ( make_request_options, ) -from ....types.zones.settings import ZoneSettingBrotli, brotli_edit_params +from ....types.zones.settings import Brotli, brotli_edit_params -__all__ = ["Brotli", "AsyncBrotli"] +__all__ = ["BrotliResource", "AsyncBrotliResource"] -class Brotli(SyncAPIResource): +class BrotliResource(SyncAPIResource): @cached_property - def with_raw_response(self) -> BrotliWithRawResponse: - return BrotliWithRawResponse(self) + def with_raw_response(self) -> BrotliResourceWithRawResponse: + return BrotliResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> BrotliWithStreamingResponse: - return BrotliWithStreamingResponse(self) + def with_streaming_response(self) -> BrotliResourceWithStreamingResponse: + return BrotliResourceWithStreamingResponse(self) def edit( self, @@ -49,7 +49,7 @@ def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingBrotli]: + ) -> Optional[Brotli]: """ When the client requesting an asset supports the Brotli compression algorithm, Cloudflare will serve a Brotli compressed version of the asset. @@ -79,7 +79,7 @@ def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingBrotli]], ResultWrapper[ZoneSettingBrotli]), + cast_to=cast(Type[Optional[Brotli]], ResultWrapper[Brotli]), ) def get( @@ -92,7 +92,7 @@ def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingBrotli]: + ) -> Optional[Brotli]: """ When the client requesting an asset supports the Brotli compression algorithm, Cloudflare will serve a Brotli compressed version of the asset. @@ -119,18 +119,18 @@ def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingBrotli]], ResultWrapper[ZoneSettingBrotli]), + cast_to=cast(Type[Optional[Brotli]], ResultWrapper[Brotli]), ) -class AsyncBrotli(AsyncAPIResource): +class AsyncBrotliResource(AsyncAPIResource): @cached_property - def with_raw_response(self) -> AsyncBrotliWithRawResponse: - return AsyncBrotliWithRawResponse(self) + def with_raw_response(self) -> AsyncBrotliResourceWithRawResponse: + return AsyncBrotliResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> AsyncBrotliWithStreamingResponse: - return AsyncBrotliWithStreamingResponse(self) + def with_streaming_response(self) -> AsyncBrotliResourceWithStreamingResponse: + return AsyncBrotliResourceWithStreamingResponse(self) async def edit( self, @@ -143,7 +143,7 @@ async def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingBrotli]: + ) -> Optional[Brotli]: """ When the client requesting an asset supports the Brotli compression algorithm, Cloudflare will serve a Brotli compressed version of the asset. @@ -173,7 +173,7 @@ async def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingBrotli]], ResultWrapper[ZoneSettingBrotli]), + cast_to=cast(Type[Optional[Brotli]], ResultWrapper[Brotli]), ) async def get( @@ -186,7 +186,7 @@ async def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingBrotli]: + ) -> Optional[Brotli]: """ When the client requesting an asset supports the Brotli compression algorithm, Cloudflare will serve a Brotli compressed version of the asset. @@ -213,12 +213,12 @@ async def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingBrotli]], ResultWrapper[ZoneSettingBrotli]), + cast_to=cast(Type[Optional[Brotli]], ResultWrapper[Brotli]), ) -class BrotliWithRawResponse: - def __init__(self, brotli: Brotli) -> None: +class BrotliResourceWithRawResponse: + def __init__(self, brotli: BrotliResource) -> None: self._brotli = brotli self.edit = to_raw_response_wrapper( @@ -229,8 +229,8 @@ def __init__(self, brotli: Brotli) -> None: ) -class AsyncBrotliWithRawResponse: - def __init__(self, brotli: AsyncBrotli) -> None: +class AsyncBrotliResourceWithRawResponse: + def __init__(self, brotli: AsyncBrotliResource) -> None: self._brotli = brotli self.edit = async_to_raw_response_wrapper( @@ -241,8 +241,8 @@ def __init__(self, brotli: AsyncBrotli) -> None: ) -class BrotliWithStreamingResponse: - def __init__(self, brotli: Brotli) -> None: +class BrotliResourceWithStreamingResponse: + def __init__(self, brotli: BrotliResource) -> None: self._brotli = brotli self.edit = to_streamed_response_wrapper( @@ -253,8 +253,8 @@ def __init__(self, brotli: Brotli) -> None: ) -class AsyncBrotliWithStreamingResponse: - def __init__(self, brotli: AsyncBrotli) -> None: +class AsyncBrotliResourceWithStreamingResponse: + def __init__(self, brotli: AsyncBrotliResource) -> None: self._brotli = brotli self.edit = async_to_streamed_response_wrapper( diff --git a/src/cloudflare/resources/zones/settings/browser_cache_ttl.py b/src/cloudflare/resources/zones/settings/browser_cache_ttl.py index ffa3a59e1b2e..7e56a56da82d 100644 --- a/src/cloudflare/resources/zones/settings/browser_cache_ttl.py +++ b/src/cloudflare/resources/zones/settings/browser_cache_ttl.py @@ -24,19 +24,19 @@ from ...._base_client import ( make_request_options, ) -from ....types.zones.settings import ZoneSettingBrowserCacheTTL, browser_cache_ttl_edit_params +from ....types.zones.settings import BrowserCacheTTL, browser_cache_ttl_edit_params -__all__ = ["BrowserCacheTTL", "AsyncBrowserCacheTTL"] +__all__ = ["BrowserCacheTTLResource", "AsyncBrowserCacheTTLResource"] -class BrowserCacheTTL(SyncAPIResource): +class BrowserCacheTTLResource(SyncAPIResource): @cached_property - def with_raw_response(self) -> BrowserCacheTTLWithRawResponse: - return BrowserCacheTTLWithRawResponse(self) + def with_raw_response(self) -> BrowserCacheTTLResourceWithRawResponse: + return BrowserCacheTTLResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> BrowserCacheTTLWithStreamingResponse: - return BrowserCacheTTLWithStreamingResponse(self) + def with_streaming_response(self) -> BrowserCacheTTLResourceWithStreamingResponse: + return BrowserCacheTTLResourceWithStreamingResponse(self) def edit( self, @@ -78,7 +78,7 @@ def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingBrowserCacheTTL]: + ) -> Optional[BrowserCacheTTL]: """ Browser Cache TTL (in seconds) specifies how long Cloudflare-cached resources will remain on your visitors' computers. Cloudflare will honor any larger times @@ -111,7 +111,7 @@ def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingBrowserCacheTTL]], ResultWrapper[ZoneSettingBrowserCacheTTL]), + cast_to=cast(Type[Optional[BrowserCacheTTL]], ResultWrapper[BrowserCacheTTL]), ) def get( @@ -124,7 +124,7 @@ def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingBrowserCacheTTL]: + ) -> Optional[BrowserCacheTTL]: """ Browser Cache TTL (in seconds) specifies how long Cloudflare-cached resources will remain on your visitors' computers. Cloudflare will honor any larger times @@ -153,18 +153,18 @@ def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingBrowserCacheTTL]], ResultWrapper[ZoneSettingBrowserCacheTTL]), + cast_to=cast(Type[Optional[BrowserCacheTTL]], ResultWrapper[BrowserCacheTTL]), ) -class AsyncBrowserCacheTTL(AsyncAPIResource): +class AsyncBrowserCacheTTLResource(AsyncAPIResource): @cached_property - def with_raw_response(self) -> AsyncBrowserCacheTTLWithRawResponse: - return AsyncBrowserCacheTTLWithRawResponse(self) + def with_raw_response(self) -> AsyncBrowserCacheTTLResourceWithRawResponse: + return AsyncBrowserCacheTTLResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> AsyncBrowserCacheTTLWithStreamingResponse: - return AsyncBrowserCacheTTLWithStreamingResponse(self) + def with_streaming_response(self) -> AsyncBrowserCacheTTLResourceWithStreamingResponse: + return AsyncBrowserCacheTTLResourceWithStreamingResponse(self) async def edit( self, @@ -206,7 +206,7 @@ async def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingBrowserCacheTTL]: + ) -> Optional[BrowserCacheTTL]: """ Browser Cache TTL (in seconds) specifies how long Cloudflare-cached resources will remain on your visitors' computers. Cloudflare will honor any larger times @@ -239,7 +239,7 @@ async def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingBrowserCacheTTL]], ResultWrapper[ZoneSettingBrowserCacheTTL]), + cast_to=cast(Type[Optional[BrowserCacheTTL]], ResultWrapper[BrowserCacheTTL]), ) async def get( @@ -252,7 +252,7 @@ async def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingBrowserCacheTTL]: + ) -> Optional[BrowserCacheTTL]: """ Browser Cache TTL (in seconds) specifies how long Cloudflare-cached resources will remain on your visitors' computers. Cloudflare will honor any larger times @@ -281,12 +281,12 @@ async def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingBrowserCacheTTL]], ResultWrapper[ZoneSettingBrowserCacheTTL]), + cast_to=cast(Type[Optional[BrowserCacheTTL]], ResultWrapper[BrowserCacheTTL]), ) -class BrowserCacheTTLWithRawResponse: - def __init__(self, browser_cache_ttl: BrowserCacheTTL) -> None: +class BrowserCacheTTLResourceWithRawResponse: + def __init__(self, browser_cache_ttl: BrowserCacheTTLResource) -> None: self._browser_cache_ttl = browser_cache_ttl self.edit = to_raw_response_wrapper( @@ -297,8 +297,8 @@ def __init__(self, browser_cache_ttl: BrowserCacheTTL) -> None: ) -class AsyncBrowserCacheTTLWithRawResponse: - def __init__(self, browser_cache_ttl: AsyncBrowserCacheTTL) -> None: +class AsyncBrowserCacheTTLResourceWithRawResponse: + def __init__(self, browser_cache_ttl: AsyncBrowserCacheTTLResource) -> None: self._browser_cache_ttl = browser_cache_ttl self.edit = async_to_raw_response_wrapper( @@ -309,8 +309,8 @@ def __init__(self, browser_cache_ttl: AsyncBrowserCacheTTL) -> None: ) -class BrowserCacheTTLWithStreamingResponse: - def __init__(self, browser_cache_ttl: BrowserCacheTTL) -> None: +class BrowserCacheTTLResourceWithStreamingResponse: + def __init__(self, browser_cache_ttl: BrowserCacheTTLResource) -> None: self._browser_cache_ttl = browser_cache_ttl self.edit = to_streamed_response_wrapper( @@ -321,8 +321,8 @@ def __init__(self, browser_cache_ttl: BrowserCacheTTL) -> None: ) -class AsyncBrowserCacheTTLWithStreamingResponse: - def __init__(self, browser_cache_ttl: AsyncBrowserCacheTTL) -> None: +class AsyncBrowserCacheTTLResourceWithStreamingResponse: + def __init__(self, browser_cache_ttl: AsyncBrowserCacheTTLResource) -> None: self._browser_cache_ttl = browser_cache_ttl self.edit = async_to_streamed_response_wrapper( diff --git a/src/cloudflare/resources/zones/settings/browser_check.py b/src/cloudflare/resources/zones/settings/browser_check.py index ab4b6e9e7ec7..145405b22c8e 100644 --- a/src/cloudflare/resources/zones/settings/browser_check.py +++ b/src/cloudflare/resources/zones/settings/browser_check.py @@ -24,19 +24,19 @@ from ...._base_client import ( make_request_options, ) -from ....types.zones.settings import ZoneSettingBrowserCheck, browser_check_edit_params +from ....types.zones.settings import BrowserCheck, browser_check_edit_params -__all__ = ["BrowserCheck", "AsyncBrowserCheck"] +__all__ = ["BrowserCheckResource", "AsyncBrowserCheckResource"] -class BrowserCheck(SyncAPIResource): +class BrowserCheckResource(SyncAPIResource): @cached_property - def with_raw_response(self) -> BrowserCheckWithRawResponse: - return BrowserCheckWithRawResponse(self) + def with_raw_response(self) -> BrowserCheckResourceWithRawResponse: + return BrowserCheckResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> BrowserCheckWithStreamingResponse: - return BrowserCheckWithStreamingResponse(self) + def with_streaming_response(self) -> BrowserCheckResourceWithStreamingResponse: + return BrowserCheckResourceWithStreamingResponse(self) def edit( self, @@ -49,7 +49,7 @@ def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingBrowserCheck]: + ) -> Optional[BrowserCheck]: """ Browser Integrity Check is similar to Bad Behavior and looks for common HTTP headers abused most commonly by spammers and denies access to your page. It will @@ -82,7 +82,7 @@ def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingBrowserCheck]], ResultWrapper[ZoneSettingBrowserCheck]), + cast_to=cast(Type[Optional[BrowserCheck]], ResultWrapper[BrowserCheck]), ) def get( @@ -95,7 +95,7 @@ def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingBrowserCheck]: + ) -> Optional[BrowserCheck]: """ Browser Integrity Check is similar to Bad Behavior and looks for common HTTP headers abused most commonly by spammers and denies access to your page. It will @@ -125,18 +125,18 @@ def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingBrowserCheck]], ResultWrapper[ZoneSettingBrowserCheck]), + cast_to=cast(Type[Optional[BrowserCheck]], ResultWrapper[BrowserCheck]), ) -class AsyncBrowserCheck(AsyncAPIResource): +class AsyncBrowserCheckResource(AsyncAPIResource): @cached_property - def with_raw_response(self) -> AsyncBrowserCheckWithRawResponse: - return AsyncBrowserCheckWithRawResponse(self) + def with_raw_response(self) -> AsyncBrowserCheckResourceWithRawResponse: + return AsyncBrowserCheckResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> AsyncBrowserCheckWithStreamingResponse: - return AsyncBrowserCheckWithStreamingResponse(self) + def with_streaming_response(self) -> AsyncBrowserCheckResourceWithStreamingResponse: + return AsyncBrowserCheckResourceWithStreamingResponse(self) async def edit( self, @@ -149,7 +149,7 @@ async def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingBrowserCheck]: + ) -> Optional[BrowserCheck]: """ Browser Integrity Check is similar to Bad Behavior and looks for common HTTP headers abused most commonly by spammers and denies access to your page. It will @@ -182,7 +182,7 @@ async def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingBrowserCheck]], ResultWrapper[ZoneSettingBrowserCheck]), + cast_to=cast(Type[Optional[BrowserCheck]], ResultWrapper[BrowserCheck]), ) async def get( @@ -195,7 +195,7 @@ async def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingBrowserCheck]: + ) -> Optional[BrowserCheck]: """ Browser Integrity Check is similar to Bad Behavior and looks for common HTTP headers abused most commonly by spammers and denies access to your page. It will @@ -225,12 +225,12 @@ async def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingBrowserCheck]], ResultWrapper[ZoneSettingBrowserCheck]), + cast_to=cast(Type[Optional[BrowserCheck]], ResultWrapper[BrowserCheck]), ) -class BrowserCheckWithRawResponse: - def __init__(self, browser_check: BrowserCheck) -> None: +class BrowserCheckResourceWithRawResponse: + def __init__(self, browser_check: BrowserCheckResource) -> None: self._browser_check = browser_check self.edit = to_raw_response_wrapper( @@ -241,8 +241,8 @@ def __init__(self, browser_check: BrowserCheck) -> None: ) -class AsyncBrowserCheckWithRawResponse: - def __init__(self, browser_check: AsyncBrowserCheck) -> None: +class AsyncBrowserCheckResourceWithRawResponse: + def __init__(self, browser_check: AsyncBrowserCheckResource) -> None: self._browser_check = browser_check self.edit = async_to_raw_response_wrapper( @@ -253,8 +253,8 @@ def __init__(self, browser_check: AsyncBrowserCheck) -> None: ) -class BrowserCheckWithStreamingResponse: - def __init__(self, browser_check: BrowserCheck) -> None: +class BrowserCheckResourceWithStreamingResponse: + def __init__(self, browser_check: BrowserCheckResource) -> None: self._browser_check = browser_check self.edit = to_streamed_response_wrapper( @@ -265,8 +265,8 @@ def __init__(self, browser_check: BrowserCheck) -> None: ) -class AsyncBrowserCheckWithStreamingResponse: - def __init__(self, browser_check: AsyncBrowserCheck) -> None: +class AsyncBrowserCheckResourceWithStreamingResponse: + def __init__(self, browser_check: AsyncBrowserCheckResource) -> None: self._browser_check = browser_check self.edit = async_to_streamed_response_wrapper( diff --git a/src/cloudflare/resources/zones/settings/cache_level.py b/src/cloudflare/resources/zones/settings/cache_level.py index eeff2a8091d7..622375548bc5 100644 --- a/src/cloudflare/resources/zones/settings/cache_level.py +++ b/src/cloudflare/resources/zones/settings/cache_level.py @@ -24,19 +24,19 @@ from ...._base_client import ( make_request_options, ) -from ....types.zones.settings import ZoneSettingCacheLevel, cache_level_edit_params +from ....types.zones.settings import CacheLevel, cache_level_edit_params -__all__ = ["CacheLevel", "AsyncCacheLevel"] +__all__ = ["CacheLevelResource", "AsyncCacheLevelResource"] -class CacheLevel(SyncAPIResource): +class CacheLevelResource(SyncAPIResource): @cached_property - def with_raw_response(self) -> CacheLevelWithRawResponse: - return CacheLevelWithRawResponse(self) + def with_raw_response(self) -> CacheLevelResourceWithRawResponse: + return CacheLevelResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> CacheLevelWithStreamingResponse: - return CacheLevelWithStreamingResponse(self) + def with_streaming_response(self) -> CacheLevelResourceWithStreamingResponse: + return CacheLevelResourceWithStreamingResponse(self) def edit( self, @@ -49,7 +49,7 @@ def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingCacheLevel]: + ) -> Optional[CacheLevel]: """Cache Level functions based off the setting level. The basic setting will cache @@ -83,7 +83,7 @@ def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingCacheLevel]], ResultWrapper[ZoneSettingCacheLevel]), + cast_to=cast(Type[Optional[CacheLevel]], ResultWrapper[CacheLevel]), ) def get( @@ -96,7 +96,7 @@ def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingCacheLevel]: + ) -> Optional[CacheLevel]: """Cache Level functions based off the setting level. The basic setting will cache @@ -127,18 +127,18 @@ def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingCacheLevel]], ResultWrapper[ZoneSettingCacheLevel]), + cast_to=cast(Type[Optional[CacheLevel]], ResultWrapper[CacheLevel]), ) -class AsyncCacheLevel(AsyncAPIResource): +class AsyncCacheLevelResource(AsyncAPIResource): @cached_property - def with_raw_response(self) -> AsyncCacheLevelWithRawResponse: - return AsyncCacheLevelWithRawResponse(self) + def with_raw_response(self) -> AsyncCacheLevelResourceWithRawResponse: + return AsyncCacheLevelResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> AsyncCacheLevelWithStreamingResponse: - return AsyncCacheLevelWithStreamingResponse(self) + def with_streaming_response(self) -> AsyncCacheLevelResourceWithStreamingResponse: + return AsyncCacheLevelResourceWithStreamingResponse(self) async def edit( self, @@ -151,7 +151,7 @@ async def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingCacheLevel]: + ) -> Optional[CacheLevel]: """Cache Level functions based off the setting level. The basic setting will cache @@ -185,7 +185,7 @@ async def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingCacheLevel]], ResultWrapper[ZoneSettingCacheLevel]), + cast_to=cast(Type[Optional[CacheLevel]], ResultWrapper[CacheLevel]), ) async def get( @@ -198,7 +198,7 @@ async def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingCacheLevel]: + ) -> Optional[CacheLevel]: """Cache Level functions based off the setting level. The basic setting will cache @@ -229,12 +229,12 @@ async def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingCacheLevel]], ResultWrapper[ZoneSettingCacheLevel]), + cast_to=cast(Type[Optional[CacheLevel]], ResultWrapper[CacheLevel]), ) -class CacheLevelWithRawResponse: - def __init__(self, cache_level: CacheLevel) -> None: +class CacheLevelResourceWithRawResponse: + def __init__(self, cache_level: CacheLevelResource) -> None: self._cache_level = cache_level self.edit = to_raw_response_wrapper( @@ -245,8 +245,8 @@ def __init__(self, cache_level: CacheLevel) -> None: ) -class AsyncCacheLevelWithRawResponse: - def __init__(self, cache_level: AsyncCacheLevel) -> None: +class AsyncCacheLevelResourceWithRawResponse: + def __init__(self, cache_level: AsyncCacheLevelResource) -> None: self._cache_level = cache_level self.edit = async_to_raw_response_wrapper( @@ -257,8 +257,8 @@ def __init__(self, cache_level: AsyncCacheLevel) -> None: ) -class CacheLevelWithStreamingResponse: - def __init__(self, cache_level: CacheLevel) -> None: +class CacheLevelResourceWithStreamingResponse: + def __init__(self, cache_level: CacheLevelResource) -> None: self._cache_level = cache_level self.edit = to_streamed_response_wrapper( @@ -269,8 +269,8 @@ def __init__(self, cache_level: CacheLevel) -> None: ) -class AsyncCacheLevelWithStreamingResponse: - def __init__(self, cache_level: AsyncCacheLevel) -> None: +class AsyncCacheLevelResourceWithStreamingResponse: + def __init__(self, cache_level: AsyncCacheLevelResource) -> None: self._cache_level = cache_level self.edit = async_to_streamed_response_wrapper( diff --git a/src/cloudflare/resources/zones/settings/challenge_ttl.py b/src/cloudflare/resources/zones/settings/challenge_ttl.py index b1c812074f93..28b07abc1c1e 100644 --- a/src/cloudflare/resources/zones/settings/challenge_ttl.py +++ b/src/cloudflare/resources/zones/settings/challenge_ttl.py @@ -24,19 +24,19 @@ from ...._base_client import ( make_request_options, ) -from ....types.zones.settings import ZoneSettingChallengeTTL, challenge_ttl_edit_params +from ....types.zones.settings import ChallengeTTL, challenge_ttl_edit_params -__all__ = ["ChallengeTTL", "AsyncChallengeTTL"] +__all__ = ["ChallengeTTLResource", "AsyncChallengeTTLResource"] -class ChallengeTTL(SyncAPIResource): +class ChallengeTTLResource(SyncAPIResource): @cached_property - def with_raw_response(self) -> ChallengeTTLWithRawResponse: - return ChallengeTTLWithRawResponse(self) + def with_raw_response(self) -> ChallengeTTLResourceWithRawResponse: + return ChallengeTTLResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> ChallengeTTLWithStreamingResponse: - return ChallengeTTLWithStreamingResponse(self) + def with_streaming_response(self) -> ChallengeTTLResourceWithStreamingResponse: + return ChallengeTTLResourceWithStreamingResponse(self) def edit( self, @@ -49,7 +49,7 @@ def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingChallengeTTL]: + ) -> Optional[ChallengeTTL]: """ Specify how long a visitor is allowed access to your site after successfully completing a challenge (such as a CAPTCHA). After the TTL has expired the @@ -82,7 +82,7 @@ def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingChallengeTTL]], ResultWrapper[ZoneSettingChallengeTTL]), + cast_to=cast(Type[Optional[ChallengeTTL]], ResultWrapper[ChallengeTTL]), ) def get( @@ -95,7 +95,7 @@ def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingChallengeTTL]: + ) -> Optional[ChallengeTTL]: """ Specify how long a visitor is allowed access to your site after successfully completing a challenge (such as a CAPTCHA). After the TTL has expired the @@ -125,18 +125,18 @@ def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingChallengeTTL]], ResultWrapper[ZoneSettingChallengeTTL]), + cast_to=cast(Type[Optional[ChallengeTTL]], ResultWrapper[ChallengeTTL]), ) -class AsyncChallengeTTL(AsyncAPIResource): +class AsyncChallengeTTLResource(AsyncAPIResource): @cached_property - def with_raw_response(self) -> AsyncChallengeTTLWithRawResponse: - return AsyncChallengeTTLWithRawResponse(self) + def with_raw_response(self) -> AsyncChallengeTTLResourceWithRawResponse: + return AsyncChallengeTTLResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> AsyncChallengeTTLWithStreamingResponse: - return AsyncChallengeTTLWithStreamingResponse(self) + def with_streaming_response(self) -> AsyncChallengeTTLResourceWithStreamingResponse: + return AsyncChallengeTTLResourceWithStreamingResponse(self) async def edit( self, @@ -149,7 +149,7 @@ async def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingChallengeTTL]: + ) -> Optional[ChallengeTTL]: """ Specify how long a visitor is allowed access to your site after successfully completing a challenge (such as a CAPTCHA). After the TTL has expired the @@ -182,7 +182,7 @@ async def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingChallengeTTL]], ResultWrapper[ZoneSettingChallengeTTL]), + cast_to=cast(Type[Optional[ChallengeTTL]], ResultWrapper[ChallengeTTL]), ) async def get( @@ -195,7 +195,7 @@ async def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingChallengeTTL]: + ) -> Optional[ChallengeTTL]: """ Specify how long a visitor is allowed access to your site after successfully completing a challenge (such as a CAPTCHA). After the TTL has expired the @@ -225,12 +225,12 @@ async def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingChallengeTTL]], ResultWrapper[ZoneSettingChallengeTTL]), + cast_to=cast(Type[Optional[ChallengeTTL]], ResultWrapper[ChallengeTTL]), ) -class ChallengeTTLWithRawResponse: - def __init__(self, challenge_ttl: ChallengeTTL) -> None: +class ChallengeTTLResourceWithRawResponse: + def __init__(self, challenge_ttl: ChallengeTTLResource) -> None: self._challenge_ttl = challenge_ttl self.edit = to_raw_response_wrapper( @@ -241,8 +241,8 @@ def __init__(self, challenge_ttl: ChallengeTTL) -> None: ) -class AsyncChallengeTTLWithRawResponse: - def __init__(self, challenge_ttl: AsyncChallengeTTL) -> None: +class AsyncChallengeTTLResourceWithRawResponse: + def __init__(self, challenge_ttl: AsyncChallengeTTLResource) -> None: self._challenge_ttl = challenge_ttl self.edit = async_to_raw_response_wrapper( @@ -253,8 +253,8 @@ def __init__(self, challenge_ttl: AsyncChallengeTTL) -> None: ) -class ChallengeTTLWithStreamingResponse: - def __init__(self, challenge_ttl: ChallengeTTL) -> None: +class ChallengeTTLResourceWithStreamingResponse: + def __init__(self, challenge_ttl: ChallengeTTLResource) -> None: self._challenge_ttl = challenge_ttl self.edit = to_streamed_response_wrapper( @@ -265,8 +265,8 @@ def __init__(self, challenge_ttl: ChallengeTTL) -> None: ) -class AsyncChallengeTTLWithStreamingResponse: - def __init__(self, challenge_ttl: AsyncChallengeTTL) -> None: +class AsyncChallengeTTLResourceWithStreamingResponse: + def __init__(self, challenge_ttl: AsyncChallengeTTLResource) -> None: self._challenge_ttl = challenge_ttl self.edit = async_to_streamed_response_wrapper( diff --git a/src/cloudflare/resources/zones/settings/ciphers.py b/src/cloudflare/resources/zones/settings/ciphers.py index 7a3ae57a9c66..362c72d02ccf 100644 --- a/src/cloudflare/resources/zones/settings/ciphers.py +++ b/src/cloudflare/resources/zones/settings/ciphers.py @@ -23,7 +23,7 @@ from ...._base_client import ( make_request_options, ) -from ....types.zones.settings import ZoneSettingCiphers, cipher_edit_params +from ....types.zones.settings import ciphers, cipher_edit_params __all__ = ["Ciphers", "AsyncCiphers"] @@ -48,7 +48,7 @@ def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingCiphers]: + ) -> Optional[ciphers.Ciphers]: """ Changes ciphers setting. @@ -77,7 +77,7 @@ def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingCiphers]], ResultWrapper[ZoneSettingCiphers]), + cast_to=cast(Type[Optional[ciphers.Ciphers]], ResultWrapper[ciphers.Ciphers]), ) def get( @@ -90,7 +90,7 @@ def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingCiphers]: + ) -> Optional[ciphers.Ciphers]: """ Gets ciphers setting. @@ -116,7 +116,7 @@ def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingCiphers]], ResultWrapper[ZoneSettingCiphers]), + cast_to=cast(Type[Optional[ciphers.Ciphers]], ResultWrapper[ciphers.Ciphers]), ) @@ -140,7 +140,7 @@ async def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingCiphers]: + ) -> Optional[ciphers.Ciphers]: """ Changes ciphers setting. @@ -169,7 +169,7 @@ async def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingCiphers]], ResultWrapper[ZoneSettingCiphers]), + cast_to=cast(Type[Optional[ciphers.Ciphers]], ResultWrapper[ciphers.Ciphers]), ) async def get( @@ -182,7 +182,7 @@ async def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingCiphers]: + ) -> Optional[ciphers.Ciphers]: """ Gets ciphers setting. @@ -208,7 +208,7 @@ async def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingCiphers]], ResultWrapper[ZoneSettingCiphers]), + cast_to=cast(Type[Optional[ciphers.Ciphers]], ResultWrapper[ciphers.Ciphers]), ) diff --git a/src/cloudflare/resources/zones/settings/development_mode.py b/src/cloudflare/resources/zones/settings/development_mode.py index a79b455bbb2a..63fb88ad36ae 100644 --- a/src/cloudflare/resources/zones/settings/development_mode.py +++ b/src/cloudflare/resources/zones/settings/development_mode.py @@ -24,19 +24,19 @@ from ...._base_client import ( make_request_options, ) -from ....types.zones.settings import ZoneSettingDevelopmentMode, development_mode_edit_params +from ....types.zones.settings import DevelopmentMode, development_mode_edit_params -__all__ = ["DevelopmentMode", "AsyncDevelopmentMode"] +__all__ = ["DevelopmentModeResource", "AsyncDevelopmentModeResource"] -class DevelopmentMode(SyncAPIResource): +class DevelopmentModeResource(SyncAPIResource): @cached_property - def with_raw_response(self) -> DevelopmentModeWithRawResponse: - return DevelopmentModeWithRawResponse(self) + def with_raw_response(self) -> DevelopmentModeResourceWithRawResponse: + return DevelopmentModeResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> DevelopmentModeWithStreamingResponse: - return DevelopmentModeWithStreamingResponse(self) + def with_streaming_response(self) -> DevelopmentModeResourceWithStreamingResponse: + return DevelopmentModeResourceWithStreamingResponse(self) def edit( self, @@ -49,7 +49,7 @@ def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingDevelopmentMode]: + ) -> Optional[DevelopmentMode]: """ Development Mode temporarily allows you to enter development mode for your websites if you need to make changes to your site. This will bypass Cloudflare's @@ -83,7 +83,7 @@ def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingDevelopmentMode]], ResultWrapper[ZoneSettingDevelopmentMode]), + cast_to=cast(Type[Optional[DevelopmentMode]], ResultWrapper[DevelopmentMode]), ) def get( @@ -96,7 +96,7 @@ def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingDevelopmentMode]: + ) -> Optional[DevelopmentMode]: """ Development Mode temporarily allows you to enter development mode for your websites if you need to make changes to your site. This will bypass Cloudflare's @@ -127,18 +127,18 @@ def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingDevelopmentMode]], ResultWrapper[ZoneSettingDevelopmentMode]), + cast_to=cast(Type[Optional[DevelopmentMode]], ResultWrapper[DevelopmentMode]), ) -class AsyncDevelopmentMode(AsyncAPIResource): +class AsyncDevelopmentModeResource(AsyncAPIResource): @cached_property - def with_raw_response(self) -> AsyncDevelopmentModeWithRawResponse: - return AsyncDevelopmentModeWithRawResponse(self) + def with_raw_response(self) -> AsyncDevelopmentModeResourceWithRawResponse: + return AsyncDevelopmentModeResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> AsyncDevelopmentModeWithStreamingResponse: - return AsyncDevelopmentModeWithStreamingResponse(self) + def with_streaming_response(self) -> AsyncDevelopmentModeResourceWithStreamingResponse: + return AsyncDevelopmentModeResourceWithStreamingResponse(self) async def edit( self, @@ -151,7 +151,7 @@ async def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingDevelopmentMode]: + ) -> Optional[DevelopmentMode]: """ Development Mode temporarily allows you to enter development mode for your websites if you need to make changes to your site. This will bypass Cloudflare's @@ -185,7 +185,7 @@ async def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingDevelopmentMode]], ResultWrapper[ZoneSettingDevelopmentMode]), + cast_to=cast(Type[Optional[DevelopmentMode]], ResultWrapper[DevelopmentMode]), ) async def get( @@ -198,7 +198,7 @@ async def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingDevelopmentMode]: + ) -> Optional[DevelopmentMode]: """ Development Mode temporarily allows you to enter development mode for your websites if you need to make changes to your site. This will bypass Cloudflare's @@ -229,12 +229,12 @@ async def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingDevelopmentMode]], ResultWrapper[ZoneSettingDevelopmentMode]), + cast_to=cast(Type[Optional[DevelopmentMode]], ResultWrapper[DevelopmentMode]), ) -class DevelopmentModeWithRawResponse: - def __init__(self, development_mode: DevelopmentMode) -> None: +class DevelopmentModeResourceWithRawResponse: + def __init__(self, development_mode: DevelopmentModeResource) -> None: self._development_mode = development_mode self.edit = to_raw_response_wrapper( @@ -245,8 +245,8 @@ def __init__(self, development_mode: DevelopmentMode) -> None: ) -class AsyncDevelopmentModeWithRawResponse: - def __init__(self, development_mode: AsyncDevelopmentMode) -> None: +class AsyncDevelopmentModeResourceWithRawResponse: + def __init__(self, development_mode: AsyncDevelopmentModeResource) -> None: self._development_mode = development_mode self.edit = async_to_raw_response_wrapper( @@ -257,8 +257,8 @@ def __init__(self, development_mode: AsyncDevelopmentMode) -> None: ) -class DevelopmentModeWithStreamingResponse: - def __init__(self, development_mode: DevelopmentMode) -> None: +class DevelopmentModeResourceWithStreamingResponse: + def __init__(self, development_mode: DevelopmentModeResource) -> None: self._development_mode = development_mode self.edit = to_streamed_response_wrapper( @@ -269,8 +269,8 @@ def __init__(self, development_mode: DevelopmentMode) -> None: ) -class AsyncDevelopmentModeWithStreamingResponse: - def __init__(self, development_mode: AsyncDevelopmentMode) -> None: +class AsyncDevelopmentModeResourceWithStreamingResponse: + def __init__(self, development_mode: AsyncDevelopmentModeResource) -> None: self._development_mode = development_mode self.edit = async_to_streamed_response_wrapper( diff --git a/src/cloudflare/resources/zones/settings/early_hints.py b/src/cloudflare/resources/zones/settings/early_hints.py index d4b971bdf171..ce86734a4c24 100644 --- a/src/cloudflare/resources/zones/settings/early_hints.py +++ b/src/cloudflare/resources/zones/settings/early_hints.py @@ -24,7 +24,7 @@ from ...._base_client import ( make_request_options, ) -from ....types.zones.settings import ZoneSettingEarlyHints, early_hint_edit_params +from ....types.zones.settings import early_hints, early_hint_edit_params __all__ = ["EarlyHints", "AsyncEarlyHints"] @@ -49,7 +49,7 @@ def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingEarlyHints]: + ) -> Optional[early_hints.EarlyHints]: """ When enabled, Cloudflare will attempt to speed up overall page loads by serving `103` responses with `Link` headers from the final response. Refer to @@ -81,7 +81,7 @@ def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingEarlyHints]], ResultWrapper[ZoneSettingEarlyHints]), + cast_to=cast(Type[Optional[early_hints.EarlyHints]], ResultWrapper[early_hints.EarlyHints]), ) def get( @@ -94,7 +94,7 @@ def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingEarlyHints]: + ) -> Optional[early_hints.EarlyHints]: """ When enabled, Cloudflare will attempt to speed up overall page loads by serving `103` responses with `Link` headers from the final response. Refer to @@ -123,7 +123,7 @@ def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingEarlyHints]], ResultWrapper[ZoneSettingEarlyHints]), + cast_to=cast(Type[Optional[early_hints.EarlyHints]], ResultWrapper[early_hints.EarlyHints]), ) @@ -147,7 +147,7 @@ async def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingEarlyHints]: + ) -> Optional[early_hints.EarlyHints]: """ When enabled, Cloudflare will attempt to speed up overall page loads by serving `103` responses with `Link` headers from the final response. Refer to @@ -179,7 +179,7 @@ async def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingEarlyHints]], ResultWrapper[ZoneSettingEarlyHints]), + cast_to=cast(Type[Optional[early_hints.EarlyHints]], ResultWrapper[early_hints.EarlyHints]), ) async def get( @@ -192,7 +192,7 @@ async def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingEarlyHints]: + ) -> Optional[early_hints.EarlyHints]: """ When enabled, Cloudflare will attempt to speed up overall page loads by serving `103` responses with `Link` headers from the final response. Refer to @@ -221,7 +221,7 @@ async def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingEarlyHints]], ResultWrapper[ZoneSettingEarlyHints]), + cast_to=cast(Type[Optional[early_hints.EarlyHints]], ResultWrapper[early_hints.EarlyHints]), ) diff --git a/src/cloudflare/resources/zones/settings/email_obfuscation.py b/src/cloudflare/resources/zones/settings/email_obfuscation.py index 2e544bb44af0..4d2b7c65f72e 100644 --- a/src/cloudflare/resources/zones/settings/email_obfuscation.py +++ b/src/cloudflare/resources/zones/settings/email_obfuscation.py @@ -24,19 +24,19 @@ from ...._base_client import ( make_request_options, ) -from ....types.zones.settings import ZoneSettingEmailObfuscation, email_obfuscation_edit_params +from ....types.zones.settings import EmailObfuscation, email_obfuscation_edit_params -__all__ = ["EmailObfuscation", "AsyncEmailObfuscation"] +__all__ = ["EmailObfuscationResource", "AsyncEmailObfuscationResource"] -class EmailObfuscation(SyncAPIResource): +class EmailObfuscationResource(SyncAPIResource): @cached_property - def with_raw_response(self) -> EmailObfuscationWithRawResponse: - return EmailObfuscationWithRawResponse(self) + def with_raw_response(self) -> EmailObfuscationResourceWithRawResponse: + return EmailObfuscationResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> EmailObfuscationWithStreamingResponse: - return EmailObfuscationWithStreamingResponse(self) + def with_streaming_response(self) -> EmailObfuscationResourceWithStreamingResponse: + return EmailObfuscationResourceWithStreamingResponse(self) def edit( self, @@ -49,7 +49,7 @@ def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingEmailObfuscation]: + ) -> Optional[EmailObfuscation]: """ Encrypt email adresses on your web page from bots, while keeping them visible to humans. (https://support.cloudflare.com/hc/en-us/articles/200170016). @@ -79,7 +79,7 @@ def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingEmailObfuscation]], ResultWrapper[ZoneSettingEmailObfuscation]), + cast_to=cast(Type[Optional[EmailObfuscation]], ResultWrapper[EmailObfuscation]), ) def get( @@ -92,7 +92,7 @@ def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingEmailObfuscation]: + ) -> Optional[EmailObfuscation]: """ Encrypt email adresses on your web page from bots, while keeping them visible to humans. (https://support.cloudflare.com/hc/en-us/articles/200170016). @@ -119,18 +119,18 @@ def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingEmailObfuscation]], ResultWrapper[ZoneSettingEmailObfuscation]), + cast_to=cast(Type[Optional[EmailObfuscation]], ResultWrapper[EmailObfuscation]), ) -class AsyncEmailObfuscation(AsyncAPIResource): +class AsyncEmailObfuscationResource(AsyncAPIResource): @cached_property - def with_raw_response(self) -> AsyncEmailObfuscationWithRawResponse: - return AsyncEmailObfuscationWithRawResponse(self) + def with_raw_response(self) -> AsyncEmailObfuscationResourceWithRawResponse: + return AsyncEmailObfuscationResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> AsyncEmailObfuscationWithStreamingResponse: - return AsyncEmailObfuscationWithStreamingResponse(self) + def with_streaming_response(self) -> AsyncEmailObfuscationResourceWithStreamingResponse: + return AsyncEmailObfuscationResourceWithStreamingResponse(self) async def edit( self, @@ -143,7 +143,7 @@ async def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingEmailObfuscation]: + ) -> Optional[EmailObfuscation]: """ Encrypt email adresses on your web page from bots, while keeping them visible to humans. (https://support.cloudflare.com/hc/en-us/articles/200170016). @@ -175,7 +175,7 @@ async def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingEmailObfuscation]], ResultWrapper[ZoneSettingEmailObfuscation]), + cast_to=cast(Type[Optional[EmailObfuscation]], ResultWrapper[EmailObfuscation]), ) async def get( @@ -188,7 +188,7 @@ async def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingEmailObfuscation]: + ) -> Optional[EmailObfuscation]: """ Encrypt email adresses on your web page from bots, while keeping them visible to humans. (https://support.cloudflare.com/hc/en-us/articles/200170016). @@ -215,12 +215,12 @@ async def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingEmailObfuscation]], ResultWrapper[ZoneSettingEmailObfuscation]), + cast_to=cast(Type[Optional[EmailObfuscation]], ResultWrapper[EmailObfuscation]), ) -class EmailObfuscationWithRawResponse: - def __init__(self, email_obfuscation: EmailObfuscation) -> None: +class EmailObfuscationResourceWithRawResponse: + def __init__(self, email_obfuscation: EmailObfuscationResource) -> None: self._email_obfuscation = email_obfuscation self.edit = to_raw_response_wrapper( @@ -231,8 +231,8 @@ def __init__(self, email_obfuscation: EmailObfuscation) -> None: ) -class AsyncEmailObfuscationWithRawResponse: - def __init__(self, email_obfuscation: AsyncEmailObfuscation) -> None: +class AsyncEmailObfuscationResourceWithRawResponse: + def __init__(self, email_obfuscation: AsyncEmailObfuscationResource) -> None: self._email_obfuscation = email_obfuscation self.edit = async_to_raw_response_wrapper( @@ -243,8 +243,8 @@ def __init__(self, email_obfuscation: AsyncEmailObfuscation) -> None: ) -class EmailObfuscationWithStreamingResponse: - def __init__(self, email_obfuscation: EmailObfuscation) -> None: +class EmailObfuscationResourceWithStreamingResponse: + def __init__(self, email_obfuscation: EmailObfuscationResource) -> None: self._email_obfuscation = email_obfuscation self.edit = to_streamed_response_wrapper( @@ -255,8 +255,8 @@ def __init__(self, email_obfuscation: EmailObfuscation) -> None: ) -class AsyncEmailObfuscationWithStreamingResponse: - def __init__(self, email_obfuscation: AsyncEmailObfuscation) -> None: +class AsyncEmailObfuscationResourceWithStreamingResponse: + def __init__(self, email_obfuscation: AsyncEmailObfuscationResource) -> None: self._email_obfuscation = email_obfuscation self.edit = async_to_streamed_response_wrapper( diff --git a/src/cloudflare/resources/zones/settings/font_settings.py b/src/cloudflare/resources/zones/settings/font_settings.py index 301bb27d686e..598592a7d065 100644 --- a/src/cloudflare/resources/zones/settings/font_settings.py +++ b/src/cloudflare/resources/zones/settings/font_settings.py @@ -24,7 +24,7 @@ from ...._base_client import ( make_request_options, ) -from ....types.zones.settings import ZoneSettingFonts, font_setting_edit_params +from ....types.zones.settings import font_settings, font_setting_edit_params __all__ = ["FontSettings", "AsyncFontSettings"] @@ -49,7 +49,7 @@ def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingFonts]: + ) -> Optional[font_settings.FontSettings]: """Enhance your website's font delivery with Cloudflare Fonts. Deliver Google @@ -81,7 +81,7 @@ def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingFonts]], ResultWrapper[ZoneSettingFonts]), + cast_to=cast(Type[Optional[font_settings.FontSettings]], ResultWrapper[font_settings.FontSettings]), ) def get( @@ -94,7 +94,7 @@ def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingFonts]: + ) -> Optional[font_settings.FontSettings]: """Enhance your website's font delivery with Cloudflare Fonts. Deliver Google @@ -123,7 +123,7 @@ def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingFonts]], ResultWrapper[ZoneSettingFonts]), + cast_to=cast(Type[Optional[font_settings.FontSettings]], ResultWrapper[font_settings.FontSettings]), ) @@ -147,7 +147,7 @@ async def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingFonts]: + ) -> Optional[font_settings.FontSettings]: """Enhance your website's font delivery with Cloudflare Fonts. Deliver Google @@ -179,7 +179,7 @@ async def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingFonts]], ResultWrapper[ZoneSettingFonts]), + cast_to=cast(Type[Optional[font_settings.FontSettings]], ResultWrapper[font_settings.FontSettings]), ) async def get( @@ -192,7 +192,7 @@ async def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingFonts]: + ) -> Optional[font_settings.FontSettings]: """Enhance your website's font delivery with Cloudflare Fonts. Deliver Google @@ -221,7 +221,7 @@ async def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingFonts]], ResultWrapper[ZoneSettingFonts]), + cast_to=cast(Type[Optional[font_settings.FontSettings]], ResultWrapper[font_settings.FontSettings]), ) diff --git a/src/cloudflare/resources/zones/settings/h2_prioritization.py b/src/cloudflare/resources/zones/settings/h2_prioritization.py index 6b571b0dcd10..cf597d7a65f1 100644 --- a/src/cloudflare/resources/zones/settings/h2_prioritization.py +++ b/src/cloudflare/resources/zones/settings/h2_prioritization.py @@ -23,36 +23,32 @@ from ...._base_client import ( make_request_options, ) -from ....types.zones.settings import ( - ZoneSettingH2Prioritization, - ZoneSettingH2PrioritizationParam, - h2_prioritization_edit_params, -) +from ....types.zones.settings import H2Prioritization, H2PrioritizationParam, h2_prioritization_edit_params -__all__ = ["H2Prioritization", "AsyncH2Prioritization"] +__all__ = ["H2PrioritizationResource", "AsyncH2PrioritizationResource"] -class H2Prioritization(SyncAPIResource): +class H2PrioritizationResource(SyncAPIResource): @cached_property - def with_raw_response(self) -> H2PrioritizationWithRawResponse: - return H2PrioritizationWithRawResponse(self) + def with_raw_response(self) -> H2PrioritizationResourceWithRawResponse: + return H2PrioritizationResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> H2PrioritizationWithStreamingResponse: - return H2PrioritizationWithStreamingResponse(self) + def with_streaming_response(self) -> H2PrioritizationResourceWithStreamingResponse: + return H2PrioritizationResourceWithStreamingResponse(self) def edit( self, *, zone_id: str, - value: ZoneSettingH2PrioritizationParam, + value: H2PrioritizationParam, # 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[ZoneSettingH2Prioritization]: + ) -> Optional[H2Prioritization]: """ Gets HTTP/2 Edge Prioritization setting. @@ -83,7 +79,7 @@ def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingH2Prioritization]], ResultWrapper[ZoneSettingH2Prioritization]), + cast_to=cast(Type[Optional[H2Prioritization]], ResultWrapper[H2Prioritization]), ) def get( @@ -96,7 +92,7 @@ def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingH2Prioritization]: + ) -> Optional[H2Prioritization]: """ Gets HTTP/2 Edge Prioritization setting. @@ -122,31 +118,31 @@ def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingH2Prioritization]], ResultWrapper[ZoneSettingH2Prioritization]), + cast_to=cast(Type[Optional[H2Prioritization]], ResultWrapper[H2Prioritization]), ) -class AsyncH2Prioritization(AsyncAPIResource): +class AsyncH2PrioritizationResource(AsyncAPIResource): @cached_property - def with_raw_response(self) -> AsyncH2PrioritizationWithRawResponse: - return AsyncH2PrioritizationWithRawResponse(self) + def with_raw_response(self) -> AsyncH2PrioritizationResourceWithRawResponse: + return AsyncH2PrioritizationResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> AsyncH2PrioritizationWithStreamingResponse: - return AsyncH2PrioritizationWithStreamingResponse(self) + def with_streaming_response(self) -> AsyncH2PrioritizationResourceWithStreamingResponse: + return AsyncH2PrioritizationResourceWithStreamingResponse(self) async def edit( self, *, zone_id: str, - value: ZoneSettingH2PrioritizationParam, + value: H2PrioritizationParam, # 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[ZoneSettingH2Prioritization]: + ) -> Optional[H2Prioritization]: """ Gets HTTP/2 Edge Prioritization setting. @@ -179,7 +175,7 @@ async def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingH2Prioritization]], ResultWrapper[ZoneSettingH2Prioritization]), + cast_to=cast(Type[Optional[H2Prioritization]], ResultWrapper[H2Prioritization]), ) async def get( @@ -192,7 +188,7 @@ async def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingH2Prioritization]: + ) -> Optional[H2Prioritization]: """ Gets HTTP/2 Edge Prioritization setting. @@ -218,12 +214,12 @@ async def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingH2Prioritization]], ResultWrapper[ZoneSettingH2Prioritization]), + cast_to=cast(Type[Optional[H2Prioritization]], ResultWrapper[H2Prioritization]), ) -class H2PrioritizationWithRawResponse: - def __init__(self, h2_prioritization: H2Prioritization) -> None: +class H2PrioritizationResourceWithRawResponse: + def __init__(self, h2_prioritization: H2PrioritizationResource) -> None: self._h2_prioritization = h2_prioritization self.edit = to_raw_response_wrapper( @@ -234,8 +230,8 @@ def __init__(self, h2_prioritization: H2Prioritization) -> None: ) -class AsyncH2PrioritizationWithRawResponse: - def __init__(self, h2_prioritization: AsyncH2Prioritization) -> None: +class AsyncH2PrioritizationResourceWithRawResponse: + def __init__(self, h2_prioritization: AsyncH2PrioritizationResource) -> None: self._h2_prioritization = h2_prioritization self.edit = async_to_raw_response_wrapper( @@ -246,8 +242,8 @@ def __init__(self, h2_prioritization: AsyncH2Prioritization) -> None: ) -class H2PrioritizationWithStreamingResponse: - def __init__(self, h2_prioritization: H2Prioritization) -> None: +class H2PrioritizationResourceWithStreamingResponse: + def __init__(self, h2_prioritization: H2PrioritizationResource) -> None: self._h2_prioritization = h2_prioritization self.edit = to_streamed_response_wrapper( @@ -258,8 +254,8 @@ def __init__(self, h2_prioritization: H2Prioritization) -> None: ) -class AsyncH2PrioritizationWithStreamingResponse: - def __init__(self, h2_prioritization: AsyncH2Prioritization) -> None: +class AsyncH2PrioritizationResourceWithStreamingResponse: + def __init__(self, h2_prioritization: AsyncH2PrioritizationResource) -> None: self._h2_prioritization = h2_prioritization self.edit = async_to_streamed_response_wrapper( diff --git a/src/cloudflare/resources/zones/settings/hotlink_protection.py b/src/cloudflare/resources/zones/settings/hotlink_protection.py index aa71c4eb57bd..d20128da732a 100644 --- a/src/cloudflare/resources/zones/settings/hotlink_protection.py +++ b/src/cloudflare/resources/zones/settings/hotlink_protection.py @@ -24,19 +24,19 @@ from ...._base_client import ( make_request_options, ) -from ....types.zones.settings import ZoneSettingHotlinkProtection, hotlink_protection_edit_params +from ....types.zones.settings import HotlinkProtection, hotlink_protection_edit_params -__all__ = ["HotlinkProtection", "AsyncHotlinkProtection"] +__all__ = ["HotlinkProtectionResource", "AsyncHotlinkProtectionResource"] -class HotlinkProtection(SyncAPIResource): +class HotlinkProtectionResource(SyncAPIResource): @cached_property - def with_raw_response(self) -> HotlinkProtectionWithRawResponse: - return HotlinkProtectionWithRawResponse(self) + def with_raw_response(self) -> HotlinkProtectionResourceWithRawResponse: + return HotlinkProtectionResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> HotlinkProtectionWithStreamingResponse: - return HotlinkProtectionWithStreamingResponse(self) + def with_streaming_response(self) -> HotlinkProtectionResourceWithStreamingResponse: + return HotlinkProtectionResourceWithStreamingResponse(self) def edit( self, @@ -49,7 +49,7 @@ def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingHotlinkProtection]: + ) -> Optional[HotlinkProtection]: """ When enabled, the Hotlink Protection option ensures that other sites cannot suck up your bandwidth by building pages that use images hosted on your site. Anytime @@ -84,7 +84,7 @@ def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingHotlinkProtection]], ResultWrapper[ZoneSettingHotlinkProtection]), + cast_to=cast(Type[Optional[HotlinkProtection]], ResultWrapper[HotlinkProtection]), ) def get( @@ -97,7 +97,7 @@ def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingHotlinkProtection]: + ) -> Optional[HotlinkProtection]: """ When enabled, the Hotlink Protection option ensures that other sites cannot suck up your bandwidth by building pages that use images hosted on your site. Anytime @@ -129,18 +129,18 @@ def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingHotlinkProtection]], ResultWrapper[ZoneSettingHotlinkProtection]), + cast_to=cast(Type[Optional[HotlinkProtection]], ResultWrapper[HotlinkProtection]), ) -class AsyncHotlinkProtection(AsyncAPIResource): +class AsyncHotlinkProtectionResource(AsyncAPIResource): @cached_property - def with_raw_response(self) -> AsyncHotlinkProtectionWithRawResponse: - return AsyncHotlinkProtectionWithRawResponse(self) + def with_raw_response(self) -> AsyncHotlinkProtectionResourceWithRawResponse: + return AsyncHotlinkProtectionResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> AsyncHotlinkProtectionWithStreamingResponse: - return AsyncHotlinkProtectionWithStreamingResponse(self) + def with_streaming_response(self) -> AsyncHotlinkProtectionResourceWithStreamingResponse: + return AsyncHotlinkProtectionResourceWithStreamingResponse(self) async def edit( self, @@ -153,7 +153,7 @@ async def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingHotlinkProtection]: + ) -> Optional[HotlinkProtection]: """ When enabled, the Hotlink Protection option ensures that other sites cannot suck up your bandwidth by building pages that use images hosted on your site. Anytime @@ -190,7 +190,7 @@ async def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingHotlinkProtection]], ResultWrapper[ZoneSettingHotlinkProtection]), + cast_to=cast(Type[Optional[HotlinkProtection]], ResultWrapper[HotlinkProtection]), ) async def get( @@ -203,7 +203,7 @@ async def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingHotlinkProtection]: + ) -> Optional[HotlinkProtection]: """ When enabled, the Hotlink Protection option ensures that other sites cannot suck up your bandwidth by building pages that use images hosted on your site. Anytime @@ -235,12 +235,12 @@ async def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingHotlinkProtection]], ResultWrapper[ZoneSettingHotlinkProtection]), + cast_to=cast(Type[Optional[HotlinkProtection]], ResultWrapper[HotlinkProtection]), ) -class HotlinkProtectionWithRawResponse: - def __init__(self, hotlink_protection: HotlinkProtection) -> None: +class HotlinkProtectionResourceWithRawResponse: + def __init__(self, hotlink_protection: HotlinkProtectionResource) -> None: self._hotlink_protection = hotlink_protection self.edit = to_raw_response_wrapper( @@ -251,8 +251,8 @@ def __init__(self, hotlink_protection: HotlinkProtection) -> None: ) -class AsyncHotlinkProtectionWithRawResponse: - def __init__(self, hotlink_protection: AsyncHotlinkProtection) -> None: +class AsyncHotlinkProtectionResourceWithRawResponse: + def __init__(self, hotlink_protection: AsyncHotlinkProtectionResource) -> None: self._hotlink_protection = hotlink_protection self.edit = async_to_raw_response_wrapper( @@ -263,8 +263,8 @@ def __init__(self, hotlink_protection: AsyncHotlinkProtection) -> None: ) -class HotlinkProtectionWithStreamingResponse: - def __init__(self, hotlink_protection: HotlinkProtection) -> None: +class HotlinkProtectionResourceWithStreamingResponse: + def __init__(self, hotlink_protection: HotlinkProtectionResource) -> None: self._hotlink_protection = hotlink_protection self.edit = to_streamed_response_wrapper( @@ -275,8 +275,8 @@ def __init__(self, hotlink_protection: HotlinkProtection) -> None: ) -class AsyncHotlinkProtectionWithStreamingResponse: - def __init__(self, hotlink_protection: AsyncHotlinkProtection) -> None: +class AsyncHotlinkProtectionResourceWithStreamingResponse: + def __init__(self, hotlink_protection: AsyncHotlinkProtectionResource) -> None: self._hotlink_protection = hotlink_protection self.edit = async_to_streamed_response_wrapper( diff --git a/src/cloudflare/resources/zones/settings/http2.py b/src/cloudflare/resources/zones/settings/http2.py index 0fd5bd4100db..e9db222c88a1 100644 --- a/src/cloudflare/resources/zones/settings/http2.py +++ b/src/cloudflare/resources/zones/settings/http2.py @@ -24,19 +24,19 @@ from ...._base_client import ( make_request_options, ) -from ....types.zones.settings import ZoneSettingHTTP2, http2_edit_params +from ....types.zones.settings import HTTP2, http2_edit_params -__all__ = ["HTTP2", "AsyncHTTP2"] +__all__ = ["HTTP2Resource", "AsyncHTTP2Resource"] -class HTTP2(SyncAPIResource): +class HTTP2Resource(SyncAPIResource): @cached_property - def with_raw_response(self) -> HTTP2WithRawResponse: - return HTTP2WithRawResponse(self) + def with_raw_response(self) -> HTTP2ResourceWithRawResponse: + return HTTP2ResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> HTTP2WithStreamingResponse: - return HTTP2WithStreamingResponse(self) + def with_streaming_response(self) -> HTTP2ResourceWithStreamingResponse: + return HTTP2ResourceWithStreamingResponse(self) def edit( self, @@ -49,7 +49,7 @@ def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingHTTP2]: + ) -> Optional[HTTP2]: """ Value of the HTTP2 setting. @@ -78,7 +78,7 @@ def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingHTTP2]], ResultWrapper[ZoneSettingHTTP2]), + cast_to=cast(Type[Optional[HTTP2]], ResultWrapper[HTTP2]), ) def get( @@ -91,7 +91,7 @@ def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingHTTP2]: + ) -> Optional[HTTP2]: """ Value of the HTTP2 setting. @@ -117,18 +117,18 @@ def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingHTTP2]], ResultWrapper[ZoneSettingHTTP2]), + cast_to=cast(Type[Optional[HTTP2]], ResultWrapper[HTTP2]), ) -class AsyncHTTP2(AsyncAPIResource): +class AsyncHTTP2Resource(AsyncAPIResource): @cached_property - def with_raw_response(self) -> AsyncHTTP2WithRawResponse: - return AsyncHTTP2WithRawResponse(self) + def with_raw_response(self) -> AsyncHTTP2ResourceWithRawResponse: + return AsyncHTTP2ResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> AsyncHTTP2WithStreamingResponse: - return AsyncHTTP2WithStreamingResponse(self) + def with_streaming_response(self) -> AsyncHTTP2ResourceWithStreamingResponse: + return AsyncHTTP2ResourceWithStreamingResponse(self) async def edit( self, @@ -141,7 +141,7 @@ async def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingHTTP2]: + ) -> Optional[HTTP2]: """ Value of the HTTP2 setting. @@ -170,7 +170,7 @@ async def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingHTTP2]], ResultWrapper[ZoneSettingHTTP2]), + cast_to=cast(Type[Optional[HTTP2]], ResultWrapper[HTTP2]), ) async def get( @@ -183,7 +183,7 @@ async def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingHTTP2]: + ) -> Optional[HTTP2]: """ Value of the HTTP2 setting. @@ -209,12 +209,12 @@ async def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingHTTP2]], ResultWrapper[ZoneSettingHTTP2]), + cast_to=cast(Type[Optional[HTTP2]], ResultWrapper[HTTP2]), ) -class HTTP2WithRawResponse: - def __init__(self, http2: HTTP2) -> None: +class HTTP2ResourceWithRawResponse: + def __init__(self, http2: HTTP2Resource) -> None: self._http2 = http2 self.edit = to_raw_response_wrapper( @@ -225,8 +225,8 @@ def __init__(self, http2: HTTP2) -> None: ) -class AsyncHTTP2WithRawResponse: - def __init__(self, http2: AsyncHTTP2) -> None: +class AsyncHTTP2ResourceWithRawResponse: + def __init__(self, http2: AsyncHTTP2Resource) -> None: self._http2 = http2 self.edit = async_to_raw_response_wrapper( @@ -237,8 +237,8 @@ def __init__(self, http2: AsyncHTTP2) -> None: ) -class HTTP2WithStreamingResponse: - def __init__(self, http2: HTTP2) -> None: +class HTTP2ResourceWithStreamingResponse: + def __init__(self, http2: HTTP2Resource) -> None: self._http2 = http2 self.edit = to_streamed_response_wrapper( @@ -249,8 +249,8 @@ def __init__(self, http2: HTTP2) -> None: ) -class AsyncHTTP2WithStreamingResponse: - def __init__(self, http2: AsyncHTTP2) -> None: +class AsyncHTTP2ResourceWithStreamingResponse: + def __init__(self, http2: AsyncHTTP2Resource) -> None: self._http2 = http2 self.edit = async_to_streamed_response_wrapper( diff --git a/src/cloudflare/resources/zones/settings/http3.py b/src/cloudflare/resources/zones/settings/http3.py index 3ce7c57c1ebd..08f99c42680b 100644 --- a/src/cloudflare/resources/zones/settings/http3.py +++ b/src/cloudflare/resources/zones/settings/http3.py @@ -24,19 +24,19 @@ from ...._base_client import ( make_request_options, ) -from ....types.zones.settings import ZoneSettingHTTP3, http3_edit_params +from ....types.zones.settings import HTTP3, http3_edit_params -__all__ = ["HTTP3", "AsyncHTTP3"] +__all__ = ["HTTP3Resource", "AsyncHTTP3Resource"] -class HTTP3(SyncAPIResource): +class HTTP3Resource(SyncAPIResource): @cached_property - def with_raw_response(self) -> HTTP3WithRawResponse: - return HTTP3WithRawResponse(self) + def with_raw_response(self) -> HTTP3ResourceWithRawResponse: + return HTTP3ResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> HTTP3WithStreamingResponse: - return HTTP3WithStreamingResponse(self) + def with_streaming_response(self) -> HTTP3ResourceWithStreamingResponse: + return HTTP3ResourceWithStreamingResponse(self) def edit( self, @@ -49,7 +49,7 @@ def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingHTTP3]: + ) -> Optional[HTTP3]: """ Value of the HTTP3 setting. @@ -78,7 +78,7 @@ def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingHTTP3]], ResultWrapper[ZoneSettingHTTP3]), + cast_to=cast(Type[Optional[HTTP3]], ResultWrapper[HTTP3]), ) def get( @@ -91,7 +91,7 @@ def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingHTTP3]: + ) -> Optional[HTTP3]: """ Value of the HTTP3 setting. @@ -117,18 +117,18 @@ def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingHTTP3]], ResultWrapper[ZoneSettingHTTP3]), + cast_to=cast(Type[Optional[HTTP3]], ResultWrapper[HTTP3]), ) -class AsyncHTTP3(AsyncAPIResource): +class AsyncHTTP3Resource(AsyncAPIResource): @cached_property - def with_raw_response(self) -> AsyncHTTP3WithRawResponse: - return AsyncHTTP3WithRawResponse(self) + def with_raw_response(self) -> AsyncHTTP3ResourceWithRawResponse: + return AsyncHTTP3ResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> AsyncHTTP3WithStreamingResponse: - return AsyncHTTP3WithStreamingResponse(self) + def with_streaming_response(self) -> AsyncHTTP3ResourceWithStreamingResponse: + return AsyncHTTP3ResourceWithStreamingResponse(self) async def edit( self, @@ -141,7 +141,7 @@ async def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingHTTP3]: + ) -> Optional[HTTP3]: """ Value of the HTTP3 setting. @@ -170,7 +170,7 @@ async def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingHTTP3]], ResultWrapper[ZoneSettingHTTP3]), + cast_to=cast(Type[Optional[HTTP3]], ResultWrapper[HTTP3]), ) async def get( @@ -183,7 +183,7 @@ async def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingHTTP3]: + ) -> Optional[HTTP3]: """ Value of the HTTP3 setting. @@ -209,12 +209,12 @@ async def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingHTTP3]], ResultWrapper[ZoneSettingHTTP3]), + cast_to=cast(Type[Optional[HTTP3]], ResultWrapper[HTTP3]), ) -class HTTP3WithRawResponse: - def __init__(self, http3: HTTP3) -> None: +class HTTP3ResourceWithRawResponse: + def __init__(self, http3: HTTP3Resource) -> None: self._http3 = http3 self.edit = to_raw_response_wrapper( @@ -225,8 +225,8 @@ def __init__(self, http3: HTTP3) -> None: ) -class AsyncHTTP3WithRawResponse: - def __init__(self, http3: AsyncHTTP3) -> None: +class AsyncHTTP3ResourceWithRawResponse: + def __init__(self, http3: AsyncHTTP3Resource) -> None: self._http3 = http3 self.edit = async_to_raw_response_wrapper( @@ -237,8 +237,8 @@ def __init__(self, http3: AsyncHTTP3) -> None: ) -class HTTP3WithStreamingResponse: - def __init__(self, http3: HTTP3) -> None: +class HTTP3ResourceWithStreamingResponse: + def __init__(self, http3: HTTP3Resource) -> None: self._http3 = http3 self.edit = to_streamed_response_wrapper( @@ -249,8 +249,8 @@ def __init__(self, http3: HTTP3) -> None: ) -class AsyncHTTP3WithStreamingResponse: - def __init__(self, http3: AsyncHTTP3) -> None: +class AsyncHTTP3ResourceWithStreamingResponse: + def __init__(self, http3: AsyncHTTP3Resource) -> None: self._http3 = http3 self.edit = async_to_streamed_response_wrapper( diff --git a/src/cloudflare/resources/zones/settings/image_resizing.py b/src/cloudflare/resources/zones/settings/image_resizing.py index 3b3a9f888c32..2cdd75277548 100644 --- a/src/cloudflare/resources/zones/settings/image_resizing.py +++ b/src/cloudflare/resources/zones/settings/image_resizing.py @@ -23,32 +23,32 @@ from ...._base_client import ( make_request_options, ) -from ....types.zones.settings import ZoneSettingImageResizing, ZoneSettingImageResizingParam, image_resizing_edit_params +from ....types.zones.settings import ImageResizing, ImageResizingParam, image_resizing_edit_params -__all__ = ["ImageResizing", "AsyncImageResizing"] +__all__ = ["ImageResizingResource", "AsyncImageResizingResource"] -class ImageResizing(SyncAPIResource): +class ImageResizingResource(SyncAPIResource): @cached_property - def with_raw_response(self) -> ImageResizingWithRawResponse: - return ImageResizingWithRawResponse(self) + def with_raw_response(self) -> ImageResizingResourceWithRawResponse: + return ImageResizingResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> ImageResizingWithStreamingResponse: - return ImageResizingWithStreamingResponse(self) + def with_streaming_response(self) -> ImageResizingResourceWithStreamingResponse: + return ImageResizingResourceWithStreamingResponse(self) def edit( self, *, zone_id: str, - value: ZoneSettingImageResizingParam, + value: ImageResizingParam, # 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[ZoneSettingImageResizing]: + ) -> Optional[ImageResizing]: """ Image Resizing provides on-demand resizing, conversion and optimisation for images served through Cloudflare's network. Refer to the @@ -83,7 +83,7 @@ def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingImageResizing]], ResultWrapper[ZoneSettingImageResizing]), + cast_to=cast(Type[Optional[ImageResizing]], ResultWrapper[ImageResizing]), ) def get( @@ -96,7 +96,7 @@ def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingImageResizing]: + ) -> Optional[ImageResizing]: """ Image Resizing provides on-demand resizing, conversion and optimisation for images served through Cloudflare's network. Refer to the @@ -125,31 +125,31 @@ def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingImageResizing]], ResultWrapper[ZoneSettingImageResizing]), + cast_to=cast(Type[Optional[ImageResizing]], ResultWrapper[ImageResizing]), ) -class AsyncImageResizing(AsyncAPIResource): +class AsyncImageResizingResource(AsyncAPIResource): @cached_property - def with_raw_response(self) -> AsyncImageResizingWithRawResponse: - return AsyncImageResizingWithRawResponse(self) + def with_raw_response(self) -> AsyncImageResizingResourceWithRawResponse: + return AsyncImageResizingResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> AsyncImageResizingWithStreamingResponse: - return AsyncImageResizingWithStreamingResponse(self) + def with_streaming_response(self) -> AsyncImageResizingResourceWithStreamingResponse: + return AsyncImageResizingResourceWithStreamingResponse(self) async def edit( self, *, zone_id: str, - value: ZoneSettingImageResizingParam, + value: ImageResizingParam, # 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[ZoneSettingImageResizing]: + ) -> Optional[ImageResizing]: """ Image Resizing provides on-demand resizing, conversion and optimisation for images served through Cloudflare's network. Refer to the @@ -184,7 +184,7 @@ async def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingImageResizing]], ResultWrapper[ZoneSettingImageResizing]), + cast_to=cast(Type[Optional[ImageResizing]], ResultWrapper[ImageResizing]), ) async def get( @@ -197,7 +197,7 @@ async def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingImageResizing]: + ) -> Optional[ImageResizing]: """ Image Resizing provides on-demand resizing, conversion and optimisation for images served through Cloudflare's network. Refer to the @@ -226,12 +226,12 @@ async def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingImageResizing]], ResultWrapper[ZoneSettingImageResizing]), + cast_to=cast(Type[Optional[ImageResizing]], ResultWrapper[ImageResizing]), ) -class ImageResizingWithRawResponse: - def __init__(self, image_resizing: ImageResizing) -> None: +class ImageResizingResourceWithRawResponse: + def __init__(self, image_resizing: ImageResizingResource) -> None: self._image_resizing = image_resizing self.edit = to_raw_response_wrapper( @@ -242,8 +242,8 @@ def __init__(self, image_resizing: ImageResizing) -> None: ) -class AsyncImageResizingWithRawResponse: - def __init__(self, image_resizing: AsyncImageResizing) -> None: +class AsyncImageResizingResourceWithRawResponse: + def __init__(self, image_resizing: AsyncImageResizingResource) -> None: self._image_resizing = image_resizing self.edit = async_to_raw_response_wrapper( @@ -254,8 +254,8 @@ def __init__(self, image_resizing: AsyncImageResizing) -> None: ) -class ImageResizingWithStreamingResponse: - def __init__(self, image_resizing: ImageResizing) -> None: +class ImageResizingResourceWithStreamingResponse: + def __init__(self, image_resizing: ImageResizingResource) -> None: self._image_resizing = image_resizing self.edit = to_streamed_response_wrapper( @@ -266,8 +266,8 @@ def __init__(self, image_resizing: ImageResizing) -> None: ) -class AsyncImageResizingWithStreamingResponse: - def __init__(self, image_resizing: AsyncImageResizing) -> None: +class AsyncImageResizingResourceWithStreamingResponse: + def __init__(self, image_resizing: AsyncImageResizingResource) -> None: self._image_resizing = image_resizing self.edit = async_to_streamed_response_wrapper( diff --git a/src/cloudflare/resources/zones/settings/ip_geolocation.py b/src/cloudflare/resources/zones/settings/ip_geolocation.py index 8a14a19702a0..8f0382721ba8 100644 --- a/src/cloudflare/resources/zones/settings/ip_geolocation.py +++ b/src/cloudflare/resources/zones/settings/ip_geolocation.py @@ -24,19 +24,19 @@ from ...._base_client import ( make_request_options, ) -from ....types.zones.settings import ZoneSettingIPGeolocation, ip_geolocation_edit_params +from ....types.zones.settings import IPGeolocation, ip_geolocation_edit_params -__all__ = ["IPGeolocation", "AsyncIPGeolocation"] +__all__ = ["IPGeolocationResource", "AsyncIPGeolocationResource"] -class IPGeolocation(SyncAPIResource): +class IPGeolocationResource(SyncAPIResource): @cached_property - def with_raw_response(self) -> IPGeolocationWithRawResponse: - return IPGeolocationWithRawResponse(self) + def with_raw_response(self) -> IPGeolocationResourceWithRawResponse: + return IPGeolocationResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> IPGeolocationWithStreamingResponse: - return IPGeolocationWithStreamingResponse(self) + def with_streaming_response(self) -> IPGeolocationResourceWithStreamingResponse: + return IPGeolocationResourceWithStreamingResponse(self) def edit( self, @@ -49,7 +49,7 @@ def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingIPGeolocation]: + ) -> Optional[IPGeolocation]: """ Enable IP Geolocation to have Cloudflare geolocate visitors to your website and pass the country code to you. @@ -80,7 +80,7 @@ def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingIPGeolocation]], ResultWrapper[ZoneSettingIPGeolocation]), + cast_to=cast(Type[Optional[IPGeolocation]], ResultWrapper[IPGeolocation]), ) def get( @@ -93,7 +93,7 @@ def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingIPGeolocation]: + ) -> Optional[IPGeolocation]: """ Enable IP Geolocation to have Cloudflare geolocate visitors to your website and pass the country code to you. @@ -121,18 +121,18 @@ def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingIPGeolocation]], ResultWrapper[ZoneSettingIPGeolocation]), + cast_to=cast(Type[Optional[IPGeolocation]], ResultWrapper[IPGeolocation]), ) -class AsyncIPGeolocation(AsyncAPIResource): +class AsyncIPGeolocationResource(AsyncAPIResource): @cached_property - def with_raw_response(self) -> AsyncIPGeolocationWithRawResponse: - return AsyncIPGeolocationWithRawResponse(self) + def with_raw_response(self) -> AsyncIPGeolocationResourceWithRawResponse: + return AsyncIPGeolocationResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> AsyncIPGeolocationWithStreamingResponse: - return AsyncIPGeolocationWithStreamingResponse(self) + def with_streaming_response(self) -> AsyncIPGeolocationResourceWithStreamingResponse: + return AsyncIPGeolocationResourceWithStreamingResponse(self) async def edit( self, @@ -145,7 +145,7 @@ async def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingIPGeolocation]: + ) -> Optional[IPGeolocation]: """ Enable IP Geolocation to have Cloudflare geolocate visitors to your website and pass the country code to you. @@ -176,7 +176,7 @@ async def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingIPGeolocation]], ResultWrapper[ZoneSettingIPGeolocation]), + cast_to=cast(Type[Optional[IPGeolocation]], ResultWrapper[IPGeolocation]), ) async def get( @@ -189,7 +189,7 @@ async def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingIPGeolocation]: + ) -> Optional[IPGeolocation]: """ Enable IP Geolocation to have Cloudflare geolocate visitors to your website and pass the country code to you. @@ -217,12 +217,12 @@ async def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingIPGeolocation]], ResultWrapper[ZoneSettingIPGeolocation]), + cast_to=cast(Type[Optional[IPGeolocation]], ResultWrapper[IPGeolocation]), ) -class IPGeolocationWithRawResponse: - def __init__(self, ip_geolocation: IPGeolocation) -> None: +class IPGeolocationResourceWithRawResponse: + def __init__(self, ip_geolocation: IPGeolocationResource) -> None: self._ip_geolocation = ip_geolocation self.edit = to_raw_response_wrapper( @@ -233,8 +233,8 @@ def __init__(self, ip_geolocation: IPGeolocation) -> None: ) -class AsyncIPGeolocationWithRawResponse: - def __init__(self, ip_geolocation: AsyncIPGeolocation) -> None: +class AsyncIPGeolocationResourceWithRawResponse: + def __init__(self, ip_geolocation: AsyncIPGeolocationResource) -> None: self._ip_geolocation = ip_geolocation self.edit = async_to_raw_response_wrapper( @@ -245,8 +245,8 @@ def __init__(self, ip_geolocation: AsyncIPGeolocation) -> None: ) -class IPGeolocationWithStreamingResponse: - def __init__(self, ip_geolocation: IPGeolocation) -> None: +class IPGeolocationResourceWithStreamingResponse: + def __init__(self, ip_geolocation: IPGeolocationResource) -> None: self._ip_geolocation = ip_geolocation self.edit = to_streamed_response_wrapper( @@ -257,8 +257,8 @@ def __init__(self, ip_geolocation: IPGeolocation) -> None: ) -class AsyncIPGeolocationWithStreamingResponse: - def __init__(self, ip_geolocation: AsyncIPGeolocation) -> None: +class AsyncIPGeolocationResourceWithStreamingResponse: + def __init__(self, ip_geolocation: AsyncIPGeolocationResource) -> None: self._ip_geolocation = ip_geolocation self.edit = async_to_streamed_response_wrapper( diff --git a/src/cloudflare/resources/zones/settings/ipv6.py b/src/cloudflare/resources/zones/settings/ipv6.py index f9284b5731dc..ca178ae794c2 100644 --- a/src/cloudflare/resources/zones/settings/ipv6.py +++ b/src/cloudflare/resources/zones/settings/ipv6.py @@ -24,19 +24,19 @@ from ...._base_client import ( make_request_options, ) -from ....types.zones.settings import ZoneSettingIPV6, ipv6_edit_params +from ....types.zones.settings import IPV6, ipv6_edit_params -__all__ = ["IPV6", "AsyncIPV6"] +__all__ = ["IPV6Resource", "AsyncIPV6Resource"] -class IPV6(SyncAPIResource): +class IPV6Resource(SyncAPIResource): @cached_property - def with_raw_response(self) -> IPV6WithRawResponse: - return IPV6WithRawResponse(self) + def with_raw_response(self) -> IPV6ResourceWithRawResponse: + return IPV6ResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> IPV6WithStreamingResponse: - return IPV6WithStreamingResponse(self) + def with_streaming_response(self) -> IPV6ResourceWithStreamingResponse: + return IPV6ResourceWithStreamingResponse(self) def edit( self, @@ -49,7 +49,7 @@ def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingIPV6]: + ) -> Optional[IPV6]: """ Enable IPv6 on all subdomains that are Cloudflare enabled. (https://support.cloudflare.com/hc/en-us/articles/200168586). @@ -79,7 +79,7 @@ def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingIPV6]], ResultWrapper[ZoneSettingIPV6]), + cast_to=cast(Type[Optional[IPV6]], ResultWrapper[IPV6]), ) def get( @@ -92,7 +92,7 @@ def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingIPV6]: + ) -> Optional[IPV6]: """ Enable IPv6 on all subdomains that are Cloudflare enabled. (https://support.cloudflare.com/hc/en-us/articles/200168586). @@ -119,18 +119,18 @@ def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingIPV6]], ResultWrapper[ZoneSettingIPV6]), + cast_to=cast(Type[Optional[IPV6]], ResultWrapper[IPV6]), ) -class AsyncIPV6(AsyncAPIResource): +class AsyncIPV6Resource(AsyncAPIResource): @cached_property - def with_raw_response(self) -> AsyncIPV6WithRawResponse: - return AsyncIPV6WithRawResponse(self) + def with_raw_response(self) -> AsyncIPV6ResourceWithRawResponse: + return AsyncIPV6ResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> AsyncIPV6WithStreamingResponse: - return AsyncIPV6WithStreamingResponse(self) + def with_streaming_response(self) -> AsyncIPV6ResourceWithStreamingResponse: + return AsyncIPV6ResourceWithStreamingResponse(self) async def edit( self, @@ -143,7 +143,7 @@ async def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingIPV6]: + ) -> Optional[IPV6]: """ Enable IPv6 on all subdomains that are Cloudflare enabled. (https://support.cloudflare.com/hc/en-us/articles/200168586). @@ -173,7 +173,7 @@ async def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingIPV6]], ResultWrapper[ZoneSettingIPV6]), + cast_to=cast(Type[Optional[IPV6]], ResultWrapper[IPV6]), ) async def get( @@ -186,7 +186,7 @@ async def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingIPV6]: + ) -> Optional[IPV6]: """ Enable IPv6 on all subdomains that are Cloudflare enabled. (https://support.cloudflare.com/hc/en-us/articles/200168586). @@ -213,12 +213,12 @@ async def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingIPV6]], ResultWrapper[ZoneSettingIPV6]), + cast_to=cast(Type[Optional[IPV6]], ResultWrapper[IPV6]), ) -class IPV6WithRawResponse: - def __init__(self, ipv6: IPV6) -> None: +class IPV6ResourceWithRawResponse: + def __init__(self, ipv6: IPV6Resource) -> None: self._ipv6 = ipv6 self.edit = to_raw_response_wrapper( @@ -229,8 +229,8 @@ def __init__(self, ipv6: IPV6) -> None: ) -class AsyncIPV6WithRawResponse: - def __init__(self, ipv6: AsyncIPV6) -> None: +class AsyncIPV6ResourceWithRawResponse: + def __init__(self, ipv6: AsyncIPV6Resource) -> None: self._ipv6 = ipv6 self.edit = async_to_raw_response_wrapper( @@ -241,8 +241,8 @@ def __init__(self, ipv6: AsyncIPV6) -> None: ) -class IPV6WithStreamingResponse: - def __init__(self, ipv6: IPV6) -> None: +class IPV6ResourceWithStreamingResponse: + def __init__(self, ipv6: IPV6Resource) -> None: self._ipv6 = ipv6 self.edit = to_streamed_response_wrapper( @@ -253,8 +253,8 @@ def __init__(self, ipv6: IPV6) -> None: ) -class AsyncIPV6WithStreamingResponse: - def __init__(self, ipv6: AsyncIPV6) -> None: +class AsyncIPV6ResourceWithStreamingResponse: + def __init__(self, ipv6: AsyncIPV6Resource) -> None: self._ipv6 = ipv6 self.edit = async_to_streamed_response_wrapper( diff --git a/src/cloudflare/resources/zones/settings/min_tls_version.py b/src/cloudflare/resources/zones/settings/min_tls_version.py index bbddcecee439..5c43d11929c9 100644 --- a/src/cloudflare/resources/zones/settings/min_tls_version.py +++ b/src/cloudflare/resources/zones/settings/min_tls_version.py @@ -24,19 +24,19 @@ from ...._base_client import ( make_request_options, ) -from ....types.zones.settings import ZoneSettingMinTLSVersion, min_tls_version_edit_params +from ....types.zones.settings import MinTLSVersion, min_tls_version_edit_params -__all__ = ["MinTLSVersion", "AsyncMinTLSVersion"] +__all__ = ["MinTLSVersionResource", "AsyncMinTLSVersionResource"] -class MinTLSVersion(SyncAPIResource): +class MinTLSVersionResource(SyncAPIResource): @cached_property - def with_raw_response(self) -> MinTLSVersionWithRawResponse: - return MinTLSVersionWithRawResponse(self) + def with_raw_response(self) -> MinTLSVersionResourceWithRawResponse: + return MinTLSVersionResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> MinTLSVersionWithStreamingResponse: - return MinTLSVersionWithStreamingResponse(self) + def with_streaming_response(self) -> MinTLSVersionResourceWithStreamingResponse: + return MinTLSVersionResourceWithStreamingResponse(self) def edit( self, @@ -49,7 +49,7 @@ def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingMinTLSVersion]: + ) -> Optional[MinTLSVersion]: """ Changes Minimum TLS Version setting. @@ -78,7 +78,7 @@ def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingMinTLSVersion]], ResultWrapper[ZoneSettingMinTLSVersion]), + cast_to=cast(Type[Optional[MinTLSVersion]], ResultWrapper[MinTLSVersion]), ) def get( @@ -91,7 +91,7 @@ def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingMinTLSVersion]: + ) -> Optional[MinTLSVersion]: """ Gets Minimum TLS Version setting. @@ -117,18 +117,18 @@ def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingMinTLSVersion]], ResultWrapper[ZoneSettingMinTLSVersion]), + cast_to=cast(Type[Optional[MinTLSVersion]], ResultWrapper[MinTLSVersion]), ) -class AsyncMinTLSVersion(AsyncAPIResource): +class AsyncMinTLSVersionResource(AsyncAPIResource): @cached_property - def with_raw_response(self) -> AsyncMinTLSVersionWithRawResponse: - return AsyncMinTLSVersionWithRawResponse(self) + def with_raw_response(self) -> AsyncMinTLSVersionResourceWithRawResponse: + return AsyncMinTLSVersionResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> AsyncMinTLSVersionWithStreamingResponse: - return AsyncMinTLSVersionWithStreamingResponse(self) + def with_streaming_response(self) -> AsyncMinTLSVersionResourceWithStreamingResponse: + return AsyncMinTLSVersionResourceWithStreamingResponse(self) async def edit( self, @@ -141,7 +141,7 @@ async def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingMinTLSVersion]: + ) -> Optional[MinTLSVersion]: """ Changes Minimum TLS Version setting. @@ -170,7 +170,7 @@ async def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingMinTLSVersion]], ResultWrapper[ZoneSettingMinTLSVersion]), + cast_to=cast(Type[Optional[MinTLSVersion]], ResultWrapper[MinTLSVersion]), ) async def get( @@ -183,7 +183,7 @@ async def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingMinTLSVersion]: + ) -> Optional[MinTLSVersion]: """ Gets Minimum TLS Version setting. @@ -209,12 +209,12 @@ async def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingMinTLSVersion]], ResultWrapper[ZoneSettingMinTLSVersion]), + cast_to=cast(Type[Optional[MinTLSVersion]], ResultWrapper[MinTLSVersion]), ) -class MinTLSVersionWithRawResponse: - def __init__(self, min_tls_version: MinTLSVersion) -> None: +class MinTLSVersionResourceWithRawResponse: + def __init__(self, min_tls_version: MinTLSVersionResource) -> None: self._min_tls_version = min_tls_version self.edit = to_raw_response_wrapper( @@ -225,8 +225,8 @@ def __init__(self, min_tls_version: MinTLSVersion) -> None: ) -class AsyncMinTLSVersionWithRawResponse: - def __init__(self, min_tls_version: AsyncMinTLSVersion) -> None: +class AsyncMinTLSVersionResourceWithRawResponse: + def __init__(self, min_tls_version: AsyncMinTLSVersionResource) -> None: self._min_tls_version = min_tls_version self.edit = async_to_raw_response_wrapper( @@ -237,8 +237,8 @@ def __init__(self, min_tls_version: AsyncMinTLSVersion) -> None: ) -class MinTLSVersionWithStreamingResponse: - def __init__(self, min_tls_version: MinTLSVersion) -> None: +class MinTLSVersionResourceWithStreamingResponse: + def __init__(self, min_tls_version: MinTLSVersionResource) -> None: self._min_tls_version = min_tls_version self.edit = to_streamed_response_wrapper( @@ -249,8 +249,8 @@ def __init__(self, min_tls_version: MinTLSVersion) -> None: ) -class AsyncMinTLSVersionWithStreamingResponse: - def __init__(self, min_tls_version: AsyncMinTLSVersion) -> None: +class AsyncMinTLSVersionResourceWithStreamingResponse: + def __init__(self, min_tls_version: AsyncMinTLSVersionResource) -> None: self._min_tls_version = min_tls_version self.edit = async_to_streamed_response_wrapper( diff --git a/src/cloudflare/resources/zones/settings/minify.py b/src/cloudflare/resources/zones/settings/minify.py index c6c627305e35..d840f3dcc0ab 100644 --- a/src/cloudflare/resources/zones/settings/minify.py +++ b/src/cloudflare/resources/zones/settings/minify.py @@ -23,19 +23,19 @@ from ...._base_client import ( make_request_options, ) -from ....types.zones.settings import ZoneSettingMinify, minify_edit_params +from ....types.zones.settings import Minify, minify_edit_params -__all__ = ["Minify", "AsyncMinify"] +__all__ = ["MinifyResource", "AsyncMinifyResource"] -class Minify(SyncAPIResource): +class MinifyResource(SyncAPIResource): @cached_property - def with_raw_response(self) -> MinifyWithRawResponse: - return MinifyWithRawResponse(self) + def with_raw_response(self) -> MinifyResourceWithRawResponse: + return MinifyResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> MinifyWithStreamingResponse: - return MinifyWithStreamingResponse(self) + def with_streaming_response(self) -> MinifyResourceWithStreamingResponse: + return MinifyResourceWithStreamingResponse(self) def edit( self, @@ -48,7 +48,7 @@ def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingMinify]: + ) -> Optional[Minify]: """Automatically minify certain assets for your website. Refer to @@ -80,7 +80,7 @@ def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingMinify]], ResultWrapper[ZoneSettingMinify]), + cast_to=cast(Type[Optional[Minify]], ResultWrapper[Minify]), ) def get( @@ -93,7 +93,7 @@ def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingMinify]: + ) -> Optional[Minify]: """Automatically minify certain assets for your website. Refer to @@ -122,18 +122,18 @@ def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingMinify]], ResultWrapper[ZoneSettingMinify]), + cast_to=cast(Type[Optional[Minify]], ResultWrapper[Minify]), ) -class AsyncMinify(AsyncAPIResource): +class AsyncMinifyResource(AsyncAPIResource): @cached_property - def with_raw_response(self) -> AsyncMinifyWithRawResponse: - return AsyncMinifyWithRawResponse(self) + def with_raw_response(self) -> AsyncMinifyResourceWithRawResponse: + return AsyncMinifyResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> AsyncMinifyWithStreamingResponse: - return AsyncMinifyWithStreamingResponse(self) + def with_streaming_response(self) -> AsyncMinifyResourceWithStreamingResponse: + return AsyncMinifyResourceWithStreamingResponse(self) async def edit( self, @@ -146,7 +146,7 @@ async def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingMinify]: + ) -> Optional[Minify]: """Automatically minify certain assets for your website. Refer to @@ -178,7 +178,7 @@ async def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingMinify]], ResultWrapper[ZoneSettingMinify]), + cast_to=cast(Type[Optional[Minify]], ResultWrapper[Minify]), ) async def get( @@ -191,7 +191,7 @@ async def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingMinify]: + ) -> Optional[Minify]: """Automatically minify certain assets for your website. Refer to @@ -220,12 +220,12 @@ async def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingMinify]], ResultWrapper[ZoneSettingMinify]), + cast_to=cast(Type[Optional[Minify]], ResultWrapper[Minify]), ) -class MinifyWithRawResponse: - def __init__(self, minify: Minify) -> None: +class MinifyResourceWithRawResponse: + def __init__(self, minify: MinifyResource) -> None: self._minify = minify self.edit = to_raw_response_wrapper( @@ -236,8 +236,8 @@ def __init__(self, minify: Minify) -> None: ) -class AsyncMinifyWithRawResponse: - def __init__(self, minify: AsyncMinify) -> None: +class AsyncMinifyResourceWithRawResponse: + def __init__(self, minify: AsyncMinifyResource) -> None: self._minify = minify self.edit = async_to_raw_response_wrapper( @@ -248,8 +248,8 @@ def __init__(self, minify: AsyncMinify) -> None: ) -class MinifyWithStreamingResponse: - def __init__(self, minify: Minify) -> None: +class MinifyResourceWithStreamingResponse: + def __init__(self, minify: MinifyResource) -> None: self._minify = minify self.edit = to_streamed_response_wrapper( @@ -260,8 +260,8 @@ def __init__(self, minify: Minify) -> None: ) -class AsyncMinifyWithStreamingResponse: - def __init__(self, minify: AsyncMinify) -> None: +class AsyncMinifyResourceWithStreamingResponse: + def __init__(self, minify: AsyncMinifyResource) -> None: self._minify = minify self.edit = async_to_streamed_response_wrapper( diff --git a/src/cloudflare/resources/zones/settings/mirage.py b/src/cloudflare/resources/zones/settings/mirage.py index adb93b4163a1..a801744b867e 100644 --- a/src/cloudflare/resources/zones/settings/mirage.py +++ b/src/cloudflare/resources/zones/settings/mirage.py @@ -24,19 +24,19 @@ from ...._base_client import ( make_request_options, ) -from ....types.zones.settings import ZoneSettingMirage, mirage_edit_params +from ....types.zones.settings import Mirage, mirage_edit_params -__all__ = ["Mirage", "AsyncMirage"] +__all__ = ["MirageResource", "AsyncMirageResource"] -class Mirage(SyncAPIResource): +class MirageResource(SyncAPIResource): @cached_property - def with_raw_response(self) -> MirageWithRawResponse: - return MirageWithRawResponse(self) + def with_raw_response(self) -> MirageResourceWithRawResponse: + return MirageResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> MirageWithStreamingResponse: - return MirageWithStreamingResponse(self) + def with_streaming_response(self) -> MirageResourceWithStreamingResponse: + return MirageResourceWithStreamingResponse(self) def edit( self, @@ -49,7 +49,7 @@ def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingMirage]: + ) -> Optional[Mirage]: """ Automatically optimize image loading for website visitors on mobile devices. Refer to our @@ -81,7 +81,7 @@ def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingMirage]], ResultWrapper[ZoneSettingMirage]), + cast_to=cast(Type[Optional[Mirage]], ResultWrapper[Mirage]), ) def get( @@ -94,7 +94,7 @@ def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingMirage]: + ) -> Optional[Mirage]: """ Automatically optimize image loading for website visitors on mobile devices. Refer to our @@ -123,18 +123,18 @@ def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingMirage]], ResultWrapper[ZoneSettingMirage]), + cast_to=cast(Type[Optional[Mirage]], ResultWrapper[Mirage]), ) -class AsyncMirage(AsyncAPIResource): +class AsyncMirageResource(AsyncAPIResource): @cached_property - def with_raw_response(self) -> AsyncMirageWithRawResponse: - return AsyncMirageWithRawResponse(self) + def with_raw_response(self) -> AsyncMirageResourceWithRawResponse: + return AsyncMirageResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> AsyncMirageWithStreamingResponse: - return AsyncMirageWithStreamingResponse(self) + def with_streaming_response(self) -> AsyncMirageResourceWithStreamingResponse: + return AsyncMirageResourceWithStreamingResponse(self) async def edit( self, @@ -147,7 +147,7 @@ async def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingMirage]: + ) -> Optional[Mirage]: """ Automatically optimize image loading for website visitors on mobile devices. Refer to our @@ -179,7 +179,7 @@ async def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingMirage]], ResultWrapper[ZoneSettingMirage]), + cast_to=cast(Type[Optional[Mirage]], ResultWrapper[Mirage]), ) async def get( @@ -192,7 +192,7 @@ async def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingMirage]: + ) -> Optional[Mirage]: """ Automatically optimize image loading for website visitors on mobile devices. Refer to our @@ -221,12 +221,12 @@ async def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingMirage]], ResultWrapper[ZoneSettingMirage]), + cast_to=cast(Type[Optional[Mirage]], ResultWrapper[Mirage]), ) -class MirageWithRawResponse: - def __init__(self, mirage: Mirage) -> None: +class MirageResourceWithRawResponse: + def __init__(self, mirage: MirageResource) -> None: self._mirage = mirage self.edit = to_raw_response_wrapper( @@ -237,8 +237,8 @@ def __init__(self, mirage: Mirage) -> None: ) -class AsyncMirageWithRawResponse: - def __init__(self, mirage: AsyncMirage) -> None: +class AsyncMirageResourceWithRawResponse: + def __init__(self, mirage: AsyncMirageResource) -> None: self._mirage = mirage self.edit = async_to_raw_response_wrapper( @@ -249,8 +249,8 @@ def __init__(self, mirage: AsyncMirage) -> None: ) -class MirageWithStreamingResponse: - def __init__(self, mirage: Mirage) -> None: +class MirageResourceWithStreamingResponse: + def __init__(self, mirage: MirageResource) -> None: self._mirage = mirage self.edit = to_streamed_response_wrapper( @@ -261,8 +261,8 @@ def __init__(self, mirage: Mirage) -> None: ) -class AsyncMirageWithStreamingResponse: - def __init__(self, mirage: AsyncMirage) -> None: +class AsyncMirageResourceWithStreamingResponse: + def __init__(self, mirage: AsyncMirageResource) -> None: self._mirage = mirage self.edit = async_to_streamed_response_wrapper( diff --git a/src/cloudflare/resources/zones/settings/mobile_redirect.py b/src/cloudflare/resources/zones/settings/mobile_redirect.py index f02b392efff6..e40b779991af 100644 --- a/src/cloudflare/resources/zones/settings/mobile_redirect.py +++ b/src/cloudflare/resources/zones/settings/mobile_redirect.py @@ -23,19 +23,19 @@ from ...._base_client import ( make_request_options, ) -from ....types.zones.settings import ZoneSettingMobileRedirect, mobile_redirect_edit_params +from ....types.zones.settings import MobileRedirect, mobile_redirect_edit_params -__all__ = ["MobileRedirect", "AsyncMobileRedirect"] +__all__ = ["MobileRedirectResource", "AsyncMobileRedirectResource"] -class MobileRedirect(SyncAPIResource): +class MobileRedirectResource(SyncAPIResource): @cached_property - def with_raw_response(self) -> MobileRedirectWithRawResponse: - return MobileRedirectWithRawResponse(self) + def with_raw_response(self) -> MobileRedirectResourceWithRawResponse: + return MobileRedirectResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> MobileRedirectWithStreamingResponse: - return MobileRedirectWithStreamingResponse(self) + def with_streaming_response(self) -> MobileRedirectResourceWithStreamingResponse: + return MobileRedirectResourceWithStreamingResponse(self) def edit( self, @@ -48,7 +48,7 @@ def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingMobileRedirect]: + ) -> Optional[MobileRedirect]: """ Automatically redirect visitors on mobile devices to a mobile-optimized subdomain. Refer to @@ -80,7 +80,7 @@ def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingMobileRedirect]], ResultWrapper[ZoneSettingMobileRedirect]), + cast_to=cast(Type[Optional[MobileRedirect]], ResultWrapper[MobileRedirect]), ) def get( @@ -93,7 +93,7 @@ def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingMobileRedirect]: + ) -> Optional[MobileRedirect]: """ Automatically redirect visitors on mobile devices to a mobile-optimized subdomain. Refer to @@ -122,18 +122,18 @@ def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingMobileRedirect]], ResultWrapper[ZoneSettingMobileRedirect]), + cast_to=cast(Type[Optional[MobileRedirect]], ResultWrapper[MobileRedirect]), ) -class AsyncMobileRedirect(AsyncAPIResource): +class AsyncMobileRedirectResource(AsyncAPIResource): @cached_property - def with_raw_response(self) -> AsyncMobileRedirectWithRawResponse: - return AsyncMobileRedirectWithRawResponse(self) + def with_raw_response(self) -> AsyncMobileRedirectResourceWithRawResponse: + return AsyncMobileRedirectResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> AsyncMobileRedirectWithStreamingResponse: - return AsyncMobileRedirectWithStreamingResponse(self) + def with_streaming_response(self) -> AsyncMobileRedirectResourceWithStreamingResponse: + return AsyncMobileRedirectResourceWithStreamingResponse(self) async def edit( self, @@ -146,7 +146,7 @@ async def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingMobileRedirect]: + ) -> Optional[MobileRedirect]: """ Automatically redirect visitors on mobile devices to a mobile-optimized subdomain. Refer to @@ -178,7 +178,7 @@ async def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingMobileRedirect]], ResultWrapper[ZoneSettingMobileRedirect]), + cast_to=cast(Type[Optional[MobileRedirect]], ResultWrapper[MobileRedirect]), ) async def get( @@ -191,7 +191,7 @@ async def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingMobileRedirect]: + ) -> Optional[MobileRedirect]: """ Automatically redirect visitors on mobile devices to a mobile-optimized subdomain. Refer to @@ -220,12 +220,12 @@ async def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingMobileRedirect]], ResultWrapper[ZoneSettingMobileRedirect]), + cast_to=cast(Type[Optional[MobileRedirect]], ResultWrapper[MobileRedirect]), ) -class MobileRedirectWithRawResponse: - def __init__(self, mobile_redirect: MobileRedirect) -> None: +class MobileRedirectResourceWithRawResponse: + def __init__(self, mobile_redirect: MobileRedirectResource) -> None: self._mobile_redirect = mobile_redirect self.edit = to_raw_response_wrapper( @@ -236,8 +236,8 @@ def __init__(self, mobile_redirect: MobileRedirect) -> None: ) -class AsyncMobileRedirectWithRawResponse: - def __init__(self, mobile_redirect: AsyncMobileRedirect) -> None: +class AsyncMobileRedirectResourceWithRawResponse: + def __init__(self, mobile_redirect: AsyncMobileRedirectResource) -> None: self._mobile_redirect = mobile_redirect self.edit = async_to_raw_response_wrapper( @@ -248,8 +248,8 @@ def __init__(self, mobile_redirect: AsyncMobileRedirect) -> None: ) -class MobileRedirectWithStreamingResponse: - def __init__(self, mobile_redirect: MobileRedirect) -> None: +class MobileRedirectResourceWithStreamingResponse: + def __init__(self, mobile_redirect: MobileRedirectResource) -> None: self._mobile_redirect = mobile_redirect self.edit = to_streamed_response_wrapper( @@ -260,8 +260,8 @@ def __init__(self, mobile_redirect: MobileRedirect) -> None: ) -class AsyncMobileRedirectWithStreamingResponse: - def __init__(self, mobile_redirect: AsyncMobileRedirect) -> None: +class AsyncMobileRedirectResourceWithStreamingResponse: + def __init__(self, mobile_redirect: AsyncMobileRedirectResource) -> None: self._mobile_redirect = mobile_redirect self.edit = async_to_streamed_response_wrapper( diff --git a/src/cloudflare/resources/zones/settings/nel.py b/src/cloudflare/resources/zones/settings/nel.py index a258ecdf6392..f304d15fca98 100644 --- a/src/cloudflare/resources/zones/settings/nel.py +++ b/src/cloudflare/resources/zones/settings/nel.py @@ -23,32 +23,32 @@ from ...._base_client import ( make_request_options, ) -from ....types.zones.settings import ZoneSettingNEL, ZoneSettingNELParam, nel_edit_params +from ....types.zones.settings import NEL, NELParam, nel_edit_params -__all__ = ["NEL", "AsyncNEL"] +__all__ = ["NELResource", "AsyncNELResource"] -class NEL(SyncAPIResource): +class NELResource(SyncAPIResource): @cached_property - def with_raw_response(self) -> NELWithRawResponse: - return NELWithRawResponse(self) + def with_raw_response(self) -> NELResourceWithRawResponse: + return NELResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> NELWithStreamingResponse: - return NELWithStreamingResponse(self) + def with_streaming_response(self) -> NELResourceWithStreamingResponse: + return NELResourceWithStreamingResponse(self) def edit( self, *, zone_id: str, - value: ZoneSettingNELParam, + value: NELParam, # 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[ZoneSettingNEL]: + ) -> Optional[NEL]: """ Automatically optimize image loading for website visitors on mobile devices. Refer to our [blog post](http://blog.cloudflare.com/nel-solving-mobile-speed) @@ -79,7 +79,7 @@ def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingNEL]], ResultWrapper[ZoneSettingNEL]), + cast_to=cast(Type[Optional[NEL]], ResultWrapper[NEL]), ) def get( @@ -92,7 +92,7 @@ def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingNEL]: + ) -> Optional[NEL]: """Enable Network Error Logging reporting on your zone. (Beta) @@ -119,31 +119,31 @@ def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingNEL]], ResultWrapper[ZoneSettingNEL]), + cast_to=cast(Type[Optional[NEL]], ResultWrapper[NEL]), ) -class AsyncNEL(AsyncAPIResource): +class AsyncNELResource(AsyncAPIResource): @cached_property - def with_raw_response(self) -> AsyncNELWithRawResponse: - return AsyncNELWithRawResponse(self) + def with_raw_response(self) -> AsyncNELResourceWithRawResponse: + return AsyncNELResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> AsyncNELWithStreamingResponse: - return AsyncNELWithStreamingResponse(self) + def with_streaming_response(self) -> AsyncNELResourceWithStreamingResponse: + return AsyncNELResourceWithStreamingResponse(self) async def edit( self, *, zone_id: str, - value: ZoneSettingNELParam, + value: NELParam, # 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[ZoneSettingNEL]: + ) -> Optional[NEL]: """ Automatically optimize image loading for website visitors on mobile devices. Refer to our [blog post](http://blog.cloudflare.com/nel-solving-mobile-speed) @@ -174,7 +174,7 @@ async def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingNEL]], ResultWrapper[ZoneSettingNEL]), + cast_to=cast(Type[Optional[NEL]], ResultWrapper[NEL]), ) async def get( @@ -187,7 +187,7 @@ async def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingNEL]: + ) -> Optional[NEL]: """Enable Network Error Logging reporting on your zone. (Beta) @@ -214,12 +214,12 @@ async def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingNEL]], ResultWrapper[ZoneSettingNEL]), + cast_to=cast(Type[Optional[NEL]], ResultWrapper[NEL]), ) -class NELWithRawResponse: - def __init__(self, nel: NEL) -> None: +class NELResourceWithRawResponse: + def __init__(self, nel: NELResource) -> None: self._nel = nel self.edit = to_raw_response_wrapper( @@ -230,8 +230,8 @@ def __init__(self, nel: NEL) -> None: ) -class AsyncNELWithRawResponse: - def __init__(self, nel: AsyncNEL) -> None: +class AsyncNELResourceWithRawResponse: + def __init__(self, nel: AsyncNELResource) -> None: self._nel = nel self.edit = async_to_raw_response_wrapper( @@ -242,8 +242,8 @@ def __init__(self, nel: AsyncNEL) -> None: ) -class NELWithStreamingResponse: - def __init__(self, nel: NEL) -> None: +class NELResourceWithStreamingResponse: + def __init__(self, nel: NELResource) -> None: self._nel = nel self.edit = to_streamed_response_wrapper( @@ -254,8 +254,8 @@ def __init__(self, nel: NEL) -> None: ) -class AsyncNELWithStreamingResponse: - def __init__(self, nel: AsyncNEL) -> None: +class AsyncNELResourceWithStreamingResponse: + def __init__(self, nel: AsyncNELResource) -> None: self._nel = nel self.edit = async_to_streamed_response_wrapper( diff --git a/src/cloudflare/resources/zones/settings/opportunistic_encryption.py b/src/cloudflare/resources/zones/settings/opportunistic_encryption.py index bccb494ce3c5..b186a0da37a1 100644 --- a/src/cloudflare/resources/zones/settings/opportunistic_encryption.py +++ b/src/cloudflare/resources/zones/settings/opportunistic_encryption.py @@ -24,19 +24,19 @@ from ...._base_client import ( make_request_options, ) -from ....types.zones.settings import ZoneSettingOpportunisticEncryption, opportunistic_encryption_edit_params +from ....types.zones.settings import OpportunisticEncryption, opportunistic_encryption_edit_params -__all__ = ["OpportunisticEncryption", "AsyncOpportunisticEncryption"] +__all__ = ["OpportunisticEncryptionResource", "AsyncOpportunisticEncryptionResource"] -class OpportunisticEncryption(SyncAPIResource): +class OpportunisticEncryptionResource(SyncAPIResource): @cached_property - def with_raw_response(self) -> OpportunisticEncryptionWithRawResponse: - return OpportunisticEncryptionWithRawResponse(self) + def with_raw_response(self) -> OpportunisticEncryptionResourceWithRawResponse: + return OpportunisticEncryptionResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> OpportunisticEncryptionWithStreamingResponse: - return OpportunisticEncryptionWithStreamingResponse(self) + def with_streaming_response(self) -> OpportunisticEncryptionResourceWithStreamingResponse: + return OpportunisticEncryptionResourceWithStreamingResponse(self) def edit( self, @@ -49,7 +49,7 @@ def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingOpportunisticEncryption]: + ) -> Optional[OpportunisticEncryption]: """ Changes Opportunistic Encryption setting. @@ -81,9 +81,7 @@ def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast( - Type[Optional[ZoneSettingOpportunisticEncryption]], ResultWrapper[ZoneSettingOpportunisticEncryption] - ), + cast_to=cast(Type[Optional[OpportunisticEncryption]], ResultWrapper[OpportunisticEncryption]), ) def get( @@ -96,7 +94,7 @@ def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingOpportunisticEncryption]: + ) -> Optional[OpportunisticEncryption]: """ Gets Opportunistic Encryption setting. @@ -122,20 +120,18 @@ def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast( - Type[Optional[ZoneSettingOpportunisticEncryption]], ResultWrapper[ZoneSettingOpportunisticEncryption] - ), + cast_to=cast(Type[Optional[OpportunisticEncryption]], ResultWrapper[OpportunisticEncryption]), ) -class AsyncOpportunisticEncryption(AsyncAPIResource): +class AsyncOpportunisticEncryptionResource(AsyncAPIResource): @cached_property - def with_raw_response(self) -> AsyncOpportunisticEncryptionWithRawResponse: - return AsyncOpportunisticEncryptionWithRawResponse(self) + def with_raw_response(self) -> AsyncOpportunisticEncryptionResourceWithRawResponse: + return AsyncOpportunisticEncryptionResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> AsyncOpportunisticEncryptionWithStreamingResponse: - return AsyncOpportunisticEncryptionWithStreamingResponse(self) + def with_streaming_response(self) -> AsyncOpportunisticEncryptionResourceWithStreamingResponse: + return AsyncOpportunisticEncryptionResourceWithStreamingResponse(self) async def edit( self, @@ -148,7 +144,7 @@ async def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingOpportunisticEncryption]: + ) -> Optional[OpportunisticEncryption]: """ Changes Opportunistic Encryption setting. @@ -180,9 +176,7 @@ async def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast( - Type[Optional[ZoneSettingOpportunisticEncryption]], ResultWrapper[ZoneSettingOpportunisticEncryption] - ), + cast_to=cast(Type[Optional[OpportunisticEncryption]], ResultWrapper[OpportunisticEncryption]), ) async def get( @@ -195,7 +189,7 @@ async def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingOpportunisticEncryption]: + ) -> Optional[OpportunisticEncryption]: """ Gets Opportunistic Encryption setting. @@ -221,14 +215,12 @@ async def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast( - Type[Optional[ZoneSettingOpportunisticEncryption]], ResultWrapper[ZoneSettingOpportunisticEncryption] - ), + cast_to=cast(Type[Optional[OpportunisticEncryption]], ResultWrapper[OpportunisticEncryption]), ) -class OpportunisticEncryptionWithRawResponse: - def __init__(self, opportunistic_encryption: OpportunisticEncryption) -> None: +class OpportunisticEncryptionResourceWithRawResponse: + def __init__(self, opportunistic_encryption: OpportunisticEncryptionResource) -> None: self._opportunistic_encryption = opportunistic_encryption self.edit = to_raw_response_wrapper( @@ -239,8 +231,8 @@ def __init__(self, opportunistic_encryption: OpportunisticEncryption) -> None: ) -class AsyncOpportunisticEncryptionWithRawResponse: - def __init__(self, opportunistic_encryption: AsyncOpportunisticEncryption) -> None: +class AsyncOpportunisticEncryptionResourceWithRawResponse: + def __init__(self, opportunistic_encryption: AsyncOpportunisticEncryptionResource) -> None: self._opportunistic_encryption = opportunistic_encryption self.edit = async_to_raw_response_wrapper( @@ -251,8 +243,8 @@ def __init__(self, opportunistic_encryption: AsyncOpportunisticEncryption) -> No ) -class OpportunisticEncryptionWithStreamingResponse: - def __init__(self, opportunistic_encryption: OpportunisticEncryption) -> None: +class OpportunisticEncryptionResourceWithStreamingResponse: + def __init__(self, opportunistic_encryption: OpportunisticEncryptionResource) -> None: self._opportunistic_encryption = opportunistic_encryption self.edit = to_streamed_response_wrapper( @@ -263,8 +255,8 @@ def __init__(self, opportunistic_encryption: OpportunisticEncryption) -> None: ) -class AsyncOpportunisticEncryptionWithStreamingResponse: - def __init__(self, opportunistic_encryption: AsyncOpportunisticEncryption) -> None: +class AsyncOpportunisticEncryptionResourceWithStreamingResponse: + def __init__(self, opportunistic_encryption: AsyncOpportunisticEncryptionResource) -> None: self._opportunistic_encryption = opportunistic_encryption self.edit = async_to_streamed_response_wrapper( diff --git a/src/cloudflare/resources/zones/settings/opportunistic_onion.py b/src/cloudflare/resources/zones/settings/opportunistic_onion.py index b7aac17aec47..bacb78154158 100644 --- a/src/cloudflare/resources/zones/settings/opportunistic_onion.py +++ b/src/cloudflare/resources/zones/settings/opportunistic_onion.py @@ -24,19 +24,19 @@ from ...._base_client import ( make_request_options, ) -from ....types.zones.settings import ZoneSettingOpportunisticOnion, opportunistic_onion_edit_params +from ....types.zones.settings import OpportunisticOnion, opportunistic_onion_edit_params -__all__ = ["OpportunisticOnion", "AsyncOpportunisticOnion"] +__all__ = ["OpportunisticOnionResource", "AsyncOpportunisticOnionResource"] -class OpportunisticOnion(SyncAPIResource): +class OpportunisticOnionResource(SyncAPIResource): @cached_property - def with_raw_response(self) -> OpportunisticOnionWithRawResponse: - return OpportunisticOnionWithRawResponse(self) + def with_raw_response(self) -> OpportunisticOnionResourceWithRawResponse: + return OpportunisticOnionResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> OpportunisticOnionWithStreamingResponse: - return OpportunisticOnionWithStreamingResponse(self) + def with_streaming_response(self) -> OpportunisticOnionResourceWithStreamingResponse: + return OpportunisticOnionResourceWithStreamingResponse(self) def edit( self, @@ -49,7 +49,7 @@ def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingOpportunisticOnion]: + ) -> Optional[OpportunisticOnion]: """ Add an Alt-Svc header to all legitimate requests from Tor, allowing the connection to use our onion services instead of exit nodes. @@ -80,7 +80,7 @@ def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingOpportunisticOnion]], ResultWrapper[ZoneSettingOpportunisticOnion]), + cast_to=cast(Type[Optional[OpportunisticOnion]], ResultWrapper[OpportunisticOnion]), ) def get( @@ -93,7 +93,7 @@ def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingOpportunisticOnion]: + ) -> Optional[OpportunisticOnion]: """ Add an Alt-Svc header to all legitimate requests from Tor, allowing the connection to use our onion services instead of exit nodes. @@ -120,18 +120,18 @@ def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingOpportunisticOnion]], ResultWrapper[ZoneSettingOpportunisticOnion]), + cast_to=cast(Type[Optional[OpportunisticOnion]], ResultWrapper[OpportunisticOnion]), ) -class AsyncOpportunisticOnion(AsyncAPIResource): +class AsyncOpportunisticOnionResource(AsyncAPIResource): @cached_property - def with_raw_response(self) -> AsyncOpportunisticOnionWithRawResponse: - return AsyncOpportunisticOnionWithRawResponse(self) + def with_raw_response(self) -> AsyncOpportunisticOnionResourceWithRawResponse: + return AsyncOpportunisticOnionResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> AsyncOpportunisticOnionWithStreamingResponse: - return AsyncOpportunisticOnionWithStreamingResponse(self) + def with_streaming_response(self) -> AsyncOpportunisticOnionResourceWithStreamingResponse: + return AsyncOpportunisticOnionResourceWithStreamingResponse(self) async def edit( self, @@ -144,7 +144,7 @@ async def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingOpportunisticOnion]: + ) -> Optional[OpportunisticOnion]: """ Add an Alt-Svc header to all legitimate requests from Tor, allowing the connection to use our onion services instead of exit nodes. @@ -177,7 +177,7 @@ async def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingOpportunisticOnion]], ResultWrapper[ZoneSettingOpportunisticOnion]), + cast_to=cast(Type[Optional[OpportunisticOnion]], ResultWrapper[OpportunisticOnion]), ) async def get( @@ -190,7 +190,7 @@ async def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingOpportunisticOnion]: + ) -> Optional[OpportunisticOnion]: """ Add an Alt-Svc header to all legitimate requests from Tor, allowing the connection to use our onion services instead of exit nodes. @@ -217,12 +217,12 @@ async def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingOpportunisticOnion]], ResultWrapper[ZoneSettingOpportunisticOnion]), + cast_to=cast(Type[Optional[OpportunisticOnion]], ResultWrapper[OpportunisticOnion]), ) -class OpportunisticOnionWithRawResponse: - def __init__(self, opportunistic_onion: OpportunisticOnion) -> None: +class OpportunisticOnionResourceWithRawResponse: + def __init__(self, opportunistic_onion: OpportunisticOnionResource) -> None: self._opportunistic_onion = opportunistic_onion self.edit = to_raw_response_wrapper( @@ -233,8 +233,8 @@ def __init__(self, opportunistic_onion: OpportunisticOnion) -> None: ) -class AsyncOpportunisticOnionWithRawResponse: - def __init__(self, opportunistic_onion: AsyncOpportunisticOnion) -> None: +class AsyncOpportunisticOnionResourceWithRawResponse: + def __init__(self, opportunistic_onion: AsyncOpportunisticOnionResource) -> None: self._opportunistic_onion = opportunistic_onion self.edit = async_to_raw_response_wrapper( @@ -245,8 +245,8 @@ def __init__(self, opportunistic_onion: AsyncOpportunisticOnion) -> None: ) -class OpportunisticOnionWithStreamingResponse: - def __init__(self, opportunistic_onion: OpportunisticOnion) -> None: +class OpportunisticOnionResourceWithStreamingResponse: + def __init__(self, opportunistic_onion: OpportunisticOnionResource) -> None: self._opportunistic_onion = opportunistic_onion self.edit = to_streamed_response_wrapper( @@ -257,8 +257,8 @@ def __init__(self, opportunistic_onion: OpportunisticOnion) -> None: ) -class AsyncOpportunisticOnionWithStreamingResponse: - def __init__(self, opportunistic_onion: AsyncOpportunisticOnion) -> None: +class AsyncOpportunisticOnionResourceWithStreamingResponse: + def __init__(self, opportunistic_onion: AsyncOpportunisticOnionResource) -> None: self._opportunistic_onion = opportunistic_onion self.edit = async_to_streamed_response_wrapper( diff --git a/src/cloudflare/resources/zones/settings/orange_to_orange.py b/src/cloudflare/resources/zones/settings/orange_to_orange.py index 305f070cad6a..e1512f6ed40b 100644 --- a/src/cloudflare/resources/zones/settings/orange_to_orange.py +++ b/src/cloudflare/resources/zones/settings/orange_to_orange.py @@ -23,36 +23,32 @@ from ...._base_client import ( make_request_options, ) -from ....types.zones.settings import ( - ZoneSettingOrangeToOrange, - ZoneSettingOrangeToOrangeParam, - orange_to_orange_edit_params, -) +from ....types.zones.settings import OrangeToOrange, OrangeToOrangeParam, orange_to_orange_edit_params -__all__ = ["OrangeToOrange", "AsyncOrangeToOrange"] +__all__ = ["OrangeToOrangeResource", "AsyncOrangeToOrangeResource"] -class OrangeToOrange(SyncAPIResource): +class OrangeToOrangeResource(SyncAPIResource): @cached_property - def with_raw_response(self) -> OrangeToOrangeWithRawResponse: - return OrangeToOrangeWithRawResponse(self) + def with_raw_response(self) -> OrangeToOrangeResourceWithRawResponse: + return OrangeToOrangeResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> OrangeToOrangeWithStreamingResponse: - return OrangeToOrangeWithStreamingResponse(self) + def with_streaming_response(self) -> OrangeToOrangeResourceWithStreamingResponse: + return OrangeToOrangeResourceWithStreamingResponse(self) def edit( self, *, zone_id: str, - value: ZoneSettingOrangeToOrangeParam, + value: OrangeToOrangeParam, # 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[ZoneSettingOrangeToOrange]: + ) -> Optional[OrangeToOrange]: """ Orange to Orange (O2O) allows zones on Cloudflare to CNAME to other zones also on Cloudflare. @@ -83,7 +79,7 @@ def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingOrangeToOrange]], ResultWrapper[ZoneSettingOrangeToOrange]), + cast_to=cast(Type[Optional[OrangeToOrange]], ResultWrapper[OrangeToOrange]), ) def get( @@ -96,7 +92,7 @@ def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingOrangeToOrange]: + ) -> Optional[OrangeToOrange]: """ Orange to Orange (O2O) allows zones on Cloudflare to CNAME to other zones also on Cloudflare. @@ -123,31 +119,31 @@ def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingOrangeToOrange]], ResultWrapper[ZoneSettingOrangeToOrange]), + cast_to=cast(Type[Optional[OrangeToOrange]], ResultWrapper[OrangeToOrange]), ) -class AsyncOrangeToOrange(AsyncAPIResource): +class AsyncOrangeToOrangeResource(AsyncAPIResource): @cached_property - def with_raw_response(self) -> AsyncOrangeToOrangeWithRawResponse: - return AsyncOrangeToOrangeWithRawResponse(self) + def with_raw_response(self) -> AsyncOrangeToOrangeResourceWithRawResponse: + return AsyncOrangeToOrangeResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> AsyncOrangeToOrangeWithStreamingResponse: - return AsyncOrangeToOrangeWithStreamingResponse(self) + def with_streaming_response(self) -> AsyncOrangeToOrangeResourceWithStreamingResponse: + return AsyncOrangeToOrangeResourceWithStreamingResponse(self) async def edit( self, *, zone_id: str, - value: ZoneSettingOrangeToOrangeParam, + value: OrangeToOrangeParam, # 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[ZoneSettingOrangeToOrange]: + ) -> Optional[OrangeToOrange]: """ Orange to Orange (O2O) allows zones on Cloudflare to CNAME to other zones also on Cloudflare. @@ -178,7 +174,7 @@ async def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingOrangeToOrange]], ResultWrapper[ZoneSettingOrangeToOrange]), + cast_to=cast(Type[Optional[OrangeToOrange]], ResultWrapper[OrangeToOrange]), ) async def get( @@ -191,7 +187,7 @@ async def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingOrangeToOrange]: + ) -> Optional[OrangeToOrange]: """ Orange to Orange (O2O) allows zones on Cloudflare to CNAME to other zones also on Cloudflare. @@ -218,12 +214,12 @@ async def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingOrangeToOrange]], ResultWrapper[ZoneSettingOrangeToOrange]), + cast_to=cast(Type[Optional[OrangeToOrange]], ResultWrapper[OrangeToOrange]), ) -class OrangeToOrangeWithRawResponse: - def __init__(self, orange_to_orange: OrangeToOrange) -> None: +class OrangeToOrangeResourceWithRawResponse: + def __init__(self, orange_to_orange: OrangeToOrangeResource) -> None: self._orange_to_orange = orange_to_orange self.edit = to_raw_response_wrapper( @@ -234,8 +230,8 @@ def __init__(self, orange_to_orange: OrangeToOrange) -> None: ) -class AsyncOrangeToOrangeWithRawResponse: - def __init__(self, orange_to_orange: AsyncOrangeToOrange) -> None: +class AsyncOrangeToOrangeResourceWithRawResponse: + def __init__(self, orange_to_orange: AsyncOrangeToOrangeResource) -> None: self._orange_to_orange = orange_to_orange self.edit = async_to_raw_response_wrapper( @@ -246,8 +242,8 @@ def __init__(self, orange_to_orange: AsyncOrangeToOrange) -> None: ) -class OrangeToOrangeWithStreamingResponse: - def __init__(self, orange_to_orange: OrangeToOrange) -> None: +class OrangeToOrangeResourceWithStreamingResponse: + def __init__(self, orange_to_orange: OrangeToOrangeResource) -> None: self._orange_to_orange = orange_to_orange self.edit = to_streamed_response_wrapper( @@ -258,8 +254,8 @@ def __init__(self, orange_to_orange: OrangeToOrange) -> None: ) -class AsyncOrangeToOrangeWithStreamingResponse: - def __init__(self, orange_to_orange: AsyncOrangeToOrange) -> None: +class AsyncOrangeToOrangeResourceWithStreamingResponse: + def __init__(self, orange_to_orange: AsyncOrangeToOrangeResource) -> None: self._orange_to_orange = orange_to_orange self.edit = async_to_streamed_response_wrapper( diff --git a/src/cloudflare/resources/zones/settings/origin_error_page_pass_thru.py b/src/cloudflare/resources/zones/settings/origin_error_page_pass_thru.py index 3253bc91a55b..d9a51509759a 100644 --- a/src/cloudflare/resources/zones/settings/origin_error_page_pass_thru.py +++ b/src/cloudflare/resources/zones/settings/origin_error_page_pass_thru.py @@ -24,19 +24,19 @@ from ...._base_client import ( make_request_options, ) -from ....types.zones.settings import ZoneSettingOriginErrorPagePassThru, origin_error_page_pass_thru_edit_params +from ....types.zones.settings import OriginErrorPagePassThru, origin_error_page_pass_thru_edit_params -__all__ = ["OriginErrorPagePassThru", "AsyncOriginErrorPagePassThru"] +__all__ = ["OriginErrorPagePassThruResource", "AsyncOriginErrorPagePassThruResource"] -class OriginErrorPagePassThru(SyncAPIResource): +class OriginErrorPagePassThruResource(SyncAPIResource): @cached_property - def with_raw_response(self) -> OriginErrorPagePassThruWithRawResponse: - return OriginErrorPagePassThruWithRawResponse(self) + def with_raw_response(self) -> OriginErrorPagePassThruResourceWithRawResponse: + return OriginErrorPagePassThruResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> OriginErrorPagePassThruWithStreamingResponse: - return OriginErrorPagePassThruWithStreamingResponse(self) + def with_streaming_response(self) -> OriginErrorPagePassThruResourceWithStreamingResponse: + return OriginErrorPagePassThruResourceWithStreamingResponse(self) def edit( self, @@ -49,7 +49,7 @@ def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingOriginErrorPagePassThru]: + ) -> Optional[OriginErrorPagePassThru]: """ Cloudflare will proxy customer error pages on any 502,504 errors on origin server instead of showing a default Cloudflare error page. This does not apply @@ -82,9 +82,7 @@ def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast( - Type[Optional[ZoneSettingOriginErrorPagePassThru]], ResultWrapper[ZoneSettingOriginErrorPagePassThru] - ), + cast_to=cast(Type[Optional[OriginErrorPagePassThru]], ResultWrapper[OriginErrorPagePassThru]), ) def get( @@ -97,7 +95,7 @@ def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingOriginErrorPagePassThru]: + ) -> Optional[OriginErrorPagePassThru]: """ Cloudflare will proxy customer error pages on any 502,504 errors on origin server instead of showing a default Cloudflare error page. This does not apply @@ -125,20 +123,18 @@ def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast( - Type[Optional[ZoneSettingOriginErrorPagePassThru]], ResultWrapper[ZoneSettingOriginErrorPagePassThru] - ), + cast_to=cast(Type[Optional[OriginErrorPagePassThru]], ResultWrapper[OriginErrorPagePassThru]), ) -class AsyncOriginErrorPagePassThru(AsyncAPIResource): +class AsyncOriginErrorPagePassThruResource(AsyncAPIResource): @cached_property - def with_raw_response(self) -> AsyncOriginErrorPagePassThruWithRawResponse: - return AsyncOriginErrorPagePassThruWithRawResponse(self) + def with_raw_response(self) -> AsyncOriginErrorPagePassThruResourceWithRawResponse: + return AsyncOriginErrorPagePassThruResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> AsyncOriginErrorPagePassThruWithStreamingResponse: - return AsyncOriginErrorPagePassThruWithStreamingResponse(self) + def with_streaming_response(self) -> AsyncOriginErrorPagePassThruResourceWithStreamingResponse: + return AsyncOriginErrorPagePassThruResourceWithStreamingResponse(self) async def edit( self, @@ -151,7 +147,7 @@ async def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingOriginErrorPagePassThru]: + ) -> Optional[OriginErrorPagePassThru]: """ Cloudflare will proxy customer error pages on any 502,504 errors on origin server instead of showing a default Cloudflare error page. This does not apply @@ -184,9 +180,7 @@ async def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast( - Type[Optional[ZoneSettingOriginErrorPagePassThru]], ResultWrapper[ZoneSettingOriginErrorPagePassThru] - ), + cast_to=cast(Type[Optional[OriginErrorPagePassThru]], ResultWrapper[OriginErrorPagePassThru]), ) async def get( @@ -199,7 +193,7 @@ async def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingOriginErrorPagePassThru]: + ) -> Optional[OriginErrorPagePassThru]: """ Cloudflare will proxy customer error pages on any 502,504 errors on origin server instead of showing a default Cloudflare error page. This does not apply @@ -227,14 +221,12 @@ async def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast( - Type[Optional[ZoneSettingOriginErrorPagePassThru]], ResultWrapper[ZoneSettingOriginErrorPagePassThru] - ), + cast_to=cast(Type[Optional[OriginErrorPagePassThru]], ResultWrapper[OriginErrorPagePassThru]), ) -class OriginErrorPagePassThruWithRawResponse: - def __init__(self, origin_error_page_pass_thru: OriginErrorPagePassThru) -> None: +class OriginErrorPagePassThruResourceWithRawResponse: + def __init__(self, origin_error_page_pass_thru: OriginErrorPagePassThruResource) -> None: self._origin_error_page_pass_thru = origin_error_page_pass_thru self.edit = to_raw_response_wrapper( @@ -245,8 +237,8 @@ def __init__(self, origin_error_page_pass_thru: OriginErrorPagePassThru) -> None ) -class AsyncOriginErrorPagePassThruWithRawResponse: - def __init__(self, origin_error_page_pass_thru: AsyncOriginErrorPagePassThru) -> None: +class AsyncOriginErrorPagePassThruResourceWithRawResponse: + def __init__(self, origin_error_page_pass_thru: AsyncOriginErrorPagePassThruResource) -> None: self._origin_error_page_pass_thru = origin_error_page_pass_thru self.edit = async_to_raw_response_wrapper( @@ -257,8 +249,8 @@ def __init__(self, origin_error_page_pass_thru: AsyncOriginErrorPagePassThru) -> ) -class OriginErrorPagePassThruWithStreamingResponse: - def __init__(self, origin_error_page_pass_thru: OriginErrorPagePassThru) -> None: +class OriginErrorPagePassThruResourceWithStreamingResponse: + def __init__(self, origin_error_page_pass_thru: OriginErrorPagePassThruResource) -> None: self._origin_error_page_pass_thru = origin_error_page_pass_thru self.edit = to_streamed_response_wrapper( @@ -269,8 +261,8 @@ def __init__(self, origin_error_page_pass_thru: OriginErrorPagePassThru) -> None ) -class AsyncOriginErrorPagePassThruWithStreamingResponse: - def __init__(self, origin_error_page_pass_thru: AsyncOriginErrorPagePassThru) -> None: +class AsyncOriginErrorPagePassThruResourceWithStreamingResponse: + def __init__(self, origin_error_page_pass_thru: AsyncOriginErrorPagePassThruResource) -> None: self._origin_error_page_pass_thru = origin_error_page_pass_thru self.edit = async_to_streamed_response_wrapper( diff --git a/src/cloudflare/resources/zones/settings/polish.py b/src/cloudflare/resources/zones/settings/polish.py index 90d2b75fd7ab..6bc359373296 100644 --- a/src/cloudflare/resources/zones/settings/polish.py +++ b/src/cloudflare/resources/zones/settings/polish.py @@ -23,32 +23,32 @@ from ...._base_client import ( make_request_options, ) -from ....types.zones.settings import ZoneSettingPolish, ZoneSettingPolishParam, polish_edit_params +from ....types.zones.settings import Polish, PolishParam, polish_edit_params -__all__ = ["Polish", "AsyncPolish"] +__all__ = ["PolishResource", "AsyncPolishResource"] -class Polish(SyncAPIResource): +class PolishResource(SyncAPIResource): @cached_property - def with_raw_response(self) -> PolishWithRawResponse: - return PolishWithRawResponse(self) + def with_raw_response(self) -> PolishResourceWithRawResponse: + return PolishResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> PolishWithStreamingResponse: - return PolishWithStreamingResponse(self) + def with_streaming_response(self) -> PolishResourceWithStreamingResponse: + return PolishResourceWithStreamingResponse(self) def edit( self, *, zone_id: str, - value: ZoneSettingPolishParam, + value: PolishParam, # 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[ZoneSettingPolish]: + ) -> Optional[Polish]: """ Automatically optimize image loading for website visitors on mobile devices. Refer to our [blog post](http://blog.cloudflare.com/polish-solving-mobile-speed) @@ -84,7 +84,7 @@ def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingPolish]], ResultWrapper[ZoneSettingPolish]), + cast_to=cast(Type[Optional[Polish]], ResultWrapper[Polish]), ) def get( @@ -97,7 +97,7 @@ def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingPolish]: + ) -> Optional[Polish]: """ Automatically optimize image loading for website visitors on mobile devices. Refer to our [blog post](http://blog.cloudflare.com/polish-solving-mobile-speed) @@ -125,31 +125,31 @@ def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingPolish]], ResultWrapper[ZoneSettingPolish]), + cast_to=cast(Type[Optional[Polish]], ResultWrapper[Polish]), ) -class AsyncPolish(AsyncAPIResource): +class AsyncPolishResource(AsyncAPIResource): @cached_property - def with_raw_response(self) -> AsyncPolishWithRawResponse: - return AsyncPolishWithRawResponse(self) + def with_raw_response(self) -> AsyncPolishResourceWithRawResponse: + return AsyncPolishResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> AsyncPolishWithStreamingResponse: - return AsyncPolishWithStreamingResponse(self) + def with_streaming_response(self) -> AsyncPolishResourceWithStreamingResponse: + return AsyncPolishResourceWithStreamingResponse(self) async def edit( self, *, zone_id: str, - value: ZoneSettingPolishParam, + value: PolishParam, # 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[ZoneSettingPolish]: + ) -> Optional[Polish]: """ Automatically optimize image loading for website visitors on mobile devices. Refer to our [blog post](http://blog.cloudflare.com/polish-solving-mobile-speed) @@ -185,7 +185,7 @@ async def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingPolish]], ResultWrapper[ZoneSettingPolish]), + cast_to=cast(Type[Optional[Polish]], ResultWrapper[Polish]), ) async def get( @@ -198,7 +198,7 @@ async def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingPolish]: + ) -> Optional[Polish]: """ Automatically optimize image loading for website visitors on mobile devices. Refer to our [blog post](http://blog.cloudflare.com/polish-solving-mobile-speed) @@ -226,12 +226,12 @@ async def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingPolish]], ResultWrapper[ZoneSettingPolish]), + cast_to=cast(Type[Optional[Polish]], ResultWrapper[Polish]), ) -class PolishWithRawResponse: - def __init__(self, polish: Polish) -> None: +class PolishResourceWithRawResponse: + def __init__(self, polish: PolishResource) -> None: self._polish = polish self.edit = to_raw_response_wrapper( @@ -242,8 +242,8 @@ def __init__(self, polish: Polish) -> None: ) -class AsyncPolishWithRawResponse: - def __init__(self, polish: AsyncPolish) -> None: +class AsyncPolishResourceWithRawResponse: + def __init__(self, polish: AsyncPolishResource) -> None: self._polish = polish self.edit = async_to_raw_response_wrapper( @@ -254,8 +254,8 @@ def __init__(self, polish: AsyncPolish) -> None: ) -class PolishWithStreamingResponse: - def __init__(self, polish: Polish) -> None: +class PolishResourceWithStreamingResponse: + def __init__(self, polish: PolishResource) -> None: self._polish = polish self.edit = to_streamed_response_wrapper( @@ -266,8 +266,8 @@ def __init__(self, polish: Polish) -> None: ) -class AsyncPolishWithStreamingResponse: - def __init__(self, polish: AsyncPolish) -> None: +class AsyncPolishResourceWithStreamingResponse: + def __init__(self, polish: AsyncPolishResource) -> None: self._polish = polish self.edit = async_to_streamed_response_wrapper( diff --git a/src/cloudflare/resources/zones/settings/prefetch_preload.py b/src/cloudflare/resources/zones/settings/prefetch_preload.py index bff8a11f5106..6847fac10e82 100644 --- a/src/cloudflare/resources/zones/settings/prefetch_preload.py +++ b/src/cloudflare/resources/zones/settings/prefetch_preload.py @@ -24,19 +24,19 @@ from ...._base_client import ( make_request_options, ) -from ....types.zones.settings import ZoneSettingPrefetchPreload, prefetch_preload_edit_params +from ....types.zones.settings import PrefetchPreload, prefetch_preload_edit_params -__all__ = ["PrefetchPreload", "AsyncPrefetchPreload"] +__all__ = ["PrefetchPreloadResource", "AsyncPrefetchPreloadResource"] -class PrefetchPreload(SyncAPIResource): +class PrefetchPreloadResource(SyncAPIResource): @cached_property - def with_raw_response(self) -> PrefetchPreloadWithRawResponse: - return PrefetchPreloadWithRawResponse(self) + def with_raw_response(self) -> PrefetchPreloadResourceWithRawResponse: + return PrefetchPreloadResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> PrefetchPreloadWithStreamingResponse: - return PrefetchPreloadWithStreamingResponse(self) + def with_streaming_response(self) -> PrefetchPreloadResourceWithStreamingResponse: + return PrefetchPreloadResourceWithStreamingResponse(self) def edit( self, @@ -49,7 +49,7 @@ def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingPrefetchPreload]: + ) -> Optional[PrefetchPreload]: """ Cloudflare will prefetch any URLs that are included in the response headers. This is limited to Enterprise Zones. @@ -79,7 +79,7 @@ def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingPrefetchPreload]], ResultWrapper[ZoneSettingPrefetchPreload]), + cast_to=cast(Type[Optional[PrefetchPreload]], ResultWrapper[PrefetchPreload]), ) def get( @@ -92,7 +92,7 @@ def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingPrefetchPreload]: + ) -> Optional[PrefetchPreload]: """ Cloudflare will prefetch any URLs that are included in the response headers. This is limited to Enterprise Zones. @@ -119,18 +119,18 @@ def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingPrefetchPreload]], ResultWrapper[ZoneSettingPrefetchPreload]), + cast_to=cast(Type[Optional[PrefetchPreload]], ResultWrapper[PrefetchPreload]), ) -class AsyncPrefetchPreload(AsyncAPIResource): +class AsyncPrefetchPreloadResource(AsyncAPIResource): @cached_property - def with_raw_response(self) -> AsyncPrefetchPreloadWithRawResponse: - return AsyncPrefetchPreloadWithRawResponse(self) + def with_raw_response(self) -> AsyncPrefetchPreloadResourceWithRawResponse: + return AsyncPrefetchPreloadResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> AsyncPrefetchPreloadWithStreamingResponse: - return AsyncPrefetchPreloadWithStreamingResponse(self) + def with_streaming_response(self) -> AsyncPrefetchPreloadResourceWithStreamingResponse: + return AsyncPrefetchPreloadResourceWithStreamingResponse(self) async def edit( self, @@ -143,7 +143,7 @@ async def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingPrefetchPreload]: + ) -> Optional[PrefetchPreload]: """ Cloudflare will prefetch any URLs that are included in the response headers. This is limited to Enterprise Zones. @@ -173,7 +173,7 @@ async def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingPrefetchPreload]], ResultWrapper[ZoneSettingPrefetchPreload]), + cast_to=cast(Type[Optional[PrefetchPreload]], ResultWrapper[PrefetchPreload]), ) async def get( @@ -186,7 +186,7 @@ async def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingPrefetchPreload]: + ) -> Optional[PrefetchPreload]: """ Cloudflare will prefetch any URLs that are included in the response headers. This is limited to Enterprise Zones. @@ -213,12 +213,12 @@ async def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingPrefetchPreload]], ResultWrapper[ZoneSettingPrefetchPreload]), + cast_to=cast(Type[Optional[PrefetchPreload]], ResultWrapper[PrefetchPreload]), ) -class PrefetchPreloadWithRawResponse: - def __init__(self, prefetch_preload: PrefetchPreload) -> None: +class PrefetchPreloadResourceWithRawResponse: + def __init__(self, prefetch_preload: PrefetchPreloadResource) -> None: self._prefetch_preload = prefetch_preload self.edit = to_raw_response_wrapper( @@ -229,8 +229,8 @@ def __init__(self, prefetch_preload: PrefetchPreload) -> None: ) -class AsyncPrefetchPreloadWithRawResponse: - def __init__(self, prefetch_preload: AsyncPrefetchPreload) -> None: +class AsyncPrefetchPreloadResourceWithRawResponse: + def __init__(self, prefetch_preload: AsyncPrefetchPreloadResource) -> None: self._prefetch_preload = prefetch_preload self.edit = async_to_raw_response_wrapper( @@ -241,8 +241,8 @@ def __init__(self, prefetch_preload: AsyncPrefetchPreload) -> None: ) -class PrefetchPreloadWithStreamingResponse: - def __init__(self, prefetch_preload: PrefetchPreload) -> None: +class PrefetchPreloadResourceWithStreamingResponse: + def __init__(self, prefetch_preload: PrefetchPreloadResource) -> None: self._prefetch_preload = prefetch_preload self.edit = to_streamed_response_wrapper( @@ -253,8 +253,8 @@ def __init__(self, prefetch_preload: PrefetchPreload) -> None: ) -class AsyncPrefetchPreloadWithStreamingResponse: - def __init__(self, prefetch_preload: AsyncPrefetchPreload) -> None: +class AsyncPrefetchPreloadResourceWithStreamingResponse: + def __init__(self, prefetch_preload: AsyncPrefetchPreloadResource) -> None: self._prefetch_preload = prefetch_preload self.edit = async_to_streamed_response_wrapper( diff --git a/src/cloudflare/resources/zones/settings/proxy_read_timeout.py b/src/cloudflare/resources/zones/settings/proxy_read_timeout.py index 4fd41b55ecad..cf261e03a984 100644 --- a/src/cloudflare/resources/zones/settings/proxy_read_timeout.py +++ b/src/cloudflare/resources/zones/settings/proxy_read_timeout.py @@ -23,36 +23,32 @@ from ...._base_client import ( make_request_options, ) -from ....types.zones.settings import ( - ZoneSettingProxyReadTimeout, - ZoneSettingProxyReadTimeoutParam, - proxy_read_timeout_edit_params, -) +from ....types.zones.settings import ProxyReadTimeout, ProxyReadTimeoutParam, proxy_read_timeout_edit_params -__all__ = ["ProxyReadTimeout", "AsyncProxyReadTimeout"] +__all__ = ["ProxyReadTimeoutResource", "AsyncProxyReadTimeoutResource"] -class ProxyReadTimeout(SyncAPIResource): +class ProxyReadTimeoutResource(SyncAPIResource): @cached_property - def with_raw_response(self) -> ProxyReadTimeoutWithRawResponse: - return ProxyReadTimeoutWithRawResponse(self) + def with_raw_response(self) -> ProxyReadTimeoutResourceWithRawResponse: + return ProxyReadTimeoutResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> ProxyReadTimeoutWithStreamingResponse: - return ProxyReadTimeoutWithStreamingResponse(self) + def with_streaming_response(self) -> ProxyReadTimeoutResourceWithStreamingResponse: + return ProxyReadTimeoutResourceWithStreamingResponse(self) def edit( self, *, zone_id: str, - value: ZoneSettingProxyReadTimeoutParam, + value: ProxyReadTimeoutParam, # 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[ZoneSettingProxyReadTimeout]: + ) -> Optional[ProxyReadTimeout]: """ Maximum time between two read operations from origin. @@ -81,7 +77,7 @@ def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingProxyReadTimeout]], ResultWrapper[ZoneSettingProxyReadTimeout]), + cast_to=cast(Type[Optional[ProxyReadTimeout]], ResultWrapper[ProxyReadTimeout]), ) def get( @@ -94,7 +90,7 @@ def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingProxyReadTimeout]: + ) -> Optional[ProxyReadTimeout]: """ Maximum time between two read operations from origin. @@ -120,31 +116,31 @@ def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingProxyReadTimeout]], ResultWrapper[ZoneSettingProxyReadTimeout]), + cast_to=cast(Type[Optional[ProxyReadTimeout]], ResultWrapper[ProxyReadTimeout]), ) -class AsyncProxyReadTimeout(AsyncAPIResource): +class AsyncProxyReadTimeoutResource(AsyncAPIResource): @cached_property - def with_raw_response(self) -> AsyncProxyReadTimeoutWithRawResponse: - return AsyncProxyReadTimeoutWithRawResponse(self) + def with_raw_response(self) -> AsyncProxyReadTimeoutResourceWithRawResponse: + return AsyncProxyReadTimeoutResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> AsyncProxyReadTimeoutWithStreamingResponse: - return AsyncProxyReadTimeoutWithStreamingResponse(self) + def with_streaming_response(self) -> AsyncProxyReadTimeoutResourceWithStreamingResponse: + return AsyncProxyReadTimeoutResourceWithStreamingResponse(self) async def edit( self, *, zone_id: str, - value: ZoneSettingProxyReadTimeoutParam, + value: ProxyReadTimeoutParam, # 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[ZoneSettingProxyReadTimeout]: + ) -> Optional[ProxyReadTimeout]: """ Maximum time between two read operations from origin. @@ -175,7 +171,7 @@ async def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingProxyReadTimeout]], ResultWrapper[ZoneSettingProxyReadTimeout]), + cast_to=cast(Type[Optional[ProxyReadTimeout]], ResultWrapper[ProxyReadTimeout]), ) async def get( @@ -188,7 +184,7 @@ async def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingProxyReadTimeout]: + ) -> Optional[ProxyReadTimeout]: """ Maximum time between two read operations from origin. @@ -214,12 +210,12 @@ async def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingProxyReadTimeout]], ResultWrapper[ZoneSettingProxyReadTimeout]), + cast_to=cast(Type[Optional[ProxyReadTimeout]], ResultWrapper[ProxyReadTimeout]), ) -class ProxyReadTimeoutWithRawResponse: - def __init__(self, proxy_read_timeout: ProxyReadTimeout) -> None: +class ProxyReadTimeoutResourceWithRawResponse: + def __init__(self, proxy_read_timeout: ProxyReadTimeoutResource) -> None: self._proxy_read_timeout = proxy_read_timeout self.edit = to_raw_response_wrapper( @@ -230,8 +226,8 @@ def __init__(self, proxy_read_timeout: ProxyReadTimeout) -> None: ) -class AsyncProxyReadTimeoutWithRawResponse: - def __init__(self, proxy_read_timeout: AsyncProxyReadTimeout) -> None: +class AsyncProxyReadTimeoutResourceWithRawResponse: + def __init__(self, proxy_read_timeout: AsyncProxyReadTimeoutResource) -> None: self._proxy_read_timeout = proxy_read_timeout self.edit = async_to_raw_response_wrapper( @@ -242,8 +238,8 @@ def __init__(self, proxy_read_timeout: AsyncProxyReadTimeout) -> None: ) -class ProxyReadTimeoutWithStreamingResponse: - def __init__(self, proxy_read_timeout: ProxyReadTimeout) -> None: +class ProxyReadTimeoutResourceWithStreamingResponse: + def __init__(self, proxy_read_timeout: ProxyReadTimeoutResource) -> None: self._proxy_read_timeout = proxy_read_timeout self.edit = to_streamed_response_wrapper( @@ -254,8 +250,8 @@ def __init__(self, proxy_read_timeout: ProxyReadTimeout) -> None: ) -class AsyncProxyReadTimeoutWithStreamingResponse: - def __init__(self, proxy_read_timeout: AsyncProxyReadTimeout) -> None: +class AsyncProxyReadTimeoutResourceWithStreamingResponse: + def __init__(self, proxy_read_timeout: AsyncProxyReadTimeoutResource) -> None: self._proxy_read_timeout = proxy_read_timeout self.edit = async_to_streamed_response_wrapper( diff --git a/src/cloudflare/resources/zones/settings/pseudo_ipv4.py b/src/cloudflare/resources/zones/settings/pseudo_ipv4.py index ab49ee302561..9673f9f80d2c 100644 --- a/src/cloudflare/resources/zones/settings/pseudo_ipv4.py +++ b/src/cloudflare/resources/zones/settings/pseudo_ipv4.py @@ -24,19 +24,19 @@ from ...._base_client import ( make_request_options, ) -from ....types.zones.settings import ZoneSettingPseudoIPV4, pseudo_ipv4_edit_params +from ....types.zones.settings import PseudoIPV4, pseudo_ipv4_edit_params -__all__ = ["PseudoIPV4", "AsyncPseudoIPV4"] +__all__ = ["PseudoIPV4Resource", "AsyncPseudoIPV4Resource"] -class PseudoIPV4(SyncAPIResource): +class PseudoIPV4Resource(SyncAPIResource): @cached_property - def with_raw_response(self) -> PseudoIPV4WithRawResponse: - return PseudoIPV4WithRawResponse(self) + def with_raw_response(self) -> PseudoIPV4ResourceWithRawResponse: + return PseudoIPV4ResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> PseudoIPV4WithStreamingResponse: - return PseudoIPV4WithStreamingResponse(self) + def with_streaming_response(self) -> PseudoIPV4ResourceWithStreamingResponse: + return PseudoIPV4ResourceWithStreamingResponse(self) def edit( self, @@ -49,7 +49,7 @@ def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingPseudoIPV4]: + ) -> Optional[PseudoIPV4]: """ Value of the Pseudo IPv4 setting. @@ -78,7 +78,7 @@ def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingPseudoIPV4]], ResultWrapper[ZoneSettingPseudoIPV4]), + cast_to=cast(Type[Optional[PseudoIPV4]], ResultWrapper[PseudoIPV4]), ) def get( @@ -91,7 +91,7 @@ def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingPseudoIPV4]: + ) -> Optional[PseudoIPV4]: """ Value of the Pseudo IPv4 setting. @@ -117,18 +117,18 @@ def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingPseudoIPV4]], ResultWrapper[ZoneSettingPseudoIPV4]), + cast_to=cast(Type[Optional[PseudoIPV4]], ResultWrapper[PseudoIPV4]), ) -class AsyncPseudoIPV4(AsyncAPIResource): +class AsyncPseudoIPV4Resource(AsyncAPIResource): @cached_property - def with_raw_response(self) -> AsyncPseudoIPV4WithRawResponse: - return AsyncPseudoIPV4WithRawResponse(self) + def with_raw_response(self) -> AsyncPseudoIPV4ResourceWithRawResponse: + return AsyncPseudoIPV4ResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> AsyncPseudoIPV4WithStreamingResponse: - return AsyncPseudoIPV4WithStreamingResponse(self) + def with_streaming_response(self) -> AsyncPseudoIPV4ResourceWithStreamingResponse: + return AsyncPseudoIPV4ResourceWithStreamingResponse(self) async def edit( self, @@ -141,7 +141,7 @@ async def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingPseudoIPV4]: + ) -> Optional[PseudoIPV4]: """ Value of the Pseudo IPv4 setting. @@ -170,7 +170,7 @@ async def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingPseudoIPV4]], ResultWrapper[ZoneSettingPseudoIPV4]), + cast_to=cast(Type[Optional[PseudoIPV4]], ResultWrapper[PseudoIPV4]), ) async def get( @@ -183,7 +183,7 @@ async def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingPseudoIPV4]: + ) -> Optional[PseudoIPV4]: """ Value of the Pseudo IPv4 setting. @@ -209,12 +209,12 @@ async def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingPseudoIPV4]], ResultWrapper[ZoneSettingPseudoIPV4]), + cast_to=cast(Type[Optional[PseudoIPV4]], ResultWrapper[PseudoIPV4]), ) -class PseudoIPV4WithRawResponse: - def __init__(self, pseudo_ipv4: PseudoIPV4) -> None: +class PseudoIPV4ResourceWithRawResponse: + def __init__(self, pseudo_ipv4: PseudoIPV4Resource) -> None: self._pseudo_ipv4 = pseudo_ipv4 self.edit = to_raw_response_wrapper( @@ -225,8 +225,8 @@ def __init__(self, pseudo_ipv4: PseudoIPV4) -> None: ) -class AsyncPseudoIPV4WithRawResponse: - def __init__(self, pseudo_ipv4: AsyncPseudoIPV4) -> None: +class AsyncPseudoIPV4ResourceWithRawResponse: + def __init__(self, pseudo_ipv4: AsyncPseudoIPV4Resource) -> None: self._pseudo_ipv4 = pseudo_ipv4 self.edit = async_to_raw_response_wrapper( @@ -237,8 +237,8 @@ def __init__(self, pseudo_ipv4: AsyncPseudoIPV4) -> None: ) -class PseudoIPV4WithStreamingResponse: - def __init__(self, pseudo_ipv4: PseudoIPV4) -> None: +class PseudoIPV4ResourceWithStreamingResponse: + def __init__(self, pseudo_ipv4: PseudoIPV4Resource) -> None: self._pseudo_ipv4 = pseudo_ipv4 self.edit = to_streamed_response_wrapper( @@ -249,8 +249,8 @@ def __init__(self, pseudo_ipv4: PseudoIPV4) -> None: ) -class AsyncPseudoIPV4WithStreamingResponse: - def __init__(self, pseudo_ipv4: AsyncPseudoIPV4) -> None: +class AsyncPseudoIPV4ResourceWithStreamingResponse: + def __init__(self, pseudo_ipv4: AsyncPseudoIPV4Resource) -> None: self._pseudo_ipv4 = pseudo_ipv4 self.edit = async_to_streamed_response_wrapper( diff --git a/src/cloudflare/resources/zones/settings/response_buffering.py b/src/cloudflare/resources/zones/settings/response_buffering.py index 041eb425af5c..9f59816ef833 100644 --- a/src/cloudflare/resources/zones/settings/response_buffering.py +++ b/src/cloudflare/resources/zones/settings/response_buffering.py @@ -24,19 +24,19 @@ from ...._base_client import ( make_request_options, ) -from ....types.zones.settings import ZoneSettingBuffering, response_buffering_edit_params +from ....types.zones.settings import ResponseBuffering, response_buffering_edit_params -__all__ = ["ResponseBuffering", "AsyncResponseBuffering"] +__all__ = ["ResponseBufferingResource", "AsyncResponseBufferingResource"] -class ResponseBuffering(SyncAPIResource): +class ResponseBufferingResource(SyncAPIResource): @cached_property - def with_raw_response(self) -> ResponseBufferingWithRawResponse: - return ResponseBufferingWithRawResponse(self) + def with_raw_response(self) -> ResponseBufferingResourceWithRawResponse: + return ResponseBufferingResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> ResponseBufferingWithStreamingResponse: - return ResponseBufferingWithStreamingResponse(self) + def with_streaming_response(self) -> ResponseBufferingResourceWithStreamingResponse: + return ResponseBufferingResourceWithStreamingResponse(self) def edit( self, @@ -49,7 +49,7 @@ def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingBuffering]: + ) -> Optional[ResponseBuffering]: """Enables or disables buffering of responses from the proxied server. Cloudflare @@ -82,7 +82,7 @@ def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingBuffering]], ResultWrapper[ZoneSettingBuffering]), + cast_to=cast(Type[Optional[ResponseBuffering]], ResultWrapper[ResponseBuffering]), ) def get( @@ -95,7 +95,7 @@ def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingBuffering]: + ) -> Optional[ResponseBuffering]: """Enables or disables buffering of responses from the proxied server. Cloudflare @@ -125,18 +125,18 @@ def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingBuffering]], ResultWrapper[ZoneSettingBuffering]), + cast_to=cast(Type[Optional[ResponseBuffering]], ResultWrapper[ResponseBuffering]), ) -class AsyncResponseBuffering(AsyncAPIResource): +class AsyncResponseBufferingResource(AsyncAPIResource): @cached_property - def with_raw_response(self) -> AsyncResponseBufferingWithRawResponse: - return AsyncResponseBufferingWithRawResponse(self) + def with_raw_response(self) -> AsyncResponseBufferingResourceWithRawResponse: + return AsyncResponseBufferingResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> AsyncResponseBufferingWithStreamingResponse: - return AsyncResponseBufferingWithStreamingResponse(self) + def with_streaming_response(self) -> AsyncResponseBufferingResourceWithStreamingResponse: + return AsyncResponseBufferingResourceWithStreamingResponse(self) async def edit( self, @@ -149,7 +149,7 @@ async def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingBuffering]: + ) -> Optional[ResponseBuffering]: """Enables or disables buffering of responses from the proxied server. Cloudflare @@ -184,7 +184,7 @@ async def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingBuffering]], ResultWrapper[ZoneSettingBuffering]), + cast_to=cast(Type[Optional[ResponseBuffering]], ResultWrapper[ResponseBuffering]), ) async def get( @@ -197,7 +197,7 @@ async def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingBuffering]: + ) -> Optional[ResponseBuffering]: """Enables or disables buffering of responses from the proxied server. Cloudflare @@ -227,12 +227,12 @@ async def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingBuffering]], ResultWrapper[ZoneSettingBuffering]), + cast_to=cast(Type[Optional[ResponseBuffering]], ResultWrapper[ResponseBuffering]), ) -class ResponseBufferingWithRawResponse: - def __init__(self, response_buffering: ResponseBuffering) -> None: +class ResponseBufferingResourceWithRawResponse: + def __init__(self, response_buffering: ResponseBufferingResource) -> None: self._response_buffering = response_buffering self.edit = to_raw_response_wrapper( @@ -243,8 +243,8 @@ def __init__(self, response_buffering: ResponseBuffering) -> None: ) -class AsyncResponseBufferingWithRawResponse: - def __init__(self, response_buffering: AsyncResponseBuffering) -> None: +class AsyncResponseBufferingResourceWithRawResponse: + def __init__(self, response_buffering: AsyncResponseBufferingResource) -> None: self._response_buffering = response_buffering self.edit = async_to_raw_response_wrapper( @@ -255,8 +255,8 @@ def __init__(self, response_buffering: AsyncResponseBuffering) -> None: ) -class ResponseBufferingWithStreamingResponse: - def __init__(self, response_buffering: ResponseBuffering) -> None: +class ResponseBufferingResourceWithStreamingResponse: + def __init__(self, response_buffering: ResponseBufferingResource) -> None: self._response_buffering = response_buffering self.edit = to_streamed_response_wrapper( @@ -267,8 +267,8 @@ def __init__(self, response_buffering: ResponseBuffering) -> None: ) -class AsyncResponseBufferingWithStreamingResponse: - def __init__(self, response_buffering: AsyncResponseBuffering) -> None: +class AsyncResponseBufferingResourceWithStreamingResponse: + def __init__(self, response_buffering: AsyncResponseBufferingResource) -> None: self._response_buffering = response_buffering self.edit = async_to_streamed_response_wrapper( diff --git a/src/cloudflare/resources/zones/settings/rocket_loader.py b/src/cloudflare/resources/zones/settings/rocket_loader.py index 73b5ddadd6ce..a0cb92c4198c 100644 --- a/src/cloudflare/resources/zones/settings/rocket_loader.py +++ b/src/cloudflare/resources/zones/settings/rocket_loader.py @@ -23,32 +23,32 @@ from ...._base_client import ( make_request_options, ) -from ....types.zones.settings import ZoneSettingRocketLoader, ZoneSettingRocketLoaderParam, rocket_loader_edit_params +from ....types.zones.settings import RocketLoader, RocketLoaderParam, rocket_loader_edit_params -__all__ = ["RocketLoader", "AsyncRocketLoader"] +__all__ = ["RocketLoaderResource", "AsyncRocketLoaderResource"] -class RocketLoader(SyncAPIResource): +class RocketLoaderResource(SyncAPIResource): @cached_property - def with_raw_response(self) -> RocketLoaderWithRawResponse: - return RocketLoaderWithRawResponse(self) + def with_raw_response(self) -> RocketLoaderResourceWithRawResponse: + return RocketLoaderResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> RocketLoaderWithStreamingResponse: - return RocketLoaderWithStreamingResponse(self) + def with_streaming_response(self) -> RocketLoaderResourceWithStreamingResponse: + return RocketLoaderResourceWithStreamingResponse(self) def edit( self, *, zone_id: str, - value: ZoneSettingRocketLoaderParam, + value: RocketLoaderParam, # 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[ZoneSettingRocketLoader]: + ) -> Optional[RocketLoader]: """ Rocket Loader is a general-purpose asynchronous JavaScript optimisation that prioritises rendering your content while loading your site's Javascript @@ -95,7 +95,7 @@ def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingRocketLoader]], ResultWrapper[ZoneSettingRocketLoader]), + cast_to=cast(Type[Optional[RocketLoader]], ResultWrapper[RocketLoader]), ) def get( @@ -108,7 +108,7 @@ def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingRocketLoader]: + ) -> Optional[RocketLoader]: """ Rocket Loader is a general-purpose asynchronous JavaScript optimisation that prioritises rendering your content while loading your site's Javascript @@ -143,31 +143,31 @@ def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingRocketLoader]], ResultWrapper[ZoneSettingRocketLoader]), + cast_to=cast(Type[Optional[RocketLoader]], ResultWrapper[RocketLoader]), ) -class AsyncRocketLoader(AsyncAPIResource): +class AsyncRocketLoaderResource(AsyncAPIResource): @cached_property - def with_raw_response(self) -> AsyncRocketLoaderWithRawResponse: - return AsyncRocketLoaderWithRawResponse(self) + def with_raw_response(self) -> AsyncRocketLoaderResourceWithRawResponse: + return AsyncRocketLoaderResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> AsyncRocketLoaderWithStreamingResponse: - return AsyncRocketLoaderWithStreamingResponse(self) + def with_streaming_response(self) -> AsyncRocketLoaderResourceWithStreamingResponse: + return AsyncRocketLoaderResourceWithStreamingResponse(self) async def edit( self, *, zone_id: str, - value: ZoneSettingRocketLoaderParam, + value: RocketLoaderParam, # 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[ZoneSettingRocketLoader]: + ) -> Optional[RocketLoader]: """ Rocket Loader is a general-purpose asynchronous JavaScript optimisation that prioritises rendering your content while loading your site's Javascript @@ -214,7 +214,7 @@ async def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingRocketLoader]], ResultWrapper[ZoneSettingRocketLoader]), + cast_to=cast(Type[Optional[RocketLoader]], ResultWrapper[RocketLoader]), ) async def get( @@ -227,7 +227,7 @@ async def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingRocketLoader]: + ) -> Optional[RocketLoader]: """ Rocket Loader is a general-purpose asynchronous JavaScript optimisation that prioritises rendering your content while loading your site's Javascript @@ -262,12 +262,12 @@ async def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingRocketLoader]], ResultWrapper[ZoneSettingRocketLoader]), + cast_to=cast(Type[Optional[RocketLoader]], ResultWrapper[RocketLoader]), ) -class RocketLoaderWithRawResponse: - def __init__(self, rocket_loader: RocketLoader) -> None: +class RocketLoaderResourceWithRawResponse: + def __init__(self, rocket_loader: RocketLoaderResource) -> None: self._rocket_loader = rocket_loader self.edit = to_raw_response_wrapper( @@ -278,8 +278,8 @@ def __init__(self, rocket_loader: RocketLoader) -> None: ) -class AsyncRocketLoaderWithRawResponse: - def __init__(self, rocket_loader: AsyncRocketLoader) -> None: +class AsyncRocketLoaderResourceWithRawResponse: + def __init__(self, rocket_loader: AsyncRocketLoaderResource) -> None: self._rocket_loader = rocket_loader self.edit = async_to_raw_response_wrapper( @@ -290,8 +290,8 @@ def __init__(self, rocket_loader: AsyncRocketLoader) -> None: ) -class RocketLoaderWithStreamingResponse: - def __init__(self, rocket_loader: RocketLoader) -> None: +class RocketLoaderResourceWithStreamingResponse: + def __init__(self, rocket_loader: RocketLoaderResource) -> None: self._rocket_loader = rocket_loader self.edit = to_streamed_response_wrapper( @@ -302,8 +302,8 @@ def __init__(self, rocket_loader: RocketLoader) -> None: ) -class AsyncRocketLoaderWithStreamingResponse: - def __init__(self, rocket_loader: AsyncRocketLoader) -> None: +class AsyncRocketLoaderResourceWithStreamingResponse: + def __init__(self, rocket_loader: AsyncRocketLoaderResource) -> None: self._rocket_loader = rocket_loader self.edit = async_to_streamed_response_wrapper( diff --git a/src/cloudflare/resources/zones/settings/security_headers.py b/src/cloudflare/resources/zones/settings/security_headers.py index 88fcd7d0bab9..44745706add6 100644 --- a/src/cloudflare/resources/zones/settings/security_headers.py +++ b/src/cloudflare/resources/zones/settings/security_headers.py @@ -23,7 +23,7 @@ from ...._base_client import ( make_request_options, ) -from ....types.zones.settings import ZoneSettingSecurityHeader, security_header_edit_params +from ....types.zones.settings import security_headers, security_header_edit_params __all__ = ["SecurityHeaders", "AsyncSecurityHeaders"] @@ -48,7 +48,7 @@ def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingSecurityHeader]: + ) -> Optional[security_headers.SecurityHeaders]: """ Cloudflare security header for a zone. @@ -75,7 +75,9 @@ def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingSecurityHeader]], ResultWrapper[ZoneSettingSecurityHeader]), + cast_to=cast( + Type[Optional[security_headers.SecurityHeaders]], ResultWrapper[security_headers.SecurityHeaders] + ), ) def get( @@ -88,7 +90,7 @@ def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingSecurityHeader]: + ) -> Optional[security_headers.SecurityHeaders]: """ Cloudflare security header for a zone. @@ -114,7 +116,9 @@ def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingSecurityHeader]], ResultWrapper[ZoneSettingSecurityHeader]), + cast_to=cast( + Type[Optional[security_headers.SecurityHeaders]], ResultWrapper[security_headers.SecurityHeaders] + ), ) @@ -138,7 +142,7 @@ async def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingSecurityHeader]: + ) -> Optional[security_headers.SecurityHeaders]: """ Cloudflare security header for a zone. @@ -165,7 +169,9 @@ async def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingSecurityHeader]], ResultWrapper[ZoneSettingSecurityHeader]), + cast_to=cast( + Type[Optional[security_headers.SecurityHeaders]], ResultWrapper[security_headers.SecurityHeaders] + ), ) async def get( @@ -178,7 +184,7 @@ async def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingSecurityHeader]: + ) -> Optional[security_headers.SecurityHeaders]: """ Cloudflare security header for a zone. @@ -204,7 +210,9 @@ async def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingSecurityHeader]], ResultWrapper[ZoneSettingSecurityHeader]), + cast_to=cast( + Type[Optional[security_headers.SecurityHeaders]], ResultWrapper[security_headers.SecurityHeaders] + ), ) diff --git a/src/cloudflare/resources/zones/settings/security_level.py b/src/cloudflare/resources/zones/settings/security_level.py index a5d0c78ed39b..631b4efc114c 100644 --- a/src/cloudflare/resources/zones/settings/security_level.py +++ b/src/cloudflare/resources/zones/settings/security_level.py @@ -24,19 +24,19 @@ from ...._base_client import ( make_request_options, ) -from ....types.zones.settings import ZoneSettingSecurityLevel, security_level_edit_params +from ....types.zones.settings import SecurityLevel, security_level_edit_params -__all__ = ["SecurityLevel", "AsyncSecurityLevel"] +__all__ = ["SecurityLevelResource", "AsyncSecurityLevelResource"] -class SecurityLevel(SyncAPIResource): +class SecurityLevelResource(SyncAPIResource): @cached_property - def with_raw_response(self) -> SecurityLevelWithRawResponse: - return SecurityLevelWithRawResponse(self) + def with_raw_response(self) -> SecurityLevelResourceWithRawResponse: + return SecurityLevelResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> SecurityLevelWithStreamingResponse: - return SecurityLevelWithStreamingResponse(self) + def with_streaming_response(self) -> SecurityLevelResourceWithStreamingResponse: + return SecurityLevelResourceWithStreamingResponse(self) def edit( self, @@ -49,7 +49,7 @@ def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingSecurityLevel]: + ) -> Optional[SecurityLevel]: """ Choose the appropriate security profile for your website, which will automatically adjust each of the security settings. If you choose to customize @@ -81,7 +81,7 @@ def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingSecurityLevel]], ResultWrapper[ZoneSettingSecurityLevel]), + cast_to=cast(Type[Optional[SecurityLevel]], ResultWrapper[SecurityLevel]), ) def get( @@ -94,7 +94,7 @@ def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingSecurityLevel]: + ) -> Optional[SecurityLevel]: """ Choose the appropriate security profile for your website, which will automatically adjust each of the security settings. If you choose to customize @@ -123,18 +123,18 @@ def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingSecurityLevel]], ResultWrapper[ZoneSettingSecurityLevel]), + cast_to=cast(Type[Optional[SecurityLevel]], ResultWrapper[SecurityLevel]), ) -class AsyncSecurityLevel(AsyncAPIResource): +class AsyncSecurityLevelResource(AsyncAPIResource): @cached_property - def with_raw_response(self) -> AsyncSecurityLevelWithRawResponse: - return AsyncSecurityLevelWithRawResponse(self) + def with_raw_response(self) -> AsyncSecurityLevelResourceWithRawResponse: + return AsyncSecurityLevelResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> AsyncSecurityLevelWithStreamingResponse: - return AsyncSecurityLevelWithStreamingResponse(self) + def with_streaming_response(self) -> AsyncSecurityLevelResourceWithStreamingResponse: + return AsyncSecurityLevelResourceWithStreamingResponse(self) async def edit( self, @@ -147,7 +147,7 @@ async def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingSecurityLevel]: + ) -> Optional[SecurityLevel]: """ Choose the appropriate security profile for your website, which will automatically adjust each of the security settings. If you choose to customize @@ -179,7 +179,7 @@ async def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingSecurityLevel]], ResultWrapper[ZoneSettingSecurityLevel]), + cast_to=cast(Type[Optional[SecurityLevel]], ResultWrapper[SecurityLevel]), ) async def get( @@ -192,7 +192,7 @@ async def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingSecurityLevel]: + ) -> Optional[SecurityLevel]: """ Choose the appropriate security profile for your website, which will automatically adjust each of the security settings. If you choose to customize @@ -221,12 +221,12 @@ async def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingSecurityLevel]], ResultWrapper[ZoneSettingSecurityLevel]), + cast_to=cast(Type[Optional[SecurityLevel]], ResultWrapper[SecurityLevel]), ) -class SecurityLevelWithRawResponse: - def __init__(self, security_level: SecurityLevel) -> None: +class SecurityLevelResourceWithRawResponse: + def __init__(self, security_level: SecurityLevelResource) -> None: self._security_level = security_level self.edit = to_raw_response_wrapper( @@ -237,8 +237,8 @@ def __init__(self, security_level: SecurityLevel) -> None: ) -class AsyncSecurityLevelWithRawResponse: - def __init__(self, security_level: AsyncSecurityLevel) -> None: +class AsyncSecurityLevelResourceWithRawResponse: + def __init__(self, security_level: AsyncSecurityLevelResource) -> None: self._security_level = security_level self.edit = async_to_raw_response_wrapper( @@ -249,8 +249,8 @@ def __init__(self, security_level: AsyncSecurityLevel) -> None: ) -class SecurityLevelWithStreamingResponse: - def __init__(self, security_level: SecurityLevel) -> None: +class SecurityLevelResourceWithStreamingResponse: + def __init__(self, security_level: SecurityLevelResource) -> None: self._security_level = security_level self.edit = to_streamed_response_wrapper( @@ -261,8 +261,8 @@ def __init__(self, security_level: SecurityLevel) -> None: ) -class AsyncSecurityLevelWithStreamingResponse: - def __init__(self, security_level: AsyncSecurityLevel) -> None: +class AsyncSecurityLevelResourceWithStreamingResponse: + def __init__(self, security_level: AsyncSecurityLevelResource) -> None: self._security_level = security_level self.edit = async_to_streamed_response_wrapper( diff --git a/src/cloudflare/resources/zones/settings/server_side_excludes.py b/src/cloudflare/resources/zones/settings/server_side_excludes.py index 275027853585..678e93362348 100644 --- a/src/cloudflare/resources/zones/settings/server_side_excludes.py +++ b/src/cloudflare/resources/zones/settings/server_side_excludes.py @@ -24,7 +24,7 @@ from ...._base_client import ( make_request_options, ) -from ....types.zones.settings import ZoneSettingServerSideExclude, server_side_exclude_edit_params +from ....types.zones.settings import server_side_excludes, server_side_exclude_edit_params __all__ = ["ServerSideExcludes", "AsyncServerSideExcludes"] @@ -49,7 +49,7 @@ def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingServerSideExclude]: + ) -> Optional[server_side_excludes.ServerSideExcludes]: """ If there is sensitive content on your website that you want visible to real visitors, but that you want to hide from suspicious visitors, all you have to do @@ -88,7 +88,10 @@ def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingServerSideExclude]], ResultWrapper[ZoneSettingServerSideExclude]), + cast_to=cast( + Type[Optional[server_side_excludes.ServerSideExcludes]], + ResultWrapper[server_side_excludes.ServerSideExcludes], + ), ) def get( @@ -101,7 +104,7 @@ def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingServerSideExclude]: + ) -> Optional[server_side_excludes.ServerSideExcludes]: """ If there is sensitive content on your website that you want visible to real visitors, but that you want to hide from suspicious visitors, all you have to do @@ -137,7 +140,10 @@ def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingServerSideExclude]], ResultWrapper[ZoneSettingServerSideExclude]), + cast_to=cast( + Type[Optional[server_side_excludes.ServerSideExcludes]], + ResultWrapper[server_side_excludes.ServerSideExcludes], + ), ) @@ -161,7 +167,7 @@ async def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingServerSideExclude]: + ) -> Optional[server_side_excludes.ServerSideExcludes]: """ If there is sensitive content on your website that you want visible to real visitors, but that you want to hide from suspicious visitors, all you have to do @@ -202,7 +208,10 @@ async def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingServerSideExclude]], ResultWrapper[ZoneSettingServerSideExclude]), + cast_to=cast( + Type[Optional[server_side_excludes.ServerSideExcludes]], + ResultWrapper[server_side_excludes.ServerSideExcludes], + ), ) async def get( @@ -215,7 +224,7 @@ async def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingServerSideExclude]: + ) -> Optional[server_side_excludes.ServerSideExcludes]: """ If there is sensitive content on your website that you want visible to real visitors, but that you want to hide from suspicious visitors, all you have to do @@ -251,7 +260,10 @@ async def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingServerSideExclude]], ResultWrapper[ZoneSettingServerSideExclude]), + cast_to=cast( + Type[Optional[server_side_excludes.ServerSideExcludes]], + ResultWrapper[server_side_excludes.ServerSideExcludes], + ), ) diff --git a/src/cloudflare/resources/zones/settings/settings.py b/src/cloudflare/resources/zones/settings/settings.py index 963366372966..3974be59ac1c 100644 --- a/src/cloudflare/resources/zones/settings/settings.py +++ b/src/cloudflare/resources/zones/settings/settings.py @@ -3,92 +3,92 @@ from __future__ import annotations from .nel import ( - NEL, - AsyncNEL, - NELWithRawResponse, - AsyncNELWithRawResponse, - NELWithStreamingResponse, - AsyncNELWithStreamingResponse, + NELResource, + AsyncNELResource, + NELResourceWithRawResponse, + AsyncNELResourceWithRawResponse, + NELResourceWithStreamingResponse, + AsyncNELResourceWithStreamingResponse, ) from .ssl import ( - SSL, - AsyncSSL, - SSLWithRawResponse, - AsyncSSLWithRawResponse, - SSLWithStreamingResponse, - AsyncSSLWithStreamingResponse, + SSLResource, + AsyncSSLResource, + SSLResourceWithRawResponse, + AsyncSSLResourceWithRawResponse, + SSLResourceWithStreamingResponse, + AsyncSSLResourceWithStreamingResponse, ) from .waf import ( - WAF, - AsyncWAF, - WAFWithRawResponse, - AsyncWAFWithRawResponse, - WAFWithStreamingResponse, - AsyncWAFWithStreamingResponse, + WAFResource, + AsyncWAFResource, + WAFResourceWithRawResponse, + AsyncWAFResourceWithRawResponse, + WAFResourceWithStreamingResponse, + AsyncWAFResourceWithStreamingResponse, ) from .ipv6 import ( - IPV6, - AsyncIPV6, - IPV6WithRawResponse, - AsyncIPV6WithRawResponse, - IPV6WithStreamingResponse, - AsyncIPV6WithStreamingResponse, + IPV6Resource, + AsyncIPV6Resource, + IPV6ResourceWithRawResponse, + AsyncIPV6ResourceWithRawResponse, + IPV6ResourceWithStreamingResponse, + AsyncIPV6ResourceWithStreamingResponse, ) from .webp import ( - WebP, - AsyncWebP, - WebPWithRawResponse, - AsyncWebPWithRawResponse, - WebPWithStreamingResponse, - AsyncWebPWithStreamingResponse, + WebPResource, + AsyncWebPResource, + WebPResourceWithRawResponse, + AsyncWebPResourceWithRawResponse, + WebPResourceWithStreamingResponse, + AsyncWebPResourceWithStreamingResponse, ) from .http2 import ( - HTTP2, - AsyncHTTP2, - HTTP2WithRawResponse, - AsyncHTTP2WithRawResponse, - HTTP2WithStreamingResponse, - AsyncHTTP2WithStreamingResponse, + HTTP2Resource, + AsyncHTTP2Resource, + HTTP2ResourceWithRawResponse, + AsyncHTTP2ResourceWithRawResponse, + HTTP2ResourceWithStreamingResponse, + AsyncHTTP2ResourceWithStreamingResponse, ) from .http3 import ( - HTTP3, - AsyncHTTP3, - HTTP3WithRawResponse, - AsyncHTTP3WithRawResponse, - HTTP3WithStreamingResponse, - AsyncHTTP3WithStreamingResponse, + HTTP3Resource, + AsyncHTTP3Resource, + HTTP3ResourceWithRawResponse, + AsyncHTTP3ResourceWithRawResponse, + HTTP3ResourceWithStreamingResponse, + AsyncHTTP3ResourceWithStreamingResponse, ) from .brotli import ( - Brotli, - AsyncBrotli, - BrotliWithRawResponse, - AsyncBrotliWithRawResponse, - BrotliWithStreamingResponse, - AsyncBrotliWithStreamingResponse, + BrotliResource, + AsyncBrotliResource, + BrotliResourceWithRawResponse, + AsyncBrotliResourceWithRawResponse, + BrotliResourceWithStreamingResponse, + AsyncBrotliResourceWithStreamingResponse, ) from .minify import ( - Minify, - AsyncMinify, - MinifyWithRawResponse, - AsyncMinifyWithRawResponse, - MinifyWithStreamingResponse, - AsyncMinifyWithStreamingResponse, + MinifyResource, + AsyncMinifyResource, + MinifyResourceWithRawResponse, + AsyncMinifyResourceWithRawResponse, + MinifyResourceWithStreamingResponse, + AsyncMinifyResourceWithStreamingResponse, ) from .mirage import ( - Mirage, - AsyncMirage, - MirageWithRawResponse, - AsyncMirageWithRawResponse, - MirageWithStreamingResponse, - AsyncMirageWithStreamingResponse, + MirageResource, + AsyncMirageResource, + MirageResourceWithRawResponse, + AsyncMirageResourceWithRawResponse, + MirageResourceWithStreamingResponse, + AsyncMirageResourceWithStreamingResponse, ) from .polish import ( - Polish, - AsyncPolish, - PolishWithRawResponse, - AsyncPolishWithRawResponse, - PolishWithStreamingResponse, - AsyncPolishWithStreamingResponse, + PolishResource, + AsyncPolishResource, + PolishResourceWithRawResponse, + AsyncPolishResourceWithRawResponse, + PolishResourceWithStreamingResponse, + AsyncPolishResourceWithStreamingResponse, ) from .ciphers import ( Ciphers, @@ -99,37 +99,37 @@ AsyncCiphersWithStreamingResponse, ) from .tls_1_3 import ( - TLS1_3, - AsyncTLS1_3, - TLS1_3WithRawResponse, - AsyncTLS1_3WithRawResponse, - TLS1_3WithStreamingResponse, - AsyncTLS1_3WithStreamingResponse, + TLS1_3Resource, + AsyncTLS1_3Resource, + TLS1_3ResourceWithRawResponse, + AsyncTLS1_3ResourceWithRawResponse, + TLS1_3ResourceWithStreamingResponse, + AsyncTLS1_3ResourceWithStreamingResponse, ) from .zero_rtt import ( - ZeroRTT, - AsyncZeroRTT, - ZeroRTTWithRawResponse, - AsyncZeroRTTWithRawResponse, - ZeroRTTWithStreamingResponse, - AsyncZeroRTTWithStreamingResponse, + ZeroRTTResource, + AsyncZeroRTTResource, + ZeroRTTResourceWithRawResponse, + AsyncZeroRTTResourceWithRawResponse, + ZeroRTTResourceWithStreamingResponse, + AsyncZeroRTTResourceWithStreamingResponse, ) from .websocket import ( - Websocket, - AsyncWebsocket, - WebsocketWithRawResponse, - AsyncWebsocketWithRawResponse, - WebsocketWithStreamingResponse, - AsyncWebsocketWithStreamingResponse, + WebsocketResource, + AsyncWebsocketResource, + WebsocketResourceWithRawResponse, + AsyncWebsocketResourceWithRawResponse, + WebsocketResourceWithStreamingResponse, + AsyncWebsocketResourceWithStreamingResponse, ) from ...._compat import cached_property from .cache_level import ( - CacheLevel, - AsyncCacheLevel, - CacheLevelWithRawResponse, - AsyncCacheLevelWithRawResponse, - CacheLevelWithStreamingResponse, - AsyncCacheLevelWithStreamingResponse, + CacheLevelResource, + AsyncCacheLevelResource, + CacheLevelResourceWithRawResponse, + AsyncCacheLevelResourceWithRawResponse, + CacheLevelResourceWithStreamingResponse, + AsyncCacheLevelResourceWithStreamingResponse, ) from .early_hints import ( EarlyHints, @@ -140,12 +140,12 @@ AsyncEarlyHintsWithStreamingResponse, ) from .pseudo_ipv4 import ( - PseudoIPV4, - AsyncPseudoIPV4, - PseudoIPV4WithRawResponse, - AsyncPseudoIPV4WithRawResponse, - PseudoIPV4WithStreamingResponse, - AsyncPseudoIPV4WithStreamingResponse, + PseudoIPV4Resource, + AsyncPseudoIPV4Resource, + PseudoIPV4ResourceWithRawResponse, + AsyncPseudoIPV4ResourceWithRawResponse, + PseudoIPV4ResourceWithStreamingResponse, + AsyncPseudoIPV4ResourceWithStreamingResponse, ) from ...._resource import SyncAPIResource, AsyncAPIResource from .advanced_ddos import ( @@ -157,28 +157,28 @@ AsyncAdvancedDDoSWithStreamingResponse, ) from .always_online import ( - AlwaysOnline, - AsyncAlwaysOnline, - AlwaysOnlineWithRawResponse, - AsyncAlwaysOnlineWithRawResponse, - AlwaysOnlineWithStreamingResponse, - AsyncAlwaysOnlineWithStreamingResponse, + AlwaysOnlineResource, + AsyncAlwaysOnlineResource, + AlwaysOnlineResourceWithRawResponse, + AsyncAlwaysOnlineResourceWithRawResponse, + AlwaysOnlineResourceWithStreamingResponse, + AsyncAlwaysOnlineResourceWithStreamingResponse, ) from .browser_check import ( - BrowserCheck, - AsyncBrowserCheck, - BrowserCheckWithRawResponse, - AsyncBrowserCheckWithRawResponse, - BrowserCheckWithStreamingResponse, - AsyncBrowserCheckWithStreamingResponse, + BrowserCheckResource, + AsyncBrowserCheckResource, + BrowserCheckResourceWithRawResponse, + AsyncBrowserCheckResourceWithRawResponse, + BrowserCheckResourceWithStreamingResponse, + AsyncBrowserCheckResourceWithStreamingResponse, ) from .challenge_ttl import ( - ChallengeTTL, - AsyncChallengeTTL, - ChallengeTTLWithRawResponse, - AsyncChallengeTTLWithRawResponse, - ChallengeTTLWithStreamingResponse, - AsyncChallengeTTLWithStreamingResponse, + ChallengeTTLResource, + AsyncChallengeTTLResource, + ChallengeTTLResourceWithRawResponse, + AsyncChallengeTTLResourceWithRawResponse, + ChallengeTTLResourceWithStreamingResponse, + AsyncChallengeTTLResourceWithStreamingResponse, ) from .font_settings import ( FontSettings, @@ -189,68 +189,68 @@ AsyncFontSettingsWithStreamingResponse, ) from .rocket_loader import ( - RocketLoader, - AsyncRocketLoader, - RocketLoaderWithRawResponse, - AsyncRocketLoaderWithRawResponse, - RocketLoaderWithStreamingResponse, - AsyncRocketLoaderWithStreamingResponse, + RocketLoaderResource, + AsyncRocketLoaderResource, + RocketLoaderResourceWithRawResponse, + AsyncRocketLoaderResourceWithRawResponse, + RocketLoaderResourceWithStreamingResponse, + AsyncRocketLoaderResourceWithStreamingResponse, ) from .image_resizing import ( - ImageResizing, - AsyncImageResizing, - ImageResizingWithRawResponse, - AsyncImageResizingWithRawResponse, - ImageResizingWithStreamingResponse, - AsyncImageResizingWithStreamingResponse, + ImageResizingResource, + AsyncImageResizingResource, + ImageResizingResourceWithRawResponse, + AsyncImageResizingResourceWithRawResponse, + ImageResizingResourceWithStreamingResponse, + AsyncImageResizingResourceWithStreamingResponse, ) from .ip_geolocation import ( - IPGeolocation, - AsyncIPGeolocation, - IPGeolocationWithRawResponse, - AsyncIPGeolocationWithRawResponse, - IPGeolocationWithStreamingResponse, - AsyncIPGeolocationWithStreamingResponse, + IPGeolocationResource, + AsyncIPGeolocationResource, + IPGeolocationResourceWithRawResponse, + AsyncIPGeolocationResourceWithRawResponse, + IPGeolocationResourceWithStreamingResponse, + AsyncIPGeolocationResourceWithStreamingResponse, ) from .security_level import ( - SecurityLevel, - AsyncSecurityLevel, - SecurityLevelWithRawResponse, - AsyncSecurityLevelWithRawResponse, - SecurityLevelWithStreamingResponse, - AsyncSecurityLevelWithStreamingResponse, + SecurityLevelResource, + AsyncSecurityLevelResource, + SecurityLevelResourceWithRawResponse, + AsyncSecurityLevelResourceWithRawResponse, + SecurityLevelResourceWithStreamingResponse, + AsyncSecurityLevelResourceWithStreamingResponse, ) from .min_tls_version import ( - MinTLSVersion, - AsyncMinTLSVersion, - MinTLSVersionWithRawResponse, - AsyncMinTLSVersionWithRawResponse, - MinTLSVersionWithStreamingResponse, - AsyncMinTLSVersionWithStreamingResponse, + MinTLSVersionResource, + AsyncMinTLSVersionResource, + MinTLSVersionResourceWithRawResponse, + AsyncMinTLSVersionResourceWithRawResponse, + MinTLSVersionResourceWithStreamingResponse, + AsyncMinTLSVersionResourceWithStreamingResponse, ) from .mobile_redirect import ( - MobileRedirect, - AsyncMobileRedirect, - MobileRedirectWithRawResponse, - AsyncMobileRedirectWithRawResponse, - MobileRedirectWithStreamingResponse, - AsyncMobileRedirectWithStreamingResponse, + MobileRedirectResource, + AsyncMobileRedirectResource, + MobileRedirectResourceWithRawResponse, + AsyncMobileRedirectResourceWithRawResponse, + MobileRedirectResourceWithStreamingResponse, + AsyncMobileRedirectResourceWithStreamingResponse, ) from .ssl_recommender import ( - SSLRecommender, - AsyncSSLRecommender, - SSLRecommenderWithRawResponse, - AsyncSSLRecommenderWithRawResponse, - SSLRecommenderWithStreamingResponse, - AsyncSSLRecommenderWithStreamingResponse, + SSLRecommenderResource, + AsyncSSLRecommenderResource, + SSLRecommenderResourceWithRawResponse, + AsyncSSLRecommenderResourceWithRawResponse, + SSLRecommenderResourceWithStreamingResponse, + AsyncSSLRecommenderResourceWithStreamingResponse, ) from .tls_client_auth import ( - TLSClientAuth, - AsyncTLSClientAuth, - TLSClientAuthWithRawResponse, - AsyncTLSClientAuthWithRawResponse, - TLSClientAuthWithStreamingResponse, - AsyncTLSClientAuthWithStreamingResponse, + TLSClientAuthResource, + AsyncTLSClientAuthResource, + TLSClientAuthResourceWithRawResponse, + AsyncTLSClientAuthResourceWithRawResponse, + TLSClientAuthResourceWithStreamingResponse, + AsyncTLSClientAuthResourceWithStreamingResponse, ) from .always_use_https import ( AlwaysUseHTTPS, @@ -261,28 +261,28 @@ AsyncAlwaysUseHTTPSWithStreamingResponse, ) from .development_mode import ( - DevelopmentMode, - AsyncDevelopmentMode, - DevelopmentModeWithRawResponse, - AsyncDevelopmentModeWithRawResponse, - DevelopmentModeWithStreamingResponse, - AsyncDevelopmentModeWithStreamingResponse, + DevelopmentModeResource, + AsyncDevelopmentModeResource, + DevelopmentModeResourceWithRawResponse, + AsyncDevelopmentModeResourceWithRawResponse, + DevelopmentModeResourceWithStreamingResponse, + AsyncDevelopmentModeResourceWithStreamingResponse, ) from .orange_to_orange import ( - OrangeToOrange, - AsyncOrangeToOrange, - OrangeToOrangeWithRawResponse, - AsyncOrangeToOrangeWithRawResponse, - OrangeToOrangeWithStreamingResponse, - AsyncOrangeToOrangeWithStreamingResponse, + OrangeToOrangeResource, + AsyncOrangeToOrangeResource, + OrangeToOrangeResourceWithRawResponse, + AsyncOrangeToOrangeResourceWithRawResponse, + OrangeToOrangeResourceWithStreamingResponse, + AsyncOrangeToOrangeResourceWithStreamingResponse, ) from .prefetch_preload import ( - PrefetchPreload, - AsyncPrefetchPreload, - PrefetchPreloadWithRawResponse, - AsyncPrefetchPreloadWithRawResponse, - PrefetchPreloadWithStreamingResponse, - AsyncPrefetchPreloadWithStreamingResponse, + PrefetchPreloadResource, + AsyncPrefetchPreloadResource, + PrefetchPreloadResourceWithRawResponse, + AsyncPrefetchPreloadResourceWithRawResponse, + PrefetchPreloadResourceWithStreamingResponse, + AsyncPrefetchPreloadResourceWithStreamingResponse, ) from .security_headers import ( SecurityHeaders, @@ -293,60 +293,60 @@ AsyncSecurityHeadersWithStreamingResponse, ) from .browser_cache_ttl import ( - BrowserCacheTTL, - AsyncBrowserCacheTTL, - BrowserCacheTTLWithRawResponse, - AsyncBrowserCacheTTLWithRawResponse, - BrowserCacheTTLWithStreamingResponse, - AsyncBrowserCacheTTLWithStreamingResponse, + BrowserCacheTTLResource, + AsyncBrowserCacheTTLResource, + BrowserCacheTTLResourceWithRawResponse, + AsyncBrowserCacheTTLResourceWithRawResponse, + BrowserCacheTTLResourceWithStreamingResponse, + AsyncBrowserCacheTTLResourceWithStreamingResponse, ) from .email_obfuscation import ( - EmailObfuscation, - AsyncEmailObfuscation, - EmailObfuscationWithRawResponse, - AsyncEmailObfuscationWithRawResponse, - EmailObfuscationWithStreamingResponse, - AsyncEmailObfuscationWithStreamingResponse, + EmailObfuscationResource, + AsyncEmailObfuscationResource, + EmailObfuscationResourceWithRawResponse, + AsyncEmailObfuscationResourceWithRawResponse, + EmailObfuscationResourceWithStreamingResponse, + AsyncEmailObfuscationResourceWithStreamingResponse, ) from .h2_prioritization import ( - H2Prioritization, - AsyncH2Prioritization, - H2PrioritizationWithRawResponse, - AsyncH2PrioritizationWithRawResponse, - H2PrioritizationWithStreamingResponse, - AsyncH2PrioritizationWithStreamingResponse, + H2PrioritizationResource, + AsyncH2PrioritizationResource, + H2PrioritizationResourceWithRawResponse, + AsyncH2PrioritizationResourceWithRawResponse, + H2PrioritizationResourceWithStreamingResponse, + AsyncH2PrioritizationResourceWithStreamingResponse, ) from .hotlink_protection import ( - HotlinkProtection, - AsyncHotlinkProtection, - HotlinkProtectionWithRawResponse, - AsyncHotlinkProtectionWithRawResponse, - HotlinkProtectionWithStreamingResponse, - AsyncHotlinkProtectionWithStreamingResponse, + HotlinkProtectionResource, + AsyncHotlinkProtectionResource, + HotlinkProtectionResourceWithRawResponse, + AsyncHotlinkProtectionResourceWithRawResponse, + HotlinkProtectionResourceWithStreamingResponse, + AsyncHotlinkProtectionResourceWithStreamingResponse, ) from .proxy_read_timeout import ( - ProxyReadTimeout, - AsyncProxyReadTimeout, - ProxyReadTimeoutWithRawResponse, - AsyncProxyReadTimeoutWithRawResponse, - ProxyReadTimeoutWithStreamingResponse, - AsyncProxyReadTimeoutWithStreamingResponse, + ProxyReadTimeoutResource, + AsyncProxyReadTimeoutResource, + ProxyReadTimeoutResourceWithRawResponse, + AsyncProxyReadTimeoutResourceWithRawResponse, + ProxyReadTimeoutResourceWithStreamingResponse, + AsyncProxyReadTimeoutResourceWithStreamingResponse, ) from .response_buffering import ( - ResponseBuffering, - AsyncResponseBuffering, - ResponseBufferingWithRawResponse, - AsyncResponseBufferingWithRawResponse, - ResponseBufferingWithStreamingResponse, - AsyncResponseBufferingWithStreamingResponse, + ResponseBufferingResource, + AsyncResponseBufferingResource, + ResponseBufferingResourceWithRawResponse, + AsyncResponseBufferingResourceWithRawResponse, + ResponseBufferingResourceWithStreamingResponse, + AsyncResponseBufferingResourceWithStreamingResponse, ) from .opportunistic_onion import ( - OpportunisticOnion, - AsyncOpportunisticOnion, - OpportunisticOnionWithRawResponse, - AsyncOpportunisticOnionWithRawResponse, - OpportunisticOnionWithStreamingResponse, - AsyncOpportunisticOnionWithStreamingResponse, + OpportunisticOnionResource, + AsyncOpportunisticOnionResource, + OpportunisticOnionResourceWithRawResponse, + AsyncOpportunisticOnionResourceWithRawResponse, + OpportunisticOnionResourceWithStreamingResponse, + AsyncOpportunisticOnionResourceWithStreamingResponse, ) from .server_side_excludes import ( ServerSideExcludes, @@ -357,12 +357,12 @@ AsyncServerSideExcludesWithStreamingResponse, ) from .true_client_ip_header import ( - TrueClientIPHeader, - AsyncTrueClientIPHeader, - TrueClientIPHeaderWithRawResponse, - AsyncTrueClientIPHeaderWithRawResponse, - TrueClientIPHeaderWithStreamingResponse, - AsyncTrueClientIPHeaderWithStreamingResponse, + TrueClientIPHeaderResource, + AsyncTrueClientIPHeaderResource, + TrueClientIPHeaderResourceWithRawResponse, + AsyncTrueClientIPHeaderResourceWithRawResponse, + TrueClientIPHeaderResourceWithStreamingResponse, + AsyncTrueClientIPHeaderResourceWithStreamingResponse, ) from .origin_max_http_version import ( OriginMaxHTTPVersion, @@ -381,36 +381,36 @@ AsyncAutomaticHTTPSRewritesWithStreamingResponse, ) from .opportunistic_encryption import ( - OpportunisticEncryption, - AsyncOpportunisticEncryption, - OpportunisticEncryptionWithRawResponse, - AsyncOpportunisticEncryptionWithRawResponse, - OpportunisticEncryptionWithStreamingResponse, - AsyncOpportunisticEncryptionWithStreamingResponse, + OpportunisticEncryptionResource, + AsyncOpportunisticEncryptionResource, + OpportunisticEncryptionResourceWithRawResponse, + AsyncOpportunisticEncryptionResourceWithRawResponse, + OpportunisticEncryptionResourceWithStreamingResponse, + AsyncOpportunisticEncryptionResourceWithStreamingResponse, ) from .origin_error_page_pass_thru import ( - OriginErrorPagePassThru, - AsyncOriginErrorPagePassThru, - OriginErrorPagePassThruWithRawResponse, - AsyncOriginErrorPagePassThruWithRawResponse, - OriginErrorPagePassThruWithStreamingResponse, - AsyncOriginErrorPagePassThruWithStreamingResponse, + OriginErrorPagePassThruResource, + AsyncOriginErrorPagePassThruResource, + OriginErrorPagePassThruResourceWithRawResponse, + AsyncOriginErrorPagePassThruResourceWithRawResponse, + OriginErrorPagePassThruResourceWithStreamingResponse, + AsyncOriginErrorPagePassThruResourceWithStreamingResponse, ) from .sort_query_string_for_cache import ( - SortQueryStringForCache, - AsyncSortQueryStringForCache, - SortQueryStringForCacheWithRawResponse, - AsyncSortQueryStringForCacheWithRawResponse, - SortQueryStringForCacheWithStreamingResponse, - AsyncSortQueryStringForCacheWithStreamingResponse, + SortQueryStringForCacheResource, + AsyncSortQueryStringForCacheResource, + SortQueryStringForCacheResourceWithRawResponse, + AsyncSortQueryStringForCacheResourceWithRawResponse, + SortQueryStringForCacheResourceWithStreamingResponse, + AsyncSortQueryStringForCacheResourceWithStreamingResponse, ) from .automatic_platform_optimization import ( - AutomaticPlatformOptimization, - AsyncAutomaticPlatformOptimization, - AutomaticPlatformOptimizationWithRawResponse, - AsyncAutomaticPlatformOptimizationWithRawResponse, - AutomaticPlatformOptimizationWithStreamingResponse, - AsyncAutomaticPlatformOptimizationWithStreamingResponse, + AutomaticPlatformOptimizationResource, + AsyncAutomaticPlatformOptimizationResource, + AutomaticPlatformOptimizationResourceWithRawResponse, + AsyncAutomaticPlatformOptimizationResourceWithRawResponse, + AutomaticPlatformOptimizationResourceWithStreamingResponse, + AsyncAutomaticPlatformOptimizationResourceWithStreamingResponse, ) __all__ = ["Settings", "AsyncSettings"] @@ -418,16 +418,16 @@ class Settings(SyncAPIResource): @cached_property - def zero_rtt(self) -> ZeroRTT: - return ZeroRTT(self._client) + def zero_rtt(self) -> ZeroRTTResource: + return ZeroRTTResource(self._client) @cached_property def advanced_ddos(self) -> AdvancedDDoS: return AdvancedDDoS(self._client) @cached_property - def always_online(self) -> AlwaysOnline: - return AlwaysOnline(self._client) + def always_online(self) -> AlwaysOnlineResource: + return AlwaysOnlineResource(self._client) @cached_property def always_use_https(self) -> AlwaysUseHTTPS: @@ -438,184 +438,184 @@ def automatic_https_rewrites(self) -> AutomaticHTTPSRewrites: return AutomaticHTTPSRewrites(self._client) @cached_property - def automatic_platform_optimization(self) -> AutomaticPlatformOptimization: - return AutomaticPlatformOptimization(self._client) + def automatic_platform_optimization(self) -> AutomaticPlatformOptimizationResource: + return AutomaticPlatformOptimizationResource(self._client) @cached_property - def brotli(self) -> Brotli: - return Brotli(self._client) + def brotli(self) -> BrotliResource: + return BrotliResource(self._client) @cached_property - def browser_cache_ttl(self) -> BrowserCacheTTL: - return BrowserCacheTTL(self._client) + def browser_cache_ttl(self) -> BrowserCacheTTLResource: + return BrowserCacheTTLResource(self._client) @cached_property - def browser_check(self) -> BrowserCheck: - return BrowserCheck(self._client) + def browser_check(self) -> BrowserCheckResource: + return BrowserCheckResource(self._client) @cached_property - def cache_level(self) -> CacheLevel: - return CacheLevel(self._client) + def cache_level(self) -> CacheLevelResource: + return CacheLevelResource(self._client) @cached_property - def challenge_ttl(self) -> ChallengeTTL: - return ChallengeTTL(self._client) + def challenge_ttl(self) -> ChallengeTTLResource: + return ChallengeTTLResource(self._client) @cached_property def ciphers(self) -> Ciphers: return Ciphers(self._client) @cached_property - def development_mode(self) -> DevelopmentMode: - return DevelopmentMode(self._client) + def development_mode(self) -> DevelopmentModeResource: + return DevelopmentModeResource(self._client) @cached_property def early_hints(self) -> EarlyHints: return EarlyHints(self._client) @cached_property - def email_obfuscation(self) -> EmailObfuscation: - return EmailObfuscation(self._client) + def email_obfuscation(self) -> EmailObfuscationResource: + return EmailObfuscationResource(self._client) @cached_property - def h2_prioritization(self) -> H2Prioritization: - return H2Prioritization(self._client) + def h2_prioritization(self) -> H2PrioritizationResource: + return H2PrioritizationResource(self._client) @cached_property - def hotlink_protection(self) -> HotlinkProtection: - return HotlinkProtection(self._client) + def hotlink_protection(self) -> HotlinkProtectionResource: + return HotlinkProtectionResource(self._client) @cached_property - def http2(self) -> HTTP2: - return HTTP2(self._client) + def http2(self) -> HTTP2Resource: + return HTTP2Resource(self._client) @cached_property - def http3(self) -> HTTP3: - return HTTP3(self._client) + def http3(self) -> HTTP3Resource: + return HTTP3Resource(self._client) @cached_property - def image_resizing(self) -> ImageResizing: - return ImageResizing(self._client) + def image_resizing(self) -> ImageResizingResource: + return ImageResizingResource(self._client) @cached_property - def ip_geolocation(self) -> IPGeolocation: - return IPGeolocation(self._client) + def ip_geolocation(self) -> IPGeolocationResource: + return IPGeolocationResource(self._client) @cached_property - def ipv6(self) -> IPV6: - return IPV6(self._client) + def ipv6(self) -> IPV6Resource: + return IPV6Resource(self._client) @cached_property - def min_tls_version(self) -> MinTLSVersion: - return MinTLSVersion(self._client) + def min_tls_version(self) -> MinTLSVersionResource: + return MinTLSVersionResource(self._client) @cached_property - def minify(self) -> Minify: - return Minify(self._client) + def minify(self) -> MinifyResource: + return MinifyResource(self._client) @cached_property - def mirage(self) -> Mirage: - return Mirage(self._client) + def mirage(self) -> MirageResource: + return MirageResource(self._client) @cached_property - def mobile_redirect(self) -> MobileRedirect: - return MobileRedirect(self._client) + def mobile_redirect(self) -> MobileRedirectResource: + return MobileRedirectResource(self._client) @cached_property - def nel(self) -> NEL: - return NEL(self._client) + def nel(self) -> NELResource: + return NELResource(self._client) @cached_property - def opportunistic_encryption(self) -> OpportunisticEncryption: - return OpportunisticEncryption(self._client) + def opportunistic_encryption(self) -> OpportunisticEncryptionResource: + return OpportunisticEncryptionResource(self._client) @cached_property - def opportunistic_onion(self) -> OpportunisticOnion: - return OpportunisticOnion(self._client) + def opportunistic_onion(self) -> OpportunisticOnionResource: + return OpportunisticOnionResource(self._client) @cached_property - def orange_to_orange(self) -> OrangeToOrange: - return OrangeToOrange(self._client) + def orange_to_orange(self) -> OrangeToOrangeResource: + return OrangeToOrangeResource(self._client) @cached_property - def origin_error_page_pass_thru(self) -> OriginErrorPagePassThru: - return OriginErrorPagePassThru(self._client) + def origin_error_page_pass_thru(self) -> OriginErrorPagePassThruResource: + return OriginErrorPagePassThruResource(self._client) @cached_property def origin_max_http_version(self) -> OriginMaxHTTPVersion: return OriginMaxHTTPVersion(self._client) @cached_property - def polish(self) -> Polish: - return Polish(self._client) + def polish(self) -> PolishResource: + return PolishResource(self._client) @cached_property - def prefetch_preload(self) -> PrefetchPreload: - return PrefetchPreload(self._client) + def prefetch_preload(self) -> PrefetchPreloadResource: + return PrefetchPreloadResource(self._client) @cached_property - def proxy_read_timeout(self) -> ProxyReadTimeout: - return ProxyReadTimeout(self._client) + def proxy_read_timeout(self) -> ProxyReadTimeoutResource: + return ProxyReadTimeoutResource(self._client) @cached_property - def pseudo_ipv4(self) -> PseudoIPV4: - return PseudoIPV4(self._client) + def pseudo_ipv4(self) -> PseudoIPV4Resource: + return PseudoIPV4Resource(self._client) @cached_property - def response_buffering(self) -> ResponseBuffering: - return ResponseBuffering(self._client) + def response_buffering(self) -> ResponseBufferingResource: + return ResponseBufferingResource(self._client) @cached_property - def rocket_loader(self) -> RocketLoader: - return RocketLoader(self._client) + def rocket_loader(self) -> RocketLoaderResource: + return RocketLoaderResource(self._client) @cached_property def security_headers(self) -> SecurityHeaders: return SecurityHeaders(self._client) @cached_property - def security_level(self) -> SecurityLevel: - return SecurityLevel(self._client) + def security_level(self) -> SecurityLevelResource: + return SecurityLevelResource(self._client) @cached_property def server_side_excludes(self) -> ServerSideExcludes: return ServerSideExcludes(self._client) @cached_property - def sort_query_string_for_cache(self) -> SortQueryStringForCache: - return SortQueryStringForCache(self._client) + def sort_query_string_for_cache(self) -> SortQueryStringForCacheResource: + return SortQueryStringForCacheResource(self._client) @cached_property - def ssl(self) -> SSL: - return SSL(self._client) + def ssl(self) -> SSLResource: + return SSLResource(self._client) @cached_property - def ssl_recommender(self) -> SSLRecommender: - return SSLRecommender(self._client) + def ssl_recommender(self) -> SSLRecommenderResource: + return SSLRecommenderResource(self._client) @cached_property - def tls_1_3(self) -> TLS1_3: - return TLS1_3(self._client) + def tls_1_3(self) -> TLS1_3Resource: + return TLS1_3Resource(self._client) @cached_property - def tls_client_auth(self) -> TLSClientAuth: - return TLSClientAuth(self._client) + def tls_client_auth(self) -> TLSClientAuthResource: + return TLSClientAuthResource(self._client) @cached_property - def true_client_ip_header(self) -> TrueClientIPHeader: - return TrueClientIPHeader(self._client) + def true_client_ip_header(self) -> TrueClientIPHeaderResource: + return TrueClientIPHeaderResource(self._client) @cached_property - def waf(self) -> WAF: - return WAF(self._client) + def waf(self) -> WAFResource: + return WAFResource(self._client) @cached_property - def webp(self) -> WebP: - return WebP(self._client) + def webp(self) -> WebPResource: + return WebPResource(self._client) @cached_property - def websocket(self) -> Websocket: - return Websocket(self._client) + def websocket(self) -> WebsocketResource: + return WebsocketResource(self._client) @cached_property def font_settings(self) -> FontSettings: @@ -632,16 +632,16 @@ def with_streaming_response(self) -> SettingsWithStreamingResponse: class AsyncSettings(AsyncAPIResource): @cached_property - def zero_rtt(self) -> AsyncZeroRTT: - return AsyncZeroRTT(self._client) + def zero_rtt(self) -> AsyncZeroRTTResource: + return AsyncZeroRTTResource(self._client) @cached_property def advanced_ddos(self) -> AsyncAdvancedDDoS: return AsyncAdvancedDDoS(self._client) @cached_property - def always_online(self) -> AsyncAlwaysOnline: - return AsyncAlwaysOnline(self._client) + def always_online(self) -> AsyncAlwaysOnlineResource: + return AsyncAlwaysOnlineResource(self._client) @cached_property def always_use_https(self) -> AsyncAlwaysUseHTTPS: @@ -652,184 +652,184 @@ def automatic_https_rewrites(self) -> AsyncAutomaticHTTPSRewrites: return AsyncAutomaticHTTPSRewrites(self._client) @cached_property - def automatic_platform_optimization(self) -> AsyncAutomaticPlatformOptimization: - return AsyncAutomaticPlatformOptimization(self._client) + def automatic_platform_optimization(self) -> AsyncAutomaticPlatformOptimizationResource: + return AsyncAutomaticPlatformOptimizationResource(self._client) @cached_property - def brotli(self) -> AsyncBrotli: - return AsyncBrotli(self._client) + def brotli(self) -> AsyncBrotliResource: + return AsyncBrotliResource(self._client) @cached_property - def browser_cache_ttl(self) -> AsyncBrowserCacheTTL: - return AsyncBrowserCacheTTL(self._client) + def browser_cache_ttl(self) -> AsyncBrowserCacheTTLResource: + return AsyncBrowserCacheTTLResource(self._client) @cached_property - def browser_check(self) -> AsyncBrowserCheck: - return AsyncBrowserCheck(self._client) + def browser_check(self) -> AsyncBrowserCheckResource: + return AsyncBrowserCheckResource(self._client) @cached_property - def cache_level(self) -> AsyncCacheLevel: - return AsyncCacheLevel(self._client) + def cache_level(self) -> AsyncCacheLevelResource: + return AsyncCacheLevelResource(self._client) @cached_property - def challenge_ttl(self) -> AsyncChallengeTTL: - return AsyncChallengeTTL(self._client) + def challenge_ttl(self) -> AsyncChallengeTTLResource: + return AsyncChallengeTTLResource(self._client) @cached_property def ciphers(self) -> AsyncCiphers: return AsyncCiphers(self._client) @cached_property - def development_mode(self) -> AsyncDevelopmentMode: - return AsyncDevelopmentMode(self._client) + def development_mode(self) -> AsyncDevelopmentModeResource: + return AsyncDevelopmentModeResource(self._client) @cached_property def early_hints(self) -> AsyncEarlyHints: return AsyncEarlyHints(self._client) @cached_property - def email_obfuscation(self) -> AsyncEmailObfuscation: - return AsyncEmailObfuscation(self._client) + def email_obfuscation(self) -> AsyncEmailObfuscationResource: + return AsyncEmailObfuscationResource(self._client) @cached_property - def h2_prioritization(self) -> AsyncH2Prioritization: - return AsyncH2Prioritization(self._client) + def h2_prioritization(self) -> AsyncH2PrioritizationResource: + return AsyncH2PrioritizationResource(self._client) @cached_property - def hotlink_protection(self) -> AsyncHotlinkProtection: - return AsyncHotlinkProtection(self._client) + def hotlink_protection(self) -> AsyncHotlinkProtectionResource: + return AsyncHotlinkProtectionResource(self._client) @cached_property - def http2(self) -> AsyncHTTP2: - return AsyncHTTP2(self._client) + def http2(self) -> AsyncHTTP2Resource: + return AsyncHTTP2Resource(self._client) @cached_property - def http3(self) -> AsyncHTTP3: - return AsyncHTTP3(self._client) + def http3(self) -> AsyncHTTP3Resource: + return AsyncHTTP3Resource(self._client) @cached_property - def image_resizing(self) -> AsyncImageResizing: - return AsyncImageResizing(self._client) + def image_resizing(self) -> AsyncImageResizingResource: + return AsyncImageResizingResource(self._client) @cached_property - def ip_geolocation(self) -> AsyncIPGeolocation: - return AsyncIPGeolocation(self._client) + def ip_geolocation(self) -> AsyncIPGeolocationResource: + return AsyncIPGeolocationResource(self._client) @cached_property - def ipv6(self) -> AsyncIPV6: - return AsyncIPV6(self._client) + def ipv6(self) -> AsyncIPV6Resource: + return AsyncIPV6Resource(self._client) @cached_property - def min_tls_version(self) -> AsyncMinTLSVersion: - return AsyncMinTLSVersion(self._client) + def min_tls_version(self) -> AsyncMinTLSVersionResource: + return AsyncMinTLSVersionResource(self._client) @cached_property - def minify(self) -> AsyncMinify: - return AsyncMinify(self._client) + def minify(self) -> AsyncMinifyResource: + return AsyncMinifyResource(self._client) @cached_property - def mirage(self) -> AsyncMirage: - return AsyncMirage(self._client) + def mirage(self) -> AsyncMirageResource: + return AsyncMirageResource(self._client) @cached_property - def mobile_redirect(self) -> AsyncMobileRedirect: - return AsyncMobileRedirect(self._client) + def mobile_redirect(self) -> AsyncMobileRedirectResource: + return AsyncMobileRedirectResource(self._client) @cached_property - def nel(self) -> AsyncNEL: - return AsyncNEL(self._client) + def nel(self) -> AsyncNELResource: + return AsyncNELResource(self._client) @cached_property - def opportunistic_encryption(self) -> AsyncOpportunisticEncryption: - return AsyncOpportunisticEncryption(self._client) + def opportunistic_encryption(self) -> AsyncOpportunisticEncryptionResource: + return AsyncOpportunisticEncryptionResource(self._client) @cached_property - def opportunistic_onion(self) -> AsyncOpportunisticOnion: - return AsyncOpportunisticOnion(self._client) + def opportunistic_onion(self) -> AsyncOpportunisticOnionResource: + return AsyncOpportunisticOnionResource(self._client) @cached_property - def orange_to_orange(self) -> AsyncOrangeToOrange: - return AsyncOrangeToOrange(self._client) + def orange_to_orange(self) -> AsyncOrangeToOrangeResource: + return AsyncOrangeToOrangeResource(self._client) @cached_property - def origin_error_page_pass_thru(self) -> AsyncOriginErrorPagePassThru: - return AsyncOriginErrorPagePassThru(self._client) + def origin_error_page_pass_thru(self) -> AsyncOriginErrorPagePassThruResource: + return AsyncOriginErrorPagePassThruResource(self._client) @cached_property def origin_max_http_version(self) -> AsyncOriginMaxHTTPVersion: return AsyncOriginMaxHTTPVersion(self._client) @cached_property - def polish(self) -> AsyncPolish: - return AsyncPolish(self._client) + def polish(self) -> AsyncPolishResource: + return AsyncPolishResource(self._client) @cached_property - def prefetch_preload(self) -> AsyncPrefetchPreload: - return AsyncPrefetchPreload(self._client) + def prefetch_preload(self) -> AsyncPrefetchPreloadResource: + return AsyncPrefetchPreloadResource(self._client) @cached_property - def proxy_read_timeout(self) -> AsyncProxyReadTimeout: - return AsyncProxyReadTimeout(self._client) + def proxy_read_timeout(self) -> AsyncProxyReadTimeoutResource: + return AsyncProxyReadTimeoutResource(self._client) @cached_property - def pseudo_ipv4(self) -> AsyncPseudoIPV4: - return AsyncPseudoIPV4(self._client) + def pseudo_ipv4(self) -> AsyncPseudoIPV4Resource: + return AsyncPseudoIPV4Resource(self._client) @cached_property - def response_buffering(self) -> AsyncResponseBuffering: - return AsyncResponseBuffering(self._client) + def response_buffering(self) -> AsyncResponseBufferingResource: + return AsyncResponseBufferingResource(self._client) @cached_property - def rocket_loader(self) -> AsyncRocketLoader: - return AsyncRocketLoader(self._client) + def rocket_loader(self) -> AsyncRocketLoaderResource: + return AsyncRocketLoaderResource(self._client) @cached_property def security_headers(self) -> AsyncSecurityHeaders: return AsyncSecurityHeaders(self._client) @cached_property - def security_level(self) -> AsyncSecurityLevel: - return AsyncSecurityLevel(self._client) + def security_level(self) -> AsyncSecurityLevelResource: + return AsyncSecurityLevelResource(self._client) @cached_property def server_side_excludes(self) -> AsyncServerSideExcludes: return AsyncServerSideExcludes(self._client) @cached_property - def sort_query_string_for_cache(self) -> AsyncSortQueryStringForCache: - return AsyncSortQueryStringForCache(self._client) + def sort_query_string_for_cache(self) -> AsyncSortQueryStringForCacheResource: + return AsyncSortQueryStringForCacheResource(self._client) @cached_property - def ssl(self) -> AsyncSSL: - return AsyncSSL(self._client) + def ssl(self) -> AsyncSSLResource: + return AsyncSSLResource(self._client) @cached_property - def ssl_recommender(self) -> AsyncSSLRecommender: - return AsyncSSLRecommender(self._client) + def ssl_recommender(self) -> AsyncSSLRecommenderResource: + return AsyncSSLRecommenderResource(self._client) @cached_property - def tls_1_3(self) -> AsyncTLS1_3: - return AsyncTLS1_3(self._client) + def tls_1_3(self) -> AsyncTLS1_3Resource: + return AsyncTLS1_3Resource(self._client) @cached_property - def tls_client_auth(self) -> AsyncTLSClientAuth: - return AsyncTLSClientAuth(self._client) + def tls_client_auth(self) -> AsyncTLSClientAuthResource: + return AsyncTLSClientAuthResource(self._client) @cached_property - def true_client_ip_header(self) -> AsyncTrueClientIPHeader: - return AsyncTrueClientIPHeader(self._client) + def true_client_ip_header(self) -> AsyncTrueClientIPHeaderResource: + return AsyncTrueClientIPHeaderResource(self._client) @cached_property - def waf(self) -> AsyncWAF: - return AsyncWAF(self._client) + def waf(self) -> AsyncWAFResource: + return AsyncWAFResource(self._client) @cached_property - def webp(self) -> AsyncWebP: - return AsyncWebP(self._client) + def webp(self) -> AsyncWebPResource: + return AsyncWebPResource(self._client) @cached_property - def websocket(self) -> AsyncWebsocket: - return AsyncWebsocket(self._client) + def websocket(self) -> AsyncWebsocketResource: + return AsyncWebsocketResource(self._client) @cached_property def font_settings(self) -> AsyncFontSettings: @@ -849,16 +849,16 @@ def __init__(self, settings: Settings) -> None: self._settings = settings @cached_property - def zero_rtt(self) -> ZeroRTTWithRawResponse: - return ZeroRTTWithRawResponse(self._settings.zero_rtt) + def zero_rtt(self) -> ZeroRTTResourceWithRawResponse: + return ZeroRTTResourceWithRawResponse(self._settings.zero_rtt) @cached_property def advanced_ddos(self) -> AdvancedDDoSWithRawResponse: return AdvancedDDoSWithRawResponse(self._settings.advanced_ddos) @cached_property - def always_online(self) -> AlwaysOnlineWithRawResponse: - return AlwaysOnlineWithRawResponse(self._settings.always_online) + def always_online(self) -> AlwaysOnlineResourceWithRawResponse: + return AlwaysOnlineResourceWithRawResponse(self._settings.always_online) @cached_property def always_use_https(self) -> AlwaysUseHTTPSWithRawResponse: @@ -869,184 +869,184 @@ def automatic_https_rewrites(self) -> AutomaticHTTPSRewritesWithRawResponse: return AutomaticHTTPSRewritesWithRawResponse(self._settings.automatic_https_rewrites) @cached_property - def automatic_platform_optimization(self) -> AutomaticPlatformOptimizationWithRawResponse: - return AutomaticPlatformOptimizationWithRawResponse(self._settings.automatic_platform_optimization) + def automatic_platform_optimization(self) -> AutomaticPlatformOptimizationResourceWithRawResponse: + return AutomaticPlatformOptimizationResourceWithRawResponse(self._settings.automatic_platform_optimization) @cached_property - def brotli(self) -> BrotliWithRawResponse: - return BrotliWithRawResponse(self._settings.brotli) + def brotli(self) -> BrotliResourceWithRawResponse: + return BrotliResourceWithRawResponse(self._settings.brotli) @cached_property - def browser_cache_ttl(self) -> BrowserCacheTTLWithRawResponse: - return BrowserCacheTTLWithRawResponse(self._settings.browser_cache_ttl) + def browser_cache_ttl(self) -> BrowserCacheTTLResourceWithRawResponse: + return BrowserCacheTTLResourceWithRawResponse(self._settings.browser_cache_ttl) @cached_property - def browser_check(self) -> BrowserCheckWithRawResponse: - return BrowserCheckWithRawResponse(self._settings.browser_check) + def browser_check(self) -> BrowserCheckResourceWithRawResponse: + return BrowserCheckResourceWithRawResponse(self._settings.browser_check) @cached_property - def cache_level(self) -> CacheLevelWithRawResponse: - return CacheLevelWithRawResponse(self._settings.cache_level) + def cache_level(self) -> CacheLevelResourceWithRawResponse: + return CacheLevelResourceWithRawResponse(self._settings.cache_level) @cached_property - def challenge_ttl(self) -> ChallengeTTLWithRawResponse: - return ChallengeTTLWithRawResponse(self._settings.challenge_ttl) + def challenge_ttl(self) -> ChallengeTTLResourceWithRawResponse: + return ChallengeTTLResourceWithRawResponse(self._settings.challenge_ttl) @cached_property def ciphers(self) -> CiphersWithRawResponse: return CiphersWithRawResponse(self._settings.ciphers) @cached_property - def development_mode(self) -> DevelopmentModeWithRawResponse: - return DevelopmentModeWithRawResponse(self._settings.development_mode) + def development_mode(self) -> DevelopmentModeResourceWithRawResponse: + return DevelopmentModeResourceWithRawResponse(self._settings.development_mode) @cached_property def early_hints(self) -> EarlyHintsWithRawResponse: return EarlyHintsWithRawResponse(self._settings.early_hints) @cached_property - def email_obfuscation(self) -> EmailObfuscationWithRawResponse: - return EmailObfuscationWithRawResponse(self._settings.email_obfuscation) + def email_obfuscation(self) -> EmailObfuscationResourceWithRawResponse: + return EmailObfuscationResourceWithRawResponse(self._settings.email_obfuscation) @cached_property - def h2_prioritization(self) -> H2PrioritizationWithRawResponse: - return H2PrioritizationWithRawResponse(self._settings.h2_prioritization) + def h2_prioritization(self) -> H2PrioritizationResourceWithRawResponse: + return H2PrioritizationResourceWithRawResponse(self._settings.h2_prioritization) @cached_property - def hotlink_protection(self) -> HotlinkProtectionWithRawResponse: - return HotlinkProtectionWithRawResponse(self._settings.hotlink_protection) + def hotlink_protection(self) -> HotlinkProtectionResourceWithRawResponse: + return HotlinkProtectionResourceWithRawResponse(self._settings.hotlink_protection) @cached_property - def http2(self) -> HTTP2WithRawResponse: - return HTTP2WithRawResponse(self._settings.http2) + def http2(self) -> HTTP2ResourceWithRawResponse: + return HTTP2ResourceWithRawResponse(self._settings.http2) @cached_property - def http3(self) -> HTTP3WithRawResponse: - return HTTP3WithRawResponse(self._settings.http3) + def http3(self) -> HTTP3ResourceWithRawResponse: + return HTTP3ResourceWithRawResponse(self._settings.http3) @cached_property - def image_resizing(self) -> ImageResizingWithRawResponse: - return ImageResizingWithRawResponse(self._settings.image_resizing) + def image_resizing(self) -> ImageResizingResourceWithRawResponse: + return ImageResizingResourceWithRawResponse(self._settings.image_resizing) @cached_property - def ip_geolocation(self) -> IPGeolocationWithRawResponse: - return IPGeolocationWithRawResponse(self._settings.ip_geolocation) + def ip_geolocation(self) -> IPGeolocationResourceWithRawResponse: + return IPGeolocationResourceWithRawResponse(self._settings.ip_geolocation) @cached_property - def ipv6(self) -> IPV6WithRawResponse: - return IPV6WithRawResponse(self._settings.ipv6) + def ipv6(self) -> IPV6ResourceWithRawResponse: + return IPV6ResourceWithRawResponse(self._settings.ipv6) @cached_property - def min_tls_version(self) -> MinTLSVersionWithRawResponse: - return MinTLSVersionWithRawResponse(self._settings.min_tls_version) + def min_tls_version(self) -> MinTLSVersionResourceWithRawResponse: + return MinTLSVersionResourceWithRawResponse(self._settings.min_tls_version) @cached_property - def minify(self) -> MinifyWithRawResponse: - return MinifyWithRawResponse(self._settings.minify) + def minify(self) -> MinifyResourceWithRawResponse: + return MinifyResourceWithRawResponse(self._settings.minify) @cached_property - def mirage(self) -> MirageWithRawResponse: - return MirageWithRawResponse(self._settings.mirage) + def mirage(self) -> MirageResourceWithRawResponse: + return MirageResourceWithRawResponse(self._settings.mirage) @cached_property - def mobile_redirect(self) -> MobileRedirectWithRawResponse: - return MobileRedirectWithRawResponse(self._settings.mobile_redirect) + def mobile_redirect(self) -> MobileRedirectResourceWithRawResponse: + return MobileRedirectResourceWithRawResponse(self._settings.mobile_redirect) @cached_property - def nel(self) -> NELWithRawResponse: - return NELWithRawResponse(self._settings.nel) + def nel(self) -> NELResourceWithRawResponse: + return NELResourceWithRawResponse(self._settings.nel) @cached_property - def opportunistic_encryption(self) -> OpportunisticEncryptionWithRawResponse: - return OpportunisticEncryptionWithRawResponse(self._settings.opportunistic_encryption) + def opportunistic_encryption(self) -> OpportunisticEncryptionResourceWithRawResponse: + return OpportunisticEncryptionResourceWithRawResponse(self._settings.opportunistic_encryption) @cached_property - def opportunistic_onion(self) -> OpportunisticOnionWithRawResponse: - return OpportunisticOnionWithRawResponse(self._settings.opportunistic_onion) + def opportunistic_onion(self) -> OpportunisticOnionResourceWithRawResponse: + return OpportunisticOnionResourceWithRawResponse(self._settings.opportunistic_onion) @cached_property - def orange_to_orange(self) -> OrangeToOrangeWithRawResponse: - return OrangeToOrangeWithRawResponse(self._settings.orange_to_orange) + def orange_to_orange(self) -> OrangeToOrangeResourceWithRawResponse: + return OrangeToOrangeResourceWithRawResponse(self._settings.orange_to_orange) @cached_property - def origin_error_page_pass_thru(self) -> OriginErrorPagePassThruWithRawResponse: - return OriginErrorPagePassThruWithRawResponse(self._settings.origin_error_page_pass_thru) + def origin_error_page_pass_thru(self) -> OriginErrorPagePassThruResourceWithRawResponse: + return OriginErrorPagePassThruResourceWithRawResponse(self._settings.origin_error_page_pass_thru) @cached_property def origin_max_http_version(self) -> OriginMaxHTTPVersionWithRawResponse: return OriginMaxHTTPVersionWithRawResponse(self._settings.origin_max_http_version) @cached_property - def polish(self) -> PolishWithRawResponse: - return PolishWithRawResponse(self._settings.polish) + def polish(self) -> PolishResourceWithRawResponse: + return PolishResourceWithRawResponse(self._settings.polish) @cached_property - def prefetch_preload(self) -> PrefetchPreloadWithRawResponse: - return PrefetchPreloadWithRawResponse(self._settings.prefetch_preload) + def prefetch_preload(self) -> PrefetchPreloadResourceWithRawResponse: + return PrefetchPreloadResourceWithRawResponse(self._settings.prefetch_preload) @cached_property - def proxy_read_timeout(self) -> ProxyReadTimeoutWithRawResponse: - return ProxyReadTimeoutWithRawResponse(self._settings.proxy_read_timeout) + def proxy_read_timeout(self) -> ProxyReadTimeoutResourceWithRawResponse: + return ProxyReadTimeoutResourceWithRawResponse(self._settings.proxy_read_timeout) @cached_property - def pseudo_ipv4(self) -> PseudoIPV4WithRawResponse: - return PseudoIPV4WithRawResponse(self._settings.pseudo_ipv4) + def pseudo_ipv4(self) -> PseudoIPV4ResourceWithRawResponse: + return PseudoIPV4ResourceWithRawResponse(self._settings.pseudo_ipv4) @cached_property - def response_buffering(self) -> ResponseBufferingWithRawResponse: - return ResponseBufferingWithRawResponse(self._settings.response_buffering) + def response_buffering(self) -> ResponseBufferingResourceWithRawResponse: + return ResponseBufferingResourceWithRawResponse(self._settings.response_buffering) @cached_property - def rocket_loader(self) -> RocketLoaderWithRawResponse: - return RocketLoaderWithRawResponse(self._settings.rocket_loader) + def rocket_loader(self) -> RocketLoaderResourceWithRawResponse: + return RocketLoaderResourceWithRawResponse(self._settings.rocket_loader) @cached_property def security_headers(self) -> SecurityHeadersWithRawResponse: return SecurityHeadersWithRawResponse(self._settings.security_headers) @cached_property - def security_level(self) -> SecurityLevelWithRawResponse: - return SecurityLevelWithRawResponse(self._settings.security_level) + def security_level(self) -> SecurityLevelResourceWithRawResponse: + return SecurityLevelResourceWithRawResponse(self._settings.security_level) @cached_property def server_side_excludes(self) -> ServerSideExcludesWithRawResponse: return ServerSideExcludesWithRawResponse(self._settings.server_side_excludes) @cached_property - def sort_query_string_for_cache(self) -> SortQueryStringForCacheWithRawResponse: - return SortQueryStringForCacheWithRawResponse(self._settings.sort_query_string_for_cache) + def sort_query_string_for_cache(self) -> SortQueryStringForCacheResourceWithRawResponse: + return SortQueryStringForCacheResourceWithRawResponse(self._settings.sort_query_string_for_cache) @cached_property - def ssl(self) -> SSLWithRawResponse: - return SSLWithRawResponse(self._settings.ssl) + def ssl(self) -> SSLResourceWithRawResponse: + return SSLResourceWithRawResponse(self._settings.ssl) @cached_property - def ssl_recommender(self) -> SSLRecommenderWithRawResponse: - return SSLRecommenderWithRawResponse(self._settings.ssl_recommender) + def ssl_recommender(self) -> SSLRecommenderResourceWithRawResponse: + return SSLRecommenderResourceWithRawResponse(self._settings.ssl_recommender) @cached_property - def tls_1_3(self) -> TLS1_3WithRawResponse: - return TLS1_3WithRawResponse(self._settings.tls_1_3) + def tls_1_3(self) -> TLS1_3ResourceWithRawResponse: + return TLS1_3ResourceWithRawResponse(self._settings.tls_1_3) @cached_property - def tls_client_auth(self) -> TLSClientAuthWithRawResponse: - return TLSClientAuthWithRawResponse(self._settings.tls_client_auth) + def tls_client_auth(self) -> TLSClientAuthResourceWithRawResponse: + return TLSClientAuthResourceWithRawResponse(self._settings.tls_client_auth) @cached_property - def true_client_ip_header(self) -> TrueClientIPHeaderWithRawResponse: - return TrueClientIPHeaderWithRawResponse(self._settings.true_client_ip_header) + def true_client_ip_header(self) -> TrueClientIPHeaderResourceWithRawResponse: + return TrueClientIPHeaderResourceWithRawResponse(self._settings.true_client_ip_header) @cached_property - def waf(self) -> WAFWithRawResponse: - return WAFWithRawResponse(self._settings.waf) + def waf(self) -> WAFResourceWithRawResponse: + return WAFResourceWithRawResponse(self._settings.waf) @cached_property - def webp(self) -> WebPWithRawResponse: - return WebPWithRawResponse(self._settings.webp) + def webp(self) -> WebPResourceWithRawResponse: + return WebPResourceWithRawResponse(self._settings.webp) @cached_property - def websocket(self) -> WebsocketWithRawResponse: - return WebsocketWithRawResponse(self._settings.websocket) + def websocket(self) -> WebsocketResourceWithRawResponse: + return WebsocketResourceWithRawResponse(self._settings.websocket) @cached_property def font_settings(self) -> FontSettingsWithRawResponse: @@ -1058,16 +1058,16 @@ def __init__(self, settings: AsyncSettings) -> None: self._settings = settings @cached_property - def zero_rtt(self) -> AsyncZeroRTTWithRawResponse: - return AsyncZeroRTTWithRawResponse(self._settings.zero_rtt) + def zero_rtt(self) -> AsyncZeroRTTResourceWithRawResponse: + return AsyncZeroRTTResourceWithRawResponse(self._settings.zero_rtt) @cached_property def advanced_ddos(self) -> AsyncAdvancedDDoSWithRawResponse: return AsyncAdvancedDDoSWithRawResponse(self._settings.advanced_ddos) @cached_property - def always_online(self) -> AsyncAlwaysOnlineWithRawResponse: - return AsyncAlwaysOnlineWithRawResponse(self._settings.always_online) + def always_online(self) -> AsyncAlwaysOnlineResourceWithRawResponse: + return AsyncAlwaysOnlineResourceWithRawResponse(self._settings.always_online) @cached_property def always_use_https(self) -> AsyncAlwaysUseHTTPSWithRawResponse: @@ -1078,184 +1078,184 @@ def automatic_https_rewrites(self) -> AsyncAutomaticHTTPSRewritesWithRawResponse return AsyncAutomaticHTTPSRewritesWithRawResponse(self._settings.automatic_https_rewrites) @cached_property - def automatic_platform_optimization(self) -> AsyncAutomaticPlatformOptimizationWithRawResponse: - return AsyncAutomaticPlatformOptimizationWithRawResponse(self._settings.automatic_platform_optimization) + def automatic_platform_optimization(self) -> AsyncAutomaticPlatformOptimizationResourceWithRawResponse: + return AsyncAutomaticPlatformOptimizationResourceWithRawResponse(self._settings.automatic_platform_optimization) @cached_property - def brotli(self) -> AsyncBrotliWithRawResponse: - return AsyncBrotliWithRawResponse(self._settings.brotli) + def brotli(self) -> AsyncBrotliResourceWithRawResponse: + return AsyncBrotliResourceWithRawResponse(self._settings.brotli) @cached_property - def browser_cache_ttl(self) -> AsyncBrowserCacheTTLWithRawResponse: - return AsyncBrowserCacheTTLWithRawResponse(self._settings.browser_cache_ttl) + def browser_cache_ttl(self) -> AsyncBrowserCacheTTLResourceWithRawResponse: + return AsyncBrowserCacheTTLResourceWithRawResponse(self._settings.browser_cache_ttl) @cached_property - def browser_check(self) -> AsyncBrowserCheckWithRawResponse: - return AsyncBrowserCheckWithRawResponse(self._settings.browser_check) + def browser_check(self) -> AsyncBrowserCheckResourceWithRawResponse: + return AsyncBrowserCheckResourceWithRawResponse(self._settings.browser_check) @cached_property - def cache_level(self) -> AsyncCacheLevelWithRawResponse: - return AsyncCacheLevelWithRawResponse(self._settings.cache_level) + def cache_level(self) -> AsyncCacheLevelResourceWithRawResponse: + return AsyncCacheLevelResourceWithRawResponse(self._settings.cache_level) @cached_property - def challenge_ttl(self) -> AsyncChallengeTTLWithRawResponse: - return AsyncChallengeTTLWithRawResponse(self._settings.challenge_ttl) + def challenge_ttl(self) -> AsyncChallengeTTLResourceWithRawResponse: + return AsyncChallengeTTLResourceWithRawResponse(self._settings.challenge_ttl) @cached_property def ciphers(self) -> AsyncCiphersWithRawResponse: return AsyncCiphersWithRawResponse(self._settings.ciphers) @cached_property - def development_mode(self) -> AsyncDevelopmentModeWithRawResponse: - return AsyncDevelopmentModeWithRawResponse(self._settings.development_mode) + def development_mode(self) -> AsyncDevelopmentModeResourceWithRawResponse: + return AsyncDevelopmentModeResourceWithRawResponse(self._settings.development_mode) @cached_property def early_hints(self) -> AsyncEarlyHintsWithRawResponse: return AsyncEarlyHintsWithRawResponse(self._settings.early_hints) @cached_property - def email_obfuscation(self) -> AsyncEmailObfuscationWithRawResponse: - return AsyncEmailObfuscationWithRawResponse(self._settings.email_obfuscation) + def email_obfuscation(self) -> AsyncEmailObfuscationResourceWithRawResponse: + return AsyncEmailObfuscationResourceWithRawResponse(self._settings.email_obfuscation) @cached_property - def h2_prioritization(self) -> AsyncH2PrioritizationWithRawResponse: - return AsyncH2PrioritizationWithRawResponse(self._settings.h2_prioritization) + def h2_prioritization(self) -> AsyncH2PrioritizationResourceWithRawResponse: + return AsyncH2PrioritizationResourceWithRawResponse(self._settings.h2_prioritization) @cached_property - def hotlink_protection(self) -> AsyncHotlinkProtectionWithRawResponse: - return AsyncHotlinkProtectionWithRawResponse(self._settings.hotlink_protection) + def hotlink_protection(self) -> AsyncHotlinkProtectionResourceWithRawResponse: + return AsyncHotlinkProtectionResourceWithRawResponse(self._settings.hotlink_protection) @cached_property - def http2(self) -> AsyncHTTP2WithRawResponse: - return AsyncHTTP2WithRawResponse(self._settings.http2) + def http2(self) -> AsyncHTTP2ResourceWithRawResponse: + return AsyncHTTP2ResourceWithRawResponse(self._settings.http2) @cached_property - def http3(self) -> AsyncHTTP3WithRawResponse: - return AsyncHTTP3WithRawResponse(self._settings.http3) + def http3(self) -> AsyncHTTP3ResourceWithRawResponse: + return AsyncHTTP3ResourceWithRawResponse(self._settings.http3) @cached_property - def image_resizing(self) -> AsyncImageResizingWithRawResponse: - return AsyncImageResizingWithRawResponse(self._settings.image_resizing) + def image_resizing(self) -> AsyncImageResizingResourceWithRawResponse: + return AsyncImageResizingResourceWithRawResponse(self._settings.image_resizing) @cached_property - def ip_geolocation(self) -> AsyncIPGeolocationWithRawResponse: - return AsyncIPGeolocationWithRawResponse(self._settings.ip_geolocation) + def ip_geolocation(self) -> AsyncIPGeolocationResourceWithRawResponse: + return AsyncIPGeolocationResourceWithRawResponse(self._settings.ip_geolocation) @cached_property - def ipv6(self) -> AsyncIPV6WithRawResponse: - return AsyncIPV6WithRawResponse(self._settings.ipv6) + def ipv6(self) -> AsyncIPV6ResourceWithRawResponse: + return AsyncIPV6ResourceWithRawResponse(self._settings.ipv6) @cached_property - def min_tls_version(self) -> AsyncMinTLSVersionWithRawResponse: - return AsyncMinTLSVersionWithRawResponse(self._settings.min_tls_version) + def min_tls_version(self) -> AsyncMinTLSVersionResourceWithRawResponse: + return AsyncMinTLSVersionResourceWithRawResponse(self._settings.min_tls_version) @cached_property - def minify(self) -> AsyncMinifyWithRawResponse: - return AsyncMinifyWithRawResponse(self._settings.minify) + def minify(self) -> AsyncMinifyResourceWithRawResponse: + return AsyncMinifyResourceWithRawResponse(self._settings.minify) @cached_property - def mirage(self) -> AsyncMirageWithRawResponse: - return AsyncMirageWithRawResponse(self._settings.mirage) + def mirage(self) -> AsyncMirageResourceWithRawResponse: + return AsyncMirageResourceWithRawResponse(self._settings.mirage) @cached_property - def mobile_redirect(self) -> AsyncMobileRedirectWithRawResponse: - return AsyncMobileRedirectWithRawResponse(self._settings.mobile_redirect) + def mobile_redirect(self) -> AsyncMobileRedirectResourceWithRawResponse: + return AsyncMobileRedirectResourceWithRawResponse(self._settings.mobile_redirect) @cached_property - def nel(self) -> AsyncNELWithRawResponse: - return AsyncNELWithRawResponse(self._settings.nel) + def nel(self) -> AsyncNELResourceWithRawResponse: + return AsyncNELResourceWithRawResponse(self._settings.nel) @cached_property - def opportunistic_encryption(self) -> AsyncOpportunisticEncryptionWithRawResponse: - return AsyncOpportunisticEncryptionWithRawResponse(self._settings.opportunistic_encryption) + def opportunistic_encryption(self) -> AsyncOpportunisticEncryptionResourceWithRawResponse: + return AsyncOpportunisticEncryptionResourceWithRawResponse(self._settings.opportunistic_encryption) @cached_property - def opportunistic_onion(self) -> AsyncOpportunisticOnionWithRawResponse: - return AsyncOpportunisticOnionWithRawResponse(self._settings.opportunistic_onion) + def opportunistic_onion(self) -> AsyncOpportunisticOnionResourceWithRawResponse: + return AsyncOpportunisticOnionResourceWithRawResponse(self._settings.opportunistic_onion) @cached_property - def orange_to_orange(self) -> AsyncOrangeToOrangeWithRawResponse: - return AsyncOrangeToOrangeWithRawResponse(self._settings.orange_to_orange) + def orange_to_orange(self) -> AsyncOrangeToOrangeResourceWithRawResponse: + return AsyncOrangeToOrangeResourceWithRawResponse(self._settings.orange_to_orange) @cached_property - def origin_error_page_pass_thru(self) -> AsyncOriginErrorPagePassThruWithRawResponse: - return AsyncOriginErrorPagePassThruWithRawResponse(self._settings.origin_error_page_pass_thru) + def origin_error_page_pass_thru(self) -> AsyncOriginErrorPagePassThruResourceWithRawResponse: + return AsyncOriginErrorPagePassThruResourceWithRawResponse(self._settings.origin_error_page_pass_thru) @cached_property def origin_max_http_version(self) -> AsyncOriginMaxHTTPVersionWithRawResponse: return AsyncOriginMaxHTTPVersionWithRawResponse(self._settings.origin_max_http_version) @cached_property - def polish(self) -> AsyncPolishWithRawResponse: - return AsyncPolishWithRawResponse(self._settings.polish) + def polish(self) -> AsyncPolishResourceWithRawResponse: + return AsyncPolishResourceWithRawResponse(self._settings.polish) @cached_property - def prefetch_preload(self) -> AsyncPrefetchPreloadWithRawResponse: - return AsyncPrefetchPreloadWithRawResponse(self._settings.prefetch_preload) + def prefetch_preload(self) -> AsyncPrefetchPreloadResourceWithRawResponse: + return AsyncPrefetchPreloadResourceWithRawResponse(self._settings.prefetch_preload) @cached_property - def proxy_read_timeout(self) -> AsyncProxyReadTimeoutWithRawResponse: - return AsyncProxyReadTimeoutWithRawResponse(self._settings.proxy_read_timeout) + def proxy_read_timeout(self) -> AsyncProxyReadTimeoutResourceWithRawResponse: + return AsyncProxyReadTimeoutResourceWithRawResponse(self._settings.proxy_read_timeout) @cached_property - def pseudo_ipv4(self) -> AsyncPseudoIPV4WithRawResponse: - return AsyncPseudoIPV4WithRawResponse(self._settings.pseudo_ipv4) + def pseudo_ipv4(self) -> AsyncPseudoIPV4ResourceWithRawResponse: + return AsyncPseudoIPV4ResourceWithRawResponse(self._settings.pseudo_ipv4) @cached_property - def response_buffering(self) -> AsyncResponseBufferingWithRawResponse: - return AsyncResponseBufferingWithRawResponse(self._settings.response_buffering) + def response_buffering(self) -> AsyncResponseBufferingResourceWithRawResponse: + return AsyncResponseBufferingResourceWithRawResponse(self._settings.response_buffering) @cached_property - def rocket_loader(self) -> AsyncRocketLoaderWithRawResponse: - return AsyncRocketLoaderWithRawResponse(self._settings.rocket_loader) + def rocket_loader(self) -> AsyncRocketLoaderResourceWithRawResponse: + return AsyncRocketLoaderResourceWithRawResponse(self._settings.rocket_loader) @cached_property def security_headers(self) -> AsyncSecurityHeadersWithRawResponse: return AsyncSecurityHeadersWithRawResponse(self._settings.security_headers) @cached_property - def security_level(self) -> AsyncSecurityLevelWithRawResponse: - return AsyncSecurityLevelWithRawResponse(self._settings.security_level) + def security_level(self) -> AsyncSecurityLevelResourceWithRawResponse: + return AsyncSecurityLevelResourceWithRawResponse(self._settings.security_level) @cached_property def server_side_excludes(self) -> AsyncServerSideExcludesWithRawResponse: return AsyncServerSideExcludesWithRawResponse(self._settings.server_side_excludes) @cached_property - def sort_query_string_for_cache(self) -> AsyncSortQueryStringForCacheWithRawResponse: - return AsyncSortQueryStringForCacheWithRawResponse(self._settings.sort_query_string_for_cache) + def sort_query_string_for_cache(self) -> AsyncSortQueryStringForCacheResourceWithRawResponse: + return AsyncSortQueryStringForCacheResourceWithRawResponse(self._settings.sort_query_string_for_cache) @cached_property - def ssl(self) -> AsyncSSLWithRawResponse: - return AsyncSSLWithRawResponse(self._settings.ssl) + def ssl(self) -> AsyncSSLResourceWithRawResponse: + return AsyncSSLResourceWithRawResponse(self._settings.ssl) @cached_property - def ssl_recommender(self) -> AsyncSSLRecommenderWithRawResponse: - return AsyncSSLRecommenderWithRawResponse(self._settings.ssl_recommender) + def ssl_recommender(self) -> AsyncSSLRecommenderResourceWithRawResponse: + return AsyncSSLRecommenderResourceWithRawResponse(self._settings.ssl_recommender) @cached_property - def tls_1_3(self) -> AsyncTLS1_3WithRawResponse: - return AsyncTLS1_3WithRawResponse(self._settings.tls_1_3) + def tls_1_3(self) -> AsyncTLS1_3ResourceWithRawResponse: + return AsyncTLS1_3ResourceWithRawResponse(self._settings.tls_1_3) @cached_property - def tls_client_auth(self) -> AsyncTLSClientAuthWithRawResponse: - return AsyncTLSClientAuthWithRawResponse(self._settings.tls_client_auth) + def tls_client_auth(self) -> AsyncTLSClientAuthResourceWithRawResponse: + return AsyncTLSClientAuthResourceWithRawResponse(self._settings.tls_client_auth) @cached_property - def true_client_ip_header(self) -> AsyncTrueClientIPHeaderWithRawResponse: - return AsyncTrueClientIPHeaderWithRawResponse(self._settings.true_client_ip_header) + def true_client_ip_header(self) -> AsyncTrueClientIPHeaderResourceWithRawResponse: + return AsyncTrueClientIPHeaderResourceWithRawResponse(self._settings.true_client_ip_header) @cached_property - def waf(self) -> AsyncWAFWithRawResponse: - return AsyncWAFWithRawResponse(self._settings.waf) + def waf(self) -> AsyncWAFResourceWithRawResponse: + return AsyncWAFResourceWithRawResponse(self._settings.waf) @cached_property - def webp(self) -> AsyncWebPWithRawResponse: - return AsyncWebPWithRawResponse(self._settings.webp) + def webp(self) -> AsyncWebPResourceWithRawResponse: + return AsyncWebPResourceWithRawResponse(self._settings.webp) @cached_property - def websocket(self) -> AsyncWebsocketWithRawResponse: - return AsyncWebsocketWithRawResponse(self._settings.websocket) + def websocket(self) -> AsyncWebsocketResourceWithRawResponse: + return AsyncWebsocketResourceWithRawResponse(self._settings.websocket) @cached_property def font_settings(self) -> AsyncFontSettingsWithRawResponse: @@ -1267,16 +1267,16 @@ def __init__(self, settings: Settings) -> None: self._settings = settings @cached_property - def zero_rtt(self) -> ZeroRTTWithStreamingResponse: - return ZeroRTTWithStreamingResponse(self._settings.zero_rtt) + def zero_rtt(self) -> ZeroRTTResourceWithStreamingResponse: + return ZeroRTTResourceWithStreamingResponse(self._settings.zero_rtt) @cached_property def advanced_ddos(self) -> AdvancedDDoSWithStreamingResponse: return AdvancedDDoSWithStreamingResponse(self._settings.advanced_ddos) @cached_property - def always_online(self) -> AlwaysOnlineWithStreamingResponse: - return AlwaysOnlineWithStreamingResponse(self._settings.always_online) + def always_online(self) -> AlwaysOnlineResourceWithStreamingResponse: + return AlwaysOnlineResourceWithStreamingResponse(self._settings.always_online) @cached_property def always_use_https(self) -> AlwaysUseHTTPSWithStreamingResponse: @@ -1287,184 +1287,186 @@ def automatic_https_rewrites(self) -> AutomaticHTTPSRewritesWithStreamingRespons return AutomaticHTTPSRewritesWithStreamingResponse(self._settings.automatic_https_rewrites) @cached_property - def automatic_platform_optimization(self) -> AutomaticPlatformOptimizationWithStreamingResponse: - return AutomaticPlatformOptimizationWithStreamingResponse(self._settings.automatic_platform_optimization) + def automatic_platform_optimization(self) -> AutomaticPlatformOptimizationResourceWithStreamingResponse: + return AutomaticPlatformOptimizationResourceWithStreamingResponse( + self._settings.automatic_platform_optimization + ) @cached_property - def brotli(self) -> BrotliWithStreamingResponse: - return BrotliWithStreamingResponse(self._settings.brotli) + def brotli(self) -> BrotliResourceWithStreamingResponse: + return BrotliResourceWithStreamingResponse(self._settings.brotli) @cached_property - def browser_cache_ttl(self) -> BrowserCacheTTLWithStreamingResponse: - return BrowserCacheTTLWithStreamingResponse(self._settings.browser_cache_ttl) + def browser_cache_ttl(self) -> BrowserCacheTTLResourceWithStreamingResponse: + return BrowserCacheTTLResourceWithStreamingResponse(self._settings.browser_cache_ttl) @cached_property - def browser_check(self) -> BrowserCheckWithStreamingResponse: - return BrowserCheckWithStreamingResponse(self._settings.browser_check) + def browser_check(self) -> BrowserCheckResourceWithStreamingResponse: + return BrowserCheckResourceWithStreamingResponse(self._settings.browser_check) @cached_property - def cache_level(self) -> CacheLevelWithStreamingResponse: - return CacheLevelWithStreamingResponse(self._settings.cache_level) + def cache_level(self) -> CacheLevelResourceWithStreamingResponse: + return CacheLevelResourceWithStreamingResponse(self._settings.cache_level) @cached_property - def challenge_ttl(self) -> ChallengeTTLWithStreamingResponse: - return ChallengeTTLWithStreamingResponse(self._settings.challenge_ttl) + def challenge_ttl(self) -> ChallengeTTLResourceWithStreamingResponse: + return ChallengeTTLResourceWithStreamingResponse(self._settings.challenge_ttl) @cached_property def ciphers(self) -> CiphersWithStreamingResponse: return CiphersWithStreamingResponse(self._settings.ciphers) @cached_property - def development_mode(self) -> DevelopmentModeWithStreamingResponse: - return DevelopmentModeWithStreamingResponse(self._settings.development_mode) + def development_mode(self) -> DevelopmentModeResourceWithStreamingResponse: + return DevelopmentModeResourceWithStreamingResponse(self._settings.development_mode) @cached_property def early_hints(self) -> EarlyHintsWithStreamingResponse: return EarlyHintsWithStreamingResponse(self._settings.early_hints) @cached_property - def email_obfuscation(self) -> EmailObfuscationWithStreamingResponse: - return EmailObfuscationWithStreamingResponse(self._settings.email_obfuscation) + def email_obfuscation(self) -> EmailObfuscationResourceWithStreamingResponse: + return EmailObfuscationResourceWithStreamingResponse(self._settings.email_obfuscation) @cached_property - def h2_prioritization(self) -> H2PrioritizationWithStreamingResponse: - return H2PrioritizationWithStreamingResponse(self._settings.h2_prioritization) + def h2_prioritization(self) -> H2PrioritizationResourceWithStreamingResponse: + return H2PrioritizationResourceWithStreamingResponse(self._settings.h2_prioritization) @cached_property - def hotlink_protection(self) -> HotlinkProtectionWithStreamingResponse: - return HotlinkProtectionWithStreamingResponse(self._settings.hotlink_protection) + def hotlink_protection(self) -> HotlinkProtectionResourceWithStreamingResponse: + return HotlinkProtectionResourceWithStreamingResponse(self._settings.hotlink_protection) @cached_property - def http2(self) -> HTTP2WithStreamingResponse: - return HTTP2WithStreamingResponse(self._settings.http2) + def http2(self) -> HTTP2ResourceWithStreamingResponse: + return HTTP2ResourceWithStreamingResponse(self._settings.http2) @cached_property - def http3(self) -> HTTP3WithStreamingResponse: - return HTTP3WithStreamingResponse(self._settings.http3) + def http3(self) -> HTTP3ResourceWithStreamingResponse: + return HTTP3ResourceWithStreamingResponse(self._settings.http3) @cached_property - def image_resizing(self) -> ImageResizingWithStreamingResponse: - return ImageResizingWithStreamingResponse(self._settings.image_resizing) + def image_resizing(self) -> ImageResizingResourceWithStreamingResponse: + return ImageResizingResourceWithStreamingResponse(self._settings.image_resizing) @cached_property - def ip_geolocation(self) -> IPGeolocationWithStreamingResponse: - return IPGeolocationWithStreamingResponse(self._settings.ip_geolocation) + def ip_geolocation(self) -> IPGeolocationResourceWithStreamingResponse: + return IPGeolocationResourceWithStreamingResponse(self._settings.ip_geolocation) @cached_property - def ipv6(self) -> IPV6WithStreamingResponse: - return IPV6WithStreamingResponse(self._settings.ipv6) + def ipv6(self) -> IPV6ResourceWithStreamingResponse: + return IPV6ResourceWithStreamingResponse(self._settings.ipv6) @cached_property - def min_tls_version(self) -> MinTLSVersionWithStreamingResponse: - return MinTLSVersionWithStreamingResponse(self._settings.min_tls_version) + def min_tls_version(self) -> MinTLSVersionResourceWithStreamingResponse: + return MinTLSVersionResourceWithStreamingResponse(self._settings.min_tls_version) @cached_property - def minify(self) -> MinifyWithStreamingResponse: - return MinifyWithStreamingResponse(self._settings.minify) + def minify(self) -> MinifyResourceWithStreamingResponse: + return MinifyResourceWithStreamingResponse(self._settings.minify) @cached_property - def mirage(self) -> MirageWithStreamingResponse: - return MirageWithStreamingResponse(self._settings.mirage) + def mirage(self) -> MirageResourceWithStreamingResponse: + return MirageResourceWithStreamingResponse(self._settings.mirage) @cached_property - def mobile_redirect(self) -> MobileRedirectWithStreamingResponse: - return MobileRedirectWithStreamingResponse(self._settings.mobile_redirect) + def mobile_redirect(self) -> MobileRedirectResourceWithStreamingResponse: + return MobileRedirectResourceWithStreamingResponse(self._settings.mobile_redirect) @cached_property - def nel(self) -> NELWithStreamingResponse: - return NELWithStreamingResponse(self._settings.nel) + def nel(self) -> NELResourceWithStreamingResponse: + return NELResourceWithStreamingResponse(self._settings.nel) @cached_property - def opportunistic_encryption(self) -> OpportunisticEncryptionWithStreamingResponse: - return OpportunisticEncryptionWithStreamingResponse(self._settings.opportunistic_encryption) + def opportunistic_encryption(self) -> OpportunisticEncryptionResourceWithStreamingResponse: + return OpportunisticEncryptionResourceWithStreamingResponse(self._settings.opportunistic_encryption) @cached_property - def opportunistic_onion(self) -> OpportunisticOnionWithStreamingResponse: - return OpportunisticOnionWithStreamingResponse(self._settings.opportunistic_onion) + def opportunistic_onion(self) -> OpportunisticOnionResourceWithStreamingResponse: + return OpportunisticOnionResourceWithStreamingResponse(self._settings.opportunistic_onion) @cached_property - def orange_to_orange(self) -> OrangeToOrangeWithStreamingResponse: - return OrangeToOrangeWithStreamingResponse(self._settings.orange_to_orange) + def orange_to_orange(self) -> OrangeToOrangeResourceWithStreamingResponse: + return OrangeToOrangeResourceWithStreamingResponse(self._settings.orange_to_orange) @cached_property - def origin_error_page_pass_thru(self) -> OriginErrorPagePassThruWithStreamingResponse: - return OriginErrorPagePassThruWithStreamingResponse(self._settings.origin_error_page_pass_thru) + def origin_error_page_pass_thru(self) -> OriginErrorPagePassThruResourceWithStreamingResponse: + return OriginErrorPagePassThruResourceWithStreamingResponse(self._settings.origin_error_page_pass_thru) @cached_property def origin_max_http_version(self) -> OriginMaxHTTPVersionWithStreamingResponse: return OriginMaxHTTPVersionWithStreamingResponse(self._settings.origin_max_http_version) @cached_property - def polish(self) -> PolishWithStreamingResponse: - return PolishWithStreamingResponse(self._settings.polish) + def polish(self) -> PolishResourceWithStreamingResponse: + return PolishResourceWithStreamingResponse(self._settings.polish) @cached_property - def prefetch_preload(self) -> PrefetchPreloadWithStreamingResponse: - return PrefetchPreloadWithStreamingResponse(self._settings.prefetch_preload) + def prefetch_preload(self) -> PrefetchPreloadResourceWithStreamingResponse: + return PrefetchPreloadResourceWithStreamingResponse(self._settings.prefetch_preload) @cached_property - def proxy_read_timeout(self) -> ProxyReadTimeoutWithStreamingResponse: - return ProxyReadTimeoutWithStreamingResponse(self._settings.proxy_read_timeout) + def proxy_read_timeout(self) -> ProxyReadTimeoutResourceWithStreamingResponse: + return ProxyReadTimeoutResourceWithStreamingResponse(self._settings.proxy_read_timeout) @cached_property - def pseudo_ipv4(self) -> PseudoIPV4WithStreamingResponse: - return PseudoIPV4WithStreamingResponse(self._settings.pseudo_ipv4) + def pseudo_ipv4(self) -> PseudoIPV4ResourceWithStreamingResponse: + return PseudoIPV4ResourceWithStreamingResponse(self._settings.pseudo_ipv4) @cached_property - def response_buffering(self) -> ResponseBufferingWithStreamingResponse: - return ResponseBufferingWithStreamingResponse(self._settings.response_buffering) + def response_buffering(self) -> ResponseBufferingResourceWithStreamingResponse: + return ResponseBufferingResourceWithStreamingResponse(self._settings.response_buffering) @cached_property - def rocket_loader(self) -> RocketLoaderWithStreamingResponse: - return RocketLoaderWithStreamingResponse(self._settings.rocket_loader) + def rocket_loader(self) -> RocketLoaderResourceWithStreamingResponse: + return RocketLoaderResourceWithStreamingResponse(self._settings.rocket_loader) @cached_property def security_headers(self) -> SecurityHeadersWithStreamingResponse: return SecurityHeadersWithStreamingResponse(self._settings.security_headers) @cached_property - def security_level(self) -> SecurityLevelWithStreamingResponse: - return SecurityLevelWithStreamingResponse(self._settings.security_level) + def security_level(self) -> SecurityLevelResourceWithStreamingResponse: + return SecurityLevelResourceWithStreamingResponse(self._settings.security_level) @cached_property def server_side_excludes(self) -> ServerSideExcludesWithStreamingResponse: return ServerSideExcludesWithStreamingResponse(self._settings.server_side_excludes) @cached_property - def sort_query_string_for_cache(self) -> SortQueryStringForCacheWithStreamingResponse: - return SortQueryStringForCacheWithStreamingResponse(self._settings.sort_query_string_for_cache) + def sort_query_string_for_cache(self) -> SortQueryStringForCacheResourceWithStreamingResponse: + return SortQueryStringForCacheResourceWithStreamingResponse(self._settings.sort_query_string_for_cache) @cached_property - def ssl(self) -> SSLWithStreamingResponse: - return SSLWithStreamingResponse(self._settings.ssl) + def ssl(self) -> SSLResourceWithStreamingResponse: + return SSLResourceWithStreamingResponse(self._settings.ssl) @cached_property - def ssl_recommender(self) -> SSLRecommenderWithStreamingResponse: - return SSLRecommenderWithStreamingResponse(self._settings.ssl_recommender) + def ssl_recommender(self) -> SSLRecommenderResourceWithStreamingResponse: + return SSLRecommenderResourceWithStreamingResponse(self._settings.ssl_recommender) @cached_property - def tls_1_3(self) -> TLS1_3WithStreamingResponse: - return TLS1_3WithStreamingResponse(self._settings.tls_1_3) + def tls_1_3(self) -> TLS1_3ResourceWithStreamingResponse: + return TLS1_3ResourceWithStreamingResponse(self._settings.tls_1_3) @cached_property - def tls_client_auth(self) -> TLSClientAuthWithStreamingResponse: - return TLSClientAuthWithStreamingResponse(self._settings.tls_client_auth) + def tls_client_auth(self) -> TLSClientAuthResourceWithStreamingResponse: + return TLSClientAuthResourceWithStreamingResponse(self._settings.tls_client_auth) @cached_property - def true_client_ip_header(self) -> TrueClientIPHeaderWithStreamingResponse: - return TrueClientIPHeaderWithStreamingResponse(self._settings.true_client_ip_header) + def true_client_ip_header(self) -> TrueClientIPHeaderResourceWithStreamingResponse: + return TrueClientIPHeaderResourceWithStreamingResponse(self._settings.true_client_ip_header) @cached_property - def waf(self) -> WAFWithStreamingResponse: - return WAFWithStreamingResponse(self._settings.waf) + def waf(self) -> WAFResourceWithStreamingResponse: + return WAFResourceWithStreamingResponse(self._settings.waf) @cached_property - def webp(self) -> WebPWithStreamingResponse: - return WebPWithStreamingResponse(self._settings.webp) + def webp(self) -> WebPResourceWithStreamingResponse: + return WebPResourceWithStreamingResponse(self._settings.webp) @cached_property - def websocket(self) -> WebsocketWithStreamingResponse: - return WebsocketWithStreamingResponse(self._settings.websocket) + def websocket(self) -> WebsocketResourceWithStreamingResponse: + return WebsocketResourceWithStreamingResponse(self._settings.websocket) @cached_property def font_settings(self) -> FontSettingsWithStreamingResponse: @@ -1476,16 +1478,16 @@ def __init__(self, settings: AsyncSettings) -> None: self._settings = settings @cached_property - def zero_rtt(self) -> AsyncZeroRTTWithStreamingResponse: - return AsyncZeroRTTWithStreamingResponse(self._settings.zero_rtt) + def zero_rtt(self) -> AsyncZeroRTTResourceWithStreamingResponse: + return AsyncZeroRTTResourceWithStreamingResponse(self._settings.zero_rtt) @cached_property def advanced_ddos(self) -> AsyncAdvancedDDoSWithStreamingResponse: return AsyncAdvancedDDoSWithStreamingResponse(self._settings.advanced_ddos) @cached_property - def always_online(self) -> AsyncAlwaysOnlineWithStreamingResponse: - return AsyncAlwaysOnlineWithStreamingResponse(self._settings.always_online) + def always_online(self) -> AsyncAlwaysOnlineResourceWithStreamingResponse: + return AsyncAlwaysOnlineResourceWithStreamingResponse(self._settings.always_online) @cached_property def always_use_https(self) -> AsyncAlwaysUseHTTPSWithStreamingResponse: @@ -1496,184 +1498,186 @@ def automatic_https_rewrites(self) -> AsyncAutomaticHTTPSRewritesWithStreamingRe return AsyncAutomaticHTTPSRewritesWithStreamingResponse(self._settings.automatic_https_rewrites) @cached_property - def automatic_platform_optimization(self) -> AsyncAutomaticPlatformOptimizationWithStreamingResponse: - return AsyncAutomaticPlatformOptimizationWithStreamingResponse(self._settings.automatic_platform_optimization) + def automatic_platform_optimization(self) -> AsyncAutomaticPlatformOptimizationResourceWithStreamingResponse: + return AsyncAutomaticPlatformOptimizationResourceWithStreamingResponse( + self._settings.automatic_platform_optimization + ) @cached_property - def brotli(self) -> AsyncBrotliWithStreamingResponse: - return AsyncBrotliWithStreamingResponse(self._settings.brotli) + def brotli(self) -> AsyncBrotliResourceWithStreamingResponse: + return AsyncBrotliResourceWithStreamingResponse(self._settings.brotli) @cached_property - def browser_cache_ttl(self) -> AsyncBrowserCacheTTLWithStreamingResponse: - return AsyncBrowserCacheTTLWithStreamingResponse(self._settings.browser_cache_ttl) + def browser_cache_ttl(self) -> AsyncBrowserCacheTTLResourceWithStreamingResponse: + return AsyncBrowserCacheTTLResourceWithStreamingResponse(self._settings.browser_cache_ttl) @cached_property - def browser_check(self) -> AsyncBrowserCheckWithStreamingResponse: - return AsyncBrowserCheckWithStreamingResponse(self._settings.browser_check) + def browser_check(self) -> AsyncBrowserCheckResourceWithStreamingResponse: + return AsyncBrowserCheckResourceWithStreamingResponse(self._settings.browser_check) @cached_property - def cache_level(self) -> AsyncCacheLevelWithStreamingResponse: - return AsyncCacheLevelWithStreamingResponse(self._settings.cache_level) + def cache_level(self) -> AsyncCacheLevelResourceWithStreamingResponse: + return AsyncCacheLevelResourceWithStreamingResponse(self._settings.cache_level) @cached_property - def challenge_ttl(self) -> AsyncChallengeTTLWithStreamingResponse: - return AsyncChallengeTTLWithStreamingResponse(self._settings.challenge_ttl) + def challenge_ttl(self) -> AsyncChallengeTTLResourceWithStreamingResponse: + return AsyncChallengeTTLResourceWithStreamingResponse(self._settings.challenge_ttl) @cached_property def ciphers(self) -> AsyncCiphersWithStreamingResponse: return AsyncCiphersWithStreamingResponse(self._settings.ciphers) @cached_property - def development_mode(self) -> AsyncDevelopmentModeWithStreamingResponse: - return AsyncDevelopmentModeWithStreamingResponse(self._settings.development_mode) + def development_mode(self) -> AsyncDevelopmentModeResourceWithStreamingResponse: + return AsyncDevelopmentModeResourceWithStreamingResponse(self._settings.development_mode) @cached_property def early_hints(self) -> AsyncEarlyHintsWithStreamingResponse: return AsyncEarlyHintsWithStreamingResponse(self._settings.early_hints) @cached_property - def email_obfuscation(self) -> AsyncEmailObfuscationWithStreamingResponse: - return AsyncEmailObfuscationWithStreamingResponse(self._settings.email_obfuscation) + def email_obfuscation(self) -> AsyncEmailObfuscationResourceWithStreamingResponse: + return AsyncEmailObfuscationResourceWithStreamingResponse(self._settings.email_obfuscation) @cached_property - def h2_prioritization(self) -> AsyncH2PrioritizationWithStreamingResponse: - return AsyncH2PrioritizationWithStreamingResponse(self._settings.h2_prioritization) + def h2_prioritization(self) -> AsyncH2PrioritizationResourceWithStreamingResponse: + return AsyncH2PrioritizationResourceWithStreamingResponse(self._settings.h2_prioritization) @cached_property - def hotlink_protection(self) -> AsyncHotlinkProtectionWithStreamingResponse: - return AsyncHotlinkProtectionWithStreamingResponse(self._settings.hotlink_protection) + def hotlink_protection(self) -> AsyncHotlinkProtectionResourceWithStreamingResponse: + return AsyncHotlinkProtectionResourceWithStreamingResponse(self._settings.hotlink_protection) @cached_property - def http2(self) -> AsyncHTTP2WithStreamingResponse: - return AsyncHTTP2WithStreamingResponse(self._settings.http2) + def http2(self) -> AsyncHTTP2ResourceWithStreamingResponse: + return AsyncHTTP2ResourceWithStreamingResponse(self._settings.http2) @cached_property - def http3(self) -> AsyncHTTP3WithStreamingResponse: - return AsyncHTTP3WithStreamingResponse(self._settings.http3) + def http3(self) -> AsyncHTTP3ResourceWithStreamingResponse: + return AsyncHTTP3ResourceWithStreamingResponse(self._settings.http3) @cached_property - def image_resizing(self) -> AsyncImageResizingWithStreamingResponse: - return AsyncImageResizingWithStreamingResponse(self._settings.image_resizing) + def image_resizing(self) -> AsyncImageResizingResourceWithStreamingResponse: + return AsyncImageResizingResourceWithStreamingResponse(self._settings.image_resizing) @cached_property - def ip_geolocation(self) -> AsyncIPGeolocationWithStreamingResponse: - return AsyncIPGeolocationWithStreamingResponse(self._settings.ip_geolocation) + def ip_geolocation(self) -> AsyncIPGeolocationResourceWithStreamingResponse: + return AsyncIPGeolocationResourceWithStreamingResponse(self._settings.ip_geolocation) @cached_property - def ipv6(self) -> AsyncIPV6WithStreamingResponse: - return AsyncIPV6WithStreamingResponse(self._settings.ipv6) + def ipv6(self) -> AsyncIPV6ResourceWithStreamingResponse: + return AsyncIPV6ResourceWithStreamingResponse(self._settings.ipv6) @cached_property - def min_tls_version(self) -> AsyncMinTLSVersionWithStreamingResponse: - return AsyncMinTLSVersionWithStreamingResponse(self._settings.min_tls_version) + def min_tls_version(self) -> AsyncMinTLSVersionResourceWithStreamingResponse: + return AsyncMinTLSVersionResourceWithStreamingResponse(self._settings.min_tls_version) @cached_property - def minify(self) -> AsyncMinifyWithStreamingResponse: - return AsyncMinifyWithStreamingResponse(self._settings.minify) + def minify(self) -> AsyncMinifyResourceWithStreamingResponse: + return AsyncMinifyResourceWithStreamingResponse(self._settings.minify) @cached_property - def mirage(self) -> AsyncMirageWithStreamingResponse: - return AsyncMirageWithStreamingResponse(self._settings.mirage) + def mirage(self) -> AsyncMirageResourceWithStreamingResponse: + return AsyncMirageResourceWithStreamingResponse(self._settings.mirage) @cached_property - def mobile_redirect(self) -> AsyncMobileRedirectWithStreamingResponse: - return AsyncMobileRedirectWithStreamingResponse(self._settings.mobile_redirect) + def mobile_redirect(self) -> AsyncMobileRedirectResourceWithStreamingResponse: + return AsyncMobileRedirectResourceWithStreamingResponse(self._settings.mobile_redirect) @cached_property - def nel(self) -> AsyncNELWithStreamingResponse: - return AsyncNELWithStreamingResponse(self._settings.nel) + def nel(self) -> AsyncNELResourceWithStreamingResponse: + return AsyncNELResourceWithStreamingResponse(self._settings.nel) @cached_property - def opportunistic_encryption(self) -> AsyncOpportunisticEncryptionWithStreamingResponse: - return AsyncOpportunisticEncryptionWithStreamingResponse(self._settings.opportunistic_encryption) + def opportunistic_encryption(self) -> AsyncOpportunisticEncryptionResourceWithStreamingResponse: + return AsyncOpportunisticEncryptionResourceWithStreamingResponse(self._settings.opportunistic_encryption) @cached_property - def opportunistic_onion(self) -> AsyncOpportunisticOnionWithStreamingResponse: - return AsyncOpportunisticOnionWithStreamingResponse(self._settings.opportunistic_onion) + def opportunistic_onion(self) -> AsyncOpportunisticOnionResourceWithStreamingResponse: + return AsyncOpportunisticOnionResourceWithStreamingResponse(self._settings.opportunistic_onion) @cached_property - def orange_to_orange(self) -> AsyncOrangeToOrangeWithStreamingResponse: - return AsyncOrangeToOrangeWithStreamingResponse(self._settings.orange_to_orange) + def orange_to_orange(self) -> AsyncOrangeToOrangeResourceWithStreamingResponse: + return AsyncOrangeToOrangeResourceWithStreamingResponse(self._settings.orange_to_orange) @cached_property - def origin_error_page_pass_thru(self) -> AsyncOriginErrorPagePassThruWithStreamingResponse: - return AsyncOriginErrorPagePassThruWithStreamingResponse(self._settings.origin_error_page_pass_thru) + def origin_error_page_pass_thru(self) -> AsyncOriginErrorPagePassThruResourceWithStreamingResponse: + return AsyncOriginErrorPagePassThruResourceWithStreamingResponse(self._settings.origin_error_page_pass_thru) @cached_property def origin_max_http_version(self) -> AsyncOriginMaxHTTPVersionWithStreamingResponse: return AsyncOriginMaxHTTPVersionWithStreamingResponse(self._settings.origin_max_http_version) @cached_property - def polish(self) -> AsyncPolishWithStreamingResponse: - return AsyncPolishWithStreamingResponse(self._settings.polish) + def polish(self) -> AsyncPolishResourceWithStreamingResponse: + return AsyncPolishResourceWithStreamingResponse(self._settings.polish) @cached_property - def prefetch_preload(self) -> AsyncPrefetchPreloadWithStreamingResponse: - return AsyncPrefetchPreloadWithStreamingResponse(self._settings.prefetch_preload) + def prefetch_preload(self) -> AsyncPrefetchPreloadResourceWithStreamingResponse: + return AsyncPrefetchPreloadResourceWithStreamingResponse(self._settings.prefetch_preload) @cached_property - def proxy_read_timeout(self) -> AsyncProxyReadTimeoutWithStreamingResponse: - return AsyncProxyReadTimeoutWithStreamingResponse(self._settings.proxy_read_timeout) + def proxy_read_timeout(self) -> AsyncProxyReadTimeoutResourceWithStreamingResponse: + return AsyncProxyReadTimeoutResourceWithStreamingResponse(self._settings.proxy_read_timeout) @cached_property - def pseudo_ipv4(self) -> AsyncPseudoIPV4WithStreamingResponse: - return AsyncPseudoIPV4WithStreamingResponse(self._settings.pseudo_ipv4) + def pseudo_ipv4(self) -> AsyncPseudoIPV4ResourceWithStreamingResponse: + return AsyncPseudoIPV4ResourceWithStreamingResponse(self._settings.pseudo_ipv4) @cached_property - def response_buffering(self) -> AsyncResponseBufferingWithStreamingResponse: - return AsyncResponseBufferingWithStreamingResponse(self._settings.response_buffering) + def response_buffering(self) -> AsyncResponseBufferingResourceWithStreamingResponse: + return AsyncResponseBufferingResourceWithStreamingResponse(self._settings.response_buffering) @cached_property - def rocket_loader(self) -> AsyncRocketLoaderWithStreamingResponse: - return AsyncRocketLoaderWithStreamingResponse(self._settings.rocket_loader) + def rocket_loader(self) -> AsyncRocketLoaderResourceWithStreamingResponse: + return AsyncRocketLoaderResourceWithStreamingResponse(self._settings.rocket_loader) @cached_property def security_headers(self) -> AsyncSecurityHeadersWithStreamingResponse: return AsyncSecurityHeadersWithStreamingResponse(self._settings.security_headers) @cached_property - def security_level(self) -> AsyncSecurityLevelWithStreamingResponse: - return AsyncSecurityLevelWithStreamingResponse(self._settings.security_level) + def security_level(self) -> AsyncSecurityLevelResourceWithStreamingResponse: + return AsyncSecurityLevelResourceWithStreamingResponse(self._settings.security_level) @cached_property def server_side_excludes(self) -> AsyncServerSideExcludesWithStreamingResponse: return AsyncServerSideExcludesWithStreamingResponse(self._settings.server_side_excludes) @cached_property - def sort_query_string_for_cache(self) -> AsyncSortQueryStringForCacheWithStreamingResponse: - return AsyncSortQueryStringForCacheWithStreamingResponse(self._settings.sort_query_string_for_cache) + def sort_query_string_for_cache(self) -> AsyncSortQueryStringForCacheResourceWithStreamingResponse: + return AsyncSortQueryStringForCacheResourceWithStreamingResponse(self._settings.sort_query_string_for_cache) @cached_property - def ssl(self) -> AsyncSSLWithStreamingResponse: - return AsyncSSLWithStreamingResponse(self._settings.ssl) + def ssl(self) -> AsyncSSLResourceWithStreamingResponse: + return AsyncSSLResourceWithStreamingResponse(self._settings.ssl) @cached_property - def ssl_recommender(self) -> AsyncSSLRecommenderWithStreamingResponse: - return AsyncSSLRecommenderWithStreamingResponse(self._settings.ssl_recommender) + def ssl_recommender(self) -> AsyncSSLRecommenderResourceWithStreamingResponse: + return AsyncSSLRecommenderResourceWithStreamingResponse(self._settings.ssl_recommender) @cached_property - def tls_1_3(self) -> AsyncTLS1_3WithStreamingResponse: - return AsyncTLS1_3WithStreamingResponse(self._settings.tls_1_3) + def tls_1_3(self) -> AsyncTLS1_3ResourceWithStreamingResponse: + return AsyncTLS1_3ResourceWithStreamingResponse(self._settings.tls_1_3) @cached_property - def tls_client_auth(self) -> AsyncTLSClientAuthWithStreamingResponse: - return AsyncTLSClientAuthWithStreamingResponse(self._settings.tls_client_auth) + def tls_client_auth(self) -> AsyncTLSClientAuthResourceWithStreamingResponse: + return AsyncTLSClientAuthResourceWithStreamingResponse(self._settings.tls_client_auth) @cached_property - def true_client_ip_header(self) -> AsyncTrueClientIPHeaderWithStreamingResponse: - return AsyncTrueClientIPHeaderWithStreamingResponse(self._settings.true_client_ip_header) + def true_client_ip_header(self) -> AsyncTrueClientIPHeaderResourceWithStreamingResponse: + return AsyncTrueClientIPHeaderResourceWithStreamingResponse(self._settings.true_client_ip_header) @cached_property - def waf(self) -> AsyncWAFWithStreamingResponse: - return AsyncWAFWithStreamingResponse(self._settings.waf) + def waf(self) -> AsyncWAFResourceWithStreamingResponse: + return AsyncWAFResourceWithStreamingResponse(self._settings.waf) @cached_property - def webp(self) -> AsyncWebPWithStreamingResponse: - return AsyncWebPWithStreamingResponse(self._settings.webp) + def webp(self) -> AsyncWebPResourceWithStreamingResponse: + return AsyncWebPResourceWithStreamingResponse(self._settings.webp) @cached_property - def websocket(self) -> AsyncWebsocketWithStreamingResponse: - return AsyncWebsocketWithStreamingResponse(self._settings.websocket) + def websocket(self) -> AsyncWebsocketResourceWithStreamingResponse: + return AsyncWebsocketResourceWithStreamingResponse(self._settings.websocket) @cached_property def font_settings(self) -> AsyncFontSettingsWithStreamingResponse: diff --git a/src/cloudflare/resources/zones/settings/sort_query_string_for_cache.py b/src/cloudflare/resources/zones/settings/sort_query_string_for_cache.py index cfb804982654..855800bcfccd 100644 --- a/src/cloudflare/resources/zones/settings/sort_query_string_for_cache.py +++ b/src/cloudflare/resources/zones/settings/sort_query_string_for_cache.py @@ -24,19 +24,19 @@ from ...._base_client import ( make_request_options, ) -from ....types.zones.settings import ZoneSettingSortQueryStringForCache, sort_query_string_for_cache_edit_params +from ....types.zones.settings import SortQueryStringForCache, sort_query_string_for_cache_edit_params -__all__ = ["SortQueryStringForCache", "AsyncSortQueryStringForCache"] +__all__ = ["SortQueryStringForCacheResource", "AsyncSortQueryStringForCacheResource"] -class SortQueryStringForCache(SyncAPIResource): +class SortQueryStringForCacheResource(SyncAPIResource): @cached_property - def with_raw_response(self) -> SortQueryStringForCacheWithRawResponse: - return SortQueryStringForCacheWithRawResponse(self) + def with_raw_response(self) -> SortQueryStringForCacheResourceWithRawResponse: + return SortQueryStringForCacheResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> SortQueryStringForCacheWithStreamingResponse: - return SortQueryStringForCacheWithStreamingResponse(self) + def with_streaming_response(self) -> SortQueryStringForCacheResourceWithStreamingResponse: + return SortQueryStringForCacheResourceWithStreamingResponse(self) def edit( self, @@ -49,7 +49,7 @@ def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingSortQueryStringForCache]: + ) -> Optional[SortQueryStringForCache]: """ Cloudflare will treat files with the same query strings as the same file in cache, regardless of the order of the query strings. This is limited to @@ -82,9 +82,7 @@ def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast( - Type[Optional[ZoneSettingSortQueryStringForCache]], ResultWrapper[ZoneSettingSortQueryStringForCache] - ), + cast_to=cast(Type[Optional[SortQueryStringForCache]], ResultWrapper[SortQueryStringForCache]), ) def get( @@ -97,7 +95,7 @@ def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingSortQueryStringForCache]: + ) -> Optional[SortQueryStringForCache]: """ Cloudflare will treat files with the same query strings as the same file in cache, regardless of the order of the query strings. This is limited to @@ -125,20 +123,18 @@ def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast( - Type[Optional[ZoneSettingSortQueryStringForCache]], ResultWrapper[ZoneSettingSortQueryStringForCache] - ), + cast_to=cast(Type[Optional[SortQueryStringForCache]], ResultWrapper[SortQueryStringForCache]), ) -class AsyncSortQueryStringForCache(AsyncAPIResource): +class AsyncSortQueryStringForCacheResource(AsyncAPIResource): @cached_property - def with_raw_response(self) -> AsyncSortQueryStringForCacheWithRawResponse: - return AsyncSortQueryStringForCacheWithRawResponse(self) + def with_raw_response(self) -> AsyncSortQueryStringForCacheResourceWithRawResponse: + return AsyncSortQueryStringForCacheResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> AsyncSortQueryStringForCacheWithStreamingResponse: - return AsyncSortQueryStringForCacheWithStreamingResponse(self) + def with_streaming_response(self) -> AsyncSortQueryStringForCacheResourceWithStreamingResponse: + return AsyncSortQueryStringForCacheResourceWithStreamingResponse(self) async def edit( self, @@ -151,7 +147,7 @@ async def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingSortQueryStringForCache]: + ) -> Optional[SortQueryStringForCache]: """ Cloudflare will treat files with the same query strings as the same file in cache, regardless of the order of the query strings. This is limited to @@ -184,9 +180,7 @@ async def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast( - Type[Optional[ZoneSettingSortQueryStringForCache]], ResultWrapper[ZoneSettingSortQueryStringForCache] - ), + cast_to=cast(Type[Optional[SortQueryStringForCache]], ResultWrapper[SortQueryStringForCache]), ) async def get( @@ -199,7 +193,7 @@ async def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingSortQueryStringForCache]: + ) -> Optional[SortQueryStringForCache]: """ Cloudflare will treat files with the same query strings as the same file in cache, regardless of the order of the query strings. This is limited to @@ -227,14 +221,12 @@ async def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast( - Type[Optional[ZoneSettingSortQueryStringForCache]], ResultWrapper[ZoneSettingSortQueryStringForCache] - ), + cast_to=cast(Type[Optional[SortQueryStringForCache]], ResultWrapper[SortQueryStringForCache]), ) -class SortQueryStringForCacheWithRawResponse: - def __init__(self, sort_query_string_for_cache: SortQueryStringForCache) -> None: +class SortQueryStringForCacheResourceWithRawResponse: + def __init__(self, sort_query_string_for_cache: SortQueryStringForCacheResource) -> None: self._sort_query_string_for_cache = sort_query_string_for_cache self.edit = to_raw_response_wrapper( @@ -245,8 +237,8 @@ def __init__(self, sort_query_string_for_cache: SortQueryStringForCache) -> None ) -class AsyncSortQueryStringForCacheWithRawResponse: - def __init__(self, sort_query_string_for_cache: AsyncSortQueryStringForCache) -> None: +class AsyncSortQueryStringForCacheResourceWithRawResponse: + def __init__(self, sort_query_string_for_cache: AsyncSortQueryStringForCacheResource) -> None: self._sort_query_string_for_cache = sort_query_string_for_cache self.edit = async_to_raw_response_wrapper( @@ -257,8 +249,8 @@ def __init__(self, sort_query_string_for_cache: AsyncSortQueryStringForCache) -> ) -class SortQueryStringForCacheWithStreamingResponse: - def __init__(self, sort_query_string_for_cache: SortQueryStringForCache) -> None: +class SortQueryStringForCacheResourceWithStreamingResponse: + def __init__(self, sort_query_string_for_cache: SortQueryStringForCacheResource) -> None: self._sort_query_string_for_cache = sort_query_string_for_cache self.edit = to_streamed_response_wrapper( @@ -269,8 +261,8 @@ def __init__(self, sort_query_string_for_cache: SortQueryStringForCache) -> None ) -class AsyncSortQueryStringForCacheWithStreamingResponse: - def __init__(self, sort_query_string_for_cache: AsyncSortQueryStringForCache) -> None: +class AsyncSortQueryStringForCacheResourceWithStreamingResponse: + def __init__(self, sort_query_string_for_cache: AsyncSortQueryStringForCacheResource) -> None: self._sort_query_string_for_cache = sort_query_string_for_cache self.edit = async_to_streamed_response_wrapper( diff --git a/src/cloudflare/resources/zones/settings/ssl.py b/src/cloudflare/resources/zones/settings/ssl.py index 56c95e74fea8..a597b3195d48 100644 --- a/src/cloudflare/resources/zones/settings/ssl.py +++ b/src/cloudflare/resources/zones/settings/ssl.py @@ -24,19 +24,19 @@ from ...._base_client import ( make_request_options, ) -from ....types.zones.settings import ZoneSettingSSL, ssl_edit_params +from ....types.zones.settings import SSL, ssl_edit_params -__all__ = ["SSL", "AsyncSSL"] +__all__ = ["SSLResource", "AsyncSSLResource"] -class SSL(SyncAPIResource): +class SSLResource(SyncAPIResource): @cached_property - def with_raw_response(self) -> SSLWithRawResponse: - return SSLWithRawResponse(self) + def with_raw_response(self) -> SSLResourceWithRawResponse: + return SSLResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> SSLWithStreamingResponse: - return SSLWithStreamingResponse(self) + def with_streaming_response(self) -> SSLResourceWithStreamingResponse: + return SSLResourceWithStreamingResponse(self) def edit( self, @@ -49,7 +49,7 @@ def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingSSL]: + ) -> Optional[SSL]: """ SSL encrypts your visitor's connection and safeguards credit card numbers and other personal data to and from your website. SSL can take up to 5 minutes to @@ -93,7 +93,7 @@ def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingSSL]], ResultWrapper[ZoneSettingSSL]), + cast_to=cast(Type[Optional[SSL]], ResultWrapper[SSL]), ) def get( @@ -106,7 +106,7 @@ def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingSSL]: + ) -> Optional[SSL]: """ SSL encrypts your visitor's connection and safeguards credit card numbers and other personal data to and from your website. SSL can take up to 5 minutes to @@ -147,18 +147,18 @@ def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingSSL]], ResultWrapper[ZoneSettingSSL]), + cast_to=cast(Type[Optional[SSL]], ResultWrapper[SSL]), ) -class AsyncSSL(AsyncAPIResource): +class AsyncSSLResource(AsyncAPIResource): @cached_property - def with_raw_response(self) -> AsyncSSLWithRawResponse: - return AsyncSSLWithRawResponse(self) + def with_raw_response(self) -> AsyncSSLResourceWithRawResponse: + return AsyncSSLResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> AsyncSSLWithStreamingResponse: - return AsyncSSLWithStreamingResponse(self) + def with_streaming_response(self) -> AsyncSSLResourceWithStreamingResponse: + return AsyncSSLResourceWithStreamingResponse(self) async def edit( self, @@ -171,7 +171,7 @@ async def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingSSL]: + ) -> Optional[SSL]: """ SSL encrypts your visitor's connection and safeguards credit card numbers and other personal data to and from your website. SSL can take up to 5 minutes to @@ -215,7 +215,7 @@ async def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingSSL]], ResultWrapper[ZoneSettingSSL]), + cast_to=cast(Type[Optional[SSL]], ResultWrapper[SSL]), ) async def get( @@ -228,7 +228,7 @@ async def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingSSL]: + ) -> Optional[SSL]: """ SSL encrypts your visitor's connection and safeguards credit card numbers and other personal data to and from your website. SSL can take up to 5 minutes to @@ -269,12 +269,12 @@ async def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingSSL]], ResultWrapper[ZoneSettingSSL]), + cast_to=cast(Type[Optional[SSL]], ResultWrapper[SSL]), ) -class SSLWithRawResponse: - def __init__(self, ssl: SSL) -> None: +class SSLResourceWithRawResponse: + def __init__(self, ssl: SSLResource) -> None: self._ssl = ssl self.edit = to_raw_response_wrapper( @@ -285,8 +285,8 @@ def __init__(self, ssl: SSL) -> None: ) -class AsyncSSLWithRawResponse: - def __init__(self, ssl: AsyncSSL) -> None: +class AsyncSSLResourceWithRawResponse: + def __init__(self, ssl: AsyncSSLResource) -> None: self._ssl = ssl self.edit = async_to_raw_response_wrapper( @@ -297,8 +297,8 @@ def __init__(self, ssl: AsyncSSL) -> None: ) -class SSLWithStreamingResponse: - def __init__(self, ssl: SSL) -> None: +class SSLResourceWithStreamingResponse: + def __init__(self, ssl: SSLResource) -> None: self._ssl = ssl self.edit = to_streamed_response_wrapper( @@ -309,8 +309,8 @@ def __init__(self, ssl: SSL) -> None: ) -class AsyncSSLWithStreamingResponse: - def __init__(self, ssl: AsyncSSL) -> None: +class AsyncSSLResourceWithStreamingResponse: + def __init__(self, ssl: AsyncSSLResource) -> None: self._ssl = ssl self.edit = async_to_streamed_response_wrapper( diff --git a/src/cloudflare/resources/zones/settings/ssl_recommender.py b/src/cloudflare/resources/zones/settings/ssl_recommender.py index 8ec9470c5564..ba9f6323d8af 100644 --- a/src/cloudflare/resources/zones/settings/ssl_recommender.py +++ b/src/cloudflare/resources/zones/settings/ssl_recommender.py @@ -23,36 +23,32 @@ from ...._base_client import ( make_request_options, ) -from ....types.zones.settings import ( - ZoneSettingSSLRecommender, - ZoneSettingSSLRecommenderParam, - ssl_recommender_edit_params, -) +from ....types.zones.settings import SSLRecommender, SSLRecommenderParam, ssl_recommender_edit_params -__all__ = ["SSLRecommender", "AsyncSSLRecommender"] +__all__ = ["SSLRecommenderResource", "AsyncSSLRecommenderResource"] -class SSLRecommender(SyncAPIResource): +class SSLRecommenderResource(SyncAPIResource): @cached_property - def with_raw_response(self) -> SSLRecommenderWithRawResponse: - return SSLRecommenderWithRawResponse(self) + def with_raw_response(self) -> SSLRecommenderResourceWithRawResponse: + return SSLRecommenderResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> SSLRecommenderWithStreamingResponse: - return SSLRecommenderWithStreamingResponse(self) + def with_streaming_response(self) -> SSLRecommenderResourceWithStreamingResponse: + return SSLRecommenderResourceWithStreamingResponse(self) def edit( self, *, zone_id: str, - value: ZoneSettingSSLRecommenderParam, + value: SSLRecommenderParam, # 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[ZoneSettingSSLRecommender]: + ) -> Optional[SSLRecommender]: """ Enrollment in the SSL/TLS Recommender service which tries to detect and recommend (by sending periodic emails) the most secure SSL/TLS setting your @@ -85,7 +81,7 @@ def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingSSLRecommender]], ResultWrapper[ZoneSettingSSLRecommender]), + cast_to=cast(Type[Optional[SSLRecommender]], ResultWrapper[SSLRecommender]), ) def get( @@ -98,7 +94,7 @@ def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingSSLRecommender]: + ) -> Optional[SSLRecommender]: """ Enrollment in the SSL/TLS Recommender service which tries to detect and recommend (by sending periodic emails) the most secure SSL/TLS setting your @@ -126,31 +122,31 @@ def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingSSLRecommender]], ResultWrapper[ZoneSettingSSLRecommender]), + cast_to=cast(Type[Optional[SSLRecommender]], ResultWrapper[SSLRecommender]), ) -class AsyncSSLRecommender(AsyncAPIResource): +class AsyncSSLRecommenderResource(AsyncAPIResource): @cached_property - def with_raw_response(self) -> AsyncSSLRecommenderWithRawResponse: - return AsyncSSLRecommenderWithRawResponse(self) + def with_raw_response(self) -> AsyncSSLRecommenderResourceWithRawResponse: + return AsyncSSLRecommenderResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> AsyncSSLRecommenderWithStreamingResponse: - return AsyncSSLRecommenderWithStreamingResponse(self) + def with_streaming_response(self) -> AsyncSSLRecommenderResourceWithStreamingResponse: + return AsyncSSLRecommenderResourceWithStreamingResponse(self) async def edit( self, *, zone_id: str, - value: ZoneSettingSSLRecommenderParam, + value: SSLRecommenderParam, # 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[ZoneSettingSSLRecommender]: + ) -> Optional[SSLRecommender]: """ Enrollment in the SSL/TLS Recommender service which tries to detect and recommend (by sending periodic emails) the most secure SSL/TLS setting your @@ -183,7 +179,7 @@ async def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingSSLRecommender]], ResultWrapper[ZoneSettingSSLRecommender]), + cast_to=cast(Type[Optional[SSLRecommender]], ResultWrapper[SSLRecommender]), ) async def get( @@ -196,7 +192,7 @@ async def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingSSLRecommender]: + ) -> Optional[SSLRecommender]: """ Enrollment in the SSL/TLS Recommender service which tries to detect and recommend (by sending periodic emails) the most secure SSL/TLS setting your @@ -224,12 +220,12 @@ async def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingSSLRecommender]], ResultWrapper[ZoneSettingSSLRecommender]), + cast_to=cast(Type[Optional[SSLRecommender]], ResultWrapper[SSLRecommender]), ) -class SSLRecommenderWithRawResponse: - def __init__(self, ssl_recommender: SSLRecommender) -> None: +class SSLRecommenderResourceWithRawResponse: + def __init__(self, ssl_recommender: SSLRecommenderResource) -> None: self._ssl_recommender = ssl_recommender self.edit = to_raw_response_wrapper( @@ -240,8 +236,8 @@ def __init__(self, ssl_recommender: SSLRecommender) -> None: ) -class AsyncSSLRecommenderWithRawResponse: - def __init__(self, ssl_recommender: AsyncSSLRecommender) -> None: +class AsyncSSLRecommenderResourceWithRawResponse: + def __init__(self, ssl_recommender: AsyncSSLRecommenderResource) -> None: self._ssl_recommender = ssl_recommender self.edit = async_to_raw_response_wrapper( @@ -252,8 +248,8 @@ def __init__(self, ssl_recommender: AsyncSSLRecommender) -> None: ) -class SSLRecommenderWithStreamingResponse: - def __init__(self, ssl_recommender: SSLRecommender) -> None: +class SSLRecommenderResourceWithStreamingResponse: + def __init__(self, ssl_recommender: SSLRecommenderResource) -> None: self._ssl_recommender = ssl_recommender self.edit = to_streamed_response_wrapper( @@ -264,8 +260,8 @@ def __init__(self, ssl_recommender: SSLRecommender) -> None: ) -class AsyncSSLRecommenderWithStreamingResponse: - def __init__(self, ssl_recommender: AsyncSSLRecommender) -> None: +class AsyncSSLRecommenderResourceWithStreamingResponse: + def __init__(self, ssl_recommender: AsyncSSLRecommenderResource) -> None: self._ssl_recommender = ssl_recommender self.edit = async_to_streamed_response_wrapper( diff --git a/src/cloudflare/resources/zones/settings/tls_1_3.py b/src/cloudflare/resources/zones/settings/tls_1_3.py index c928cb1581af..3f154dc7eb66 100644 --- a/src/cloudflare/resources/zones/settings/tls_1_3.py +++ b/src/cloudflare/resources/zones/settings/tls_1_3.py @@ -24,19 +24,19 @@ from ...._base_client import ( make_request_options, ) -from ....types.zones.settings import ZoneSettingTLS1_3, tls_1_3_edit_params +from ....types.zones.settings import TLS1_3, tls_1_3_edit_params -__all__ = ["TLS1_3", "AsyncTLS1_3"] +__all__ = ["TLS1_3Resource", "AsyncTLS1_3Resource"] -class TLS1_3(SyncAPIResource): +class TLS1_3Resource(SyncAPIResource): @cached_property - def with_raw_response(self) -> TLS1_3WithRawResponse: - return TLS1_3WithRawResponse(self) + def with_raw_response(self) -> TLS1_3ResourceWithRawResponse: + return TLS1_3ResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> TLS1_3WithStreamingResponse: - return TLS1_3WithStreamingResponse(self) + def with_streaming_response(self) -> TLS1_3ResourceWithStreamingResponse: + return TLS1_3ResourceWithStreamingResponse(self) def edit( self, @@ -49,7 +49,7 @@ def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingTLS1_3]: + ) -> Optional[TLS1_3]: """ Changes TLS 1.3 setting. @@ -79,7 +79,7 @@ def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingTLS1_3]], ResultWrapper[ZoneSettingTLS1_3]), + cast_to=cast(Type[Optional[TLS1_3]], ResultWrapper[TLS1_3]), ) def get( @@ -92,7 +92,7 @@ def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingTLS1_3]: + ) -> Optional[TLS1_3]: """ Gets TLS 1.3 setting enabled for a zone. @@ -118,18 +118,18 @@ def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingTLS1_3]], ResultWrapper[ZoneSettingTLS1_3]), + cast_to=cast(Type[Optional[TLS1_3]], ResultWrapper[TLS1_3]), ) -class AsyncTLS1_3(AsyncAPIResource): +class AsyncTLS1_3Resource(AsyncAPIResource): @cached_property - def with_raw_response(self) -> AsyncTLS1_3WithRawResponse: - return AsyncTLS1_3WithRawResponse(self) + def with_raw_response(self) -> AsyncTLS1_3ResourceWithRawResponse: + return AsyncTLS1_3ResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> AsyncTLS1_3WithStreamingResponse: - return AsyncTLS1_3WithStreamingResponse(self) + def with_streaming_response(self) -> AsyncTLS1_3ResourceWithStreamingResponse: + return AsyncTLS1_3ResourceWithStreamingResponse(self) async def edit( self, @@ -142,7 +142,7 @@ async def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingTLS1_3]: + ) -> Optional[TLS1_3]: """ Changes TLS 1.3 setting. @@ -172,7 +172,7 @@ async def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingTLS1_3]], ResultWrapper[ZoneSettingTLS1_3]), + cast_to=cast(Type[Optional[TLS1_3]], ResultWrapper[TLS1_3]), ) async def get( @@ -185,7 +185,7 @@ async def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingTLS1_3]: + ) -> Optional[TLS1_3]: """ Gets TLS 1.3 setting enabled for a zone. @@ -211,12 +211,12 @@ async def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingTLS1_3]], ResultWrapper[ZoneSettingTLS1_3]), + cast_to=cast(Type[Optional[TLS1_3]], ResultWrapper[TLS1_3]), ) -class TLS1_3WithRawResponse: - def __init__(self, tls_1_3: TLS1_3) -> None: +class TLS1_3ResourceWithRawResponse: + def __init__(self, tls_1_3: TLS1_3Resource) -> None: self._tls_1_3 = tls_1_3 self.edit = to_raw_response_wrapper( @@ -227,8 +227,8 @@ def __init__(self, tls_1_3: TLS1_3) -> None: ) -class AsyncTLS1_3WithRawResponse: - def __init__(self, tls_1_3: AsyncTLS1_3) -> None: +class AsyncTLS1_3ResourceWithRawResponse: + def __init__(self, tls_1_3: AsyncTLS1_3Resource) -> None: self._tls_1_3 = tls_1_3 self.edit = async_to_raw_response_wrapper( @@ -239,8 +239,8 @@ def __init__(self, tls_1_3: AsyncTLS1_3) -> None: ) -class TLS1_3WithStreamingResponse: - def __init__(self, tls_1_3: TLS1_3) -> None: +class TLS1_3ResourceWithStreamingResponse: + def __init__(self, tls_1_3: TLS1_3Resource) -> None: self._tls_1_3 = tls_1_3 self.edit = to_streamed_response_wrapper( @@ -251,8 +251,8 @@ def __init__(self, tls_1_3: TLS1_3) -> None: ) -class AsyncTLS1_3WithStreamingResponse: - def __init__(self, tls_1_3: AsyncTLS1_3) -> None: +class AsyncTLS1_3ResourceWithStreamingResponse: + def __init__(self, tls_1_3: AsyncTLS1_3Resource) -> None: self._tls_1_3 = tls_1_3 self.edit = async_to_streamed_response_wrapper( diff --git a/src/cloudflare/resources/zones/settings/tls_client_auth.py b/src/cloudflare/resources/zones/settings/tls_client_auth.py index e54e66bebe82..0c0d9865670d 100644 --- a/src/cloudflare/resources/zones/settings/tls_client_auth.py +++ b/src/cloudflare/resources/zones/settings/tls_client_auth.py @@ -24,19 +24,19 @@ from ...._base_client import ( make_request_options, ) -from ....types.zones.settings import ZoneSettingTLSClientAuth, tls_client_auth_edit_params +from ....types.zones.settings import TLSClientAuth, tls_client_auth_edit_params -__all__ = ["TLSClientAuth", "AsyncTLSClientAuth"] +__all__ = ["TLSClientAuthResource", "AsyncTLSClientAuthResource"] -class TLSClientAuth(SyncAPIResource): +class TLSClientAuthResource(SyncAPIResource): @cached_property - def with_raw_response(self) -> TLSClientAuthWithRawResponse: - return TLSClientAuthWithRawResponse(self) + def with_raw_response(self) -> TLSClientAuthResourceWithRawResponse: + return TLSClientAuthResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> TLSClientAuthWithStreamingResponse: - return TLSClientAuthWithStreamingResponse(self) + def with_streaming_response(self) -> TLSClientAuthResourceWithStreamingResponse: + return TLSClientAuthResourceWithStreamingResponse(self) def edit( self, @@ -49,7 +49,7 @@ def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingTLSClientAuth]: + ) -> Optional[TLSClientAuth]: """ TLS Client Auth requires Cloudflare to connect to your origin server using a client certificate (Enterprise Only). @@ -79,7 +79,7 @@ def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingTLSClientAuth]], ResultWrapper[ZoneSettingTLSClientAuth]), + cast_to=cast(Type[Optional[TLSClientAuth]], ResultWrapper[TLSClientAuth]), ) def get( @@ -92,7 +92,7 @@ def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingTLSClientAuth]: + ) -> Optional[TLSClientAuth]: """ TLS Client Auth requires Cloudflare to connect to your origin server using a client certificate (Enterprise Only). @@ -119,18 +119,18 @@ def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingTLSClientAuth]], ResultWrapper[ZoneSettingTLSClientAuth]), + cast_to=cast(Type[Optional[TLSClientAuth]], ResultWrapper[TLSClientAuth]), ) -class AsyncTLSClientAuth(AsyncAPIResource): +class AsyncTLSClientAuthResource(AsyncAPIResource): @cached_property - def with_raw_response(self) -> AsyncTLSClientAuthWithRawResponse: - return AsyncTLSClientAuthWithRawResponse(self) + def with_raw_response(self) -> AsyncTLSClientAuthResourceWithRawResponse: + return AsyncTLSClientAuthResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> AsyncTLSClientAuthWithStreamingResponse: - return AsyncTLSClientAuthWithStreamingResponse(self) + def with_streaming_response(self) -> AsyncTLSClientAuthResourceWithStreamingResponse: + return AsyncTLSClientAuthResourceWithStreamingResponse(self) async def edit( self, @@ -143,7 +143,7 @@ async def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingTLSClientAuth]: + ) -> Optional[TLSClientAuth]: """ TLS Client Auth requires Cloudflare to connect to your origin server using a client certificate (Enterprise Only). @@ -173,7 +173,7 @@ async def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingTLSClientAuth]], ResultWrapper[ZoneSettingTLSClientAuth]), + cast_to=cast(Type[Optional[TLSClientAuth]], ResultWrapper[TLSClientAuth]), ) async def get( @@ -186,7 +186,7 @@ async def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingTLSClientAuth]: + ) -> Optional[TLSClientAuth]: """ TLS Client Auth requires Cloudflare to connect to your origin server using a client certificate (Enterprise Only). @@ -213,12 +213,12 @@ async def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingTLSClientAuth]], ResultWrapper[ZoneSettingTLSClientAuth]), + cast_to=cast(Type[Optional[TLSClientAuth]], ResultWrapper[TLSClientAuth]), ) -class TLSClientAuthWithRawResponse: - def __init__(self, tls_client_auth: TLSClientAuth) -> None: +class TLSClientAuthResourceWithRawResponse: + def __init__(self, tls_client_auth: TLSClientAuthResource) -> None: self._tls_client_auth = tls_client_auth self.edit = to_raw_response_wrapper( @@ -229,8 +229,8 @@ def __init__(self, tls_client_auth: TLSClientAuth) -> None: ) -class AsyncTLSClientAuthWithRawResponse: - def __init__(self, tls_client_auth: AsyncTLSClientAuth) -> None: +class AsyncTLSClientAuthResourceWithRawResponse: + def __init__(self, tls_client_auth: AsyncTLSClientAuthResource) -> None: self._tls_client_auth = tls_client_auth self.edit = async_to_raw_response_wrapper( @@ -241,8 +241,8 @@ def __init__(self, tls_client_auth: AsyncTLSClientAuth) -> None: ) -class TLSClientAuthWithStreamingResponse: - def __init__(self, tls_client_auth: TLSClientAuth) -> None: +class TLSClientAuthResourceWithStreamingResponse: + def __init__(self, tls_client_auth: TLSClientAuthResource) -> None: self._tls_client_auth = tls_client_auth self.edit = to_streamed_response_wrapper( @@ -253,8 +253,8 @@ def __init__(self, tls_client_auth: TLSClientAuth) -> None: ) -class AsyncTLSClientAuthWithStreamingResponse: - def __init__(self, tls_client_auth: AsyncTLSClientAuth) -> None: +class AsyncTLSClientAuthResourceWithStreamingResponse: + def __init__(self, tls_client_auth: AsyncTLSClientAuthResource) -> None: self._tls_client_auth = tls_client_auth self.edit = async_to_streamed_response_wrapper( diff --git a/src/cloudflare/resources/zones/settings/true_client_ip_header.py b/src/cloudflare/resources/zones/settings/true_client_ip_header.py index 20b9b22963de..7a92ad77707e 100644 --- a/src/cloudflare/resources/zones/settings/true_client_ip_header.py +++ b/src/cloudflare/resources/zones/settings/true_client_ip_header.py @@ -24,19 +24,19 @@ from ...._base_client import ( make_request_options, ) -from ....types.zones.settings import ZoneSettingTrueClientIPHeader, true_client_ip_header_edit_params +from ....types.zones.settings import TrueClientIPHeader, true_client_ip_header_edit_params -__all__ = ["TrueClientIPHeader", "AsyncTrueClientIPHeader"] +__all__ = ["TrueClientIPHeaderResource", "AsyncTrueClientIPHeaderResource"] -class TrueClientIPHeader(SyncAPIResource): +class TrueClientIPHeaderResource(SyncAPIResource): @cached_property - def with_raw_response(self) -> TrueClientIPHeaderWithRawResponse: - return TrueClientIPHeaderWithRawResponse(self) + def with_raw_response(self) -> TrueClientIPHeaderResourceWithRawResponse: + return TrueClientIPHeaderResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> TrueClientIPHeaderWithStreamingResponse: - return TrueClientIPHeaderWithStreamingResponse(self) + def with_streaming_response(self) -> TrueClientIPHeaderResourceWithStreamingResponse: + return TrueClientIPHeaderResourceWithStreamingResponse(self) def edit( self, @@ -49,7 +49,7 @@ def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingTrueClientIPHeader]: + ) -> Optional[TrueClientIPHeader]: """ Allows customer to continue to use True Client IP (Akamai feature) in the headers we send to the origin. This is limited to Enterprise Zones. @@ -79,7 +79,7 @@ def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingTrueClientIPHeader]], ResultWrapper[ZoneSettingTrueClientIPHeader]), + cast_to=cast(Type[Optional[TrueClientIPHeader]], ResultWrapper[TrueClientIPHeader]), ) def get( @@ -92,7 +92,7 @@ def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingTrueClientIPHeader]: + ) -> Optional[TrueClientIPHeader]: """ Allows customer to continue to use True Client IP (Akamai feature) in the headers we send to the origin. This is limited to Enterprise Zones. @@ -119,18 +119,18 @@ def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingTrueClientIPHeader]], ResultWrapper[ZoneSettingTrueClientIPHeader]), + cast_to=cast(Type[Optional[TrueClientIPHeader]], ResultWrapper[TrueClientIPHeader]), ) -class AsyncTrueClientIPHeader(AsyncAPIResource): +class AsyncTrueClientIPHeaderResource(AsyncAPIResource): @cached_property - def with_raw_response(self) -> AsyncTrueClientIPHeaderWithRawResponse: - return AsyncTrueClientIPHeaderWithRawResponse(self) + def with_raw_response(self) -> AsyncTrueClientIPHeaderResourceWithRawResponse: + return AsyncTrueClientIPHeaderResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> AsyncTrueClientIPHeaderWithStreamingResponse: - return AsyncTrueClientIPHeaderWithStreamingResponse(self) + def with_streaming_response(self) -> AsyncTrueClientIPHeaderResourceWithStreamingResponse: + return AsyncTrueClientIPHeaderResourceWithStreamingResponse(self) async def edit( self, @@ -143,7 +143,7 @@ async def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingTrueClientIPHeader]: + ) -> Optional[TrueClientIPHeader]: """ Allows customer to continue to use True Client IP (Akamai feature) in the headers we send to the origin. This is limited to Enterprise Zones. @@ -175,7 +175,7 @@ async def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingTrueClientIPHeader]], ResultWrapper[ZoneSettingTrueClientIPHeader]), + cast_to=cast(Type[Optional[TrueClientIPHeader]], ResultWrapper[TrueClientIPHeader]), ) async def get( @@ -188,7 +188,7 @@ async def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingTrueClientIPHeader]: + ) -> Optional[TrueClientIPHeader]: """ Allows customer to continue to use True Client IP (Akamai feature) in the headers we send to the origin. This is limited to Enterprise Zones. @@ -215,12 +215,12 @@ async def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingTrueClientIPHeader]], ResultWrapper[ZoneSettingTrueClientIPHeader]), + cast_to=cast(Type[Optional[TrueClientIPHeader]], ResultWrapper[TrueClientIPHeader]), ) -class TrueClientIPHeaderWithRawResponse: - def __init__(self, true_client_ip_header: TrueClientIPHeader) -> None: +class TrueClientIPHeaderResourceWithRawResponse: + def __init__(self, true_client_ip_header: TrueClientIPHeaderResource) -> None: self._true_client_ip_header = true_client_ip_header self.edit = to_raw_response_wrapper( @@ -231,8 +231,8 @@ def __init__(self, true_client_ip_header: TrueClientIPHeader) -> None: ) -class AsyncTrueClientIPHeaderWithRawResponse: - def __init__(self, true_client_ip_header: AsyncTrueClientIPHeader) -> None: +class AsyncTrueClientIPHeaderResourceWithRawResponse: + def __init__(self, true_client_ip_header: AsyncTrueClientIPHeaderResource) -> None: self._true_client_ip_header = true_client_ip_header self.edit = async_to_raw_response_wrapper( @@ -243,8 +243,8 @@ def __init__(self, true_client_ip_header: AsyncTrueClientIPHeader) -> None: ) -class TrueClientIPHeaderWithStreamingResponse: - def __init__(self, true_client_ip_header: TrueClientIPHeader) -> None: +class TrueClientIPHeaderResourceWithStreamingResponse: + def __init__(self, true_client_ip_header: TrueClientIPHeaderResource) -> None: self._true_client_ip_header = true_client_ip_header self.edit = to_streamed_response_wrapper( @@ -255,8 +255,8 @@ def __init__(self, true_client_ip_header: TrueClientIPHeader) -> None: ) -class AsyncTrueClientIPHeaderWithStreamingResponse: - def __init__(self, true_client_ip_header: AsyncTrueClientIPHeader) -> None: +class AsyncTrueClientIPHeaderResourceWithStreamingResponse: + def __init__(self, true_client_ip_header: AsyncTrueClientIPHeaderResource) -> None: self._true_client_ip_header = true_client_ip_header self.edit = async_to_streamed_response_wrapper( diff --git a/src/cloudflare/resources/zones/settings/waf.py b/src/cloudflare/resources/zones/settings/waf.py index 542ffe9f82eb..d5d55766c9c4 100644 --- a/src/cloudflare/resources/zones/settings/waf.py +++ b/src/cloudflare/resources/zones/settings/waf.py @@ -24,19 +24,19 @@ from ...._base_client import ( make_request_options, ) -from ....types.zones.settings import ZoneSettingWAF, waf_edit_params +from ....types.zones.settings import WAF, waf_edit_params -__all__ = ["WAF", "AsyncWAF"] +__all__ = ["WAFResource", "AsyncWAFResource"] -class WAF(SyncAPIResource): +class WAFResource(SyncAPIResource): @cached_property - def with_raw_response(self) -> WAFWithRawResponse: - return WAFWithRawResponse(self) + def with_raw_response(self) -> WAFResourceWithRawResponse: + return WAFResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> WAFWithStreamingResponse: - return WAFWithStreamingResponse(self) + def with_streaming_response(self) -> WAFResourceWithStreamingResponse: + return WAFResourceWithStreamingResponse(self) def edit( self, @@ -49,7 +49,7 @@ def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingWAF]: + ) -> Optional[WAF]: """The WAF examines HTTP requests to your website. It inspects both GET and POST @@ -88,7 +88,7 @@ def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingWAF]], ResultWrapper[ZoneSettingWAF]), + cast_to=cast(Type[Optional[WAF]], ResultWrapper[WAF]), ) def get( @@ -101,7 +101,7 @@ def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingWAF]: + ) -> Optional[WAF]: """The WAF examines HTTP requests to your website. It inspects both GET and POST @@ -137,18 +137,18 @@ def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingWAF]], ResultWrapper[ZoneSettingWAF]), + cast_to=cast(Type[Optional[WAF]], ResultWrapper[WAF]), ) -class AsyncWAF(AsyncAPIResource): +class AsyncWAFResource(AsyncAPIResource): @cached_property - def with_raw_response(self) -> AsyncWAFWithRawResponse: - return AsyncWAFWithRawResponse(self) + def with_raw_response(self) -> AsyncWAFResourceWithRawResponse: + return AsyncWAFResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> AsyncWAFWithStreamingResponse: - return AsyncWAFWithStreamingResponse(self) + def with_streaming_response(self) -> AsyncWAFResourceWithStreamingResponse: + return AsyncWAFResourceWithStreamingResponse(self) async def edit( self, @@ -161,7 +161,7 @@ async def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingWAF]: + ) -> Optional[WAF]: """The WAF examines HTTP requests to your website. It inspects both GET and POST @@ -200,7 +200,7 @@ async def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingWAF]], ResultWrapper[ZoneSettingWAF]), + cast_to=cast(Type[Optional[WAF]], ResultWrapper[WAF]), ) async def get( @@ -213,7 +213,7 @@ async def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingWAF]: + ) -> Optional[WAF]: """The WAF examines HTTP requests to your website. It inspects both GET and POST @@ -249,12 +249,12 @@ async def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingWAF]], ResultWrapper[ZoneSettingWAF]), + cast_to=cast(Type[Optional[WAF]], ResultWrapper[WAF]), ) -class WAFWithRawResponse: - def __init__(self, waf: WAF) -> None: +class WAFResourceWithRawResponse: + def __init__(self, waf: WAFResource) -> None: self._waf = waf self.edit = to_raw_response_wrapper( @@ -265,8 +265,8 @@ def __init__(self, waf: WAF) -> None: ) -class AsyncWAFWithRawResponse: - def __init__(self, waf: AsyncWAF) -> None: +class AsyncWAFResourceWithRawResponse: + def __init__(self, waf: AsyncWAFResource) -> None: self._waf = waf self.edit = async_to_raw_response_wrapper( @@ -277,8 +277,8 @@ def __init__(self, waf: AsyncWAF) -> None: ) -class WAFWithStreamingResponse: - def __init__(self, waf: WAF) -> None: +class WAFResourceWithStreamingResponse: + def __init__(self, waf: WAFResource) -> None: self._waf = waf self.edit = to_streamed_response_wrapper( @@ -289,8 +289,8 @@ def __init__(self, waf: WAF) -> None: ) -class AsyncWAFWithStreamingResponse: - def __init__(self, waf: AsyncWAF) -> None: +class AsyncWAFResourceWithStreamingResponse: + def __init__(self, waf: AsyncWAFResource) -> None: self._waf = waf self.edit = async_to_streamed_response_wrapper( diff --git a/src/cloudflare/resources/zones/settings/webp.py b/src/cloudflare/resources/zones/settings/webp.py index 78ec76125559..ba1676b70626 100644 --- a/src/cloudflare/resources/zones/settings/webp.py +++ b/src/cloudflare/resources/zones/settings/webp.py @@ -24,19 +24,19 @@ from ...._base_client import ( make_request_options, ) -from ....types.zones.settings import ZoneSettingWebP, webp_edit_params +from ....types.zones.settings import WebP, webp_edit_params -__all__ = ["WebP", "AsyncWebP"] +__all__ = ["WebPResource", "AsyncWebPResource"] -class WebP(SyncAPIResource): +class WebPResource(SyncAPIResource): @cached_property - def with_raw_response(self) -> WebPWithRawResponse: - return WebPWithRawResponse(self) + def with_raw_response(self) -> WebPResourceWithRawResponse: + return WebPResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> WebPWithStreamingResponse: - return WebPWithStreamingResponse(self) + def with_streaming_response(self) -> WebPResourceWithStreamingResponse: + return WebPResourceWithStreamingResponse(self) def edit( self, @@ -49,7 +49,7 @@ def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingWebP]: + ) -> Optional[WebP]: """ When the client requesting the image supports the WebP image codec, and WebP offers a performance advantage over the original image format, Cloudflare will @@ -80,7 +80,7 @@ def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingWebP]], ResultWrapper[ZoneSettingWebP]), + cast_to=cast(Type[Optional[WebP]], ResultWrapper[WebP]), ) def get( @@ -93,7 +93,7 @@ def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingWebP]: + ) -> Optional[WebP]: """ When the client requesting the image supports the WebP image codec, and WebP offers a performance advantage over the original image format, Cloudflare will @@ -121,18 +121,18 @@ def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingWebP]], ResultWrapper[ZoneSettingWebP]), + cast_to=cast(Type[Optional[WebP]], ResultWrapper[WebP]), ) -class AsyncWebP(AsyncAPIResource): +class AsyncWebPResource(AsyncAPIResource): @cached_property - def with_raw_response(self) -> AsyncWebPWithRawResponse: - return AsyncWebPWithRawResponse(self) + def with_raw_response(self) -> AsyncWebPResourceWithRawResponse: + return AsyncWebPResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> AsyncWebPWithStreamingResponse: - return AsyncWebPWithStreamingResponse(self) + def with_streaming_response(self) -> AsyncWebPResourceWithStreamingResponse: + return AsyncWebPResourceWithStreamingResponse(self) async def edit( self, @@ -145,7 +145,7 @@ async def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingWebP]: + ) -> Optional[WebP]: """ When the client requesting the image supports the WebP image codec, and WebP offers a performance advantage over the original image format, Cloudflare will @@ -176,7 +176,7 @@ async def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingWebP]], ResultWrapper[ZoneSettingWebP]), + cast_to=cast(Type[Optional[WebP]], ResultWrapper[WebP]), ) async def get( @@ -189,7 +189,7 @@ async def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingWebP]: + ) -> Optional[WebP]: """ When the client requesting the image supports the WebP image codec, and WebP offers a performance advantage over the original image format, Cloudflare will @@ -217,12 +217,12 @@ async def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingWebP]], ResultWrapper[ZoneSettingWebP]), + cast_to=cast(Type[Optional[WebP]], ResultWrapper[WebP]), ) -class WebPWithRawResponse: - def __init__(self, webp: WebP) -> None: +class WebPResourceWithRawResponse: + def __init__(self, webp: WebPResource) -> None: self._webp = webp self.edit = to_raw_response_wrapper( @@ -233,8 +233,8 @@ def __init__(self, webp: WebP) -> None: ) -class AsyncWebPWithRawResponse: - def __init__(self, webp: AsyncWebP) -> None: +class AsyncWebPResourceWithRawResponse: + def __init__(self, webp: AsyncWebPResource) -> None: self._webp = webp self.edit = async_to_raw_response_wrapper( @@ -245,8 +245,8 @@ def __init__(self, webp: AsyncWebP) -> None: ) -class WebPWithStreamingResponse: - def __init__(self, webp: WebP) -> None: +class WebPResourceWithStreamingResponse: + def __init__(self, webp: WebPResource) -> None: self._webp = webp self.edit = to_streamed_response_wrapper( @@ -257,8 +257,8 @@ def __init__(self, webp: WebP) -> None: ) -class AsyncWebPWithStreamingResponse: - def __init__(self, webp: AsyncWebP) -> None: +class AsyncWebPResourceWithStreamingResponse: + def __init__(self, webp: AsyncWebPResource) -> None: self._webp = webp self.edit = async_to_streamed_response_wrapper( diff --git a/src/cloudflare/resources/zones/settings/websocket.py b/src/cloudflare/resources/zones/settings/websocket.py index 68b4940c9fd9..cc407ff8ef64 100644 --- a/src/cloudflare/resources/zones/settings/websocket.py +++ b/src/cloudflare/resources/zones/settings/websocket.py @@ -24,19 +24,19 @@ from ...._base_client import ( make_request_options, ) -from ....types.zones.settings import ZoneSettingWebsockets, websocket_edit_params +from ....types.zones.settings import Websocket, websocket_edit_params -__all__ = ["Websocket", "AsyncWebsocket"] +__all__ = ["WebsocketResource", "AsyncWebsocketResource"] -class Websocket(SyncAPIResource): +class WebsocketResource(SyncAPIResource): @cached_property - def with_raw_response(self) -> WebsocketWithRawResponse: - return WebsocketWithRawResponse(self) + def with_raw_response(self) -> WebsocketResourceWithRawResponse: + return WebsocketResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> WebsocketWithStreamingResponse: - return WebsocketWithStreamingResponse(self) + def with_streaming_response(self) -> WebsocketResourceWithStreamingResponse: + return WebsocketResourceWithStreamingResponse(self) def edit( self, @@ -49,7 +49,7 @@ def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingWebsockets]: + ) -> Optional[Websocket]: """Changes Websockets setting. For more information about Websockets, please refer @@ -81,7 +81,7 @@ def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingWebsockets]], ResultWrapper[ZoneSettingWebsockets]), + cast_to=cast(Type[Optional[Websocket]], ResultWrapper[Websocket]), ) def get( @@ -94,7 +94,7 @@ def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingWebsockets]: + ) -> Optional[Websocket]: """Gets Websockets setting. For more information about Websockets, please refer to @@ -122,18 +122,18 @@ def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingWebsockets]], ResultWrapper[ZoneSettingWebsockets]), + cast_to=cast(Type[Optional[Websocket]], ResultWrapper[Websocket]), ) -class AsyncWebsocket(AsyncAPIResource): +class AsyncWebsocketResource(AsyncAPIResource): @cached_property - def with_raw_response(self) -> AsyncWebsocketWithRawResponse: - return AsyncWebsocketWithRawResponse(self) + def with_raw_response(self) -> AsyncWebsocketResourceWithRawResponse: + return AsyncWebsocketResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> AsyncWebsocketWithStreamingResponse: - return AsyncWebsocketWithStreamingResponse(self) + def with_streaming_response(self) -> AsyncWebsocketResourceWithStreamingResponse: + return AsyncWebsocketResourceWithStreamingResponse(self) async def edit( self, @@ -146,7 +146,7 @@ async def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingWebsockets]: + ) -> Optional[Websocket]: """Changes Websockets setting. For more information about Websockets, please refer @@ -178,7 +178,7 @@ async def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingWebsockets]], ResultWrapper[ZoneSettingWebsockets]), + cast_to=cast(Type[Optional[Websocket]], ResultWrapper[Websocket]), ) async def get( @@ -191,7 +191,7 @@ async def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSettingWebsockets]: + ) -> Optional[Websocket]: """Gets Websockets setting. For more information about Websockets, please refer to @@ -219,12 +219,12 @@ async def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSettingWebsockets]], ResultWrapper[ZoneSettingWebsockets]), + cast_to=cast(Type[Optional[Websocket]], ResultWrapper[Websocket]), ) -class WebsocketWithRawResponse: - def __init__(self, websocket: Websocket) -> None: +class WebsocketResourceWithRawResponse: + def __init__(self, websocket: WebsocketResource) -> None: self._websocket = websocket self.edit = to_raw_response_wrapper( @@ -235,8 +235,8 @@ def __init__(self, websocket: Websocket) -> None: ) -class AsyncWebsocketWithRawResponse: - def __init__(self, websocket: AsyncWebsocket) -> None: +class AsyncWebsocketResourceWithRawResponse: + def __init__(self, websocket: AsyncWebsocketResource) -> None: self._websocket = websocket self.edit = async_to_raw_response_wrapper( @@ -247,8 +247,8 @@ def __init__(self, websocket: AsyncWebsocket) -> None: ) -class WebsocketWithStreamingResponse: - def __init__(self, websocket: Websocket) -> None: +class WebsocketResourceWithStreamingResponse: + def __init__(self, websocket: WebsocketResource) -> None: self._websocket = websocket self.edit = to_streamed_response_wrapper( @@ -259,8 +259,8 @@ def __init__(self, websocket: Websocket) -> None: ) -class AsyncWebsocketWithStreamingResponse: - def __init__(self, websocket: AsyncWebsocket) -> None: +class AsyncWebsocketResourceWithStreamingResponse: + def __init__(self, websocket: AsyncWebsocketResource) -> None: self._websocket = websocket self.edit = async_to_streamed_response_wrapper( diff --git a/src/cloudflare/resources/zones/settings/zero_rtt.py b/src/cloudflare/resources/zones/settings/zero_rtt.py index 9f47865ed168..f60e1cb6c81f 100644 --- a/src/cloudflare/resources/zones/settings/zero_rtt.py +++ b/src/cloudflare/resources/zones/settings/zero_rtt.py @@ -24,19 +24,19 @@ from ...._base_client import ( make_request_options, ) -from ....types.zones.settings import ZoneSetting0rtt, zero_rtt_edit_params +from ....types.zones.settings import ZeroRTT, zero_rtt_edit_params -__all__ = ["ZeroRTT", "AsyncZeroRTT"] +__all__ = ["ZeroRTTResource", "AsyncZeroRTTResource"] -class ZeroRTT(SyncAPIResource): +class ZeroRTTResource(SyncAPIResource): @cached_property - def with_raw_response(self) -> ZeroRTTWithRawResponse: - return ZeroRTTWithRawResponse(self) + def with_raw_response(self) -> ZeroRTTResourceWithRawResponse: + return ZeroRTTResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> ZeroRTTWithStreamingResponse: - return ZeroRTTWithStreamingResponse(self) + def with_streaming_response(self) -> ZeroRTTResourceWithStreamingResponse: + return ZeroRTTResourceWithStreamingResponse(self) def edit( self, @@ -49,7 +49,7 @@ def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSetting0rtt]: + ) -> Optional[ZeroRTT]: """ Changes the 0-RTT session resumption setting. @@ -78,7 +78,7 @@ def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSetting0rtt]], ResultWrapper[ZoneSetting0rtt]), + cast_to=cast(Type[Optional[ZeroRTT]], ResultWrapper[ZeroRTT]), ) def get( @@ -91,7 +91,7 @@ def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSetting0rtt]: + ) -> Optional[ZeroRTT]: """ Gets 0-RTT session resumption setting. @@ -117,18 +117,18 @@ def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSetting0rtt]], ResultWrapper[ZoneSetting0rtt]), + cast_to=cast(Type[Optional[ZeroRTT]], ResultWrapper[ZeroRTT]), ) -class AsyncZeroRTT(AsyncAPIResource): +class AsyncZeroRTTResource(AsyncAPIResource): @cached_property - def with_raw_response(self) -> AsyncZeroRTTWithRawResponse: - return AsyncZeroRTTWithRawResponse(self) + def with_raw_response(self) -> AsyncZeroRTTResourceWithRawResponse: + return AsyncZeroRTTResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> AsyncZeroRTTWithStreamingResponse: - return AsyncZeroRTTWithStreamingResponse(self) + def with_streaming_response(self) -> AsyncZeroRTTResourceWithStreamingResponse: + return AsyncZeroRTTResourceWithStreamingResponse(self) async def edit( self, @@ -141,7 +141,7 @@ async def edit( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSetting0rtt]: + ) -> Optional[ZeroRTT]: """ Changes the 0-RTT session resumption setting. @@ -170,7 +170,7 @@ async def edit( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSetting0rtt]], ResultWrapper[ZoneSetting0rtt]), + cast_to=cast(Type[Optional[ZeroRTT]], ResultWrapper[ZeroRTT]), ) async def get( @@ -183,7 +183,7 @@ async def get( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[ZoneSetting0rtt]: + ) -> Optional[ZeroRTT]: """ Gets 0-RTT session resumption setting. @@ -209,12 +209,12 @@ async def get( timeout=timeout, post_parser=ResultWrapper._unwrapper, ), - cast_to=cast(Type[Optional[ZoneSetting0rtt]], ResultWrapper[ZoneSetting0rtt]), + cast_to=cast(Type[Optional[ZeroRTT]], ResultWrapper[ZeroRTT]), ) -class ZeroRTTWithRawResponse: - def __init__(self, zero_rtt: ZeroRTT) -> None: +class ZeroRTTResourceWithRawResponse: + def __init__(self, zero_rtt: ZeroRTTResource) -> None: self._zero_rtt = zero_rtt self.edit = to_raw_response_wrapper( @@ -225,8 +225,8 @@ def __init__(self, zero_rtt: ZeroRTT) -> None: ) -class AsyncZeroRTTWithRawResponse: - def __init__(self, zero_rtt: AsyncZeroRTT) -> None: +class AsyncZeroRTTResourceWithRawResponse: + def __init__(self, zero_rtt: AsyncZeroRTTResource) -> None: self._zero_rtt = zero_rtt self.edit = async_to_raw_response_wrapper( @@ -237,8 +237,8 @@ def __init__(self, zero_rtt: AsyncZeroRTT) -> None: ) -class ZeroRTTWithStreamingResponse: - def __init__(self, zero_rtt: ZeroRTT) -> None: +class ZeroRTTResourceWithStreamingResponse: + def __init__(self, zero_rtt: ZeroRTTResource) -> None: self._zero_rtt = zero_rtt self.edit = to_streamed_response_wrapper( @@ -249,8 +249,8 @@ def __init__(self, zero_rtt: ZeroRTT) -> None: ) -class AsyncZeroRTTWithStreamingResponse: - def __init__(self, zero_rtt: AsyncZeroRTT) -> None: +class AsyncZeroRTTResourceWithStreamingResponse: + def __init__(self, zero_rtt: AsyncZeroRTTResource) -> None: self._zero_rtt = zero_rtt self.edit = async_to_streamed_response_wrapper( diff --git a/src/cloudflare/types/zones/settings/__init__.py b/src/cloudflare/types/zones/settings/__init__.py index 1f42c45a1c6b..bc892e49a1c5 100644 --- a/src/cloudflare/types/zones/settings/__init__.py +++ b/src/cloudflare/types/zones/settings/__init__.py @@ -2,135 +2,125 @@ from __future__ import annotations +from .nel import NEL as NEL +from .ssl import SSL as SSL +from .waf import WAF as WAF +from .ipv6 import IPV6 as IPV6 +from .webp import WebP as WebP +from .http2 import HTTP2 as HTTP2 +from .http3 import HTTP3 as HTTP3 +from .brotli import Brotli as Brotli +from .minify import Minify as Minify +from .mirage import Mirage as Mirage +from .polish import Polish as Polish +from .ciphers import Ciphers as Ciphers +from .tls_1_3 import TLS1_3 as TLS1_3 +from .zero_rtt import ZeroRTT as ZeroRTT +from .nel_param import NELParam as NELParam +from .websocket import Websocket as Websocket +from .cache_level import CacheLevel as CacheLevel +from .early_hints import EarlyHints as EarlyHints +from .pseudo_ipv4 import PseudoIPV4 as PseudoIPV4 +from .polish_param import PolishParam as PolishParam +from .advanced_ddos import AdvancedDDoS as AdvancedDDoS +from .always_online import AlwaysOnline as AlwaysOnline +from .browser_check import BrowserCheck as BrowserCheck +from .challenge_ttl import ChallengeTTL as ChallengeTTL +from .font_settings import FontSettings as FontSettings +from .rocket_loader import RocketLoader as RocketLoader +from .image_resizing import ImageResizing as ImageResizing +from .ip_geolocation import IPGeolocation as IPGeolocation +from .security_level import SecurityLevel as SecurityLevel +from .min_tls_version import MinTLSVersion as MinTLSVersion +from .mobile_redirect import MobileRedirect as MobileRedirect from .nel_edit_params import NELEditParams as NELEditParams from .ssl_edit_params import SSLEditParams as SSLEditParams +from .ssl_recommender import SSLRecommender as SSLRecommender +from .tls_client_auth import TLSClientAuth as TLSClientAuth from .waf_edit_params import WAFEditParams as WAFEditParams +from .always_use_https import AlwaysUseHTTPS as AlwaysUseHTTPS +from .development_mode import DevelopmentMode as DevelopmentMode from .ipv6_edit_params import IPV6EditParams as IPV6EditParams +from .orange_to_orange import OrangeToOrange as OrangeToOrange +from .prefetch_preload import PrefetchPreload as PrefetchPreload +from .security_headers import SecurityHeaders as SecurityHeaders from .webp_edit_params import WebPEditParams as WebPEditParams -from .zone_setting_nel import ZoneSettingNEL as ZoneSettingNEL -from .zone_setting_ssl import ZoneSettingSSL as ZoneSettingSSL -from .zone_setting_waf import ZoneSettingWAF as ZoneSettingWAF +from .browser_cache_ttl import BrowserCacheTTL as BrowserCacheTTL +from .email_obfuscation import EmailObfuscation as EmailObfuscation +from .h2_prioritization import H2Prioritization as H2Prioritization from .http2_edit_params import HTTP2EditParams as HTTP2EditParams from .http3_edit_params import HTTP3EditParams as HTTP3EditParams -from .zone_setting_0rtt import ZoneSetting0rtt as ZoneSetting0rtt -from .zone_setting_ipv6 import ZoneSettingIPV6 as ZoneSettingIPV6 -from .zone_setting_webp import ZoneSettingWebP as ZoneSettingWebP from .brotli_edit_params import BrotliEditParams as BrotliEditParams from .cipher_edit_params import CipherEditParams as CipherEditParams +from .hotlink_protection import HotlinkProtection as HotlinkProtection from .minify_edit_params import MinifyEditParams as MinifyEditParams from .mirage_edit_params import MirageEditParams as MirageEditParams from .polish_edit_params import PolishEditParams as PolishEditParams -from .zone_setting_fonts import ZoneSettingFonts as ZoneSettingFonts -from .zone_setting_http2 import ZoneSettingHTTP2 as ZoneSettingHTTP2 -from .zone_setting_http3 import ZoneSettingHTTP3 as ZoneSettingHTTP3 +from .proxy_read_timeout import ProxyReadTimeout as ProxyReadTimeout +from .response_buffering import ResponseBuffering as ResponseBuffering +from .opportunistic_onion import OpportunisticOnion as OpportunisticOnion +from .rocket_loader_param import RocketLoaderParam as RocketLoaderParam from .tls_1_3_edit_params import TLS1_3EditParams as TLS1_3EditParams -from .zone_setting_brotli import ZoneSettingBrotli as ZoneSettingBrotli -from .zone_setting_minify import ZoneSettingMinify as ZoneSettingMinify -from .zone_setting_mirage import ZoneSettingMirage as ZoneSettingMirage -from .zone_setting_polish import ZoneSettingPolish as ZoneSettingPolish +from .image_resizing_param import ImageResizingParam as ImageResizingParam +from .server_side_excludes import ServerSideExcludes as ServerSideExcludes from .zero_rtt_edit_params import ZeroRTTEditParams as ZeroRTTEditParams -from .zone_setting_ciphers import ZoneSettingCiphers as ZoneSettingCiphers -from .zone_setting_tls_1_3 import ZoneSettingTLS1_3 as ZoneSettingTLS1_3 +from .ssl_recommender_param import SSLRecommenderParam as SSLRecommenderParam +from .true_client_ip_header import TrueClientIPHeader as TrueClientIPHeader from .websocket_edit_params import WebsocketEditParams as WebsocketEditParams from .early_hint_edit_params import EarlyHintEditParams as EarlyHintEditParams -from .zone_setting_buffering import ZoneSettingBuffering as ZoneSettingBuffering -from .zone_setting_nel_param import ZoneSettingNELParam as ZoneSettingNELParam +from .orange_to_orange_param import OrangeToOrangeParam as OrangeToOrangeParam from .cache_level_edit_params import CacheLevelEditParams as CacheLevelEditParams +from .h2_prioritization_param import H2PrioritizationParam as H2PrioritizationParam from .pseudo_ipv4_edit_params import PseudoIPV4EditParams as PseudoIPV4EditParams -from .zone_setting_websockets import ZoneSettingWebsockets as ZoneSettingWebsockets +from .automatic_https_rewrites import AutomaticHTTPSRewrites as AutomaticHTTPSRewrites from .font_setting_edit_params import FontSettingEditParams as FontSettingEditParams -from .zone_setting_cache_level import ZoneSettingCacheLevel as ZoneSettingCacheLevel -from .zone_setting_early_hints import ZoneSettingEarlyHints as ZoneSettingEarlyHints -from .zone_setting_pseudo_ipv4 import ZoneSettingPseudoIPV4 as ZoneSettingPseudoIPV4 +from .opportunistic_encryption import OpportunisticEncryption as OpportunisticEncryption +from .proxy_read_timeout_param import ProxyReadTimeoutParam as ProxyReadTimeoutParam from .always_online_edit_params import AlwaysOnlineEditParams as AlwaysOnlineEditParams from .browser_check_edit_params import BrowserCheckEditParams as BrowserCheckEditParams from .challenge_ttl_edit_params import ChallengeTTLEditParams as ChallengeTTLEditParams from .rocket_loader_edit_params import RocketLoaderEditParams as RocketLoaderEditParams -from .zone_setting_polish_param import ZoneSettingPolishParam as ZoneSettingPolishParam from .image_resizing_edit_params import ImageResizingEditParams as ImageResizingEditParams from .ip_geolocation_edit_params import IPGeolocationEditParams as IPGeolocationEditParams from .security_level_edit_params import SecurityLevelEditParams as SecurityLevelEditParams -from .zone_setting_advanced_ddos import ZoneSettingAdvancedDDoS as ZoneSettingAdvancedDDoS -from .zone_setting_always_online import ZoneSettingAlwaysOnline as ZoneSettingAlwaysOnline -from .zone_setting_browser_check import ZoneSettingBrowserCheck as ZoneSettingBrowserCheck -from .zone_setting_challenge_ttl import ZoneSettingChallengeTTL as ZoneSettingChallengeTTL -from .zone_setting_rocket_loader import ZoneSettingRocketLoader as ZoneSettingRocketLoader from .min_tls_version_edit_params import MinTLSVersionEditParams as MinTLSVersionEditParams from .mobile_redirect_edit_params import MobileRedirectEditParams as MobileRedirectEditParams +from .origin_error_page_pass_thru import OriginErrorPagePassThru as OriginErrorPagePassThru from .security_header_edit_params import SecurityHeaderEditParams as SecurityHeaderEditParams +from .sort_query_string_for_cache import SortQueryStringForCache as SortQueryStringForCache from .ssl_recommender_edit_params import SSLRecommenderEditParams as SSLRecommenderEditParams from .tls_client_auth_edit_params import TLSClientAuthEditParams as TLSClientAuthEditParams -from .zone_setting_image_resizing import ZoneSettingImageResizing as ZoneSettingImageResizing -from .zone_setting_ip_geolocation import ZoneSettingIPGeolocation as ZoneSettingIPGeolocation -from .zone_setting_security_level import ZoneSettingSecurityLevel as ZoneSettingSecurityLevel from .always_use_https_edit_params import AlwaysUseHTTPSEditParams as AlwaysUseHTTPSEditParams from .development_mode_edit_params import DevelopmentModeEditParams as DevelopmentModeEditParams from .orange_to_orange_edit_params import OrangeToOrangeEditParams as OrangeToOrangeEditParams from .prefetch_preload_edit_params import PrefetchPreloadEditParams as PrefetchPreloadEditParams -from .zone_setting_min_tls_version import ZoneSettingMinTLSVersion as ZoneSettingMinTLSVersion -from .zone_setting_mobile_redirect import ZoneSettingMobileRedirect as ZoneSettingMobileRedirect -from .zone_setting_security_header import ZoneSettingSecurityHeader as ZoneSettingSecurityHeader -from .zone_setting_ssl_recommender import ZoneSettingSSLRecommender as ZoneSettingSSLRecommender -from .zone_setting_tls_client_auth import ZoneSettingTLSClientAuth as ZoneSettingTLSClientAuth from .browser_cache_ttl_edit_params import BrowserCacheTTLEditParams as BrowserCacheTTLEditParams from .email_obfuscation_edit_params import EmailObfuscationEditParams as EmailObfuscationEditParams from .h2_prioritization_edit_params import H2PrioritizationEditParams as H2PrioritizationEditParams -from .zone_setting_always_use_https import ZoneSettingAlwaysUseHTTPS as ZoneSettingAlwaysUseHTTPS -from .zone_setting_development_mode import ZoneSettingDevelopmentMode as ZoneSettingDevelopmentMode -from .zone_setting_orange_to_orange import ZoneSettingOrangeToOrange as ZoneSettingOrangeToOrange -from .zone_setting_prefetch_preload import ZoneSettingPrefetchPreload as ZoneSettingPrefetchPreload from .hotlink_protection_edit_params import HotlinkProtectionEditParams as HotlinkProtectionEditParams from .proxy_read_timeout_edit_params import ProxyReadTimeoutEditParams as ProxyReadTimeoutEditParams from .response_buffering_edit_params import ResponseBufferingEditParams as ResponseBufferingEditParams -from .zone_setting_browser_cache_ttl import ZoneSettingBrowserCacheTTL as ZoneSettingBrowserCacheTTL -from .zone_setting_email_obfuscation import ZoneSettingEmailObfuscation as ZoneSettingEmailObfuscation -from .zone_setting_h2_prioritization import ZoneSettingH2Prioritization as ZoneSettingH2Prioritization +from .automatic_platform_optimization import AutomaticPlatformOptimization as AutomaticPlatformOptimization from .opportunistic_onion_edit_params import OpportunisticOnionEditParams as OpportunisticOnionEditParams from .server_side_exclude_edit_params import ServerSideExcludeEditParams as ServerSideExcludeEditParams -from .zone_setting_hotlink_protection import ZoneSettingHotlinkProtection as ZoneSettingHotlinkProtection -from .zone_setting_proxy_read_timeout import ZoneSettingProxyReadTimeout as ZoneSettingProxyReadTimeout -from .zone_setting_opportunistic_onion import ZoneSettingOpportunisticOnion as ZoneSettingOpportunisticOnion -from .zone_setting_rocket_loader_param import ZoneSettingRocketLoaderParam as ZoneSettingRocketLoaderParam -from .zone_setting_server_side_exclude import ZoneSettingServerSideExclude as ZoneSettingServerSideExclude from .true_client_ip_header_edit_params import TrueClientIPHeaderEditParams as TrueClientIPHeaderEditParams -from .zone_setting_image_resizing_param import ZoneSettingImageResizingParam as ZoneSettingImageResizingParam -from .zone_setting_ssl_recommender_param import ZoneSettingSSLRecommenderParam as ZoneSettingSSLRecommenderParam -from .zone_setting_true_client_ip_header import ZoneSettingTrueClientIPHeader as ZoneSettingTrueClientIPHeader from .automatic_https_rewrite_edit_params import AutomaticHTTPSRewriteEditParams as AutomaticHTTPSRewriteEditParams from .origin_max_http_version_edit_params import OriginMaxHTTPVersionEditParams as OriginMaxHTTPVersionEditParams -from .zone_setting_orange_to_orange_param import ZoneSettingOrangeToOrangeParam as ZoneSettingOrangeToOrangeParam from .opportunistic_encryption_edit_params import OpportunisticEncryptionEditParams as OpportunisticEncryptionEditParams from .origin_max_http_version_get_response import OriginMaxHTTPVersionGetResponse as OriginMaxHTTPVersionGetResponse -from .zone_setting_h2_prioritization_param import ZoneSettingH2PrioritizationParam as ZoneSettingH2PrioritizationParam -from .origin_max_http_version_edit_response import OriginMaxHTTPVersionEditResponse as OriginMaxHTTPVersionEditResponse -from .zone_setting_automatic_https_rewrites import ( - ZoneSettingAutomaticHTTPSRewrites as ZoneSettingAutomaticHTTPSRewrites, -) -from .zone_setting_opportunistic_encryption import ( - ZoneSettingOpportunisticEncryption as ZoneSettingOpportunisticEncryption, +from .automatic_platform_optimization_param import ( + AutomaticPlatformOptimizationParam as AutomaticPlatformOptimizationParam, ) -from .zone_setting_proxy_read_timeout_param import ZoneSettingProxyReadTimeoutParam as ZoneSettingProxyReadTimeoutParam +from .origin_max_http_version_edit_response import OriginMaxHTTPVersionEditResponse as OriginMaxHTTPVersionEditResponse from .origin_error_page_pass_thru_edit_params import ( OriginErrorPagePassThruEditParams as OriginErrorPagePassThruEditParams, ) from .sort_query_string_for_cache_edit_params import ( SortQueryStringForCacheEditParams as SortQueryStringForCacheEditParams, ) -from .zone_setting_origin_error_page_pass_thru import ( - ZoneSettingOriginErrorPagePassThru as ZoneSettingOriginErrorPagePassThru, -) -from .zone_setting_sort_query_string_for_cache import ( - ZoneSettingSortQueryStringForCache as ZoneSettingSortQueryStringForCache, -) from .automatic_platform_optimization_edit_params import ( AutomaticPlatformOptimizationEditParams as AutomaticPlatformOptimizationEditParams, ) -from .zone_setting_automatic_platform_optimization import ( - ZoneSettingAutomaticPlatformOptimization as ZoneSettingAutomaticPlatformOptimization, -) -from .zone_setting_automatic_platform_optimization_param import ( - ZoneSettingAutomaticPlatformOptimizationParam as ZoneSettingAutomaticPlatformOptimizationParam, -) from .unnamed_schema_ref_b234e6a28c1a1c7c29213787c0621eaa import ( UnnamedSchemaRefB234e6a28c1a1c7c29213787c0621eaa as UnnamedSchemaRefB234e6a28c1a1c7c29213787c0621eaa, ) diff --git a/src/cloudflare/types/zones/settings/zone_setting_advanced_ddos.py b/src/cloudflare/types/zones/settings/advanced_ddos.py similarity index 88% rename from src/cloudflare/types/zones/settings/zone_setting_advanced_ddos.py rename to src/cloudflare/types/zones/settings/advanced_ddos.py index ea88edd47934..b399aa5033b1 100644 --- a/src/cloudflare/types/zones/settings/zone_setting_advanced_ddos.py +++ b/src/cloudflare/types/zones/settings/advanced_ddos.py @@ -6,10 +6,10 @@ from ...._models import BaseModel -__all__ = ["ZoneSettingAdvancedDDoS"] +__all__ = ["AdvancedDDoS"] -class ZoneSettingAdvancedDDoS(BaseModel): +class AdvancedDDoS(BaseModel): id: Literal["advanced_ddos"] """ID of the zone setting.""" diff --git a/src/cloudflare/types/zones/settings/zone_setting_always_online.py b/src/cloudflare/types/zones/settings/always_online.py similarity index 88% rename from src/cloudflare/types/zones/settings/zone_setting_always_online.py rename to src/cloudflare/types/zones/settings/always_online.py index 2fb96c5f808b..8e6e3530c862 100644 --- a/src/cloudflare/types/zones/settings/zone_setting_always_online.py +++ b/src/cloudflare/types/zones/settings/always_online.py @@ -6,10 +6,10 @@ from ...._models import BaseModel -__all__ = ["ZoneSettingAlwaysOnline"] +__all__ = ["AlwaysOnline"] -class ZoneSettingAlwaysOnline(BaseModel): +class AlwaysOnline(BaseModel): id: Literal["always_online"] """ID of the zone setting.""" diff --git a/src/cloudflare/types/zones/settings/zone_setting_always_use_https.py b/src/cloudflare/types/zones/settings/always_use_https.py similarity index 88% rename from src/cloudflare/types/zones/settings/zone_setting_always_use_https.py rename to src/cloudflare/types/zones/settings/always_use_https.py index 500d331ab023..683e5f5f23c8 100644 --- a/src/cloudflare/types/zones/settings/zone_setting_always_use_https.py +++ b/src/cloudflare/types/zones/settings/always_use_https.py @@ -6,10 +6,10 @@ from ...._models import BaseModel -__all__ = ["ZoneSettingAlwaysUseHTTPS"] +__all__ = ["AlwaysUseHTTPS"] -class ZoneSettingAlwaysUseHTTPS(BaseModel): +class AlwaysUseHTTPS(BaseModel): id: Literal["always_use_https"] """ID of the zone setting.""" diff --git a/src/cloudflare/types/zones/settings/zone_setting_automatic_https_rewrites.py b/src/cloudflare/types/zones/settings/automatic_https_rewrites.py similarity index 86% rename from src/cloudflare/types/zones/settings/zone_setting_automatic_https_rewrites.py rename to src/cloudflare/types/zones/settings/automatic_https_rewrites.py index c6b14fb8df4d..bc1d055b2c94 100644 --- a/src/cloudflare/types/zones/settings/zone_setting_automatic_https_rewrites.py +++ b/src/cloudflare/types/zones/settings/automatic_https_rewrites.py @@ -6,10 +6,10 @@ from ...._models import BaseModel -__all__ = ["ZoneSettingAutomaticHTTPSRewrites"] +__all__ = ["AutomaticHTTPSRewrites"] -class ZoneSettingAutomaticHTTPSRewrites(BaseModel): +class AutomaticHTTPSRewrites(BaseModel): id: Literal["automatic_https_rewrites"] """ID of the zone setting.""" diff --git a/src/cloudflare/types/zones/settings/zone_setting_automatic_platform_optimization.py b/src/cloudflare/types/zones/settings/automatic_platform_optimization.py similarity index 89% rename from src/cloudflare/types/zones/settings/zone_setting_automatic_platform_optimization.py rename to src/cloudflare/types/zones/settings/automatic_platform_optimization.py index c36be435288f..1523e6d792da 100644 --- a/src/cloudflare/types/zones/settings/zone_setting_automatic_platform_optimization.py +++ b/src/cloudflare/types/zones/settings/automatic_platform_optimization.py @@ -4,10 +4,10 @@ from ...._models import BaseModel -__all__ = ["ZoneSettingAutomaticPlatformOptimization"] +__all__ = ["AutomaticPlatformOptimization"] -class ZoneSettingAutomaticPlatformOptimization(BaseModel): +class AutomaticPlatformOptimization(BaseModel): cache_by_device_type: bool """ Indicates whether or not diff --git a/src/cloudflare/types/zones/settings/automatic_platform_optimization_edit_params.py b/src/cloudflare/types/zones/settings/automatic_platform_optimization_edit_params.py index e7e7da4514e0..a0f822dc9e1c 100644 --- a/src/cloudflare/types/zones/settings/automatic_platform_optimization_edit_params.py +++ b/src/cloudflare/types/zones/settings/automatic_platform_optimization_edit_params.py @@ -4,7 +4,7 @@ from typing_extensions import Required, TypedDict -from .zone_setting_automatic_platform_optimization_param import ZoneSettingAutomaticPlatformOptimizationParam +from .automatic_platform_optimization_param import AutomaticPlatformOptimizationParam __all__ = ["AutomaticPlatformOptimizationEditParams"] @@ -13,4 +13,4 @@ class AutomaticPlatformOptimizationEditParams(TypedDict, total=False): zone_id: Required[str] """Identifier""" - value: Required[ZoneSettingAutomaticPlatformOptimizationParam] + value: Required[AutomaticPlatformOptimizationParam] diff --git a/src/cloudflare/types/zones/settings/zone_setting_automatic_platform_optimization_param.py b/src/cloudflare/types/zones/settings/automatic_platform_optimization_param.py similarity index 88% rename from src/cloudflare/types/zones/settings/zone_setting_automatic_platform_optimization_param.py rename to src/cloudflare/types/zones/settings/automatic_platform_optimization_param.py index bcc686bc18d3..b39664ca0e8d 100644 --- a/src/cloudflare/types/zones/settings/zone_setting_automatic_platform_optimization_param.py +++ b/src/cloudflare/types/zones/settings/automatic_platform_optimization_param.py @@ -5,10 +5,10 @@ from typing import List from typing_extensions import Required, TypedDict -__all__ = ["ZoneSettingAutomaticPlatformOptimizationParam"] +__all__ = ["AutomaticPlatformOptimizationParam"] -class ZoneSettingAutomaticPlatformOptimizationParam(TypedDict, total=False): +class AutomaticPlatformOptimizationParam(TypedDict, total=False): cache_by_device_type: Required[bool] """ Indicates whether or not diff --git a/src/cloudflare/types/zones/settings/zone_setting_brotli.py b/src/cloudflare/types/zones/settings/brotli.py similarity index 90% rename from src/cloudflare/types/zones/settings/zone_setting_brotli.py rename to src/cloudflare/types/zones/settings/brotli.py index 6e9515ab6ef6..b950810ee414 100644 --- a/src/cloudflare/types/zones/settings/zone_setting_brotli.py +++ b/src/cloudflare/types/zones/settings/brotli.py @@ -6,10 +6,10 @@ from ...._models import BaseModel -__all__ = ["ZoneSettingBrotli"] +__all__ = ["Brotli"] -class ZoneSettingBrotli(BaseModel): +class Brotli(BaseModel): id: Literal["brotli"] """ID of the zone setting.""" diff --git a/src/cloudflare/types/zones/settings/zone_setting_browser_cache_ttl.py b/src/cloudflare/types/zones/settings/browser_cache_ttl.py similarity index 92% rename from src/cloudflare/types/zones/settings/zone_setting_browser_cache_ttl.py rename to src/cloudflare/types/zones/settings/browser_cache_ttl.py index 6240c2511d7b..f24f141978cb 100644 --- a/src/cloudflare/types/zones/settings/zone_setting_browser_cache_ttl.py +++ b/src/cloudflare/types/zones/settings/browser_cache_ttl.py @@ -6,10 +6,10 @@ from ...._models import BaseModel -__all__ = ["ZoneSettingBrowserCacheTTL"] +__all__ = ["BrowserCacheTTL"] -class ZoneSettingBrowserCacheTTL(BaseModel): +class BrowserCacheTTL(BaseModel): id: Literal["browser_cache_ttl"] """ID of the zone setting.""" diff --git a/src/cloudflare/types/zones/settings/zone_setting_browser_check.py b/src/cloudflare/types/zones/settings/browser_check.py similarity index 88% rename from src/cloudflare/types/zones/settings/zone_setting_browser_check.py rename to src/cloudflare/types/zones/settings/browser_check.py index b02ced91ce1c..eadee65af2a2 100644 --- a/src/cloudflare/types/zones/settings/zone_setting_browser_check.py +++ b/src/cloudflare/types/zones/settings/browser_check.py @@ -6,10 +6,10 @@ from ...._models import BaseModel -__all__ = ["ZoneSettingBrowserCheck"] +__all__ = ["BrowserCheck"] -class ZoneSettingBrowserCheck(BaseModel): +class BrowserCheck(BaseModel): id: Literal["browser_check"] """ID of the zone setting.""" diff --git a/src/cloudflare/types/zones/settings/zone_setting_cache_level.py b/src/cloudflare/types/zones/settings/cache_level.py similarity index 89% rename from src/cloudflare/types/zones/settings/zone_setting_cache_level.py rename to src/cloudflare/types/zones/settings/cache_level.py index fd9f1bd0a142..d383d1f6f609 100644 --- a/src/cloudflare/types/zones/settings/zone_setting_cache_level.py +++ b/src/cloudflare/types/zones/settings/cache_level.py @@ -6,10 +6,10 @@ from ...._models import BaseModel -__all__ = ["ZoneSettingCacheLevel"] +__all__ = ["CacheLevel"] -class ZoneSettingCacheLevel(BaseModel): +class CacheLevel(BaseModel): id: Literal["cache_level"] """ID of the zone setting.""" diff --git a/src/cloudflare/types/zones/settings/zone_setting_challenge_ttl.py b/src/cloudflare/types/zones/settings/challenge_ttl.py similarity index 89% rename from src/cloudflare/types/zones/settings/zone_setting_challenge_ttl.py rename to src/cloudflare/types/zones/settings/challenge_ttl.py index b803bef9eb8f..3006c3220d05 100644 --- a/src/cloudflare/types/zones/settings/zone_setting_challenge_ttl.py +++ b/src/cloudflare/types/zones/settings/challenge_ttl.py @@ -6,10 +6,10 @@ from ...._models import BaseModel -__all__ = ["ZoneSettingChallengeTTL"] +__all__ = ["ChallengeTTL"] -class ZoneSettingChallengeTTL(BaseModel): +class ChallengeTTL(BaseModel): id: Literal["challenge_ttl"] """ID of the zone setting.""" diff --git a/src/cloudflare/types/zones/settings/zone_setting_ciphers.py b/src/cloudflare/types/zones/settings/ciphers.py similarity index 89% rename from src/cloudflare/types/zones/settings/zone_setting_ciphers.py rename to src/cloudflare/types/zones/settings/ciphers.py index 7c3d9c9f8472..a27c8eed6208 100644 --- a/src/cloudflare/types/zones/settings/zone_setting_ciphers.py +++ b/src/cloudflare/types/zones/settings/ciphers.py @@ -6,10 +6,10 @@ from ...._models import BaseModel -__all__ = ["ZoneSettingCiphers"] +__all__ = ["Ciphers"] -class ZoneSettingCiphers(BaseModel): +class Ciphers(BaseModel): id: Literal["ciphers"] """ID of the zone setting.""" diff --git a/src/cloudflare/types/zones/settings/zone_setting_development_mode.py b/src/cloudflare/types/zones/settings/development_mode.py similarity index 91% rename from src/cloudflare/types/zones/settings/zone_setting_development_mode.py rename to src/cloudflare/types/zones/settings/development_mode.py index 74e2376535d7..d5f856dd2843 100644 --- a/src/cloudflare/types/zones/settings/zone_setting_development_mode.py +++ b/src/cloudflare/types/zones/settings/development_mode.py @@ -6,10 +6,10 @@ from ...._models import BaseModel -__all__ = ["ZoneSettingDevelopmentMode"] +__all__ = ["DevelopmentMode"] -class ZoneSettingDevelopmentMode(BaseModel): +class DevelopmentMode(BaseModel): id: Literal["development_mode"] """ID of the zone setting.""" diff --git a/src/cloudflare/types/zones/settings/zone_setting_early_hints.py b/src/cloudflare/types/zones/settings/early_hints.py similarity index 89% rename from src/cloudflare/types/zones/settings/zone_setting_early_hints.py rename to src/cloudflare/types/zones/settings/early_hints.py index 81ec9c315696..db3e20a7e80e 100644 --- a/src/cloudflare/types/zones/settings/zone_setting_early_hints.py +++ b/src/cloudflare/types/zones/settings/early_hints.py @@ -6,10 +6,10 @@ from ...._models import BaseModel -__all__ = ["ZoneSettingEarlyHints"] +__all__ = ["EarlyHints"] -class ZoneSettingEarlyHints(BaseModel): +class EarlyHints(BaseModel): id: Literal["early_hints"] """ID of the zone setting.""" diff --git a/src/cloudflare/types/zones/settings/zone_setting_email_obfuscation.py b/src/cloudflare/types/zones/settings/email_obfuscation.py similarity index 87% rename from src/cloudflare/types/zones/settings/zone_setting_email_obfuscation.py rename to src/cloudflare/types/zones/settings/email_obfuscation.py index a30cea80c8fb..278226136b5b 100644 --- a/src/cloudflare/types/zones/settings/zone_setting_email_obfuscation.py +++ b/src/cloudflare/types/zones/settings/email_obfuscation.py @@ -6,10 +6,10 @@ from ...._models import BaseModel -__all__ = ["ZoneSettingEmailObfuscation"] +__all__ = ["EmailObfuscation"] -class ZoneSettingEmailObfuscation(BaseModel): +class EmailObfuscation(BaseModel): id: Literal["email_obfuscation"] """ID of the zone setting.""" diff --git a/src/cloudflare/types/zones/settings/zone_setting_fonts.py b/src/cloudflare/types/zones/settings/font_settings.py similarity index 90% rename from src/cloudflare/types/zones/settings/zone_setting_fonts.py rename to src/cloudflare/types/zones/settings/font_settings.py index 4463cc08a781..c0fc9cdfac32 100644 --- a/src/cloudflare/types/zones/settings/zone_setting_fonts.py +++ b/src/cloudflare/types/zones/settings/font_settings.py @@ -6,10 +6,10 @@ from ...._models import BaseModel -__all__ = ["ZoneSettingFonts"] +__all__ = ["FontSettings"] -class ZoneSettingFonts(BaseModel): +class FontSettings(BaseModel): id: Literal["fonts"] """ID of the zone setting.""" diff --git a/src/cloudflare/types/zones/settings/zone_setting_h2_prioritization.py b/src/cloudflare/types/zones/settings/h2_prioritization.py similarity index 87% rename from src/cloudflare/types/zones/settings/zone_setting_h2_prioritization.py rename to src/cloudflare/types/zones/settings/h2_prioritization.py index 4c457096b37b..7a9144ae8b17 100644 --- a/src/cloudflare/types/zones/settings/zone_setting_h2_prioritization.py +++ b/src/cloudflare/types/zones/settings/h2_prioritization.py @@ -6,10 +6,10 @@ from ...._models import BaseModel -__all__ = ["ZoneSettingH2Prioritization"] +__all__ = ["H2Prioritization"] -class ZoneSettingH2Prioritization(BaseModel): +class H2Prioritization(BaseModel): id: Literal["h2_prioritization"] """ID of the zone setting.""" diff --git a/src/cloudflare/types/zones/settings/h2_prioritization_edit_params.py b/src/cloudflare/types/zones/settings/h2_prioritization_edit_params.py index ac5feb845118..1b51b6116d18 100644 --- a/src/cloudflare/types/zones/settings/h2_prioritization_edit_params.py +++ b/src/cloudflare/types/zones/settings/h2_prioritization_edit_params.py @@ -4,7 +4,7 @@ from typing_extensions import Required, TypedDict -from .zone_setting_h2_prioritization_param import ZoneSettingH2PrioritizationParam +from .h2_prioritization_param import H2PrioritizationParam __all__ = ["H2PrioritizationEditParams"] @@ -13,7 +13,7 @@ class H2PrioritizationEditParams(TypedDict, total=False): zone_id: Required[str] """Identifier""" - value: Required[ZoneSettingH2PrioritizationParam] + value: Required[H2PrioritizationParam] """ HTTP/2 Edge Prioritization optimises the delivery of resources served through HTTP/2 to improve page load performance. It also supports fine control of diff --git a/src/cloudflare/types/zones/settings/zone_setting_h2_prioritization_param.py b/src/cloudflare/types/zones/settings/h2_prioritization_param.py similarity index 76% rename from src/cloudflare/types/zones/settings/zone_setting_h2_prioritization_param.py rename to src/cloudflare/types/zones/settings/h2_prioritization_param.py index 5d20c404271d..0d3cc769689a 100644 --- a/src/cloudflare/types/zones/settings/zone_setting_h2_prioritization_param.py +++ b/src/cloudflare/types/zones/settings/h2_prioritization_param.py @@ -4,10 +4,10 @@ from typing_extensions import Literal, Required, TypedDict -__all__ = ["ZoneSettingH2PrioritizationParam"] +__all__ = ["H2PrioritizationParam"] -class ZoneSettingH2PrioritizationParam(TypedDict, total=False): +class H2PrioritizationParam(TypedDict, total=False): id: Required[Literal["h2_prioritization"]] """ID of the zone setting.""" diff --git a/src/cloudflare/types/zones/settings/zone_setting_hotlink_protection.py b/src/cloudflare/types/zones/settings/hotlink_protection.py similarity index 87% rename from src/cloudflare/types/zones/settings/zone_setting_hotlink_protection.py rename to src/cloudflare/types/zones/settings/hotlink_protection.py index 1046ff6e7939..52fa412f29b0 100644 --- a/src/cloudflare/types/zones/settings/zone_setting_hotlink_protection.py +++ b/src/cloudflare/types/zones/settings/hotlink_protection.py @@ -6,10 +6,10 @@ from ...._models import BaseModel -__all__ = ["ZoneSettingHotlinkProtection"] +__all__ = ["HotlinkProtection"] -class ZoneSettingHotlinkProtection(BaseModel): +class HotlinkProtection(BaseModel): id: Literal["hotlink_protection"] """ID of the zone setting.""" diff --git a/src/cloudflare/types/zones/settings/zone_setting_http2.py b/src/cloudflare/types/zones/settings/http2.py similarity index 90% rename from src/cloudflare/types/zones/settings/zone_setting_http2.py rename to src/cloudflare/types/zones/settings/http2.py index 5a5de9d13e8a..8d5399402480 100644 --- a/src/cloudflare/types/zones/settings/zone_setting_http2.py +++ b/src/cloudflare/types/zones/settings/http2.py @@ -6,10 +6,10 @@ from ...._models import BaseModel -__all__ = ["ZoneSettingHTTP2"] +__all__ = ["HTTP2"] -class ZoneSettingHTTP2(BaseModel): +class HTTP2(BaseModel): id: Literal["http2"] """ID of the zone setting.""" diff --git a/src/cloudflare/types/zones/settings/zone_setting_http3.py b/src/cloudflare/types/zones/settings/http3.py similarity index 90% rename from src/cloudflare/types/zones/settings/zone_setting_http3.py rename to src/cloudflare/types/zones/settings/http3.py index 2de87134547b..2b65951e377d 100644 --- a/src/cloudflare/types/zones/settings/zone_setting_http3.py +++ b/src/cloudflare/types/zones/settings/http3.py @@ -6,10 +6,10 @@ from ...._models import BaseModel -__all__ = ["ZoneSettingHTTP3"] +__all__ = ["HTTP3"] -class ZoneSettingHTTP3(BaseModel): +class HTTP3(BaseModel): id: Literal["http3"] """ID of the zone setting.""" diff --git a/src/cloudflare/types/zones/settings/zone_setting_image_resizing.py b/src/cloudflare/types/zones/settings/image_resizing.py similarity index 88% rename from src/cloudflare/types/zones/settings/zone_setting_image_resizing.py rename to src/cloudflare/types/zones/settings/image_resizing.py index 1454491319c9..8fa332009e7c 100644 --- a/src/cloudflare/types/zones/settings/zone_setting_image_resizing.py +++ b/src/cloudflare/types/zones/settings/image_resizing.py @@ -6,10 +6,10 @@ from ...._models import BaseModel -__all__ = ["ZoneSettingImageResizing"] +__all__ = ["ImageResizing"] -class ZoneSettingImageResizing(BaseModel): +class ImageResizing(BaseModel): id: Literal["image_resizing"] """ID of the zone setting.""" diff --git a/src/cloudflare/types/zones/settings/image_resizing_edit_params.py b/src/cloudflare/types/zones/settings/image_resizing_edit_params.py index f36d9285cd34..4425d3e42c6d 100644 --- a/src/cloudflare/types/zones/settings/image_resizing_edit_params.py +++ b/src/cloudflare/types/zones/settings/image_resizing_edit_params.py @@ -4,7 +4,7 @@ from typing_extensions import Required, TypedDict -from .zone_setting_image_resizing_param import ZoneSettingImageResizingParam +from .image_resizing_param import ImageResizingParam __all__ = ["ImageResizingEditParams"] @@ -13,7 +13,7 @@ class ImageResizingEditParams(TypedDict, total=False): zone_id: Required[str] """Identifier""" - value: Required[ZoneSettingImageResizingParam] + value: Required[ImageResizingParam] """ Image Resizing provides on-demand resizing, conversion and optimisation for images served through Cloudflare's network. Refer to the diff --git a/src/cloudflare/types/zones/settings/zone_setting_image_resizing_param.py b/src/cloudflare/types/zones/settings/image_resizing_param.py similarity index 77% rename from src/cloudflare/types/zones/settings/zone_setting_image_resizing_param.py rename to src/cloudflare/types/zones/settings/image_resizing_param.py index 6de5628ebdaf..0b6d7c669793 100644 --- a/src/cloudflare/types/zones/settings/zone_setting_image_resizing_param.py +++ b/src/cloudflare/types/zones/settings/image_resizing_param.py @@ -4,10 +4,10 @@ from typing_extensions import Literal, Required, TypedDict -__all__ = ["ZoneSettingImageResizingParam"] +__all__ = ["ImageResizingParam"] -class ZoneSettingImageResizingParam(TypedDict, total=False): +class ImageResizingParam(TypedDict, total=False): id: Required[Literal["image_resizing"]] """ID of the zone setting.""" diff --git a/src/cloudflare/types/zones/settings/zone_setting_ip_geolocation.py b/src/cloudflare/types/zones/settings/ip_geolocation.py similarity index 88% rename from src/cloudflare/types/zones/settings/zone_setting_ip_geolocation.py rename to src/cloudflare/types/zones/settings/ip_geolocation.py index f0d8e581b00c..faa0d44caec6 100644 --- a/src/cloudflare/types/zones/settings/zone_setting_ip_geolocation.py +++ b/src/cloudflare/types/zones/settings/ip_geolocation.py @@ -6,10 +6,10 @@ from ...._models import BaseModel -__all__ = ["ZoneSettingIPGeolocation"] +__all__ = ["IPGeolocation"] -class ZoneSettingIPGeolocation(BaseModel): +class IPGeolocation(BaseModel): id: Literal["ip_geolocation"] """ID of the zone setting.""" diff --git a/src/cloudflare/types/zones/settings/zone_setting_ipv6.py b/src/cloudflare/types/zones/settings/ipv6.py similarity index 90% rename from src/cloudflare/types/zones/settings/zone_setting_ipv6.py rename to src/cloudflare/types/zones/settings/ipv6.py index a2cf8a358b44..d99f87c4568e 100644 --- a/src/cloudflare/types/zones/settings/zone_setting_ipv6.py +++ b/src/cloudflare/types/zones/settings/ipv6.py @@ -6,10 +6,10 @@ from ...._models import BaseModel -__all__ = ["ZoneSettingIPV6"] +__all__ = ["IPV6"] -class ZoneSettingIPV6(BaseModel): +class IPV6(BaseModel): id: Literal["ipv6"] """ID of the zone setting.""" diff --git a/src/cloudflare/types/zones/settings/zone_setting_min_tls_version.py b/src/cloudflare/types/zones/settings/min_tls_version.py similarity index 88% rename from src/cloudflare/types/zones/settings/zone_setting_min_tls_version.py rename to src/cloudflare/types/zones/settings/min_tls_version.py index 67facc86e083..20908024cdac 100644 --- a/src/cloudflare/types/zones/settings/zone_setting_min_tls_version.py +++ b/src/cloudflare/types/zones/settings/min_tls_version.py @@ -6,10 +6,10 @@ from ...._models import BaseModel -__all__ = ["ZoneSettingMinTLSVersion"] +__all__ = ["MinTLSVersion"] -class ZoneSettingMinTLSVersion(BaseModel): +class MinTLSVersion(BaseModel): id: Literal["min_tls_version"] """ID of the zone setting.""" diff --git a/src/cloudflare/types/zones/settings/zone_setting_minify.py b/src/cloudflare/types/zones/settings/minify.py similarity index 92% rename from src/cloudflare/types/zones/settings/zone_setting_minify.py rename to src/cloudflare/types/zones/settings/minify.py index efb415b77120..eae119b27412 100644 --- a/src/cloudflare/types/zones/settings/zone_setting_minify.py +++ b/src/cloudflare/types/zones/settings/minify.py @@ -6,7 +6,7 @@ from ...._models import BaseModel -__all__ = ["ZoneSettingMinify", "Value"] +__all__ = ["Minify", "Value"] class Value(BaseModel): @@ -20,7 +20,7 @@ class Value(BaseModel): """Automatically minify all JavaScript files for your website.""" -class ZoneSettingMinify(BaseModel): +class Minify(BaseModel): id: Literal["minify"] """Zone setting identifier.""" diff --git a/src/cloudflare/types/zones/settings/zone_setting_mirage.py b/src/cloudflare/types/zones/settings/mirage.py similarity index 90% rename from src/cloudflare/types/zones/settings/zone_setting_mirage.py rename to src/cloudflare/types/zones/settings/mirage.py index f6d62586f93c..bbd2722212ea 100644 --- a/src/cloudflare/types/zones/settings/zone_setting_mirage.py +++ b/src/cloudflare/types/zones/settings/mirage.py @@ -6,10 +6,10 @@ from ...._models import BaseModel -__all__ = ["ZoneSettingMirage"] +__all__ = ["Mirage"] -class ZoneSettingMirage(BaseModel): +class Mirage(BaseModel): id: Literal["mirage"] """ID of the zone setting.""" diff --git a/src/cloudflare/types/zones/settings/zone_setting_mobile_redirect.py b/src/cloudflare/types/zones/settings/mobile_redirect.py similarity index 92% rename from src/cloudflare/types/zones/settings/zone_setting_mobile_redirect.py rename to src/cloudflare/types/zones/settings/mobile_redirect.py index 0e2823aa8069..66bab1b5ff94 100644 --- a/src/cloudflare/types/zones/settings/zone_setting_mobile_redirect.py +++ b/src/cloudflare/types/zones/settings/mobile_redirect.py @@ -6,7 +6,7 @@ from ...._models import BaseModel -__all__ = ["ZoneSettingMobileRedirect", "Value"] +__all__ = ["MobileRedirect", "Value"] class Value(BaseModel): @@ -26,7 +26,7 @@ class Value(BaseModel): """ -class ZoneSettingMobileRedirect(BaseModel): +class MobileRedirect(BaseModel): id: Literal["mobile_redirect"] """Identifier of the zone setting.""" diff --git a/src/cloudflare/types/zones/settings/zone_setting_nel.py b/src/cloudflare/types/zones/settings/nel.py similarity index 90% rename from src/cloudflare/types/zones/settings/zone_setting_nel.py rename to src/cloudflare/types/zones/settings/nel.py index 949c3684977d..f8b8d437e7e5 100644 --- a/src/cloudflare/types/zones/settings/zone_setting_nel.py +++ b/src/cloudflare/types/zones/settings/nel.py @@ -6,14 +6,14 @@ from ...._models import BaseModel -__all__ = ["ZoneSettingNEL", "Value"] +__all__ = ["NEL", "Value"] class Value(BaseModel): enabled: Optional[bool] = None -class ZoneSettingNEL(BaseModel): +class NEL(BaseModel): id: Literal["nel"] """Zone setting identifier.""" diff --git a/src/cloudflare/types/zones/settings/nel_edit_params.py b/src/cloudflare/types/zones/settings/nel_edit_params.py index 1043d489c229..114d1000df4e 100644 --- a/src/cloudflare/types/zones/settings/nel_edit_params.py +++ b/src/cloudflare/types/zones/settings/nel_edit_params.py @@ -4,7 +4,7 @@ from typing_extensions import Required, TypedDict -from .zone_setting_nel_param import ZoneSettingNELParam +from .nel_param import NELParam __all__ = ["NELEditParams"] @@ -13,5 +13,5 @@ class NELEditParams(TypedDict, total=False): zone_id: Required[str] """Identifier""" - value: Required[ZoneSettingNELParam] + value: Required[NELParam] """Enable Network Error Logging reporting on your zone. (Beta)""" diff --git a/src/cloudflare/types/zones/settings/zone_setting_nel_param.py b/src/cloudflare/types/zones/settings/nel_param.py similarity index 80% rename from src/cloudflare/types/zones/settings/zone_setting_nel_param.py rename to src/cloudflare/types/zones/settings/nel_param.py index 863351497d8a..c692f294f679 100644 --- a/src/cloudflare/types/zones/settings/zone_setting_nel_param.py +++ b/src/cloudflare/types/zones/settings/nel_param.py @@ -4,14 +4,14 @@ from typing_extensions import Literal, Required, TypedDict -__all__ = ["ZoneSettingNELParam", "Value"] +__all__ = ["NELParam", "Value"] class Value(TypedDict, total=False): enabled: bool -class ZoneSettingNELParam(TypedDict, total=False): +class NELParam(TypedDict, total=False): id: Required[Literal["nel"]] """Zone setting identifier.""" diff --git a/src/cloudflare/types/zones/settings/zone_setting_opportunistic_encryption.py b/src/cloudflare/types/zones/settings/opportunistic_encryption.py similarity index 86% rename from src/cloudflare/types/zones/settings/zone_setting_opportunistic_encryption.py rename to src/cloudflare/types/zones/settings/opportunistic_encryption.py index 2f3f067df9cc..30ecc81168bd 100644 --- a/src/cloudflare/types/zones/settings/zone_setting_opportunistic_encryption.py +++ b/src/cloudflare/types/zones/settings/opportunistic_encryption.py @@ -6,10 +6,10 @@ from ...._models import BaseModel -__all__ = ["ZoneSettingOpportunisticEncryption"] +__all__ = ["OpportunisticEncryption"] -class ZoneSettingOpportunisticEncryption(BaseModel): +class OpportunisticEncryption(BaseModel): id: Literal["opportunistic_encryption"] """ID of the zone setting.""" diff --git a/src/cloudflare/types/zones/settings/zone_setting_opportunistic_onion.py b/src/cloudflare/types/zones/settings/opportunistic_onion.py similarity index 87% rename from src/cloudflare/types/zones/settings/zone_setting_opportunistic_onion.py rename to src/cloudflare/types/zones/settings/opportunistic_onion.py index 224a12945cbb..d0beb3617686 100644 --- a/src/cloudflare/types/zones/settings/zone_setting_opportunistic_onion.py +++ b/src/cloudflare/types/zones/settings/opportunistic_onion.py @@ -6,10 +6,10 @@ from ...._models import BaseModel -__all__ = ["ZoneSettingOpportunisticOnion"] +__all__ = ["OpportunisticOnion"] -class ZoneSettingOpportunisticOnion(BaseModel): +class OpportunisticOnion(BaseModel): id: Literal["opportunistic_onion"] """ID of the zone setting.""" diff --git a/src/cloudflare/types/zones/settings/zone_setting_orange_to_orange.py b/src/cloudflare/types/zones/settings/orange_to_orange.py similarity index 88% rename from src/cloudflare/types/zones/settings/zone_setting_orange_to_orange.py rename to src/cloudflare/types/zones/settings/orange_to_orange.py index 1f0912d04bd0..ae7a5cd519e7 100644 --- a/src/cloudflare/types/zones/settings/zone_setting_orange_to_orange.py +++ b/src/cloudflare/types/zones/settings/orange_to_orange.py @@ -6,10 +6,10 @@ from ...._models import BaseModel -__all__ = ["ZoneSettingOrangeToOrange"] +__all__ = ["OrangeToOrange"] -class ZoneSettingOrangeToOrange(BaseModel): +class OrangeToOrange(BaseModel): id: Literal["orange_to_orange"] """ID of the zone setting.""" diff --git a/src/cloudflare/types/zones/settings/orange_to_orange_edit_params.py b/src/cloudflare/types/zones/settings/orange_to_orange_edit_params.py index 5758995a76ed..d2b659926cf9 100644 --- a/src/cloudflare/types/zones/settings/orange_to_orange_edit_params.py +++ b/src/cloudflare/types/zones/settings/orange_to_orange_edit_params.py @@ -4,7 +4,7 @@ from typing_extensions import Required, TypedDict -from .zone_setting_orange_to_orange_param import ZoneSettingOrangeToOrangeParam +from .orange_to_orange_param import OrangeToOrangeParam __all__ = ["OrangeToOrangeEditParams"] @@ -13,7 +13,7 @@ class OrangeToOrangeEditParams(TypedDict, total=False): zone_id: Required[str] """Identifier""" - value: Required[ZoneSettingOrangeToOrangeParam] + value: Required[OrangeToOrangeParam] """ Orange to Orange (O2O) allows zones on Cloudflare to CNAME to other zones also on Cloudflare. diff --git a/src/cloudflare/types/zones/settings/zone_setting_orange_to_orange_param.py b/src/cloudflare/types/zones/settings/orange_to_orange_param.py similarity index 76% rename from src/cloudflare/types/zones/settings/zone_setting_orange_to_orange_param.py rename to src/cloudflare/types/zones/settings/orange_to_orange_param.py index 4628db5b90dd..9a28f503c638 100644 --- a/src/cloudflare/types/zones/settings/zone_setting_orange_to_orange_param.py +++ b/src/cloudflare/types/zones/settings/orange_to_orange_param.py @@ -4,10 +4,10 @@ from typing_extensions import Literal, Required, TypedDict -__all__ = ["ZoneSettingOrangeToOrangeParam"] +__all__ = ["OrangeToOrangeParam"] -class ZoneSettingOrangeToOrangeParam(TypedDict, total=False): +class OrangeToOrangeParam(TypedDict, total=False): id: Required[Literal["orange_to_orange"]] """ID of the zone setting.""" diff --git a/src/cloudflare/types/zones/settings/zone_setting_origin_error_page_pass_thru.py b/src/cloudflare/types/zones/settings/origin_error_page_pass_thru.py similarity index 86% rename from src/cloudflare/types/zones/settings/zone_setting_origin_error_page_pass_thru.py rename to src/cloudflare/types/zones/settings/origin_error_page_pass_thru.py index 47751d84e3a9..000e5e4940e6 100644 --- a/src/cloudflare/types/zones/settings/zone_setting_origin_error_page_pass_thru.py +++ b/src/cloudflare/types/zones/settings/origin_error_page_pass_thru.py @@ -6,10 +6,10 @@ from ...._models import BaseModel -__all__ = ["ZoneSettingOriginErrorPagePassThru"] +__all__ = ["OriginErrorPagePassThru"] -class ZoneSettingOriginErrorPagePassThru(BaseModel): +class OriginErrorPagePassThru(BaseModel): id: Literal["origin_error_page_pass_thru"] """ID of the zone setting.""" diff --git a/src/cloudflare/types/zones/settings/zone_setting_polish.py b/src/cloudflare/types/zones/settings/polish.py similarity index 90% rename from src/cloudflare/types/zones/settings/zone_setting_polish.py rename to src/cloudflare/types/zones/settings/polish.py index f3209e0bd7d3..0caf6611eb33 100644 --- a/src/cloudflare/types/zones/settings/zone_setting_polish.py +++ b/src/cloudflare/types/zones/settings/polish.py @@ -6,10 +6,10 @@ from ...._models import BaseModel -__all__ = ["ZoneSettingPolish"] +__all__ = ["Polish"] -class ZoneSettingPolish(BaseModel): +class Polish(BaseModel): id: Literal["polish"] """ID of the zone setting.""" diff --git a/src/cloudflare/types/zones/settings/polish_edit_params.py b/src/cloudflare/types/zones/settings/polish_edit_params.py index 4612df87efaf..044f3b989891 100644 --- a/src/cloudflare/types/zones/settings/polish_edit_params.py +++ b/src/cloudflare/types/zones/settings/polish_edit_params.py @@ -4,7 +4,7 @@ from typing_extensions import Required, TypedDict -from .zone_setting_polish_param import ZoneSettingPolishParam +from .polish_param import PolishParam __all__ = ["PolishEditParams"] @@ -13,7 +13,7 @@ class PolishEditParams(TypedDict, total=False): zone_id: Required[str] """Identifier""" - value: Required[ZoneSettingPolishParam] + value: Required[PolishParam] """Removes metadata and compresses your images for faster page load times. Basic (Lossless): Reduce the size of PNG, JPEG, and GIF files - no impact on diff --git a/src/cloudflare/types/zones/settings/zone_setting_polish_param.py b/src/cloudflare/types/zones/settings/polish_param.py similarity index 79% rename from src/cloudflare/types/zones/settings/zone_setting_polish_param.py rename to src/cloudflare/types/zones/settings/polish_param.py index 5b66bb60ac3c..84f4c0b65c9e 100644 --- a/src/cloudflare/types/zones/settings/zone_setting_polish_param.py +++ b/src/cloudflare/types/zones/settings/polish_param.py @@ -4,10 +4,10 @@ from typing_extensions import Literal, Required, TypedDict -__all__ = ["ZoneSettingPolishParam"] +__all__ = ["PolishParam"] -class ZoneSettingPolishParam(TypedDict, total=False): +class PolishParam(TypedDict, total=False): id: Required[Literal["polish"]] """ID of the zone setting.""" diff --git a/src/cloudflare/types/zones/settings/zone_setting_prefetch_preload.py b/src/cloudflare/types/zones/settings/prefetch_preload.py similarity index 88% rename from src/cloudflare/types/zones/settings/zone_setting_prefetch_preload.py rename to src/cloudflare/types/zones/settings/prefetch_preload.py index a92fe806ecd2..4482bee389c5 100644 --- a/src/cloudflare/types/zones/settings/zone_setting_prefetch_preload.py +++ b/src/cloudflare/types/zones/settings/prefetch_preload.py @@ -6,10 +6,10 @@ from ...._models import BaseModel -__all__ = ["ZoneSettingPrefetchPreload"] +__all__ = ["PrefetchPreload"] -class ZoneSettingPrefetchPreload(BaseModel): +class PrefetchPreload(BaseModel): id: Literal["prefetch_preload"] """ID of the zone setting.""" diff --git a/src/cloudflare/types/zones/settings/zone_setting_proxy_read_timeout.py b/src/cloudflare/types/zones/settings/proxy_read_timeout.py similarity index 87% rename from src/cloudflare/types/zones/settings/zone_setting_proxy_read_timeout.py rename to src/cloudflare/types/zones/settings/proxy_read_timeout.py index ab9f562a1682..1533eb571fe2 100644 --- a/src/cloudflare/types/zones/settings/zone_setting_proxy_read_timeout.py +++ b/src/cloudflare/types/zones/settings/proxy_read_timeout.py @@ -6,10 +6,10 @@ from ...._models import BaseModel -__all__ = ["ZoneSettingProxyReadTimeout"] +__all__ = ["ProxyReadTimeout"] -class ZoneSettingProxyReadTimeout(BaseModel): +class ProxyReadTimeout(BaseModel): id: Literal["proxy_read_timeout"] """ID of the zone setting.""" diff --git a/src/cloudflare/types/zones/settings/proxy_read_timeout_edit_params.py b/src/cloudflare/types/zones/settings/proxy_read_timeout_edit_params.py index a01e1c1c05fb..7813472d0e35 100644 --- a/src/cloudflare/types/zones/settings/proxy_read_timeout_edit_params.py +++ b/src/cloudflare/types/zones/settings/proxy_read_timeout_edit_params.py @@ -4,7 +4,7 @@ from typing_extensions import Required, TypedDict -from .zone_setting_proxy_read_timeout_param import ZoneSettingProxyReadTimeoutParam +from .proxy_read_timeout_param import ProxyReadTimeoutParam __all__ = ["ProxyReadTimeoutEditParams"] @@ -13,5 +13,5 @@ class ProxyReadTimeoutEditParams(TypedDict, total=False): zone_id: Required[str] """Identifier""" - value: Required[ZoneSettingProxyReadTimeoutParam] + value: Required[ProxyReadTimeoutParam] """Maximum time between two read operations from origin.""" diff --git a/src/cloudflare/types/zones/settings/zone_setting_proxy_read_timeout_param.py b/src/cloudflare/types/zones/settings/proxy_read_timeout_param.py similarity index 75% rename from src/cloudflare/types/zones/settings/zone_setting_proxy_read_timeout_param.py rename to src/cloudflare/types/zones/settings/proxy_read_timeout_param.py index a555a87da22b..5db204030586 100644 --- a/src/cloudflare/types/zones/settings/zone_setting_proxy_read_timeout_param.py +++ b/src/cloudflare/types/zones/settings/proxy_read_timeout_param.py @@ -4,10 +4,10 @@ from typing_extensions import Literal, Required, TypedDict -__all__ = ["ZoneSettingProxyReadTimeoutParam"] +__all__ = ["ProxyReadTimeoutParam"] -class ZoneSettingProxyReadTimeoutParam(TypedDict, total=False): +class ProxyReadTimeoutParam(TypedDict, total=False): id: Required[Literal["proxy_read_timeout"]] """ID of the zone setting.""" diff --git a/src/cloudflare/types/zones/settings/zone_setting_pseudo_ipv4.py b/src/cloudflare/types/zones/settings/pseudo_ipv4.py similarity index 89% rename from src/cloudflare/types/zones/settings/zone_setting_pseudo_ipv4.py rename to src/cloudflare/types/zones/settings/pseudo_ipv4.py index 81e5172f55a6..d0e154d9ed65 100644 --- a/src/cloudflare/types/zones/settings/zone_setting_pseudo_ipv4.py +++ b/src/cloudflare/types/zones/settings/pseudo_ipv4.py @@ -6,10 +6,10 @@ from ...._models import BaseModel -__all__ = ["ZoneSettingPseudoIPV4"] +__all__ = ["PseudoIPV4"] -class ZoneSettingPseudoIPV4(BaseModel): +class PseudoIPV4(BaseModel): id: Literal["pseudo_ipv4"] """Value of the Pseudo IPv4 setting.""" diff --git a/src/cloudflare/types/zones/settings/zone_setting_buffering.py b/src/cloudflare/types/zones/settings/response_buffering.py similarity index 89% rename from src/cloudflare/types/zones/settings/zone_setting_buffering.py rename to src/cloudflare/types/zones/settings/response_buffering.py index 6f7ba2ca4ab2..567acd1b665a 100644 --- a/src/cloudflare/types/zones/settings/zone_setting_buffering.py +++ b/src/cloudflare/types/zones/settings/response_buffering.py @@ -6,10 +6,10 @@ from ...._models import BaseModel -__all__ = ["ZoneSettingBuffering"] +__all__ = ["ResponseBuffering"] -class ZoneSettingBuffering(BaseModel): +class ResponseBuffering(BaseModel): id: Literal["response_buffering"] """ID of the zone setting.""" diff --git a/src/cloudflare/types/zones/settings/zone_setting_rocket_loader.py b/src/cloudflare/types/zones/settings/rocket_loader.py similarity index 88% rename from src/cloudflare/types/zones/settings/zone_setting_rocket_loader.py rename to src/cloudflare/types/zones/settings/rocket_loader.py index 4d0d5404a771..92374df7dd11 100644 --- a/src/cloudflare/types/zones/settings/zone_setting_rocket_loader.py +++ b/src/cloudflare/types/zones/settings/rocket_loader.py @@ -6,10 +6,10 @@ from ...._models import BaseModel -__all__ = ["ZoneSettingRocketLoader"] +__all__ = ["RocketLoader"] -class ZoneSettingRocketLoader(BaseModel): +class RocketLoader(BaseModel): id: Literal["rocket_loader"] """ID of the zone setting.""" diff --git a/src/cloudflare/types/zones/settings/rocket_loader_edit_params.py b/src/cloudflare/types/zones/settings/rocket_loader_edit_params.py index a1ac846330ce..e66a7c774cbc 100644 --- a/src/cloudflare/types/zones/settings/rocket_loader_edit_params.py +++ b/src/cloudflare/types/zones/settings/rocket_loader_edit_params.py @@ -4,7 +4,7 @@ from typing_extensions import Required, TypedDict -from .zone_setting_rocket_loader_param import ZoneSettingRocketLoaderParam +from .rocket_loader_param import RocketLoaderParam __all__ = ["RocketLoaderEditParams"] @@ -13,7 +13,7 @@ class RocketLoaderEditParams(TypedDict, total=False): zone_id: Required[str] """Identifier""" - value: Required[ZoneSettingRocketLoaderParam] + value: Required[RocketLoaderParam] """ Rocket Loader is a general-purpose asynchronous JavaScript optimisation that prioritises rendering your content while loading your site's Javascript diff --git a/src/cloudflare/types/zones/settings/zone_setting_rocket_loader_param.py b/src/cloudflare/types/zones/settings/rocket_loader_param.py similarity index 77% rename from src/cloudflare/types/zones/settings/zone_setting_rocket_loader_param.py rename to src/cloudflare/types/zones/settings/rocket_loader_param.py index deed2713e415..d72dfe24e23f 100644 --- a/src/cloudflare/types/zones/settings/zone_setting_rocket_loader_param.py +++ b/src/cloudflare/types/zones/settings/rocket_loader_param.py @@ -4,10 +4,10 @@ from typing_extensions import Literal, Required, TypedDict -__all__ = ["ZoneSettingRocketLoaderParam"] +__all__ = ["RocketLoaderParam"] -class ZoneSettingRocketLoaderParam(TypedDict, total=False): +class RocketLoaderParam(TypedDict, total=False): id: Required[Literal["rocket_loader"]] """ID of the zone setting.""" diff --git a/src/cloudflare/types/zones/settings/zone_setting_security_header.py b/src/cloudflare/types/zones/settings/security_headers.py similarity index 90% rename from src/cloudflare/types/zones/settings/zone_setting_security_header.py rename to src/cloudflare/types/zones/settings/security_headers.py index 5da19ea926ad..2399ebe976c3 100644 --- a/src/cloudflare/types/zones/settings/zone_setting_security_header.py +++ b/src/cloudflare/types/zones/settings/security_headers.py @@ -6,7 +6,7 @@ from ...._models import BaseModel -__all__ = ["ZoneSettingSecurityHeader", "Value", "ValueStrictTransportSecurity"] +__all__ = ["SecurityHeaders", "Value", "ValueStrictTransportSecurity"] class ValueStrictTransportSecurity(BaseModel): @@ -28,7 +28,7 @@ class Value(BaseModel): """Strict Transport Security.""" -class ZoneSettingSecurityHeader(BaseModel): +class SecurityHeaders(BaseModel): id: Literal["security_header"] """ID of the zone's security header.""" diff --git a/src/cloudflare/types/zones/settings/zone_setting_security_level.py b/src/cloudflare/types/zones/settings/security_level.py similarity index 89% rename from src/cloudflare/types/zones/settings/zone_setting_security_level.py rename to src/cloudflare/types/zones/settings/security_level.py index 23079ae5b14c..36676d1e6440 100644 --- a/src/cloudflare/types/zones/settings/zone_setting_security_level.py +++ b/src/cloudflare/types/zones/settings/security_level.py @@ -6,10 +6,10 @@ from ...._models import BaseModel -__all__ = ["ZoneSettingSecurityLevel"] +__all__ = ["SecurityLevel"] -class ZoneSettingSecurityLevel(BaseModel): +class SecurityLevel(BaseModel): id: Literal["security_level"] """ID of the zone setting.""" diff --git a/src/cloudflare/types/zones/settings/zone_setting_server_side_exclude.py b/src/cloudflare/types/zones/settings/server_side_excludes.py similarity index 87% rename from src/cloudflare/types/zones/settings/zone_setting_server_side_exclude.py rename to src/cloudflare/types/zones/settings/server_side_excludes.py index afcb204ae3d9..96f3581d6094 100644 --- a/src/cloudflare/types/zones/settings/zone_setting_server_side_exclude.py +++ b/src/cloudflare/types/zones/settings/server_side_excludes.py @@ -6,10 +6,10 @@ from ...._models import BaseModel -__all__ = ["ZoneSettingServerSideExclude"] +__all__ = ["ServerSideExcludes"] -class ZoneSettingServerSideExclude(BaseModel): +class ServerSideExcludes(BaseModel): id: Literal["server_side_exclude"] """ID of the zone setting.""" diff --git a/src/cloudflare/types/zones/settings/zone_setting_sort_query_string_for_cache.py b/src/cloudflare/types/zones/settings/sort_query_string_for_cache.py similarity index 86% rename from src/cloudflare/types/zones/settings/zone_setting_sort_query_string_for_cache.py rename to src/cloudflare/types/zones/settings/sort_query_string_for_cache.py index cd70a12f5544..a60d4bfb63d1 100644 --- a/src/cloudflare/types/zones/settings/zone_setting_sort_query_string_for_cache.py +++ b/src/cloudflare/types/zones/settings/sort_query_string_for_cache.py @@ -6,10 +6,10 @@ from ...._models import BaseModel -__all__ = ["ZoneSettingSortQueryStringForCache"] +__all__ = ["SortQueryStringForCache"] -class ZoneSettingSortQueryStringForCache(BaseModel): +class SortQueryStringForCache(BaseModel): id: Literal["sort_query_string_for_cache"] """ID of the zone setting.""" diff --git a/src/cloudflare/types/zones/settings/zone_setting_ssl.py b/src/cloudflare/types/zones/settings/ssl.py similarity index 91% rename from src/cloudflare/types/zones/settings/zone_setting_ssl.py rename to src/cloudflare/types/zones/settings/ssl.py index 59fde7f0bb3e..43cf8ae0cb78 100644 --- a/src/cloudflare/types/zones/settings/zone_setting_ssl.py +++ b/src/cloudflare/types/zones/settings/ssl.py @@ -6,10 +6,10 @@ from ...._models import BaseModel -__all__ = ["ZoneSettingSSL"] +__all__ = ["SSL"] -class ZoneSettingSSL(BaseModel): +class SSL(BaseModel): id: Literal["ssl"] """ID of the zone setting.""" diff --git a/src/cloudflare/types/zones/settings/zone_setting_ssl_recommender.py b/src/cloudflare/types/zones/settings/ssl_recommender.py similarity index 81% rename from src/cloudflare/types/zones/settings/zone_setting_ssl_recommender.py rename to src/cloudflare/types/zones/settings/ssl_recommender.py index f6daa5851899..c3a36d8f3c84 100644 --- a/src/cloudflare/types/zones/settings/zone_setting_ssl_recommender.py +++ b/src/cloudflare/types/zones/settings/ssl_recommender.py @@ -5,10 +5,10 @@ from ...._models import BaseModel -__all__ = ["ZoneSettingSSLRecommender"] +__all__ = ["SSLRecommender"] -class ZoneSettingSSLRecommender(BaseModel): +class SSLRecommender(BaseModel): id: Optional[Literal["ssl_recommender"]] = None """Enrollment value for SSL/TLS Recommender.""" diff --git a/src/cloudflare/types/zones/settings/ssl_recommender_edit_params.py b/src/cloudflare/types/zones/settings/ssl_recommender_edit_params.py index f2db54691448..4006b39479ed 100644 --- a/src/cloudflare/types/zones/settings/ssl_recommender_edit_params.py +++ b/src/cloudflare/types/zones/settings/ssl_recommender_edit_params.py @@ -4,7 +4,7 @@ from typing_extensions import Required, TypedDict -from .zone_setting_ssl_recommender_param import ZoneSettingSSLRecommenderParam +from .ssl_recommender_param import SSLRecommenderParam __all__ = ["SSLRecommenderEditParams"] @@ -13,7 +13,7 @@ class SSLRecommenderEditParams(TypedDict, total=False): zone_id: Required[str] """Identifier""" - value: Required[ZoneSettingSSLRecommenderParam] + value: Required[SSLRecommenderParam] """ Enrollment in the SSL/TLS Recommender service which tries to detect and recommend (by sending periodic emails) the most secure SSL/TLS setting your diff --git a/src/cloudflare/types/zones/settings/zone_setting_ssl_recommender_param.py b/src/cloudflare/types/zones/settings/ssl_recommender_param.py similarity index 75% rename from src/cloudflare/types/zones/settings/zone_setting_ssl_recommender_param.py rename to src/cloudflare/types/zones/settings/ssl_recommender_param.py index 7be93660ca46..0189ce02e60c 100644 --- a/src/cloudflare/types/zones/settings/zone_setting_ssl_recommender_param.py +++ b/src/cloudflare/types/zones/settings/ssl_recommender_param.py @@ -4,10 +4,10 @@ from typing_extensions import Literal, TypedDict -__all__ = ["ZoneSettingSSLRecommenderParam"] +__all__ = ["SSLRecommenderParam"] -class ZoneSettingSSLRecommenderParam(TypedDict, total=False): +class SSLRecommenderParam(TypedDict, total=False): id: Literal["ssl_recommender"] """Enrollment value for SSL/TLS Recommender.""" diff --git a/src/cloudflare/types/zones/settings/zone_setting_tls_1_3.py b/src/cloudflare/types/zones/settings/tls_1_3.py similarity index 90% rename from src/cloudflare/types/zones/settings/zone_setting_tls_1_3.py rename to src/cloudflare/types/zones/settings/tls_1_3.py index 358da89a9236..6e72f90e7b9e 100644 --- a/src/cloudflare/types/zones/settings/zone_setting_tls_1_3.py +++ b/src/cloudflare/types/zones/settings/tls_1_3.py @@ -6,10 +6,10 @@ from ...._models import BaseModel -__all__ = ["ZoneSettingTLS1_3"] +__all__ = ["TLS1_3"] -class ZoneSettingTLS1_3(BaseModel): +class TLS1_3(BaseModel): id: Literal["tls_1_3"] """ID of the zone setting.""" diff --git a/src/cloudflare/types/zones/settings/zone_setting_tls_client_auth.py b/src/cloudflare/types/zones/settings/tls_client_auth.py similarity index 88% rename from src/cloudflare/types/zones/settings/zone_setting_tls_client_auth.py rename to src/cloudflare/types/zones/settings/tls_client_auth.py index f0e6b95ec4c5..e1ab61fb85b4 100644 --- a/src/cloudflare/types/zones/settings/zone_setting_tls_client_auth.py +++ b/src/cloudflare/types/zones/settings/tls_client_auth.py @@ -6,10 +6,10 @@ from ...._models import BaseModel -__all__ = ["ZoneSettingTLSClientAuth"] +__all__ = ["TLSClientAuth"] -class ZoneSettingTLSClientAuth(BaseModel): +class TLSClientAuth(BaseModel): id: Literal["tls_client_auth"] """ID of the zone setting.""" diff --git a/src/cloudflare/types/zones/settings/zone_setting_true_client_ip_header.py b/src/cloudflare/types/zones/settings/true_client_ip_header.py similarity index 87% rename from src/cloudflare/types/zones/settings/zone_setting_true_client_ip_header.py rename to src/cloudflare/types/zones/settings/true_client_ip_header.py index f9a885775b14..12fd0a2d037f 100644 --- a/src/cloudflare/types/zones/settings/zone_setting_true_client_ip_header.py +++ b/src/cloudflare/types/zones/settings/true_client_ip_header.py @@ -6,10 +6,10 @@ from ...._models import BaseModel -__all__ = ["ZoneSettingTrueClientIPHeader"] +__all__ = ["TrueClientIPHeader"] -class ZoneSettingTrueClientIPHeader(BaseModel): +class TrueClientIPHeader(BaseModel): id: Literal["true_client_ip_header"] """ID of the zone setting.""" diff --git a/src/cloudflare/types/zones/settings/zone_setting_waf.py b/src/cloudflare/types/zones/settings/waf.py similarity index 90% rename from src/cloudflare/types/zones/settings/zone_setting_waf.py rename to src/cloudflare/types/zones/settings/waf.py index 807977534a3d..ec7a5487541a 100644 --- a/src/cloudflare/types/zones/settings/zone_setting_waf.py +++ b/src/cloudflare/types/zones/settings/waf.py @@ -6,10 +6,10 @@ from ...._models import BaseModel -__all__ = ["ZoneSettingWAF"] +__all__ = ["WAF"] -class ZoneSettingWAF(BaseModel): +class WAF(BaseModel): id: Literal["waf"] """ID of the zone setting.""" diff --git a/src/cloudflare/types/zones/settings/zone_setting_webp.py b/src/cloudflare/types/zones/settings/webp.py similarity index 90% rename from src/cloudflare/types/zones/settings/zone_setting_webp.py rename to src/cloudflare/types/zones/settings/webp.py index 35a3bb58b405..9f4cfaeee3f4 100644 --- a/src/cloudflare/types/zones/settings/zone_setting_webp.py +++ b/src/cloudflare/types/zones/settings/webp.py @@ -6,10 +6,10 @@ from ...._models import BaseModel -__all__ = ["ZoneSettingWebP"] +__all__ = ["WebP"] -class ZoneSettingWebP(BaseModel): +class WebP(BaseModel): id: Literal["webp"] """ID of the zone setting.""" diff --git a/src/cloudflare/types/zones/settings/zone_setting_websockets.py b/src/cloudflare/types/zones/settings/websocket.py similarity index 89% rename from src/cloudflare/types/zones/settings/zone_setting_websockets.py rename to src/cloudflare/types/zones/settings/websocket.py index 6faa560ef95d..c8471ef28f90 100644 --- a/src/cloudflare/types/zones/settings/zone_setting_websockets.py +++ b/src/cloudflare/types/zones/settings/websocket.py @@ -6,10 +6,10 @@ from ...._models import BaseModel -__all__ = ["ZoneSettingWebsockets"] +__all__ = ["Websocket"] -class ZoneSettingWebsockets(BaseModel): +class Websocket(BaseModel): id: Literal["websockets"] """ID of the zone setting.""" diff --git a/src/cloudflare/types/zones/settings/zone_setting_0rtt.py b/src/cloudflare/types/zones/settings/zero_rtt.py similarity index 90% rename from src/cloudflare/types/zones/settings/zone_setting_0rtt.py rename to src/cloudflare/types/zones/settings/zero_rtt.py index dbe59f9b50b8..a627cbcc738d 100644 --- a/src/cloudflare/types/zones/settings/zone_setting_0rtt.py +++ b/src/cloudflare/types/zones/settings/zero_rtt.py @@ -6,10 +6,10 @@ from ...._models import BaseModel -__all__ = ["ZoneSetting0rtt"] +__all__ = ["ZeroRTT"] -class ZoneSetting0rtt(BaseModel): +class ZeroRTT(BaseModel): id: Literal["0rtt"] """ID of the zone setting.""" diff --git a/tests/api_resources/zones/settings/test_advanced_ddos.py b/tests/api_resources/zones/settings/test_advanced_ddos.py index 891653faed38..6866ae5e9fce 100644 --- a/tests/api_resources/zones/settings/test_advanced_ddos.py +++ b/tests/api_resources/zones/settings/test_advanced_ddos.py @@ -9,7 +9,7 @@ from cloudflare import Cloudflare, AsyncCloudflare from tests.utils import assert_matches_type -from cloudflare.types.zones.settings import ZoneSettingAdvancedDDoS +from cloudflare.types.zones.settings import AdvancedDDoS base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -23,7 +23,7 @@ def test_method_get(self, client: Cloudflare) -> None: advanced_ddos = client.zones.settings.advanced_ddos.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingAdvancedDDoS], advanced_ddos, path=["response"]) + assert_matches_type(Optional[AdvancedDDoS], advanced_ddos, path=["response"]) @pytest.mark.skip() @parametrize @@ -35,7 +35,7 @@ def test_raw_response_get(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" advanced_ddos = response.parse() - assert_matches_type(Optional[ZoneSettingAdvancedDDoS], advanced_ddos, path=["response"]) + assert_matches_type(Optional[AdvancedDDoS], advanced_ddos, path=["response"]) @pytest.mark.skip() @parametrize @@ -47,7 +47,7 @@ def test_streaming_response_get(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" advanced_ddos = response.parse() - assert_matches_type(Optional[ZoneSettingAdvancedDDoS], advanced_ddos, path=["response"]) + assert_matches_type(Optional[AdvancedDDoS], advanced_ddos, path=["response"]) assert cast(Any, response.is_closed) is True @@ -69,7 +69,7 @@ async def test_method_get(self, async_client: AsyncCloudflare) -> None: advanced_ddos = await async_client.zones.settings.advanced_ddos.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingAdvancedDDoS], advanced_ddos, path=["response"]) + assert_matches_type(Optional[AdvancedDDoS], advanced_ddos, path=["response"]) @pytest.mark.skip() @parametrize @@ -81,7 +81,7 @@ async def test_raw_response_get(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" advanced_ddos = await response.parse() - assert_matches_type(Optional[ZoneSettingAdvancedDDoS], advanced_ddos, path=["response"]) + assert_matches_type(Optional[AdvancedDDoS], advanced_ddos, path=["response"]) @pytest.mark.skip() @parametrize @@ -93,7 +93,7 @@ async def test_streaming_response_get(self, async_client: AsyncCloudflare) -> No assert response.http_request.headers.get("X-Stainless-Lang") == "python" advanced_ddos = await response.parse() - assert_matches_type(Optional[ZoneSettingAdvancedDDoS], advanced_ddos, path=["response"]) + assert_matches_type(Optional[AdvancedDDoS], advanced_ddos, path=["response"]) assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/zones/settings/test_always_online.py b/tests/api_resources/zones/settings/test_always_online.py index a9bf66a46088..8773d50c8929 100644 --- a/tests/api_resources/zones/settings/test_always_online.py +++ b/tests/api_resources/zones/settings/test_always_online.py @@ -9,7 +9,7 @@ from cloudflare import Cloudflare, AsyncCloudflare from tests.utils import assert_matches_type -from cloudflare.types.zones.settings import ZoneSettingAlwaysOnline +from cloudflare.types.zones.settings import AlwaysOnline base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -24,7 +24,7 @@ def test_method_edit(self, client: Cloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="on", ) - assert_matches_type(Optional[ZoneSettingAlwaysOnline], always_online, path=["response"]) + assert_matches_type(Optional[AlwaysOnline], always_online, path=["response"]) @pytest.mark.skip() @parametrize @@ -37,7 +37,7 @@ def test_raw_response_edit(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" always_online = response.parse() - assert_matches_type(Optional[ZoneSettingAlwaysOnline], always_online, path=["response"]) + assert_matches_type(Optional[AlwaysOnline], always_online, path=["response"]) @pytest.mark.skip() @parametrize @@ -50,7 +50,7 @@ def test_streaming_response_edit(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" always_online = response.parse() - assert_matches_type(Optional[ZoneSettingAlwaysOnline], always_online, path=["response"]) + assert_matches_type(Optional[AlwaysOnline], always_online, path=["response"]) assert cast(Any, response.is_closed) is True @@ -69,7 +69,7 @@ def test_method_get(self, client: Cloudflare) -> None: always_online = client.zones.settings.always_online.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingAlwaysOnline], always_online, path=["response"]) + assert_matches_type(Optional[AlwaysOnline], always_online, path=["response"]) @pytest.mark.skip() @parametrize @@ -81,7 +81,7 @@ def test_raw_response_get(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" always_online = response.parse() - assert_matches_type(Optional[ZoneSettingAlwaysOnline], always_online, path=["response"]) + assert_matches_type(Optional[AlwaysOnline], always_online, path=["response"]) @pytest.mark.skip() @parametrize @@ -93,7 +93,7 @@ def test_streaming_response_get(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" always_online = response.parse() - assert_matches_type(Optional[ZoneSettingAlwaysOnline], always_online, path=["response"]) + assert_matches_type(Optional[AlwaysOnline], always_online, path=["response"]) assert cast(Any, response.is_closed) is True @@ -116,7 +116,7 @@ async def test_method_edit(self, async_client: AsyncCloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="on", ) - assert_matches_type(Optional[ZoneSettingAlwaysOnline], always_online, path=["response"]) + assert_matches_type(Optional[AlwaysOnline], always_online, path=["response"]) @pytest.mark.skip() @parametrize @@ -129,7 +129,7 @@ async def test_raw_response_edit(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" always_online = await response.parse() - assert_matches_type(Optional[ZoneSettingAlwaysOnline], always_online, path=["response"]) + assert_matches_type(Optional[AlwaysOnline], always_online, path=["response"]) @pytest.mark.skip() @parametrize @@ -142,7 +142,7 @@ async def test_streaming_response_edit(self, async_client: AsyncCloudflare) -> N assert response.http_request.headers.get("X-Stainless-Lang") == "python" always_online = await response.parse() - assert_matches_type(Optional[ZoneSettingAlwaysOnline], always_online, path=["response"]) + assert_matches_type(Optional[AlwaysOnline], always_online, path=["response"]) assert cast(Any, response.is_closed) is True @@ -161,7 +161,7 @@ async def test_method_get(self, async_client: AsyncCloudflare) -> None: always_online = await async_client.zones.settings.always_online.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingAlwaysOnline], always_online, path=["response"]) + assert_matches_type(Optional[AlwaysOnline], always_online, path=["response"]) @pytest.mark.skip() @parametrize @@ -173,7 +173,7 @@ async def test_raw_response_get(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" always_online = await response.parse() - assert_matches_type(Optional[ZoneSettingAlwaysOnline], always_online, path=["response"]) + assert_matches_type(Optional[AlwaysOnline], always_online, path=["response"]) @pytest.mark.skip() @parametrize @@ -185,7 +185,7 @@ async def test_streaming_response_get(self, async_client: AsyncCloudflare) -> No assert response.http_request.headers.get("X-Stainless-Lang") == "python" always_online = await response.parse() - assert_matches_type(Optional[ZoneSettingAlwaysOnline], always_online, path=["response"]) + assert_matches_type(Optional[AlwaysOnline], always_online, path=["response"]) assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/zones/settings/test_always_use_https.py b/tests/api_resources/zones/settings/test_always_use_https.py index 6353ba32c8c5..31a42cb7de79 100644 --- a/tests/api_resources/zones/settings/test_always_use_https.py +++ b/tests/api_resources/zones/settings/test_always_use_https.py @@ -9,7 +9,7 @@ from cloudflare import Cloudflare, AsyncCloudflare from tests.utils import assert_matches_type -from cloudflare.types.zones.settings import ZoneSettingAlwaysUseHTTPS +from cloudflare.types.zones.settings import AlwaysUseHTTPS base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -24,7 +24,7 @@ def test_method_edit(self, client: Cloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="on", ) - assert_matches_type(Optional[ZoneSettingAlwaysUseHTTPS], always_use_https, path=["response"]) + assert_matches_type(Optional[AlwaysUseHTTPS], always_use_https, path=["response"]) @pytest.mark.skip() @parametrize @@ -37,7 +37,7 @@ def test_raw_response_edit(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" always_use_https = response.parse() - assert_matches_type(Optional[ZoneSettingAlwaysUseHTTPS], always_use_https, path=["response"]) + assert_matches_type(Optional[AlwaysUseHTTPS], always_use_https, path=["response"]) @pytest.mark.skip() @parametrize @@ -50,7 +50,7 @@ def test_streaming_response_edit(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" always_use_https = response.parse() - assert_matches_type(Optional[ZoneSettingAlwaysUseHTTPS], always_use_https, path=["response"]) + assert_matches_type(Optional[AlwaysUseHTTPS], always_use_https, path=["response"]) assert cast(Any, response.is_closed) is True @@ -69,7 +69,7 @@ def test_method_get(self, client: Cloudflare) -> None: always_use_https = client.zones.settings.always_use_https.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingAlwaysUseHTTPS], always_use_https, path=["response"]) + assert_matches_type(Optional[AlwaysUseHTTPS], always_use_https, path=["response"]) @pytest.mark.skip() @parametrize @@ -81,7 +81,7 @@ def test_raw_response_get(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" always_use_https = response.parse() - assert_matches_type(Optional[ZoneSettingAlwaysUseHTTPS], always_use_https, path=["response"]) + assert_matches_type(Optional[AlwaysUseHTTPS], always_use_https, path=["response"]) @pytest.mark.skip() @parametrize @@ -93,7 +93,7 @@ def test_streaming_response_get(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" always_use_https = response.parse() - assert_matches_type(Optional[ZoneSettingAlwaysUseHTTPS], always_use_https, path=["response"]) + assert_matches_type(Optional[AlwaysUseHTTPS], always_use_https, path=["response"]) assert cast(Any, response.is_closed) is True @@ -116,7 +116,7 @@ async def test_method_edit(self, async_client: AsyncCloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="on", ) - assert_matches_type(Optional[ZoneSettingAlwaysUseHTTPS], always_use_https, path=["response"]) + assert_matches_type(Optional[AlwaysUseHTTPS], always_use_https, path=["response"]) @pytest.mark.skip() @parametrize @@ -129,7 +129,7 @@ async def test_raw_response_edit(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" always_use_https = await response.parse() - assert_matches_type(Optional[ZoneSettingAlwaysUseHTTPS], always_use_https, path=["response"]) + assert_matches_type(Optional[AlwaysUseHTTPS], always_use_https, path=["response"]) @pytest.mark.skip() @parametrize @@ -142,7 +142,7 @@ async def test_streaming_response_edit(self, async_client: AsyncCloudflare) -> N assert response.http_request.headers.get("X-Stainless-Lang") == "python" always_use_https = await response.parse() - assert_matches_type(Optional[ZoneSettingAlwaysUseHTTPS], always_use_https, path=["response"]) + assert_matches_type(Optional[AlwaysUseHTTPS], always_use_https, path=["response"]) assert cast(Any, response.is_closed) is True @@ -161,7 +161,7 @@ async def test_method_get(self, async_client: AsyncCloudflare) -> None: always_use_https = await async_client.zones.settings.always_use_https.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingAlwaysUseHTTPS], always_use_https, path=["response"]) + assert_matches_type(Optional[AlwaysUseHTTPS], always_use_https, path=["response"]) @pytest.mark.skip() @parametrize @@ -173,7 +173,7 @@ async def test_raw_response_get(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" always_use_https = await response.parse() - assert_matches_type(Optional[ZoneSettingAlwaysUseHTTPS], always_use_https, path=["response"]) + assert_matches_type(Optional[AlwaysUseHTTPS], always_use_https, path=["response"]) @pytest.mark.skip() @parametrize @@ -185,7 +185,7 @@ async def test_streaming_response_get(self, async_client: AsyncCloudflare) -> No assert response.http_request.headers.get("X-Stainless-Lang") == "python" always_use_https = await response.parse() - assert_matches_type(Optional[ZoneSettingAlwaysUseHTTPS], always_use_https, path=["response"]) + assert_matches_type(Optional[AlwaysUseHTTPS], always_use_https, path=["response"]) assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/zones/settings/test_automatic_https_rewrites.py b/tests/api_resources/zones/settings/test_automatic_https_rewrites.py index 4e952b6088d2..4601468bab38 100644 --- a/tests/api_resources/zones/settings/test_automatic_https_rewrites.py +++ b/tests/api_resources/zones/settings/test_automatic_https_rewrites.py @@ -9,7 +9,7 @@ from cloudflare import Cloudflare, AsyncCloudflare from tests.utils import assert_matches_type -from cloudflare.types.zones.settings import ZoneSettingAutomaticHTTPSRewrites +from cloudflare.types.zones.settings import AutomaticHTTPSRewrites base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -24,7 +24,7 @@ def test_method_edit(self, client: Cloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="on", ) - assert_matches_type(Optional[ZoneSettingAutomaticHTTPSRewrites], automatic_https_rewrite, path=["response"]) + assert_matches_type(Optional[AutomaticHTTPSRewrites], automatic_https_rewrite, path=["response"]) @pytest.mark.skip() @parametrize @@ -37,7 +37,7 @@ def test_raw_response_edit(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" automatic_https_rewrite = response.parse() - assert_matches_type(Optional[ZoneSettingAutomaticHTTPSRewrites], automatic_https_rewrite, path=["response"]) + assert_matches_type(Optional[AutomaticHTTPSRewrites], automatic_https_rewrite, path=["response"]) @pytest.mark.skip() @parametrize @@ -50,7 +50,7 @@ def test_streaming_response_edit(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" automatic_https_rewrite = response.parse() - assert_matches_type(Optional[ZoneSettingAutomaticHTTPSRewrites], automatic_https_rewrite, path=["response"]) + assert_matches_type(Optional[AutomaticHTTPSRewrites], automatic_https_rewrite, path=["response"]) assert cast(Any, response.is_closed) is True @@ -69,7 +69,7 @@ def test_method_get(self, client: Cloudflare) -> None: automatic_https_rewrite = client.zones.settings.automatic_https_rewrites.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingAutomaticHTTPSRewrites], automatic_https_rewrite, path=["response"]) + assert_matches_type(Optional[AutomaticHTTPSRewrites], automatic_https_rewrite, path=["response"]) @pytest.mark.skip() @parametrize @@ -81,7 +81,7 @@ def test_raw_response_get(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" automatic_https_rewrite = response.parse() - assert_matches_type(Optional[ZoneSettingAutomaticHTTPSRewrites], automatic_https_rewrite, path=["response"]) + assert_matches_type(Optional[AutomaticHTTPSRewrites], automatic_https_rewrite, path=["response"]) @pytest.mark.skip() @parametrize @@ -93,7 +93,7 @@ def test_streaming_response_get(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" automatic_https_rewrite = response.parse() - assert_matches_type(Optional[ZoneSettingAutomaticHTTPSRewrites], automatic_https_rewrite, path=["response"]) + assert_matches_type(Optional[AutomaticHTTPSRewrites], automatic_https_rewrite, path=["response"]) assert cast(Any, response.is_closed) is True @@ -116,7 +116,7 @@ async def test_method_edit(self, async_client: AsyncCloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="on", ) - assert_matches_type(Optional[ZoneSettingAutomaticHTTPSRewrites], automatic_https_rewrite, path=["response"]) + assert_matches_type(Optional[AutomaticHTTPSRewrites], automatic_https_rewrite, path=["response"]) @pytest.mark.skip() @parametrize @@ -129,7 +129,7 @@ async def test_raw_response_edit(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" automatic_https_rewrite = await response.parse() - assert_matches_type(Optional[ZoneSettingAutomaticHTTPSRewrites], automatic_https_rewrite, path=["response"]) + assert_matches_type(Optional[AutomaticHTTPSRewrites], automatic_https_rewrite, path=["response"]) @pytest.mark.skip() @parametrize @@ -142,7 +142,7 @@ async def test_streaming_response_edit(self, async_client: AsyncCloudflare) -> N assert response.http_request.headers.get("X-Stainless-Lang") == "python" automatic_https_rewrite = await response.parse() - assert_matches_type(Optional[ZoneSettingAutomaticHTTPSRewrites], automatic_https_rewrite, path=["response"]) + assert_matches_type(Optional[AutomaticHTTPSRewrites], automatic_https_rewrite, path=["response"]) assert cast(Any, response.is_closed) is True @@ -161,7 +161,7 @@ async def test_method_get(self, async_client: AsyncCloudflare) -> None: automatic_https_rewrite = await async_client.zones.settings.automatic_https_rewrites.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingAutomaticHTTPSRewrites], automatic_https_rewrite, path=["response"]) + assert_matches_type(Optional[AutomaticHTTPSRewrites], automatic_https_rewrite, path=["response"]) @pytest.mark.skip() @parametrize @@ -173,7 +173,7 @@ async def test_raw_response_get(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" automatic_https_rewrite = await response.parse() - assert_matches_type(Optional[ZoneSettingAutomaticHTTPSRewrites], automatic_https_rewrite, path=["response"]) + assert_matches_type(Optional[AutomaticHTTPSRewrites], automatic_https_rewrite, path=["response"]) @pytest.mark.skip() @parametrize @@ -185,7 +185,7 @@ async def test_streaming_response_get(self, async_client: AsyncCloudflare) -> No assert response.http_request.headers.get("X-Stainless-Lang") == "python" automatic_https_rewrite = await response.parse() - assert_matches_type(Optional[ZoneSettingAutomaticHTTPSRewrites], automatic_https_rewrite, path=["response"]) + assert_matches_type(Optional[AutomaticHTTPSRewrites], automatic_https_rewrite, path=["response"]) assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/zones/settings/test_automatic_platform_optimization.py b/tests/api_resources/zones/settings/test_automatic_platform_optimization.py index 70d171a60dfb..d9b945e5762d 100644 --- a/tests/api_resources/zones/settings/test_automatic_platform_optimization.py +++ b/tests/api_resources/zones/settings/test_automatic_platform_optimization.py @@ -9,9 +9,7 @@ from cloudflare import Cloudflare, AsyncCloudflare from tests.utils import assert_matches_type -from cloudflare.types.zones.settings import ( - ZoneSettingAutomaticPlatformOptimization, -) +from cloudflare.types.zones.settings import AutomaticPlatformOptimization base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -33,9 +31,7 @@ def test_method_edit(self, client: Cloudflare) -> None: "wp_plugin": True, }, ) - assert_matches_type( - Optional[ZoneSettingAutomaticPlatformOptimization], automatic_platform_optimization, path=["response"] - ) + assert_matches_type(Optional[AutomaticPlatformOptimization], automatic_platform_optimization, path=["response"]) @pytest.mark.skip() @parametrize @@ -55,9 +51,7 @@ def test_raw_response_edit(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" automatic_platform_optimization = response.parse() - assert_matches_type( - Optional[ZoneSettingAutomaticPlatformOptimization], automatic_platform_optimization, path=["response"] - ) + assert_matches_type(Optional[AutomaticPlatformOptimization], automatic_platform_optimization, path=["response"]) @pytest.mark.skip() @parametrize @@ -78,7 +72,7 @@ def test_streaming_response_edit(self, client: Cloudflare) -> None: automatic_platform_optimization = response.parse() assert_matches_type( - Optional[ZoneSettingAutomaticPlatformOptimization], automatic_platform_optimization, path=["response"] + Optional[AutomaticPlatformOptimization], automatic_platform_optimization, path=["response"] ) assert cast(Any, response.is_closed) is True @@ -105,9 +99,7 @@ def test_method_get(self, client: Cloudflare) -> None: automatic_platform_optimization = client.zones.settings.automatic_platform_optimization.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type( - Optional[ZoneSettingAutomaticPlatformOptimization], automatic_platform_optimization, path=["response"] - ) + assert_matches_type(Optional[AutomaticPlatformOptimization], automatic_platform_optimization, path=["response"]) @pytest.mark.skip() @parametrize @@ -119,9 +111,7 @@ def test_raw_response_get(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" automatic_platform_optimization = response.parse() - assert_matches_type( - Optional[ZoneSettingAutomaticPlatformOptimization], automatic_platform_optimization, path=["response"] - ) + assert_matches_type(Optional[AutomaticPlatformOptimization], automatic_platform_optimization, path=["response"]) @pytest.mark.skip() @parametrize @@ -134,7 +124,7 @@ def test_streaming_response_get(self, client: Cloudflare) -> None: automatic_platform_optimization = response.parse() assert_matches_type( - Optional[ZoneSettingAutomaticPlatformOptimization], automatic_platform_optimization, path=["response"] + Optional[AutomaticPlatformOptimization], automatic_platform_optimization, path=["response"] ) assert cast(Any, response.is_closed) is True @@ -165,9 +155,7 @@ async def test_method_edit(self, async_client: AsyncCloudflare) -> None: "wp_plugin": True, }, ) - assert_matches_type( - Optional[ZoneSettingAutomaticPlatformOptimization], automatic_platform_optimization, path=["response"] - ) + assert_matches_type(Optional[AutomaticPlatformOptimization], automatic_platform_optimization, path=["response"]) @pytest.mark.skip() @parametrize @@ -187,9 +175,7 @@ async def test_raw_response_edit(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" automatic_platform_optimization = await response.parse() - assert_matches_type( - Optional[ZoneSettingAutomaticPlatformOptimization], automatic_platform_optimization, path=["response"] - ) + assert_matches_type(Optional[AutomaticPlatformOptimization], automatic_platform_optimization, path=["response"]) @pytest.mark.skip() @parametrize @@ -210,7 +196,7 @@ async def test_streaming_response_edit(self, async_client: AsyncCloudflare) -> N automatic_platform_optimization = await response.parse() assert_matches_type( - Optional[ZoneSettingAutomaticPlatformOptimization], automatic_platform_optimization, path=["response"] + Optional[AutomaticPlatformOptimization], automatic_platform_optimization, path=["response"] ) assert cast(Any, response.is_closed) is True @@ -237,9 +223,7 @@ async def test_method_get(self, async_client: AsyncCloudflare) -> None: automatic_platform_optimization = await async_client.zones.settings.automatic_platform_optimization.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type( - Optional[ZoneSettingAutomaticPlatformOptimization], automatic_platform_optimization, path=["response"] - ) + assert_matches_type(Optional[AutomaticPlatformOptimization], automatic_platform_optimization, path=["response"]) @pytest.mark.skip() @parametrize @@ -251,9 +235,7 @@ async def test_raw_response_get(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" automatic_platform_optimization = await response.parse() - assert_matches_type( - Optional[ZoneSettingAutomaticPlatformOptimization], automatic_platform_optimization, path=["response"] - ) + assert_matches_type(Optional[AutomaticPlatformOptimization], automatic_platform_optimization, path=["response"]) @pytest.mark.skip() @parametrize @@ -266,7 +248,7 @@ async def test_streaming_response_get(self, async_client: AsyncCloudflare) -> No automatic_platform_optimization = await response.parse() assert_matches_type( - Optional[ZoneSettingAutomaticPlatformOptimization], automatic_platform_optimization, path=["response"] + Optional[AutomaticPlatformOptimization], automatic_platform_optimization, path=["response"] ) assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/zones/settings/test_brotli.py b/tests/api_resources/zones/settings/test_brotli.py index 73766d4c64ae..98ac6368896f 100644 --- a/tests/api_resources/zones/settings/test_brotli.py +++ b/tests/api_resources/zones/settings/test_brotli.py @@ -9,7 +9,7 @@ from cloudflare import Cloudflare, AsyncCloudflare from tests.utils import assert_matches_type -from cloudflare.types.zones.settings import ZoneSettingBrotli +from cloudflare.types.zones.settings import Brotli base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -24,7 +24,7 @@ def test_method_edit(self, client: Cloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="off", ) - assert_matches_type(Optional[ZoneSettingBrotli], brotli, path=["response"]) + assert_matches_type(Optional[Brotli], brotli, path=["response"]) @pytest.mark.skip() @parametrize @@ -37,7 +37,7 @@ def test_raw_response_edit(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" brotli = response.parse() - assert_matches_type(Optional[ZoneSettingBrotli], brotli, path=["response"]) + assert_matches_type(Optional[Brotli], brotli, path=["response"]) @pytest.mark.skip() @parametrize @@ -50,7 +50,7 @@ def test_streaming_response_edit(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" brotli = response.parse() - assert_matches_type(Optional[ZoneSettingBrotli], brotli, path=["response"]) + assert_matches_type(Optional[Brotli], brotli, path=["response"]) assert cast(Any, response.is_closed) is True @@ -69,7 +69,7 @@ def test_method_get(self, client: Cloudflare) -> None: brotli = client.zones.settings.brotli.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingBrotli], brotli, path=["response"]) + assert_matches_type(Optional[Brotli], brotli, path=["response"]) @pytest.mark.skip() @parametrize @@ -81,7 +81,7 @@ def test_raw_response_get(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" brotli = response.parse() - assert_matches_type(Optional[ZoneSettingBrotli], brotli, path=["response"]) + assert_matches_type(Optional[Brotli], brotli, path=["response"]) @pytest.mark.skip() @parametrize @@ -93,7 +93,7 @@ def test_streaming_response_get(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" brotli = response.parse() - assert_matches_type(Optional[ZoneSettingBrotli], brotli, path=["response"]) + assert_matches_type(Optional[Brotli], brotli, path=["response"]) assert cast(Any, response.is_closed) is True @@ -116,7 +116,7 @@ async def test_method_edit(self, async_client: AsyncCloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="off", ) - assert_matches_type(Optional[ZoneSettingBrotli], brotli, path=["response"]) + assert_matches_type(Optional[Brotli], brotli, path=["response"]) @pytest.mark.skip() @parametrize @@ -129,7 +129,7 @@ async def test_raw_response_edit(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" brotli = await response.parse() - assert_matches_type(Optional[ZoneSettingBrotli], brotli, path=["response"]) + assert_matches_type(Optional[Brotli], brotli, path=["response"]) @pytest.mark.skip() @parametrize @@ -142,7 +142,7 @@ async def test_streaming_response_edit(self, async_client: AsyncCloudflare) -> N assert response.http_request.headers.get("X-Stainless-Lang") == "python" brotli = await response.parse() - assert_matches_type(Optional[ZoneSettingBrotli], brotli, path=["response"]) + assert_matches_type(Optional[Brotli], brotli, path=["response"]) assert cast(Any, response.is_closed) is True @@ -161,7 +161,7 @@ async def test_method_get(self, async_client: AsyncCloudflare) -> None: brotli = await async_client.zones.settings.brotli.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingBrotli], brotli, path=["response"]) + assert_matches_type(Optional[Brotli], brotli, path=["response"]) @pytest.mark.skip() @parametrize @@ -173,7 +173,7 @@ async def test_raw_response_get(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" brotli = await response.parse() - assert_matches_type(Optional[ZoneSettingBrotli], brotli, path=["response"]) + assert_matches_type(Optional[Brotli], brotli, path=["response"]) @pytest.mark.skip() @parametrize @@ -185,7 +185,7 @@ async def test_streaming_response_get(self, async_client: AsyncCloudflare) -> No assert response.http_request.headers.get("X-Stainless-Lang") == "python" brotli = await response.parse() - assert_matches_type(Optional[ZoneSettingBrotli], brotli, path=["response"]) + assert_matches_type(Optional[Brotli], brotli, path=["response"]) assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/zones/settings/test_browser_cache_ttl.py b/tests/api_resources/zones/settings/test_browser_cache_ttl.py index 8d268c3ef368..c971841241f3 100644 --- a/tests/api_resources/zones/settings/test_browser_cache_ttl.py +++ b/tests/api_resources/zones/settings/test_browser_cache_ttl.py @@ -9,7 +9,7 @@ from cloudflare import Cloudflare, AsyncCloudflare from tests.utils import assert_matches_type -from cloudflare.types.zones.settings import ZoneSettingBrowserCacheTTL +from cloudflare.types.zones.settings import BrowserCacheTTL base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -24,7 +24,7 @@ def test_method_edit(self, client: Cloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value=0, ) - assert_matches_type(Optional[ZoneSettingBrowserCacheTTL], browser_cache_ttl, path=["response"]) + assert_matches_type(Optional[BrowserCacheTTL], browser_cache_ttl, path=["response"]) @pytest.mark.skip() @parametrize @@ -37,7 +37,7 @@ def test_raw_response_edit(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" browser_cache_ttl = response.parse() - assert_matches_type(Optional[ZoneSettingBrowserCacheTTL], browser_cache_ttl, path=["response"]) + assert_matches_type(Optional[BrowserCacheTTL], browser_cache_ttl, path=["response"]) @pytest.mark.skip() @parametrize @@ -50,7 +50,7 @@ def test_streaming_response_edit(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" browser_cache_ttl = response.parse() - assert_matches_type(Optional[ZoneSettingBrowserCacheTTL], browser_cache_ttl, path=["response"]) + assert_matches_type(Optional[BrowserCacheTTL], browser_cache_ttl, path=["response"]) assert cast(Any, response.is_closed) is True @@ -69,7 +69,7 @@ def test_method_get(self, client: Cloudflare) -> None: browser_cache_ttl = client.zones.settings.browser_cache_ttl.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingBrowserCacheTTL], browser_cache_ttl, path=["response"]) + assert_matches_type(Optional[BrowserCacheTTL], browser_cache_ttl, path=["response"]) @pytest.mark.skip() @parametrize @@ -81,7 +81,7 @@ def test_raw_response_get(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" browser_cache_ttl = response.parse() - assert_matches_type(Optional[ZoneSettingBrowserCacheTTL], browser_cache_ttl, path=["response"]) + assert_matches_type(Optional[BrowserCacheTTL], browser_cache_ttl, path=["response"]) @pytest.mark.skip() @parametrize @@ -93,7 +93,7 @@ def test_streaming_response_get(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" browser_cache_ttl = response.parse() - assert_matches_type(Optional[ZoneSettingBrowserCacheTTL], browser_cache_ttl, path=["response"]) + assert_matches_type(Optional[BrowserCacheTTL], browser_cache_ttl, path=["response"]) assert cast(Any, response.is_closed) is True @@ -116,7 +116,7 @@ async def test_method_edit(self, async_client: AsyncCloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value=0, ) - assert_matches_type(Optional[ZoneSettingBrowserCacheTTL], browser_cache_ttl, path=["response"]) + assert_matches_type(Optional[BrowserCacheTTL], browser_cache_ttl, path=["response"]) @pytest.mark.skip() @parametrize @@ -129,7 +129,7 @@ async def test_raw_response_edit(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" browser_cache_ttl = await response.parse() - assert_matches_type(Optional[ZoneSettingBrowserCacheTTL], browser_cache_ttl, path=["response"]) + assert_matches_type(Optional[BrowserCacheTTL], browser_cache_ttl, path=["response"]) @pytest.mark.skip() @parametrize @@ -142,7 +142,7 @@ async def test_streaming_response_edit(self, async_client: AsyncCloudflare) -> N assert response.http_request.headers.get("X-Stainless-Lang") == "python" browser_cache_ttl = await response.parse() - assert_matches_type(Optional[ZoneSettingBrowserCacheTTL], browser_cache_ttl, path=["response"]) + assert_matches_type(Optional[BrowserCacheTTL], browser_cache_ttl, path=["response"]) assert cast(Any, response.is_closed) is True @@ -161,7 +161,7 @@ async def test_method_get(self, async_client: AsyncCloudflare) -> None: browser_cache_ttl = await async_client.zones.settings.browser_cache_ttl.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingBrowserCacheTTL], browser_cache_ttl, path=["response"]) + assert_matches_type(Optional[BrowserCacheTTL], browser_cache_ttl, path=["response"]) @pytest.mark.skip() @parametrize @@ -173,7 +173,7 @@ async def test_raw_response_get(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" browser_cache_ttl = await response.parse() - assert_matches_type(Optional[ZoneSettingBrowserCacheTTL], browser_cache_ttl, path=["response"]) + assert_matches_type(Optional[BrowserCacheTTL], browser_cache_ttl, path=["response"]) @pytest.mark.skip() @parametrize @@ -185,7 +185,7 @@ async def test_streaming_response_get(self, async_client: AsyncCloudflare) -> No assert response.http_request.headers.get("X-Stainless-Lang") == "python" browser_cache_ttl = await response.parse() - assert_matches_type(Optional[ZoneSettingBrowserCacheTTL], browser_cache_ttl, path=["response"]) + assert_matches_type(Optional[BrowserCacheTTL], browser_cache_ttl, path=["response"]) assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/zones/settings/test_browser_check.py b/tests/api_resources/zones/settings/test_browser_check.py index 61272e97eead..e025959af30b 100644 --- a/tests/api_resources/zones/settings/test_browser_check.py +++ b/tests/api_resources/zones/settings/test_browser_check.py @@ -9,7 +9,7 @@ from cloudflare import Cloudflare, AsyncCloudflare from tests.utils import assert_matches_type -from cloudflare.types.zones.settings import ZoneSettingBrowserCheck +from cloudflare.types.zones.settings import BrowserCheck base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -24,7 +24,7 @@ def test_method_edit(self, client: Cloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="on", ) - assert_matches_type(Optional[ZoneSettingBrowserCheck], browser_check, path=["response"]) + assert_matches_type(Optional[BrowserCheck], browser_check, path=["response"]) @pytest.mark.skip() @parametrize @@ -37,7 +37,7 @@ def test_raw_response_edit(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" browser_check = response.parse() - assert_matches_type(Optional[ZoneSettingBrowserCheck], browser_check, path=["response"]) + assert_matches_type(Optional[BrowserCheck], browser_check, path=["response"]) @pytest.mark.skip() @parametrize @@ -50,7 +50,7 @@ def test_streaming_response_edit(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" browser_check = response.parse() - assert_matches_type(Optional[ZoneSettingBrowserCheck], browser_check, path=["response"]) + assert_matches_type(Optional[BrowserCheck], browser_check, path=["response"]) assert cast(Any, response.is_closed) is True @@ -69,7 +69,7 @@ def test_method_get(self, client: Cloudflare) -> None: browser_check = client.zones.settings.browser_check.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingBrowserCheck], browser_check, path=["response"]) + assert_matches_type(Optional[BrowserCheck], browser_check, path=["response"]) @pytest.mark.skip() @parametrize @@ -81,7 +81,7 @@ def test_raw_response_get(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" browser_check = response.parse() - assert_matches_type(Optional[ZoneSettingBrowserCheck], browser_check, path=["response"]) + assert_matches_type(Optional[BrowserCheck], browser_check, path=["response"]) @pytest.mark.skip() @parametrize @@ -93,7 +93,7 @@ def test_streaming_response_get(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" browser_check = response.parse() - assert_matches_type(Optional[ZoneSettingBrowserCheck], browser_check, path=["response"]) + assert_matches_type(Optional[BrowserCheck], browser_check, path=["response"]) assert cast(Any, response.is_closed) is True @@ -116,7 +116,7 @@ async def test_method_edit(self, async_client: AsyncCloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="on", ) - assert_matches_type(Optional[ZoneSettingBrowserCheck], browser_check, path=["response"]) + assert_matches_type(Optional[BrowserCheck], browser_check, path=["response"]) @pytest.mark.skip() @parametrize @@ -129,7 +129,7 @@ async def test_raw_response_edit(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" browser_check = await response.parse() - assert_matches_type(Optional[ZoneSettingBrowserCheck], browser_check, path=["response"]) + assert_matches_type(Optional[BrowserCheck], browser_check, path=["response"]) @pytest.mark.skip() @parametrize @@ -142,7 +142,7 @@ async def test_streaming_response_edit(self, async_client: AsyncCloudflare) -> N assert response.http_request.headers.get("X-Stainless-Lang") == "python" browser_check = await response.parse() - assert_matches_type(Optional[ZoneSettingBrowserCheck], browser_check, path=["response"]) + assert_matches_type(Optional[BrowserCheck], browser_check, path=["response"]) assert cast(Any, response.is_closed) is True @@ -161,7 +161,7 @@ async def test_method_get(self, async_client: AsyncCloudflare) -> None: browser_check = await async_client.zones.settings.browser_check.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingBrowserCheck], browser_check, path=["response"]) + assert_matches_type(Optional[BrowserCheck], browser_check, path=["response"]) @pytest.mark.skip() @parametrize @@ -173,7 +173,7 @@ async def test_raw_response_get(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" browser_check = await response.parse() - assert_matches_type(Optional[ZoneSettingBrowserCheck], browser_check, path=["response"]) + assert_matches_type(Optional[BrowserCheck], browser_check, path=["response"]) @pytest.mark.skip() @parametrize @@ -185,7 +185,7 @@ async def test_streaming_response_get(self, async_client: AsyncCloudflare) -> No assert response.http_request.headers.get("X-Stainless-Lang") == "python" browser_check = await response.parse() - assert_matches_type(Optional[ZoneSettingBrowserCheck], browser_check, path=["response"]) + assert_matches_type(Optional[BrowserCheck], browser_check, path=["response"]) assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/zones/settings/test_cache_level.py b/tests/api_resources/zones/settings/test_cache_level.py index a0a286362954..cc8808120e47 100644 --- a/tests/api_resources/zones/settings/test_cache_level.py +++ b/tests/api_resources/zones/settings/test_cache_level.py @@ -9,7 +9,7 @@ from cloudflare import Cloudflare, AsyncCloudflare from tests.utils import assert_matches_type -from cloudflare.types.zones.settings import ZoneSettingCacheLevel +from cloudflare.types.zones.settings import CacheLevel base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -24,7 +24,7 @@ def test_method_edit(self, client: Cloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="aggressive", ) - assert_matches_type(Optional[ZoneSettingCacheLevel], cache_level, path=["response"]) + assert_matches_type(Optional[CacheLevel], cache_level, path=["response"]) @pytest.mark.skip() @parametrize @@ -37,7 +37,7 @@ def test_raw_response_edit(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" cache_level = response.parse() - assert_matches_type(Optional[ZoneSettingCacheLevel], cache_level, path=["response"]) + assert_matches_type(Optional[CacheLevel], cache_level, path=["response"]) @pytest.mark.skip() @parametrize @@ -50,7 +50,7 @@ def test_streaming_response_edit(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" cache_level = response.parse() - assert_matches_type(Optional[ZoneSettingCacheLevel], cache_level, path=["response"]) + assert_matches_type(Optional[CacheLevel], cache_level, path=["response"]) assert cast(Any, response.is_closed) is True @@ -69,7 +69,7 @@ def test_method_get(self, client: Cloudflare) -> None: cache_level = client.zones.settings.cache_level.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingCacheLevel], cache_level, path=["response"]) + assert_matches_type(Optional[CacheLevel], cache_level, path=["response"]) @pytest.mark.skip() @parametrize @@ -81,7 +81,7 @@ def test_raw_response_get(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" cache_level = response.parse() - assert_matches_type(Optional[ZoneSettingCacheLevel], cache_level, path=["response"]) + assert_matches_type(Optional[CacheLevel], cache_level, path=["response"]) @pytest.mark.skip() @parametrize @@ -93,7 +93,7 @@ def test_streaming_response_get(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" cache_level = response.parse() - assert_matches_type(Optional[ZoneSettingCacheLevel], cache_level, path=["response"]) + assert_matches_type(Optional[CacheLevel], cache_level, path=["response"]) assert cast(Any, response.is_closed) is True @@ -116,7 +116,7 @@ async def test_method_edit(self, async_client: AsyncCloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="aggressive", ) - assert_matches_type(Optional[ZoneSettingCacheLevel], cache_level, path=["response"]) + assert_matches_type(Optional[CacheLevel], cache_level, path=["response"]) @pytest.mark.skip() @parametrize @@ -129,7 +129,7 @@ async def test_raw_response_edit(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" cache_level = await response.parse() - assert_matches_type(Optional[ZoneSettingCacheLevel], cache_level, path=["response"]) + assert_matches_type(Optional[CacheLevel], cache_level, path=["response"]) @pytest.mark.skip() @parametrize @@ -142,7 +142,7 @@ async def test_streaming_response_edit(self, async_client: AsyncCloudflare) -> N assert response.http_request.headers.get("X-Stainless-Lang") == "python" cache_level = await response.parse() - assert_matches_type(Optional[ZoneSettingCacheLevel], cache_level, path=["response"]) + assert_matches_type(Optional[CacheLevel], cache_level, path=["response"]) assert cast(Any, response.is_closed) is True @@ -161,7 +161,7 @@ async def test_method_get(self, async_client: AsyncCloudflare) -> None: cache_level = await async_client.zones.settings.cache_level.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingCacheLevel], cache_level, path=["response"]) + assert_matches_type(Optional[CacheLevel], cache_level, path=["response"]) @pytest.mark.skip() @parametrize @@ -173,7 +173,7 @@ async def test_raw_response_get(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" cache_level = await response.parse() - assert_matches_type(Optional[ZoneSettingCacheLevel], cache_level, path=["response"]) + assert_matches_type(Optional[CacheLevel], cache_level, path=["response"]) @pytest.mark.skip() @parametrize @@ -185,7 +185,7 @@ async def test_streaming_response_get(self, async_client: AsyncCloudflare) -> No assert response.http_request.headers.get("X-Stainless-Lang") == "python" cache_level = await response.parse() - assert_matches_type(Optional[ZoneSettingCacheLevel], cache_level, path=["response"]) + assert_matches_type(Optional[CacheLevel], cache_level, path=["response"]) assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/zones/settings/test_challenge_ttl.py b/tests/api_resources/zones/settings/test_challenge_ttl.py index a65a5f5acc52..b5074a454b73 100644 --- a/tests/api_resources/zones/settings/test_challenge_ttl.py +++ b/tests/api_resources/zones/settings/test_challenge_ttl.py @@ -9,7 +9,7 @@ from cloudflare import Cloudflare, AsyncCloudflare from tests.utils import assert_matches_type -from cloudflare.types.zones.settings import ZoneSettingChallengeTTL +from cloudflare.types.zones.settings import ChallengeTTL base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -24,7 +24,7 @@ def test_method_edit(self, client: Cloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value=300, ) - assert_matches_type(Optional[ZoneSettingChallengeTTL], challenge_ttl, path=["response"]) + assert_matches_type(Optional[ChallengeTTL], challenge_ttl, path=["response"]) @pytest.mark.skip() @parametrize @@ -37,7 +37,7 @@ def test_raw_response_edit(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" challenge_ttl = response.parse() - assert_matches_type(Optional[ZoneSettingChallengeTTL], challenge_ttl, path=["response"]) + assert_matches_type(Optional[ChallengeTTL], challenge_ttl, path=["response"]) @pytest.mark.skip() @parametrize @@ -50,7 +50,7 @@ def test_streaming_response_edit(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" challenge_ttl = response.parse() - assert_matches_type(Optional[ZoneSettingChallengeTTL], challenge_ttl, path=["response"]) + assert_matches_type(Optional[ChallengeTTL], challenge_ttl, path=["response"]) assert cast(Any, response.is_closed) is True @@ -69,7 +69,7 @@ def test_method_get(self, client: Cloudflare) -> None: challenge_ttl = client.zones.settings.challenge_ttl.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingChallengeTTL], challenge_ttl, path=["response"]) + assert_matches_type(Optional[ChallengeTTL], challenge_ttl, path=["response"]) @pytest.mark.skip() @parametrize @@ -81,7 +81,7 @@ def test_raw_response_get(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" challenge_ttl = response.parse() - assert_matches_type(Optional[ZoneSettingChallengeTTL], challenge_ttl, path=["response"]) + assert_matches_type(Optional[ChallengeTTL], challenge_ttl, path=["response"]) @pytest.mark.skip() @parametrize @@ -93,7 +93,7 @@ def test_streaming_response_get(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" challenge_ttl = response.parse() - assert_matches_type(Optional[ZoneSettingChallengeTTL], challenge_ttl, path=["response"]) + assert_matches_type(Optional[ChallengeTTL], challenge_ttl, path=["response"]) assert cast(Any, response.is_closed) is True @@ -116,7 +116,7 @@ async def test_method_edit(self, async_client: AsyncCloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value=300, ) - assert_matches_type(Optional[ZoneSettingChallengeTTL], challenge_ttl, path=["response"]) + assert_matches_type(Optional[ChallengeTTL], challenge_ttl, path=["response"]) @pytest.mark.skip() @parametrize @@ -129,7 +129,7 @@ async def test_raw_response_edit(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" challenge_ttl = await response.parse() - assert_matches_type(Optional[ZoneSettingChallengeTTL], challenge_ttl, path=["response"]) + assert_matches_type(Optional[ChallengeTTL], challenge_ttl, path=["response"]) @pytest.mark.skip() @parametrize @@ -142,7 +142,7 @@ async def test_streaming_response_edit(self, async_client: AsyncCloudflare) -> N assert response.http_request.headers.get("X-Stainless-Lang") == "python" challenge_ttl = await response.parse() - assert_matches_type(Optional[ZoneSettingChallengeTTL], challenge_ttl, path=["response"]) + assert_matches_type(Optional[ChallengeTTL], challenge_ttl, path=["response"]) assert cast(Any, response.is_closed) is True @@ -161,7 +161,7 @@ async def test_method_get(self, async_client: AsyncCloudflare) -> None: challenge_ttl = await async_client.zones.settings.challenge_ttl.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingChallengeTTL], challenge_ttl, path=["response"]) + assert_matches_type(Optional[ChallengeTTL], challenge_ttl, path=["response"]) @pytest.mark.skip() @parametrize @@ -173,7 +173,7 @@ async def test_raw_response_get(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" challenge_ttl = await response.parse() - assert_matches_type(Optional[ZoneSettingChallengeTTL], challenge_ttl, path=["response"]) + assert_matches_type(Optional[ChallengeTTL], challenge_ttl, path=["response"]) @pytest.mark.skip() @parametrize @@ -185,7 +185,7 @@ async def test_streaming_response_get(self, async_client: AsyncCloudflare) -> No assert response.http_request.headers.get("X-Stainless-Lang") == "python" challenge_ttl = await response.parse() - assert_matches_type(Optional[ZoneSettingChallengeTTL], challenge_ttl, path=["response"]) + assert_matches_type(Optional[ChallengeTTL], challenge_ttl, path=["response"]) assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/zones/settings/test_ciphers.py b/tests/api_resources/zones/settings/test_ciphers.py index db8234f0cb05..5faf738d89ce 100644 --- a/tests/api_resources/zones/settings/test_ciphers.py +++ b/tests/api_resources/zones/settings/test_ciphers.py @@ -9,7 +9,7 @@ from cloudflare import Cloudflare, AsyncCloudflare from tests.utils import assert_matches_type -from cloudflare.types.zones.settings import ZoneSettingCiphers +from cloudflare.types.zones.settings import Ciphers base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -24,7 +24,7 @@ def test_method_edit(self, client: Cloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value=["ECDHE-RSA-AES128-GCM-SHA256", "AES128-SHA"], ) - assert_matches_type(Optional[ZoneSettingCiphers], cipher, path=["response"]) + assert_matches_type(Optional[Ciphers], cipher, path=["response"]) @pytest.mark.skip() @parametrize @@ -37,7 +37,7 @@ def test_raw_response_edit(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" cipher = response.parse() - assert_matches_type(Optional[ZoneSettingCiphers], cipher, path=["response"]) + assert_matches_type(Optional[Ciphers], cipher, path=["response"]) @pytest.mark.skip() @parametrize @@ -50,7 +50,7 @@ def test_streaming_response_edit(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" cipher = response.parse() - assert_matches_type(Optional[ZoneSettingCiphers], cipher, path=["response"]) + assert_matches_type(Optional[Ciphers], cipher, path=["response"]) assert cast(Any, response.is_closed) is True @@ -69,7 +69,7 @@ def test_method_get(self, client: Cloudflare) -> None: cipher = client.zones.settings.ciphers.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingCiphers], cipher, path=["response"]) + assert_matches_type(Optional[Ciphers], cipher, path=["response"]) @pytest.mark.skip() @parametrize @@ -81,7 +81,7 @@ def test_raw_response_get(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" cipher = response.parse() - assert_matches_type(Optional[ZoneSettingCiphers], cipher, path=["response"]) + assert_matches_type(Optional[Ciphers], cipher, path=["response"]) @pytest.mark.skip() @parametrize @@ -93,7 +93,7 @@ def test_streaming_response_get(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" cipher = response.parse() - assert_matches_type(Optional[ZoneSettingCiphers], cipher, path=["response"]) + assert_matches_type(Optional[Ciphers], cipher, path=["response"]) assert cast(Any, response.is_closed) is True @@ -116,7 +116,7 @@ async def test_method_edit(self, async_client: AsyncCloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value=["ECDHE-RSA-AES128-GCM-SHA256", "AES128-SHA"], ) - assert_matches_type(Optional[ZoneSettingCiphers], cipher, path=["response"]) + assert_matches_type(Optional[Ciphers], cipher, path=["response"]) @pytest.mark.skip() @parametrize @@ -129,7 +129,7 @@ async def test_raw_response_edit(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" cipher = await response.parse() - assert_matches_type(Optional[ZoneSettingCiphers], cipher, path=["response"]) + assert_matches_type(Optional[Ciphers], cipher, path=["response"]) @pytest.mark.skip() @parametrize @@ -142,7 +142,7 @@ async def test_streaming_response_edit(self, async_client: AsyncCloudflare) -> N assert response.http_request.headers.get("X-Stainless-Lang") == "python" cipher = await response.parse() - assert_matches_type(Optional[ZoneSettingCiphers], cipher, path=["response"]) + assert_matches_type(Optional[Ciphers], cipher, path=["response"]) assert cast(Any, response.is_closed) is True @@ -161,7 +161,7 @@ async def test_method_get(self, async_client: AsyncCloudflare) -> None: cipher = await async_client.zones.settings.ciphers.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingCiphers], cipher, path=["response"]) + assert_matches_type(Optional[Ciphers], cipher, path=["response"]) @pytest.mark.skip() @parametrize @@ -173,7 +173,7 @@ async def test_raw_response_get(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" cipher = await response.parse() - assert_matches_type(Optional[ZoneSettingCiphers], cipher, path=["response"]) + assert_matches_type(Optional[Ciphers], cipher, path=["response"]) @pytest.mark.skip() @parametrize @@ -185,7 +185,7 @@ async def test_streaming_response_get(self, async_client: AsyncCloudflare) -> No assert response.http_request.headers.get("X-Stainless-Lang") == "python" cipher = await response.parse() - assert_matches_type(Optional[ZoneSettingCiphers], cipher, path=["response"]) + assert_matches_type(Optional[Ciphers], cipher, path=["response"]) assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/zones/settings/test_development_mode.py b/tests/api_resources/zones/settings/test_development_mode.py index da544ae4902d..3255e5c314b9 100644 --- a/tests/api_resources/zones/settings/test_development_mode.py +++ b/tests/api_resources/zones/settings/test_development_mode.py @@ -9,7 +9,7 @@ from cloudflare import Cloudflare, AsyncCloudflare from tests.utils import assert_matches_type -from cloudflare.types.zones.settings import ZoneSettingDevelopmentMode +from cloudflare.types.zones.settings import DevelopmentMode base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -24,7 +24,7 @@ def test_method_edit(self, client: Cloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="on", ) - assert_matches_type(Optional[ZoneSettingDevelopmentMode], development_mode, path=["response"]) + assert_matches_type(Optional[DevelopmentMode], development_mode, path=["response"]) @pytest.mark.skip() @parametrize @@ -37,7 +37,7 @@ def test_raw_response_edit(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" development_mode = response.parse() - assert_matches_type(Optional[ZoneSettingDevelopmentMode], development_mode, path=["response"]) + assert_matches_type(Optional[DevelopmentMode], development_mode, path=["response"]) @pytest.mark.skip() @parametrize @@ -50,7 +50,7 @@ def test_streaming_response_edit(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" development_mode = response.parse() - assert_matches_type(Optional[ZoneSettingDevelopmentMode], development_mode, path=["response"]) + assert_matches_type(Optional[DevelopmentMode], development_mode, path=["response"]) assert cast(Any, response.is_closed) is True @@ -69,7 +69,7 @@ def test_method_get(self, client: Cloudflare) -> None: development_mode = client.zones.settings.development_mode.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingDevelopmentMode], development_mode, path=["response"]) + assert_matches_type(Optional[DevelopmentMode], development_mode, path=["response"]) @pytest.mark.skip() @parametrize @@ -81,7 +81,7 @@ def test_raw_response_get(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" development_mode = response.parse() - assert_matches_type(Optional[ZoneSettingDevelopmentMode], development_mode, path=["response"]) + assert_matches_type(Optional[DevelopmentMode], development_mode, path=["response"]) @pytest.mark.skip() @parametrize @@ -93,7 +93,7 @@ def test_streaming_response_get(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" development_mode = response.parse() - assert_matches_type(Optional[ZoneSettingDevelopmentMode], development_mode, path=["response"]) + assert_matches_type(Optional[DevelopmentMode], development_mode, path=["response"]) assert cast(Any, response.is_closed) is True @@ -116,7 +116,7 @@ async def test_method_edit(self, async_client: AsyncCloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="on", ) - assert_matches_type(Optional[ZoneSettingDevelopmentMode], development_mode, path=["response"]) + assert_matches_type(Optional[DevelopmentMode], development_mode, path=["response"]) @pytest.mark.skip() @parametrize @@ -129,7 +129,7 @@ async def test_raw_response_edit(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" development_mode = await response.parse() - assert_matches_type(Optional[ZoneSettingDevelopmentMode], development_mode, path=["response"]) + assert_matches_type(Optional[DevelopmentMode], development_mode, path=["response"]) @pytest.mark.skip() @parametrize @@ -142,7 +142,7 @@ async def test_streaming_response_edit(self, async_client: AsyncCloudflare) -> N assert response.http_request.headers.get("X-Stainless-Lang") == "python" development_mode = await response.parse() - assert_matches_type(Optional[ZoneSettingDevelopmentMode], development_mode, path=["response"]) + assert_matches_type(Optional[DevelopmentMode], development_mode, path=["response"]) assert cast(Any, response.is_closed) is True @@ -161,7 +161,7 @@ async def test_method_get(self, async_client: AsyncCloudflare) -> None: development_mode = await async_client.zones.settings.development_mode.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingDevelopmentMode], development_mode, path=["response"]) + assert_matches_type(Optional[DevelopmentMode], development_mode, path=["response"]) @pytest.mark.skip() @parametrize @@ -173,7 +173,7 @@ async def test_raw_response_get(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" development_mode = await response.parse() - assert_matches_type(Optional[ZoneSettingDevelopmentMode], development_mode, path=["response"]) + assert_matches_type(Optional[DevelopmentMode], development_mode, path=["response"]) @pytest.mark.skip() @parametrize @@ -185,7 +185,7 @@ async def test_streaming_response_get(self, async_client: AsyncCloudflare) -> No assert response.http_request.headers.get("X-Stainless-Lang") == "python" development_mode = await response.parse() - assert_matches_type(Optional[ZoneSettingDevelopmentMode], development_mode, path=["response"]) + assert_matches_type(Optional[DevelopmentMode], development_mode, path=["response"]) assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/zones/settings/test_early_hints.py b/tests/api_resources/zones/settings/test_early_hints.py index 22f8fc291c68..201428cdcc31 100644 --- a/tests/api_resources/zones/settings/test_early_hints.py +++ b/tests/api_resources/zones/settings/test_early_hints.py @@ -9,7 +9,7 @@ from cloudflare import Cloudflare, AsyncCloudflare from tests.utils import assert_matches_type -from cloudflare.types.zones.settings import ZoneSettingEarlyHints +from cloudflare.types.zones.settings import EarlyHints base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -24,7 +24,7 @@ def test_method_edit(self, client: Cloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="on", ) - assert_matches_type(Optional[ZoneSettingEarlyHints], early_hint, path=["response"]) + assert_matches_type(Optional[EarlyHints], early_hint, path=["response"]) @pytest.mark.skip() @parametrize @@ -37,7 +37,7 @@ def test_raw_response_edit(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" early_hint = response.parse() - assert_matches_type(Optional[ZoneSettingEarlyHints], early_hint, path=["response"]) + assert_matches_type(Optional[EarlyHints], early_hint, path=["response"]) @pytest.mark.skip() @parametrize @@ -50,7 +50,7 @@ def test_streaming_response_edit(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" early_hint = response.parse() - assert_matches_type(Optional[ZoneSettingEarlyHints], early_hint, path=["response"]) + assert_matches_type(Optional[EarlyHints], early_hint, path=["response"]) assert cast(Any, response.is_closed) is True @@ -69,7 +69,7 @@ def test_method_get(self, client: Cloudflare) -> None: early_hint = client.zones.settings.early_hints.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingEarlyHints], early_hint, path=["response"]) + assert_matches_type(Optional[EarlyHints], early_hint, path=["response"]) @pytest.mark.skip() @parametrize @@ -81,7 +81,7 @@ def test_raw_response_get(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" early_hint = response.parse() - assert_matches_type(Optional[ZoneSettingEarlyHints], early_hint, path=["response"]) + assert_matches_type(Optional[EarlyHints], early_hint, path=["response"]) @pytest.mark.skip() @parametrize @@ -93,7 +93,7 @@ def test_streaming_response_get(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" early_hint = response.parse() - assert_matches_type(Optional[ZoneSettingEarlyHints], early_hint, path=["response"]) + assert_matches_type(Optional[EarlyHints], early_hint, path=["response"]) assert cast(Any, response.is_closed) is True @@ -116,7 +116,7 @@ async def test_method_edit(self, async_client: AsyncCloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="on", ) - assert_matches_type(Optional[ZoneSettingEarlyHints], early_hint, path=["response"]) + assert_matches_type(Optional[EarlyHints], early_hint, path=["response"]) @pytest.mark.skip() @parametrize @@ -129,7 +129,7 @@ async def test_raw_response_edit(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" early_hint = await response.parse() - assert_matches_type(Optional[ZoneSettingEarlyHints], early_hint, path=["response"]) + assert_matches_type(Optional[EarlyHints], early_hint, path=["response"]) @pytest.mark.skip() @parametrize @@ -142,7 +142,7 @@ async def test_streaming_response_edit(self, async_client: AsyncCloudflare) -> N assert response.http_request.headers.get("X-Stainless-Lang") == "python" early_hint = await response.parse() - assert_matches_type(Optional[ZoneSettingEarlyHints], early_hint, path=["response"]) + assert_matches_type(Optional[EarlyHints], early_hint, path=["response"]) assert cast(Any, response.is_closed) is True @@ -161,7 +161,7 @@ async def test_method_get(self, async_client: AsyncCloudflare) -> None: early_hint = await async_client.zones.settings.early_hints.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingEarlyHints], early_hint, path=["response"]) + assert_matches_type(Optional[EarlyHints], early_hint, path=["response"]) @pytest.mark.skip() @parametrize @@ -173,7 +173,7 @@ async def test_raw_response_get(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" early_hint = await response.parse() - assert_matches_type(Optional[ZoneSettingEarlyHints], early_hint, path=["response"]) + assert_matches_type(Optional[EarlyHints], early_hint, path=["response"]) @pytest.mark.skip() @parametrize @@ -185,7 +185,7 @@ async def test_streaming_response_get(self, async_client: AsyncCloudflare) -> No assert response.http_request.headers.get("X-Stainless-Lang") == "python" early_hint = await response.parse() - assert_matches_type(Optional[ZoneSettingEarlyHints], early_hint, path=["response"]) + assert_matches_type(Optional[EarlyHints], early_hint, path=["response"]) assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/zones/settings/test_email_obfuscation.py b/tests/api_resources/zones/settings/test_email_obfuscation.py index 21e99a91238e..da0b23d3c3f0 100644 --- a/tests/api_resources/zones/settings/test_email_obfuscation.py +++ b/tests/api_resources/zones/settings/test_email_obfuscation.py @@ -9,7 +9,7 @@ from cloudflare import Cloudflare, AsyncCloudflare from tests.utils import assert_matches_type -from cloudflare.types.zones.settings import ZoneSettingEmailObfuscation +from cloudflare.types.zones.settings import EmailObfuscation base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -24,7 +24,7 @@ def test_method_edit(self, client: Cloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="on", ) - assert_matches_type(Optional[ZoneSettingEmailObfuscation], email_obfuscation, path=["response"]) + assert_matches_type(Optional[EmailObfuscation], email_obfuscation, path=["response"]) @pytest.mark.skip() @parametrize @@ -37,7 +37,7 @@ def test_raw_response_edit(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" email_obfuscation = response.parse() - assert_matches_type(Optional[ZoneSettingEmailObfuscation], email_obfuscation, path=["response"]) + assert_matches_type(Optional[EmailObfuscation], email_obfuscation, path=["response"]) @pytest.mark.skip() @parametrize @@ -50,7 +50,7 @@ def test_streaming_response_edit(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" email_obfuscation = response.parse() - assert_matches_type(Optional[ZoneSettingEmailObfuscation], email_obfuscation, path=["response"]) + assert_matches_type(Optional[EmailObfuscation], email_obfuscation, path=["response"]) assert cast(Any, response.is_closed) is True @@ -69,7 +69,7 @@ def test_method_get(self, client: Cloudflare) -> None: email_obfuscation = client.zones.settings.email_obfuscation.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingEmailObfuscation], email_obfuscation, path=["response"]) + assert_matches_type(Optional[EmailObfuscation], email_obfuscation, path=["response"]) @pytest.mark.skip() @parametrize @@ -81,7 +81,7 @@ def test_raw_response_get(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" email_obfuscation = response.parse() - assert_matches_type(Optional[ZoneSettingEmailObfuscation], email_obfuscation, path=["response"]) + assert_matches_type(Optional[EmailObfuscation], email_obfuscation, path=["response"]) @pytest.mark.skip() @parametrize @@ -93,7 +93,7 @@ def test_streaming_response_get(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" email_obfuscation = response.parse() - assert_matches_type(Optional[ZoneSettingEmailObfuscation], email_obfuscation, path=["response"]) + assert_matches_type(Optional[EmailObfuscation], email_obfuscation, path=["response"]) assert cast(Any, response.is_closed) is True @@ -116,7 +116,7 @@ async def test_method_edit(self, async_client: AsyncCloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="on", ) - assert_matches_type(Optional[ZoneSettingEmailObfuscation], email_obfuscation, path=["response"]) + assert_matches_type(Optional[EmailObfuscation], email_obfuscation, path=["response"]) @pytest.mark.skip() @parametrize @@ -129,7 +129,7 @@ async def test_raw_response_edit(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" email_obfuscation = await response.parse() - assert_matches_type(Optional[ZoneSettingEmailObfuscation], email_obfuscation, path=["response"]) + assert_matches_type(Optional[EmailObfuscation], email_obfuscation, path=["response"]) @pytest.mark.skip() @parametrize @@ -142,7 +142,7 @@ async def test_streaming_response_edit(self, async_client: AsyncCloudflare) -> N assert response.http_request.headers.get("X-Stainless-Lang") == "python" email_obfuscation = await response.parse() - assert_matches_type(Optional[ZoneSettingEmailObfuscation], email_obfuscation, path=["response"]) + assert_matches_type(Optional[EmailObfuscation], email_obfuscation, path=["response"]) assert cast(Any, response.is_closed) is True @@ -161,7 +161,7 @@ async def test_method_get(self, async_client: AsyncCloudflare) -> None: email_obfuscation = await async_client.zones.settings.email_obfuscation.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingEmailObfuscation], email_obfuscation, path=["response"]) + assert_matches_type(Optional[EmailObfuscation], email_obfuscation, path=["response"]) @pytest.mark.skip() @parametrize @@ -173,7 +173,7 @@ async def test_raw_response_get(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" email_obfuscation = await response.parse() - assert_matches_type(Optional[ZoneSettingEmailObfuscation], email_obfuscation, path=["response"]) + assert_matches_type(Optional[EmailObfuscation], email_obfuscation, path=["response"]) @pytest.mark.skip() @parametrize @@ -185,7 +185,7 @@ async def test_streaming_response_get(self, async_client: AsyncCloudflare) -> No assert response.http_request.headers.get("X-Stainless-Lang") == "python" email_obfuscation = await response.parse() - assert_matches_type(Optional[ZoneSettingEmailObfuscation], email_obfuscation, path=["response"]) + assert_matches_type(Optional[EmailObfuscation], email_obfuscation, path=["response"]) assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/zones/settings/test_font_settings.py b/tests/api_resources/zones/settings/test_font_settings.py index a67a18b82819..962ef1d1ef26 100644 --- a/tests/api_resources/zones/settings/test_font_settings.py +++ b/tests/api_resources/zones/settings/test_font_settings.py @@ -9,7 +9,7 @@ from cloudflare import Cloudflare, AsyncCloudflare from tests.utils import assert_matches_type -from cloudflare.types.zones.settings import ZoneSettingFonts +from cloudflare.types.zones.settings import FontSettings base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -24,7 +24,7 @@ def test_method_edit(self, client: Cloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="on", ) - assert_matches_type(Optional[ZoneSettingFonts], font_setting, path=["response"]) + assert_matches_type(Optional[FontSettings], font_setting, path=["response"]) @pytest.mark.skip() @parametrize @@ -37,7 +37,7 @@ def test_raw_response_edit(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" font_setting = response.parse() - assert_matches_type(Optional[ZoneSettingFonts], font_setting, path=["response"]) + assert_matches_type(Optional[FontSettings], font_setting, path=["response"]) @pytest.mark.skip() @parametrize @@ -50,7 +50,7 @@ def test_streaming_response_edit(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" font_setting = response.parse() - assert_matches_type(Optional[ZoneSettingFonts], font_setting, path=["response"]) + assert_matches_type(Optional[FontSettings], font_setting, path=["response"]) assert cast(Any, response.is_closed) is True @@ -69,7 +69,7 @@ def test_method_get(self, client: Cloudflare) -> None: font_setting = client.zones.settings.font_settings.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingFonts], font_setting, path=["response"]) + assert_matches_type(Optional[FontSettings], font_setting, path=["response"]) @pytest.mark.skip() @parametrize @@ -81,7 +81,7 @@ def test_raw_response_get(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" font_setting = response.parse() - assert_matches_type(Optional[ZoneSettingFonts], font_setting, path=["response"]) + assert_matches_type(Optional[FontSettings], font_setting, path=["response"]) @pytest.mark.skip() @parametrize @@ -93,7 +93,7 @@ def test_streaming_response_get(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" font_setting = response.parse() - assert_matches_type(Optional[ZoneSettingFonts], font_setting, path=["response"]) + assert_matches_type(Optional[FontSettings], font_setting, path=["response"]) assert cast(Any, response.is_closed) is True @@ -116,7 +116,7 @@ async def test_method_edit(self, async_client: AsyncCloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="on", ) - assert_matches_type(Optional[ZoneSettingFonts], font_setting, path=["response"]) + assert_matches_type(Optional[FontSettings], font_setting, path=["response"]) @pytest.mark.skip() @parametrize @@ -129,7 +129,7 @@ async def test_raw_response_edit(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" font_setting = await response.parse() - assert_matches_type(Optional[ZoneSettingFonts], font_setting, path=["response"]) + assert_matches_type(Optional[FontSettings], font_setting, path=["response"]) @pytest.mark.skip() @parametrize @@ -142,7 +142,7 @@ async def test_streaming_response_edit(self, async_client: AsyncCloudflare) -> N assert response.http_request.headers.get("X-Stainless-Lang") == "python" font_setting = await response.parse() - assert_matches_type(Optional[ZoneSettingFonts], font_setting, path=["response"]) + assert_matches_type(Optional[FontSettings], font_setting, path=["response"]) assert cast(Any, response.is_closed) is True @@ -161,7 +161,7 @@ async def test_method_get(self, async_client: AsyncCloudflare) -> None: font_setting = await async_client.zones.settings.font_settings.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingFonts], font_setting, path=["response"]) + assert_matches_type(Optional[FontSettings], font_setting, path=["response"]) @pytest.mark.skip() @parametrize @@ -173,7 +173,7 @@ async def test_raw_response_get(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" font_setting = await response.parse() - assert_matches_type(Optional[ZoneSettingFonts], font_setting, path=["response"]) + assert_matches_type(Optional[FontSettings], font_setting, path=["response"]) @pytest.mark.skip() @parametrize @@ -185,7 +185,7 @@ async def test_streaming_response_get(self, async_client: AsyncCloudflare) -> No assert response.http_request.headers.get("X-Stainless-Lang") == "python" font_setting = await response.parse() - assert_matches_type(Optional[ZoneSettingFonts], font_setting, path=["response"]) + assert_matches_type(Optional[FontSettings], font_setting, path=["response"]) assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/zones/settings/test_h2_prioritization.py b/tests/api_resources/zones/settings/test_h2_prioritization.py index b6d774deea13..ec70ca9633e2 100644 --- a/tests/api_resources/zones/settings/test_h2_prioritization.py +++ b/tests/api_resources/zones/settings/test_h2_prioritization.py @@ -9,7 +9,7 @@ from cloudflare import Cloudflare, AsyncCloudflare from tests.utils import assert_matches_type -from cloudflare.types.zones.settings import ZoneSettingH2Prioritization +from cloudflare.types.zones.settings import H2Prioritization base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -27,7 +27,7 @@ def test_method_edit(self, client: Cloudflare) -> None: "value": "on", }, ) - assert_matches_type(Optional[ZoneSettingH2Prioritization], h2_prioritization, path=["response"]) + assert_matches_type(Optional[H2Prioritization], h2_prioritization, path=["response"]) @pytest.mark.skip() @parametrize @@ -39,7 +39,7 @@ def test_method_edit_with_all_params(self, client: Cloudflare) -> None: "value": "on", }, ) - assert_matches_type(Optional[ZoneSettingH2Prioritization], h2_prioritization, path=["response"]) + assert_matches_type(Optional[H2Prioritization], h2_prioritization, path=["response"]) @pytest.mark.skip() @parametrize @@ -55,7 +55,7 @@ def test_raw_response_edit(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" h2_prioritization = response.parse() - assert_matches_type(Optional[ZoneSettingH2Prioritization], h2_prioritization, path=["response"]) + assert_matches_type(Optional[H2Prioritization], h2_prioritization, path=["response"]) @pytest.mark.skip() @parametrize @@ -71,7 +71,7 @@ def test_streaming_response_edit(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" h2_prioritization = response.parse() - assert_matches_type(Optional[ZoneSettingH2Prioritization], h2_prioritization, path=["response"]) + assert_matches_type(Optional[H2Prioritization], h2_prioritization, path=["response"]) assert cast(Any, response.is_closed) is True @@ -93,7 +93,7 @@ def test_method_get(self, client: Cloudflare) -> None: h2_prioritization = client.zones.settings.h2_prioritization.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingH2Prioritization], h2_prioritization, path=["response"]) + assert_matches_type(Optional[H2Prioritization], h2_prioritization, path=["response"]) @pytest.mark.skip() @parametrize @@ -105,7 +105,7 @@ def test_raw_response_get(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" h2_prioritization = response.parse() - assert_matches_type(Optional[ZoneSettingH2Prioritization], h2_prioritization, path=["response"]) + assert_matches_type(Optional[H2Prioritization], h2_prioritization, path=["response"]) @pytest.mark.skip() @parametrize @@ -117,7 +117,7 @@ def test_streaming_response_get(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" h2_prioritization = response.parse() - assert_matches_type(Optional[ZoneSettingH2Prioritization], h2_prioritization, path=["response"]) + assert_matches_type(Optional[H2Prioritization], h2_prioritization, path=["response"]) assert cast(Any, response.is_closed) is True @@ -143,7 +143,7 @@ async def test_method_edit(self, async_client: AsyncCloudflare) -> None: "value": "on", }, ) - assert_matches_type(Optional[ZoneSettingH2Prioritization], h2_prioritization, path=["response"]) + assert_matches_type(Optional[H2Prioritization], h2_prioritization, path=["response"]) @pytest.mark.skip() @parametrize @@ -155,7 +155,7 @@ async def test_method_edit_with_all_params(self, async_client: AsyncCloudflare) "value": "on", }, ) - assert_matches_type(Optional[ZoneSettingH2Prioritization], h2_prioritization, path=["response"]) + assert_matches_type(Optional[H2Prioritization], h2_prioritization, path=["response"]) @pytest.mark.skip() @parametrize @@ -171,7 +171,7 @@ async def test_raw_response_edit(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" h2_prioritization = await response.parse() - assert_matches_type(Optional[ZoneSettingH2Prioritization], h2_prioritization, path=["response"]) + assert_matches_type(Optional[H2Prioritization], h2_prioritization, path=["response"]) @pytest.mark.skip() @parametrize @@ -187,7 +187,7 @@ async def test_streaming_response_edit(self, async_client: AsyncCloudflare) -> N assert response.http_request.headers.get("X-Stainless-Lang") == "python" h2_prioritization = await response.parse() - assert_matches_type(Optional[ZoneSettingH2Prioritization], h2_prioritization, path=["response"]) + assert_matches_type(Optional[H2Prioritization], h2_prioritization, path=["response"]) assert cast(Any, response.is_closed) is True @@ -209,7 +209,7 @@ async def test_method_get(self, async_client: AsyncCloudflare) -> None: h2_prioritization = await async_client.zones.settings.h2_prioritization.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingH2Prioritization], h2_prioritization, path=["response"]) + assert_matches_type(Optional[H2Prioritization], h2_prioritization, path=["response"]) @pytest.mark.skip() @parametrize @@ -221,7 +221,7 @@ async def test_raw_response_get(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" h2_prioritization = await response.parse() - assert_matches_type(Optional[ZoneSettingH2Prioritization], h2_prioritization, path=["response"]) + assert_matches_type(Optional[H2Prioritization], h2_prioritization, path=["response"]) @pytest.mark.skip() @parametrize @@ -233,7 +233,7 @@ async def test_streaming_response_get(self, async_client: AsyncCloudflare) -> No assert response.http_request.headers.get("X-Stainless-Lang") == "python" h2_prioritization = await response.parse() - assert_matches_type(Optional[ZoneSettingH2Prioritization], h2_prioritization, path=["response"]) + assert_matches_type(Optional[H2Prioritization], h2_prioritization, path=["response"]) assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/zones/settings/test_hotlink_protection.py b/tests/api_resources/zones/settings/test_hotlink_protection.py index 8373f4e3e143..59aafb76c7c1 100644 --- a/tests/api_resources/zones/settings/test_hotlink_protection.py +++ b/tests/api_resources/zones/settings/test_hotlink_protection.py @@ -9,7 +9,7 @@ from cloudflare import Cloudflare, AsyncCloudflare from tests.utils import assert_matches_type -from cloudflare.types.zones.settings import ZoneSettingHotlinkProtection +from cloudflare.types.zones.settings import HotlinkProtection base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -24,7 +24,7 @@ def test_method_edit(self, client: Cloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="on", ) - assert_matches_type(Optional[ZoneSettingHotlinkProtection], hotlink_protection, path=["response"]) + assert_matches_type(Optional[HotlinkProtection], hotlink_protection, path=["response"]) @pytest.mark.skip() @parametrize @@ -37,7 +37,7 @@ def test_raw_response_edit(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" hotlink_protection = response.parse() - assert_matches_type(Optional[ZoneSettingHotlinkProtection], hotlink_protection, path=["response"]) + assert_matches_type(Optional[HotlinkProtection], hotlink_protection, path=["response"]) @pytest.mark.skip() @parametrize @@ -50,7 +50,7 @@ def test_streaming_response_edit(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" hotlink_protection = response.parse() - assert_matches_type(Optional[ZoneSettingHotlinkProtection], hotlink_protection, path=["response"]) + assert_matches_type(Optional[HotlinkProtection], hotlink_protection, path=["response"]) assert cast(Any, response.is_closed) is True @@ -69,7 +69,7 @@ def test_method_get(self, client: Cloudflare) -> None: hotlink_protection = client.zones.settings.hotlink_protection.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingHotlinkProtection], hotlink_protection, path=["response"]) + assert_matches_type(Optional[HotlinkProtection], hotlink_protection, path=["response"]) @pytest.mark.skip() @parametrize @@ -81,7 +81,7 @@ def test_raw_response_get(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" hotlink_protection = response.parse() - assert_matches_type(Optional[ZoneSettingHotlinkProtection], hotlink_protection, path=["response"]) + assert_matches_type(Optional[HotlinkProtection], hotlink_protection, path=["response"]) @pytest.mark.skip() @parametrize @@ -93,7 +93,7 @@ def test_streaming_response_get(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" hotlink_protection = response.parse() - assert_matches_type(Optional[ZoneSettingHotlinkProtection], hotlink_protection, path=["response"]) + assert_matches_type(Optional[HotlinkProtection], hotlink_protection, path=["response"]) assert cast(Any, response.is_closed) is True @@ -116,7 +116,7 @@ async def test_method_edit(self, async_client: AsyncCloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="on", ) - assert_matches_type(Optional[ZoneSettingHotlinkProtection], hotlink_protection, path=["response"]) + assert_matches_type(Optional[HotlinkProtection], hotlink_protection, path=["response"]) @pytest.mark.skip() @parametrize @@ -129,7 +129,7 @@ async def test_raw_response_edit(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" hotlink_protection = await response.parse() - assert_matches_type(Optional[ZoneSettingHotlinkProtection], hotlink_protection, path=["response"]) + assert_matches_type(Optional[HotlinkProtection], hotlink_protection, path=["response"]) @pytest.mark.skip() @parametrize @@ -142,7 +142,7 @@ async def test_streaming_response_edit(self, async_client: AsyncCloudflare) -> N assert response.http_request.headers.get("X-Stainless-Lang") == "python" hotlink_protection = await response.parse() - assert_matches_type(Optional[ZoneSettingHotlinkProtection], hotlink_protection, path=["response"]) + assert_matches_type(Optional[HotlinkProtection], hotlink_protection, path=["response"]) assert cast(Any, response.is_closed) is True @@ -161,7 +161,7 @@ async def test_method_get(self, async_client: AsyncCloudflare) -> None: hotlink_protection = await async_client.zones.settings.hotlink_protection.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingHotlinkProtection], hotlink_protection, path=["response"]) + assert_matches_type(Optional[HotlinkProtection], hotlink_protection, path=["response"]) @pytest.mark.skip() @parametrize @@ -173,7 +173,7 @@ async def test_raw_response_get(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" hotlink_protection = await response.parse() - assert_matches_type(Optional[ZoneSettingHotlinkProtection], hotlink_protection, path=["response"]) + assert_matches_type(Optional[HotlinkProtection], hotlink_protection, path=["response"]) @pytest.mark.skip() @parametrize @@ -185,7 +185,7 @@ async def test_streaming_response_get(self, async_client: AsyncCloudflare) -> No assert response.http_request.headers.get("X-Stainless-Lang") == "python" hotlink_protection = await response.parse() - assert_matches_type(Optional[ZoneSettingHotlinkProtection], hotlink_protection, path=["response"]) + assert_matches_type(Optional[HotlinkProtection], hotlink_protection, path=["response"]) assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/zones/settings/test_http2.py b/tests/api_resources/zones/settings/test_http2.py index d4158ff76dba..6a0f922bd206 100644 --- a/tests/api_resources/zones/settings/test_http2.py +++ b/tests/api_resources/zones/settings/test_http2.py @@ -9,7 +9,7 @@ from cloudflare import Cloudflare, AsyncCloudflare from tests.utils import assert_matches_type -from cloudflare.types.zones.settings import ZoneSettingHTTP2 +from cloudflare.types.zones.settings import HTTP2 base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -24,7 +24,7 @@ def test_method_edit(self, client: Cloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="on", ) - assert_matches_type(Optional[ZoneSettingHTTP2], http2, path=["response"]) + assert_matches_type(Optional[HTTP2], http2, path=["response"]) @pytest.mark.skip() @parametrize @@ -37,7 +37,7 @@ def test_raw_response_edit(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" http2 = response.parse() - assert_matches_type(Optional[ZoneSettingHTTP2], http2, path=["response"]) + assert_matches_type(Optional[HTTP2], http2, path=["response"]) @pytest.mark.skip() @parametrize @@ -50,7 +50,7 @@ def test_streaming_response_edit(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" http2 = response.parse() - assert_matches_type(Optional[ZoneSettingHTTP2], http2, path=["response"]) + assert_matches_type(Optional[HTTP2], http2, path=["response"]) assert cast(Any, response.is_closed) is True @@ -69,7 +69,7 @@ def test_method_get(self, client: Cloudflare) -> None: http2 = client.zones.settings.http2.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingHTTP2], http2, path=["response"]) + assert_matches_type(Optional[HTTP2], http2, path=["response"]) @pytest.mark.skip() @parametrize @@ -81,7 +81,7 @@ def test_raw_response_get(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" http2 = response.parse() - assert_matches_type(Optional[ZoneSettingHTTP2], http2, path=["response"]) + assert_matches_type(Optional[HTTP2], http2, path=["response"]) @pytest.mark.skip() @parametrize @@ -93,7 +93,7 @@ def test_streaming_response_get(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" http2 = response.parse() - assert_matches_type(Optional[ZoneSettingHTTP2], http2, path=["response"]) + assert_matches_type(Optional[HTTP2], http2, path=["response"]) assert cast(Any, response.is_closed) is True @@ -116,7 +116,7 @@ async def test_method_edit(self, async_client: AsyncCloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="on", ) - assert_matches_type(Optional[ZoneSettingHTTP2], http2, path=["response"]) + assert_matches_type(Optional[HTTP2], http2, path=["response"]) @pytest.mark.skip() @parametrize @@ -129,7 +129,7 @@ async def test_raw_response_edit(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" http2 = await response.parse() - assert_matches_type(Optional[ZoneSettingHTTP2], http2, path=["response"]) + assert_matches_type(Optional[HTTP2], http2, path=["response"]) @pytest.mark.skip() @parametrize @@ -142,7 +142,7 @@ async def test_streaming_response_edit(self, async_client: AsyncCloudflare) -> N assert response.http_request.headers.get("X-Stainless-Lang") == "python" http2 = await response.parse() - assert_matches_type(Optional[ZoneSettingHTTP2], http2, path=["response"]) + assert_matches_type(Optional[HTTP2], http2, path=["response"]) assert cast(Any, response.is_closed) is True @@ -161,7 +161,7 @@ async def test_method_get(self, async_client: AsyncCloudflare) -> None: http2 = await async_client.zones.settings.http2.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingHTTP2], http2, path=["response"]) + assert_matches_type(Optional[HTTP2], http2, path=["response"]) @pytest.mark.skip() @parametrize @@ -173,7 +173,7 @@ async def test_raw_response_get(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" http2 = await response.parse() - assert_matches_type(Optional[ZoneSettingHTTP2], http2, path=["response"]) + assert_matches_type(Optional[HTTP2], http2, path=["response"]) @pytest.mark.skip() @parametrize @@ -185,7 +185,7 @@ async def test_streaming_response_get(self, async_client: AsyncCloudflare) -> No assert response.http_request.headers.get("X-Stainless-Lang") == "python" http2 = await response.parse() - assert_matches_type(Optional[ZoneSettingHTTP2], http2, path=["response"]) + assert_matches_type(Optional[HTTP2], http2, path=["response"]) assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/zones/settings/test_http3.py b/tests/api_resources/zones/settings/test_http3.py index 9bf0e153a669..258a55d13659 100644 --- a/tests/api_resources/zones/settings/test_http3.py +++ b/tests/api_resources/zones/settings/test_http3.py @@ -9,7 +9,7 @@ from cloudflare import Cloudflare, AsyncCloudflare from tests.utils import assert_matches_type -from cloudflare.types.zones.settings import ZoneSettingHTTP3 +from cloudflare.types.zones.settings import HTTP3 base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -24,7 +24,7 @@ def test_method_edit(self, client: Cloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="on", ) - assert_matches_type(Optional[ZoneSettingHTTP3], http3, path=["response"]) + assert_matches_type(Optional[HTTP3], http3, path=["response"]) @pytest.mark.skip() @parametrize @@ -37,7 +37,7 @@ def test_raw_response_edit(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" http3 = response.parse() - assert_matches_type(Optional[ZoneSettingHTTP3], http3, path=["response"]) + assert_matches_type(Optional[HTTP3], http3, path=["response"]) @pytest.mark.skip() @parametrize @@ -50,7 +50,7 @@ def test_streaming_response_edit(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" http3 = response.parse() - assert_matches_type(Optional[ZoneSettingHTTP3], http3, path=["response"]) + assert_matches_type(Optional[HTTP3], http3, path=["response"]) assert cast(Any, response.is_closed) is True @@ -69,7 +69,7 @@ def test_method_get(self, client: Cloudflare) -> None: http3 = client.zones.settings.http3.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingHTTP3], http3, path=["response"]) + assert_matches_type(Optional[HTTP3], http3, path=["response"]) @pytest.mark.skip() @parametrize @@ -81,7 +81,7 @@ def test_raw_response_get(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" http3 = response.parse() - assert_matches_type(Optional[ZoneSettingHTTP3], http3, path=["response"]) + assert_matches_type(Optional[HTTP3], http3, path=["response"]) @pytest.mark.skip() @parametrize @@ -93,7 +93,7 @@ def test_streaming_response_get(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" http3 = response.parse() - assert_matches_type(Optional[ZoneSettingHTTP3], http3, path=["response"]) + assert_matches_type(Optional[HTTP3], http3, path=["response"]) assert cast(Any, response.is_closed) is True @@ -116,7 +116,7 @@ async def test_method_edit(self, async_client: AsyncCloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="on", ) - assert_matches_type(Optional[ZoneSettingHTTP3], http3, path=["response"]) + assert_matches_type(Optional[HTTP3], http3, path=["response"]) @pytest.mark.skip() @parametrize @@ -129,7 +129,7 @@ async def test_raw_response_edit(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" http3 = await response.parse() - assert_matches_type(Optional[ZoneSettingHTTP3], http3, path=["response"]) + assert_matches_type(Optional[HTTP3], http3, path=["response"]) @pytest.mark.skip() @parametrize @@ -142,7 +142,7 @@ async def test_streaming_response_edit(self, async_client: AsyncCloudflare) -> N assert response.http_request.headers.get("X-Stainless-Lang") == "python" http3 = await response.parse() - assert_matches_type(Optional[ZoneSettingHTTP3], http3, path=["response"]) + assert_matches_type(Optional[HTTP3], http3, path=["response"]) assert cast(Any, response.is_closed) is True @@ -161,7 +161,7 @@ async def test_method_get(self, async_client: AsyncCloudflare) -> None: http3 = await async_client.zones.settings.http3.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingHTTP3], http3, path=["response"]) + assert_matches_type(Optional[HTTP3], http3, path=["response"]) @pytest.mark.skip() @parametrize @@ -173,7 +173,7 @@ async def test_raw_response_get(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" http3 = await response.parse() - assert_matches_type(Optional[ZoneSettingHTTP3], http3, path=["response"]) + assert_matches_type(Optional[HTTP3], http3, path=["response"]) @pytest.mark.skip() @parametrize @@ -185,7 +185,7 @@ async def test_streaming_response_get(self, async_client: AsyncCloudflare) -> No assert response.http_request.headers.get("X-Stainless-Lang") == "python" http3 = await response.parse() - assert_matches_type(Optional[ZoneSettingHTTP3], http3, path=["response"]) + assert_matches_type(Optional[HTTP3], http3, path=["response"]) assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/zones/settings/test_image_resizing.py b/tests/api_resources/zones/settings/test_image_resizing.py index 14e1f4bdedb9..c87a4190713d 100644 --- a/tests/api_resources/zones/settings/test_image_resizing.py +++ b/tests/api_resources/zones/settings/test_image_resizing.py @@ -9,7 +9,7 @@ from cloudflare import Cloudflare, AsyncCloudflare from tests.utils import assert_matches_type -from cloudflare.types.zones.settings import ZoneSettingImageResizing +from cloudflare.types.zones.settings import ImageResizing base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -27,7 +27,7 @@ def test_method_edit(self, client: Cloudflare) -> None: "value": "on", }, ) - assert_matches_type(Optional[ZoneSettingImageResizing], image_resizing, path=["response"]) + assert_matches_type(Optional[ImageResizing], image_resizing, path=["response"]) @pytest.mark.skip() @parametrize @@ -39,7 +39,7 @@ def test_method_edit_with_all_params(self, client: Cloudflare) -> None: "value": "on", }, ) - assert_matches_type(Optional[ZoneSettingImageResizing], image_resizing, path=["response"]) + assert_matches_type(Optional[ImageResizing], image_resizing, path=["response"]) @pytest.mark.skip() @parametrize @@ -55,7 +55,7 @@ def test_raw_response_edit(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" image_resizing = response.parse() - assert_matches_type(Optional[ZoneSettingImageResizing], image_resizing, path=["response"]) + assert_matches_type(Optional[ImageResizing], image_resizing, path=["response"]) @pytest.mark.skip() @parametrize @@ -71,7 +71,7 @@ def test_streaming_response_edit(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" image_resizing = response.parse() - assert_matches_type(Optional[ZoneSettingImageResizing], image_resizing, path=["response"]) + assert_matches_type(Optional[ImageResizing], image_resizing, path=["response"]) assert cast(Any, response.is_closed) is True @@ -93,7 +93,7 @@ def test_method_get(self, client: Cloudflare) -> None: image_resizing = client.zones.settings.image_resizing.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingImageResizing], image_resizing, path=["response"]) + assert_matches_type(Optional[ImageResizing], image_resizing, path=["response"]) @pytest.mark.skip() @parametrize @@ -105,7 +105,7 @@ def test_raw_response_get(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" image_resizing = response.parse() - assert_matches_type(Optional[ZoneSettingImageResizing], image_resizing, path=["response"]) + assert_matches_type(Optional[ImageResizing], image_resizing, path=["response"]) @pytest.mark.skip() @parametrize @@ -117,7 +117,7 @@ def test_streaming_response_get(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" image_resizing = response.parse() - assert_matches_type(Optional[ZoneSettingImageResizing], image_resizing, path=["response"]) + assert_matches_type(Optional[ImageResizing], image_resizing, path=["response"]) assert cast(Any, response.is_closed) is True @@ -143,7 +143,7 @@ async def test_method_edit(self, async_client: AsyncCloudflare) -> None: "value": "on", }, ) - assert_matches_type(Optional[ZoneSettingImageResizing], image_resizing, path=["response"]) + assert_matches_type(Optional[ImageResizing], image_resizing, path=["response"]) @pytest.mark.skip() @parametrize @@ -155,7 +155,7 @@ async def test_method_edit_with_all_params(self, async_client: AsyncCloudflare) "value": "on", }, ) - assert_matches_type(Optional[ZoneSettingImageResizing], image_resizing, path=["response"]) + assert_matches_type(Optional[ImageResizing], image_resizing, path=["response"]) @pytest.mark.skip() @parametrize @@ -171,7 +171,7 @@ async def test_raw_response_edit(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" image_resizing = await response.parse() - assert_matches_type(Optional[ZoneSettingImageResizing], image_resizing, path=["response"]) + assert_matches_type(Optional[ImageResizing], image_resizing, path=["response"]) @pytest.mark.skip() @parametrize @@ -187,7 +187,7 @@ async def test_streaming_response_edit(self, async_client: AsyncCloudflare) -> N assert response.http_request.headers.get("X-Stainless-Lang") == "python" image_resizing = await response.parse() - assert_matches_type(Optional[ZoneSettingImageResizing], image_resizing, path=["response"]) + assert_matches_type(Optional[ImageResizing], image_resizing, path=["response"]) assert cast(Any, response.is_closed) is True @@ -209,7 +209,7 @@ async def test_method_get(self, async_client: AsyncCloudflare) -> None: image_resizing = await async_client.zones.settings.image_resizing.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingImageResizing], image_resizing, path=["response"]) + assert_matches_type(Optional[ImageResizing], image_resizing, path=["response"]) @pytest.mark.skip() @parametrize @@ -221,7 +221,7 @@ async def test_raw_response_get(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" image_resizing = await response.parse() - assert_matches_type(Optional[ZoneSettingImageResizing], image_resizing, path=["response"]) + assert_matches_type(Optional[ImageResizing], image_resizing, path=["response"]) @pytest.mark.skip() @parametrize @@ -233,7 +233,7 @@ async def test_streaming_response_get(self, async_client: AsyncCloudflare) -> No assert response.http_request.headers.get("X-Stainless-Lang") == "python" image_resizing = await response.parse() - assert_matches_type(Optional[ZoneSettingImageResizing], image_resizing, path=["response"]) + assert_matches_type(Optional[ImageResizing], image_resizing, path=["response"]) assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/zones/settings/test_ip_geolocation.py b/tests/api_resources/zones/settings/test_ip_geolocation.py index 3bd9a3caadf4..090494ed0848 100644 --- a/tests/api_resources/zones/settings/test_ip_geolocation.py +++ b/tests/api_resources/zones/settings/test_ip_geolocation.py @@ -9,7 +9,7 @@ from cloudflare import Cloudflare, AsyncCloudflare from tests.utils import assert_matches_type -from cloudflare.types.zones.settings import ZoneSettingIPGeolocation +from cloudflare.types.zones.settings import IPGeolocation base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -24,7 +24,7 @@ def test_method_edit(self, client: Cloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="on", ) - assert_matches_type(Optional[ZoneSettingIPGeolocation], ip_geolocation, path=["response"]) + assert_matches_type(Optional[IPGeolocation], ip_geolocation, path=["response"]) @pytest.mark.skip() @parametrize @@ -37,7 +37,7 @@ def test_raw_response_edit(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" ip_geolocation = response.parse() - assert_matches_type(Optional[ZoneSettingIPGeolocation], ip_geolocation, path=["response"]) + assert_matches_type(Optional[IPGeolocation], ip_geolocation, path=["response"]) @pytest.mark.skip() @parametrize @@ -50,7 +50,7 @@ def test_streaming_response_edit(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" ip_geolocation = response.parse() - assert_matches_type(Optional[ZoneSettingIPGeolocation], ip_geolocation, path=["response"]) + assert_matches_type(Optional[IPGeolocation], ip_geolocation, path=["response"]) assert cast(Any, response.is_closed) is True @@ -69,7 +69,7 @@ def test_method_get(self, client: Cloudflare) -> None: ip_geolocation = client.zones.settings.ip_geolocation.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingIPGeolocation], ip_geolocation, path=["response"]) + assert_matches_type(Optional[IPGeolocation], ip_geolocation, path=["response"]) @pytest.mark.skip() @parametrize @@ -81,7 +81,7 @@ def test_raw_response_get(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" ip_geolocation = response.parse() - assert_matches_type(Optional[ZoneSettingIPGeolocation], ip_geolocation, path=["response"]) + assert_matches_type(Optional[IPGeolocation], ip_geolocation, path=["response"]) @pytest.mark.skip() @parametrize @@ -93,7 +93,7 @@ def test_streaming_response_get(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" ip_geolocation = response.parse() - assert_matches_type(Optional[ZoneSettingIPGeolocation], ip_geolocation, path=["response"]) + assert_matches_type(Optional[IPGeolocation], ip_geolocation, path=["response"]) assert cast(Any, response.is_closed) is True @@ -116,7 +116,7 @@ async def test_method_edit(self, async_client: AsyncCloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="on", ) - assert_matches_type(Optional[ZoneSettingIPGeolocation], ip_geolocation, path=["response"]) + assert_matches_type(Optional[IPGeolocation], ip_geolocation, path=["response"]) @pytest.mark.skip() @parametrize @@ -129,7 +129,7 @@ async def test_raw_response_edit(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" ip_geolocation = await response.parse() - assert_matches_type(Optional[ZoneSettingIPGeolocation], ip_geolocation, path=["response"]) + assert_matches_type(Optional[IPGeolocation], ip_geolocation, path=["response"]) @pytest.mark.skip() @parametrize @@ -142,7 +142,7 @@ async def test_streaming_response_edit(self, async_client: AsyncCloudflare) -> N assert response.http_request.headers.get("X-Stainless-Lang") == "python" ip_geolocation = await response.parse() - assert_matches_type(Optional[ZoneSettingIPGeolocation], ip_geolocation, path=["response"]) + assert_matches_type(Optional[IPGeolocation], ip_geolocation, path=["response"]) assert cast(Any, response.is_closed) is True @@ -161,7 +161,7 @@ async def test_method_get(self, async_client: AsyncCloudflare) -> None: ip_geolocation = await async_client.zones.settings.ip_geolocation.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingIPGeolocation], ip_geolocation, path=["response"]) + assert_matches_type(Optional[IPGeolocation], ip_geolocation, path=["response"]) @pytest.mark.skip() @parametrize @@ -173,7 +173,7 @@ async def test_raw_response_get(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" ip_geolocation = await response.parse() - assert_matches_type(Optional[ZoneSettingIPGeolocation], ip_geolocation, path=["response"]) + assert_matches_type(Optional[IPGeolocation], ip_geolocation, path=["response"]) @pytest.mark.skip() @parametrize @@ -185,7 +185,7 @@ async def test_streaming_response_get(self, async_client: AsyncCloudflare) -> No assert response.http_request.headers.get("X-Stainless-Lang") == "python" ip_geolocation = await response.parse() - assert_matches_type(Optional[ZoneSettingIPGeolocation], ip_geolocation, path=["response"]) + assert_matches_type(Optional[IPGeolocation], ip_geolocation, path=["response"]) assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/zones/settings/test_ipv6.py b/tests/api_resources/zones/settings/test_ipv6.py index 7022d02d0580..9e5c0651d2cd 100644 --- a/tests/api_resources/zones/settings/test_ipv6.py +++ b/tests/api_resources/zones/settings/test_ipv6.py @@ -9,7 +9,7 @@ from cloudflare import Cloudflare, AsyncCloudflare from tests.utils import assert_matches_type -from cloudflare.types.zones.settings import ZoneSettingIPV6 +from cloudflare.types.zones.settings import IPV6 base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -24,7 +24,7 @@ def test_method_edit(self, client: Cloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="off", ) - assert_matches_type(Optional[ZoneSettingIPV6], ipv6, path=["response"]) + assert_matches_type(Optional[IPV6], ipv6, path=["response"]) @pytest.mark.skip() @parametrize @@ -37,7 +37,7 @@ def test_raw_response_edit(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" ipv6 = response.parse() - assert_matches_type(Optional[ZoneSettingIPV6], ipv6, path=["response"]) + assert_matches_type(Optional[IPV6], ipv6, path=["response"]) @pytest.mark.skip() @parametrize @@ -50,7 +50,7 @@ def test_streaming_response_edit(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" ipv6 = response.parse() - assert_matches_type(Optional[ZoneSettingIPV6], ipv6, path=["response"]) + assert_matches_type(Optional[IPV6], ipv6, path=["response"]) assert cast(Any, response.is_closed) is True @@ -69,7 +69,7 @@ def test_method_get(self, client: Cloudflare) -> None: ipv6 = client.zones.settings.ipv6.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingIPV6], ipv6, path=["response"]) + assert_matches_type(Optional[IPV6], ipv6, path=["response"]) @pytest.mark.skip() @parametrize @@ -81,7 +81,7 @@ def test_raw_response_get(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" ipv6 = response.parse() - assert_matches_type(Optional[ZoneSettingIPV6], ipv6, path=["response"]) + assert_matches_type(Optional[IPV6], ipv6, path=["response"]) @pytest.mark.skip() @parametrize @@ -93,7 +93,7 @@ def test_streaming_response_get(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" ipv6 = response.parse() - assert_matches_type(Optional[ZoneSettingIPV6], ipv6, path=["response"]) + assert_matches_type(Optional[IPV6], ipv6, path=["response"]) assert cast(Any, response.is_closed) is True @@ -116,7 +116,7 @@ async def test_method_edit(self, async_client: AsyncCloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="off", ) - assert_matches_type(Optional[ZoneSettingIPV6], ipv6, path=["response"]) + assert_matches_type(Optional[IPV6], ipv6, path=["response"]) @pytest.mark.skip() @parametrize @@ -129,7 +129,7 @@ async def test_raw_response_edit(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" ipv6 = await response.parse() - assert_matches_type(Optional[ZoneSettingIPV6], ipv6, path=["response"]) + assert_matches_type(Optional[IPV6], ipv6, path=["response"]) @pytest.mark.skip() @parametrize @@ -142,7 +142,7 @@ async def test_streaming_response_edit(self, async_client: AsyncCloudflare) -> N assert response.http_request.headers.get("X-Stainless-Lang") == "python" ipv6 = await response.parse() - assert_matches_type(Optional[ZoneSettingIPV6], ipv6, path=["response"]) + assert_matches_type(Optional[IPV6], ipv6, path=["response"]) assert cast(Any, response.is_closed) is True @@ -161,7 +161,7 @@ async def test_method_get(self, async_client: AsyncCloudflare) -> None: ipv6 = await async_client.zones.settings.ipv6.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingIPV6], ipv6, path=["response"]) + assert_matches_type(Optional[IPV6], ipv6, path=["response"]) @pytest.mark.skip() @parametrize @@ -173,7 +173,7 @@ async def test_raw_response_get(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" ipv6 = await response.parse() - assert_matches_type(Optional[ZoneSettingIPV6], ipv6, path=["response"]) + assert_matches_type(Optional[IPV6], ipv6, path=["response"]) @pytest.mark.skip() @parametrize @@ -185,7 +185,7 @@ async def test_streaming_response_get(self, async_client: AsyncCloudflare) -> No assert response.http_request.headers.get("X-Stainless-Lang") == "python" ipv6 = await response.parse() - assert_matches_type(Optional[ZoneSettingIPV6], ipv6, path=["response"]) + assert_matches_type(Optional[IPV6], ipv6, path=["response"]) assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/zones/settings/test_min_tls_version.py b/tests/api_resources/zones/settings/test_min_tls_version.py index 77dcffe9737e..e9667e3d696d 100644 --- a/tests/api_resources/zones/settings/test_min_tls_version.py +++ b/tests/api_resources/zones/settings/test_min_tls_version.py @@ -9,7 +9,7 @@ from cloudflare import Cloudflare, AsyncCloudflare from tests.utils import assert_matches_type -from cloudflare.types.zones.settings import ZoneSettingMinTLSVersion +from cloudflare.types.zones.settings import MinTLSVersion base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -24,7 +24,7 @@ def test_method_edit(self, client: Cloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="1.0", ) - assert_matches_type(Optional[ZoneSettingMinTLSVersion], min_tls_version, path=["response"]) + assert_matches_type(Optional[MinTLSVersion], min_tls_version, path=["response"]) @pytest.mark.skip() @parametrize @@ -37,7 +37,7 @@ def test_raw_response_edit(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" min_tls_version = response.parse() - assert_matches_type(Optional[ZoneSettingMinTLSVersion], min_tls_version, path=["response"]) + assert_matches_type(Optional[MinTLSVersion], min_tls_version, path=["response"]) @pytest.mark.skip() @parametrize @@ -50,7 +50,7 @@ def test_streaming_response_edit(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" min_tls_version = response.parse() - assert_matches_type(Optional[ZoneSettingMinTLSVersion], min_tls_version, path=["response"]) + assert_matches_type(Optional[MinTLSVersion], min_tls_version, path=["response"]) assert cast(Any, response.is_closed) is True @@ -69,7 +69,7 @@ def test_method_get(self, client: Cloudflare) -> None: min_tls_version = client.zones.settings.min_tls_version.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingMinTLSVersion], min_tls_version, path=["response"]) + assert_matches_type(Optional[MinTLSVersion], min_tls_version, path=["response"]) @pytest.mark.skip() @parametrize @@ -81,7 +81,7 @@ def test_raw_response_get(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" min_tls_version = response.parse() - assert_matches_type(Optional[ZoneSettingMinTLSVersion], min_tls_version, path=["response"]) + assert_matches_type(Optional[MinTLSVersion], min_tls_version, path=["response"]) @pytest.mark.skip() @parametrize @@ -93,7 +93,7 @@ def test_streaming_response_get(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" min_tls_version = response.parse() - assert_matches_type(Optional[ZoneSettingMinTLSVersion], min_tls_version, path=["response"]) + assert_matches_type(Optional[MinTLSVersion], min_tls_version, path=["response"]) assert cast(Any, response.is_closed) is True @@ -116,7 +116,7 @@ async def test_method_edit(self, async_client: AsyncCloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="1.0", ) - assert_matches_type(Optional[ZoneSettingMinTLSVersion], min_tls_version, path=["response"]) + assert_matches_type(Optional[MinTLSVersion], min_tls_version, path=["response"]) @pytest.mark.skip() @parametrize @@ -129,7 +129,7 @@ async def test_raw_response_edit(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" min_tls_version = await response.parse() - assert_matches_type(Optional[ZoneSettingMinTLSVersion], min_tls_version, path=["response"]) + assert_matches_type(Optional[MinTLSVersion], min_tls_version, path=["response"]) @pytest.mark.skip() @parametrize @@ -142,7 +142,7 @@ async def test_streaming_response_edit(self, async_client: AsyncCloudflare) -> N assert response.http_request.headers.get("X-Stainless-Lang") == "python" min_tls_version = await response.parse() - assert_matches_type(Optional[ZoneSettingMinTLSVersion], min_tls_version, path=["response"]) + assert_matches_type(Optional[MinTLSVersion], min_tls_version, path=["response"]) assert cast(Any, response.is_closed) is True @@ -161,7 +161,7 @@ async def test_method_get(self, async_client: AsyncCloudflare) -> None: min_tls_version = await async_client.zones.settings.min_tls_version.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingMinTLSVersion], min_tls_version, path=["response"]) + assert_matches_type(Optional[MinTLSVersion], min_tls_version, path=["response"]) @pytest.mark.skip() @parametrize @@ -173,7 +173,7 @@ async def test_raw_response_get(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" min_tls_version = await response.parse() - assert_matches_type(Optional[ZoneSettingMinTLSVersion], min_tls_version, path=["response"]) + assert_matches_type(Optional[MinTLSVersion], min_tls_version, path=["response"]) @pytest.mark.skip() @parametrize @@ -185,7 +185,7 @@ async def test_streaming_response_get(self, async_client: AsyncCloudflare) -> No assert response.http_request.headers.get("X-Stainless-Lang") == "python" min_tls_version = await response.parse() - assert_matches_type(Optional[ZoneSettingMinTLSVersion], min_tls_version, path=["response"]) + assert_matches_type(Optional[MinTLSVersion], min_tls_version, path=["response"]) assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/zones/settings/test_minify.py b/tests/api_resources/zones/settings/test_minify.py index ccd289fcaeb2..fbfdffb16a79 100644 --- a/tests/api_resources/zones/settings/test_minify.py +++ b/tests/api_resources/zones/settings/test_minify.py @@ -9,7 +9,7 @@ from cloudflare import Cloudflare, AsyncCloudflare from tests.utils import assert_matches_type -from cloudflare.types.zones.settings import ZoneSettingMinify +from cloudflare.types.zones.settings import Minify base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -24,7 +24,7 @@ def test_method_edit(self, client: Cloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value={}, ) - assert_matches_type(Optional[ZoneSettingMinify], minify, path=["response"]) + assert_matches_type(Optional[Minify], minify, path=["response"]) @pytest.mark.skip() @parametrize @@ -37,7 +37,7 @@ def test_method_edit_with_all_params(self, client: Cloudflare) -> None: "js": "on", }, ) - assert_matches_type(Optional[ZoneSettingMinify], minify, path=["response"]) + assert_matches_type(Optional[Minify], minify, path=["response"]) @pytest.mark.skip() @parametrize @@ -50,7 +50,7 @@ def test_raw_response_edit(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" minify = response.parse() - assert_matches_type(Optional[ZoneSettingMinify], minify, path=["response"]) + assert_matches_type(Optional[Minify], minify, path=["response"]) @pytest.mark.skip() @parametrize @@ -63,7 +63,7 @@ def test_streaming_response_edit(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" minify = response.parse() - assert_matches_type(Optional[ZoneSettingMinify], minify, path=["response"]) + assert_matches_type(Optional[Minify], minify, path=["response"]) assert cast(Any, response.is_closed) is True @@ -82,7 +82,7 @@ def test_method_get(self, client: Cloudflare) -> None: minify = client.zones.settings.minify.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingMinify], minify, path=["response"]) + assert_matches_type(Optional[Minify], minify, path=["response"]) @pytest.mark.skip() @parametrize @@ -94,7 +94,7 @@ def test_raw_response_get(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" minify = response.parse() - assert_matches_type(Optional[ZoneSettingMinify], minify, path=["response"]) + assert_matches_type(Optional[Minify], minify, path=["response"]) @pytest.mark.skip() @parametrize @@ -106,7 +106,7 @@ def test_streaming_response_get(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" minify = response.parse() - assert_matches_type(Optional[ZoneSettingMinify], minify, path=["response"]) + assert_matches_type(Optional[Minify], minify, path=["response"]) assert cast(Any, response.is_closed) is True @@ -129,7 +129,7 @@ async def test_method_edit(self, async_client: AsyncCloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value={}, ) - assert_matches_type(Optional[ZoneSettingMinify], minify, path=["response"]) + assert_matches_type(Optional[Minify], minify, path=["response"]) @pytest.mark.skip() @parametrize @@ -142,7 +142,7 @@ async def test_method_edit_with_all_params(self, async_client: AsyncCloudflare) "js": "on", }, ) - assert_matches_type(Optional[ZoneSettingMinify], minify, path=["response"]) + assert_matches_type(Optional[Minify], minify, path=["response"]) @pytest.mark.skip() @parametrize @@ -155,7 +155,7 @@ async def test_raw_response_edit(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" minify = await response.parse() - assert_matches_type(Optional[ZoneSettingMinify], minify, path=["response"]) + assert_matches_type(Optional[Minify], minify, path=["response"]) @pytest.mark.skip() @parametrize @@ -168,7 +168,7 @@ async def test_streaming_response_edit(self, async_client: AsyncCloudflare) -> N assert response.http_request.headers.get("X-Stainless-Lang") == "python" minify = await response.parse() - assert_matches_type(Optional[ZoneSettingMinify], minify, path=["response"]) + assert_matches_type(Optional[Minify], minify, path=["response"]) assert cast(Any, response.is_closed) is True @@ -187,7 +187,7 @@ async def test_method_get(self, async_client: AsyncCloudflare) -> None: minify = await async_client.zones.settings.minify.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingMinify], minify, path=["response"]) + assert_matches_type(Optional[Minify], minify, path=["response"]) @pytest.mark.skip() @parametrize @@ -199,7 +199,7 @@ async def test_raw_response_get(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" minify = await response.parse() - assert_matches_type(Optional[ZoneSettingMinify], minify, path=["response"]) + assert_matches_type(Optional[Minify], minify, path=["response"]) @pytest.mark.skip() @parametrize @@ -211,7 +211,7 @@ async def test_streaming_response_get(self, async_client: AsyncCloudflare) -> No assert response.http_request.headers.get("X-Stainless-Lang") == "python" minify = await response.parse() - assert_matches_type(Optional[ZoneSettingMinify], minify, path=["response"]) + assert_matches_type(Optional[Minify], minify, path=["response"]) assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/zones/settings/test_mirage.py b/tests/api_resources/zones/settings/test_mirage.py index 26681ffdbefc..54af1256547b 100644 --- a/tests/api_resources/zones/settings/test_mirage.py +++ b/tests/api_resources/zones/settings/test_mirage.py @@ -9,7 +9,7 @@ from cloudflare import Cloudflare, AsyncCloudflare from tests.utils import assert_matches_type -from cloudflare.types.zones.settings import ZoneSettingMirage +from cloudflare.types.zones.settings import Mirage base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -24,7 +24,7 @@ def test_method_edit(self, client: Cloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="on", ) - assert_matches_type(Optional[ZoneSettingMirage], mirage, path=["response"]) + assert_matches_type(Optional[Mirage], mirage, path=["response"]) @pytest.mark.skip() @parametrize @@ -37,7 +37,7 @@ def test_raw_response_edit(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" mirage = response.parse() - assert_matches_type(Optional[ZoneSettingMirage], mirage, path=["response"]) + assert_matches_type(Optional[Mirage], mirage, path=["response"]) @pytest.mark.skip() @parametrize @@ -50,7 +50,7 @@ def test_streaming_response_edit(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" mirage = response.parse() - assert_matches_type(Optional[ZoneSettingMirage], mirage, path=["response"]) + assert_matches_type(Optional[Mirage], mirage, path=["response"]) assert cast(Any, response.is_closed) is True @@ -69,7 +69,7 @@ def test_method_get(self, client: Cloudflare) -> None: mirage = client.zones.settings.mirage.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingMirage], mirage, path=["response"]) + assert_matches_type(Optional[Mirage], mirage, path=["response"]) @pytest.mark.skip() @parametrize @@ -81,7 +81,7 @@ def test_raw_response_get(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" mirage = response.parse() - assert_matches_type(Optional[ZoneSettingMirage], mirage, path=["response"]) + assert_matches_type(Optional[Mirage], mirage, path=["response"]) @pytest.mark.skip() @parametrize @@ -93,7 +93,7 @@ def test_streaming_response_get(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" mirage = response.parse() - assert_matches_type(Optional[ZoneSettingMirage], mirage, path=["response"]) + assert_matches_type(Optional[Mirage], mirage, path=["response"]) assert cast(Any, response.is_closed) is True @@ -116,7 +116,7 @@ async def test_method_edit(self, async_client: AsyncCloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="on", ) - assert_matches_type(Optional[ZoneSettingMirage], mirage, path=["response"]) + assert_matches_type(Optional[Mirage], mirage, path=["response"]) @pytest.mark.skip() @parametrize @@ -129,7 +129,7 @@ async def test_raw_response_edit(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" mirage = await response.parse() - assert_matches_type(Optional[ZoneSettingMirage], mirage, path=["response"]) + assert_matches_type(Optional[Mirage], mirage, path=["response"]) @pytest.mark.skip() @parametrize @@ -142,7 +142,7 @@ async def test_streaming_response_edit(self, async_client: AsyncCloudflare) -> N assert response.http_request.headers.get("X-Stainless-Lang") == "python" mirage = await response.parse() - assert_matches_type(Optional[ZoneSettingMirage], mirage, path=["response"]) + assert_matches_type(Optional[Mirage], mirage, path=["response"]) assert cast(Any, response.is_closed) is True @@ -161,7 +161,7 @@ async def test_method_get(self, async_client: AsyncCloudflare) -> None: mirage = await async_client.zones.settings.mirage.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingMirage], mirage, path=["response"]) + assert_matches_type(Optional[Mirage], mirage, path=["response"]) @pytest.mark.skip() @parametrize @@ -173,7 +173,7 @@ async def test_raw_response_get(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" mirage = await response.parse() - assert_matches_type(Optional[ZoneSettingMirage], mirage, path=["response"]) + assert_matches_type(Optional[Mirage], mirage, path=["response"]) @pytest.mark.skip() @parametrize @@ -185,7 +185,7 @@ async def test_streaming_response_get(self, async_client: AsyncCloudflare) -> No assert response.http_request.headers.get("X-Stainless-Lang") == "python" mirage = await response.parse() - assert_matches_type(Optional[ZoneSettingMirage], mirage, path=["response"]) + assert_matches_type(Optional[Mirage], mirage, path=["response"]) assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/zones/settings/test_mobile_redirect.py b/tests/api_resources/zones/settings/test_mobile_redirect.py index dd3ddd992ac2..da662f3d23ff 100644 --- a/tests/api_resources/zones/settings/test_mobile_redirect.py +++ b/tests/api_resources/zones/settings/test_mobile_redirect.py @@ -9,7 +9,7 @@ from cloudflare import Cloudflare, AsyncCloudflare from tests.utils import assert_matches_type -from cloudflare.types.zones.settings import ZoneSettingMobileRedirect +from cloudflare.types.zones.settings import MobileRedirect base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -24,7 +24,7 @@ def test_method_edit(self, client: Cloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value={}, ) - assert_matches_type(Optional[ZoneSettingMobileRedirect], mobile_redirect, path=["response"]) + assert_matches_type(Optional[MobileRedirect], mobile_redirect, path=["response"]) @pytest.mark.skip() @parametrize @@ -37,7 +37,7 @@ def test_method_edit_with_all_params(self, client: Cloudflare) -> None: "strip_uri": False, }, ) - assert_matches_type(Optional[ZoneSettingMobileRedirect], mobile_redirect, path=["response"]) + assert_matches_type(Optional[MobileRedirect], mobile_redirect, path=["response"]) @pytest.mark.skip() @parametrize @@ -50,7 +50,7 @@ def test_raw_response_edit(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" mobile_redirect = response.parse() - assert_matches_type(Optional[ZoneSettingMobileRedirect], mobile_redirect, path=["response"]) + assert_matches_type(Optional[MobileRedirect], mobile_redirect, path=["response"]) @pytest.mark.skip() @parametrize @@ -63,7 +63,7 @@ def test_streaming_response_edit(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" mobile_redirect = response.parse() - assert_matches_type(Optional[ZoneSettingMobileRedirect], mobile_redirect, path=["response"]) + assert_matches_type(Optional[MobileRedirect], mobile_redirect, path=["response"]) assert cast(Any, response.is_closed) is True @@ -82,7 +82,7 @@ def test_method_get(self, client: Cloudflare) -> None: mobile_redirect = client.zones.settings.mobile_redirect.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingMobileRedirect], mobile_redirect, path=["response"]) + assert_matches_type(Optional[MobileRedirect], mobile_redirect, path=["response"]) @pytest.mark.skip() @parametrize @@ -94,7 +94,7 @@ def test_raw_response_get(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" mobile_redirect = response.parse() - assert_matches_type(Optional[ZoneSettingMobileRedirect], mobile_redirect, path=["response"]) + assert_matches_type(Optional[MobileRedirect], mobile_redirect, path=["response"]) @pytest.mark.skip() @parametrize @@ -106,7 +106,7 @@ def test_streaming_response_get(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" mobile_redirect = response.parse() - assert_matches_type(Optional[ZoneSettingMobileRedirect], mobile_redirect, path=["response"]) + assert_matches_type(Optional[MobileRedirect], mobile_redirect, path=["response"]) assert cast(Any, response.is_closed) is True @@ -129,7 +129,7 @@ async def test_method_edit(self, async_client: AsyncCloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value={}, ) - assert_matches_type(Optional[ZoneSettingMobileRedirect], mobile_redirect, path=["response"]) + assert_matches_type(Optional[MobileRedirect], mobile_redirect, path=["response"]) @pytest.mark.skip() @parametrize @@ -142,7 +142,7 @@ async def test_method_edit_with_all_params(self, async_client: AsyncCloudflare) "strip_uri": False, }, ) - assert_matches_type(Optional[ZoneSettingMobileRedirect], mobile_redirect, path=["response"]) + assert_matches_type(Optional[MobileRedirect], mobile_redirect, path=["response"]) @pytest.mark.skip() @parametrize @@ -155,7 +155,7 @@ async def test_raw_response_edit(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" mobile_redirect = await response.parse() - assert_matches_type(Optional[ZoneSettingMobileRedirect], mobile_redirect, path=["response"]) + assert_matches_type(Optional[MobileRedirect], mobile_redirect, path=["response"]) @pytest.mark.skip() @parametrize @@ -168,7 +168,7 @@ async def test_streaming_response_edit(self, async_client: AsyncCloudflare) -> N assert response.http_request.headers.get("X-Stainless-Lang") == "python" mobile_redirect = await response.parse() - assert_matches_type(Optional[ZoneSettingMobileRedirect], mobile_redirect, path=["response"]) + assert_matches_type(Optional[MobileRedirect], mobile_redirect, path=["response"]) assert cast(Any, response.is_closed) is True @@ -187,7 +187,7 @@ async def test_method_get(self, async_client: AsyncCloudflare) -> None: mobile_redirect = await async_client.zones.settings.mobile_redirect.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingMobileRedirect], mobile_redirect, path=["response"]) + assert_matches_type(Optional[MobileRedirect], mobile_redirect, path=["response"]) @pytest.mark.skip() @parametrize @@ -199,7 +199,7 @@ async def test_raw_response_get(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" mobile_redirect = await response.parse() - assert_matches_type(Optional[ZoneSettingMobileRedirect], mobile_redirect, path=["response"]) + assert_matches_type(Optional[MobileRedirect], mobile_redirect, path=["response"]) @pytest.mark.skip() @parametrize @@ -211,7 +211,7 @@ async def test_streaming_response_get(self, async_client: AsyncCloudflare) -> No assert response.http_request.headers.get("X-Stainless-Lang") == "python" mobile_redirect = await response.parse() - assert_matches_type(Optional[ZoneSettingMobileRedirect], mobile_redirect, path=["response"]) + assert_matches_type(Optional[MobileRedirect], mobile_redirect, path=["response"]) assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/zones/settings/test_nel.py b/tests/api_resources/zones/settings/test_nel.py index a15a85d9be0a..06df1c52474c 100644 --- a/tests/api_resources/zones/settings/test_nel.py +++ b/tests/api_resources/zones/settings/test_nel.py @@ -9,7 +9,7 @@ from cloudflare import Cloudflare, AsyncCloudflare from tests.utils import assert_matches_type -from cloudflare.types.zones.settings import ZoneSettingNEL +from cloudflare.types.zones.settings import NEL base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -27,7 +27,7 @@ def test_method_edit(self, client: Cloudflare) -> None: "value": {}, }, ) - assert_matches_type(Optional[ZoneSettingNEL], nel, path=["response"]) + assert_matches_type(Optional[NEL], nel, path=["response"]) @pytest.mark.skip() @parametrize @@ -39,7 +39,7 @@ def test_method_edit_with_all_params(self, client: Cloudflare) -> None: "value": {"enabled": False}, }, ) - assert_matches_type(Optional[ZoneSettingNEL], nel, path=["response"]) + assert_matches_type(Optional[NEL], nel, path=["response"]) @pytest.mark.skip() @parametrize @@ -55,7 +55,7 @@ def test_raw_response_edit(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" nel = response.parse() - assert_matches_type(Optional[ZoneSettingNEL], nel, path=["response"]) + assert_matches_type(Optional[NEL], nel, path=["response"]) @pytest.mark.skip() @parametrize @@ -71,7 +71,7 @@ def test_streaming_response_edit(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" nel = response.parse() - assert_matches_type(Optional[ZoneSettingNEL], nel, path=["response"]) + assert_matches_type(Optional[NEL], nel, path=["response"]) assert cast(Any, response.is_closed) is True @@ -93,7 +93,7 @@ def test_method_get(self, client: Cloudflare) -> None: nel = client.zones.settings.nel.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingNEL], nel, path=["response"]) + assert_matches_type(Optional[NEL], nel, path=["response"]) @pytest.mark.skip() @parametrize @@ -105,7 +105,7 @@ def test_raw_response_get(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" nel = response.parse() - assert_matches_type(Optional[ZoneSettingNEL], nel, path=["response"]) + assert_matches_type(Optional[NEL], nel, path=["response"]) @pytest.mark.skip() @parametrize @@ -117,7 +117,7 @@ def test_streaming_response_get(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" nel = response.parse() - assert_matches_type(Optional[ZoneSettingNEL], nel, path=["response"]) + assert_matches_type(Optional[NEL], nel, path=["response"]) assert cast(Any, response.is_closed) is True @@ -143,7 +143,7 @@ async def test_method_edit(self, async_client: AsyncCloudflare) -> None: "value": {}, }, ) - assert_matches_type(Optional[ZoneSettingNEL], nel, path=["response"]) + assert_matches_type(Optional[NEL], nel, path=["response"]) @pytest.mark.skip() @parametrize @@ -155,7 +155,7 @@ async def test_method_edit_with_all_params(self, async_client: AsyncCloudflare) "value": {"enabled": False}, }, ) - assert_matches_type(Optional[ZoneSettingNEL], nel, path=["response"]) + assert_matches_type(Optional[NEL], nel, path=["response"]) @pytest.mark.skip() @parametrize @@ -171,7 +171,7 @@ async def test_raw_response_edit(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" nel = await response.parse() - assert_matches_type(Optional[ZoneSettingNEL], nel, path=["response"]) + assert_matches_type(Optional[NEL], nel, path=["response"]) @pytest.mark.skip() @parametrize @@ -187,7 +187,7 @@ async def test_streaming_response_edit(self, async_client: AsyncCloudflare) -> N assert response.http_request.headers.get("X-Stainless-Lang") == "python" nel = await response.parse() - assert_matches_type(Optional[ZoneSettingNEL], nel, path=["response"]) + assert_matches_type(Optional[NEL], nel, path=["response"]) assert cast(Any, response.is_closed) is True @@ -209,7 +209,7 @@ async def test_method_get(self, async_client: AsyncCloudflare) -> None: nel = await async_client.zones.settings.nel.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingNEL], nel, path=["response"]) + assert_matches_type(Optional[NEL], nel, path=["response"]) @pytest.mark.skip() @parametrize @@ -221,7 +221,7 @@ async def test_raw_response_get(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" nel = await response.parse() - assert_matches_type(Optional[ZoneSettingNEL], nel, path=["response"]) + assert_matches_type(Optional[NEL], nel, path=["response"]) @pytest.mark.skip() @parametrize @@ -233,7 +233,7 @@ async def test_streaming_response_get(self, async_client: AsyncCloudflare) -> No assert response.http_request.headers.get("X-Stainless-Lang") == "python" nel = await response.parse() - assert_matches_type(Optional[ZoneSettingNEL], nel, path=["response"]) + assert_matches_type(Optional[NEL], nel, path=["response"]) assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/zones/settings/test_opportunistic_encryption.py b/tests/api_resources/zones/settings/test_opportunistic_encryption.py index 88126a497038..de0952f3313e 100644 --- a/tests/api_resources/zones/settings/test_opportunistic_encryption.py +++ b/tests/api_resources/zones/settings/test_opportunistic_encryption.py @@ -9,7 +9,7 @@ from cloudflare import Cloudflare, AsyncCloudflare from tests.utils import assert_matches_type -from cloudflare.types.zones.settings import ZoneSettingOpportunisticEncryption +from cloudflare.types.zones.settings import OpportunisticEncryption base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -24,7 +24,7 @@ def test_method_edit(self, client: Cloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="on", ) - assert_matches_type(Optional[ZoneSettingOpportunisticEncryption], opportunistic_encryption, path=["response"]) + assert_matches_type(Optional[OpportunisticEncryption], opportunistic_encryption, path=["response"]) @pytest.mark.skip() @parametrize @@ -37,7 +37,7 @@ def test_raw_response_edit(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" opportunistic_encryption = response.parse() - assert_matches_type(Optional[ZoneSettingOpportunisticEncryption], opportunistic_encryption, path=["response"]) + assert_matches_type(Optional[OpportunisticEncryption], opportunistic_encryption, path=["response"]) @pytest.mark.skip() @parametrize @@ -50,9 +50,7 @@ def test_streaming_response_edit(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" opportunistic_encryption = response.parse() - assert_matches_type( - Optional[ZoneSettingOpportunisticEncryption], opportunistic_encryption, path=["response"] - ) + assert_matches_type(Optional[OpportunisticEncryption], opportunistic_encryption, path=["response"]) assert cast(Any, response.is_closed) is True @@ -71,7 +69,7 @@ def test_method_get(self, client: Cloudflare) -> None: opportunistic_encryption = client.zones.settings.opportunistic_encryption.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingOpportunisticEncryption], opportunistic_encryption, path=["response"]) + assert_matches_type(Optional[OpportunisticEncryption], opportunistic_encryption, path=["response"]) @pytest.mark.skip() @parametrize @@ -83,7 +81,7 @@ def test_raw_response_get(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" opportunistic_encryption = response.parse() - assert_matches_type(Optional[ZoneSettingOpportunisticEncryption], opportunistic_encryption, path=["response"]) + assert_matches_type(Optional[OpportunisticEncryption], opportunistic_encryption, path=["response"]) @pytest.mark.skip() @parametrize @@ -95,9 +93,7 @@ def test_streaming_response_get(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" opportunistic_encryption = response.parse() - assert_matches_type( - Optional[ZoneSettingOpportunisticEncryption], opportunistic_encryption, path=["response"] - ) + assert_matches_type(Optional[OpportunisticEncryption], opportunistic_encryption, path=["response"]) assert cast(Any, response.is_closed) is True @@ -120,7 +116,7 @@ async def test_method_edit(self, async_client: AsyncCloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="on", ) - assert_matches_type(Optional[ZoneSettingOpportunisticEncryption], opportunistic_encryption, path=["response"]) + assert_matches_type(Optional[OpportunisticEncryption], opportunistic_encryption, path=["response"]) @pytest.mark.skip() @parametrize @@ -133,7 +129,7 @@ async def test_raw_response_edit(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" opportunistic_encryption = await response.parse() - assert_matches_type(Optional[ZoneSettingOpportunisticEncryption], opportunistic_encryption, path=["response"]) + assert_matches_type(Optional[OpportunisticEncryption], opportunistic_encryption, path=["response"]) @pytest.mark.skip() @parametrize @@ -146,9 +142,7 @@ async def test_streaming_response_edit(self, async_client: AsyncCloudflare) -> N assert response.http_request.headers.get("X-Stainless-Lang") == "python" opportunistic_encryption = await response.parse() - assert_matches_type( - Optional[ZoneSettingOpportunisticEncryption], opportunistic_encryption, path=["response"] - ) + assert_matches_type(Optional[OpportunisticEncryption], opportunistic_encryption, path=["response"]) assert cast(Any, response.is_closed) is True @@ -167,7 +161,7 @@ async def test_method_get(self, async_client: AsyncCloudflare) -> None: opportunistic_encryption = await async_client.zones.settings.opportunistic_encryption.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingOpportunisticEncryption], opportunistic_encryption, path=["response"]) + assert_matches_type(Optional[OpportunisticEncryption], opportunistic_encryption, path=["response"]) @pytest.mark.skip() @parametrize @@ -179,7 +173,7 @@ async def test_raw_response_get(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" opportunistic_encryption = await response.parse() - assert_matches_type(Optional[ZoneSettingOpportunisticEncryption], opportunistic_encryption, path=["response"]) + assert_matches_type(Optional[OpportunisticEncryption], opportunistic_encryption, path=["response"]) @pytest.mark.skip() @parametrize @@ -191,9 +185,7 @@ async def test_streaming_response_get(self, async_client: AsyncCloudflare) -> No assert response.http_request.headers.get("X-Stainless-Lang") == "python" opportunistic_encryption = await response.parse() - assert_matches_type( - Optional[ZoneSettingOpportunisticEncryption], opportunistic_encryption, path=["response"] - ) + assert_matches_type(Optional[OpportunisticEncryption], opportunistic_encryption, path=["response"]) assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/zones/settings/test_opportunistic_onion.py b/tests/api_resources/zones/settings/test_opportunistic_onion.py index da6a2844d4ff..95d177adbc8c 100644 --- a/tests/api_resources/zones/settings/test_opportunistic_onion.py +++ b/tests/api_resources/zones/settings/test_opportunistic_onion.py @@ -9,7 +9,7 @@ from cloudflare import Cloudflare, AsyncCloudflare from tests.utils import assert_matches_type -from cloudflare.types.zones.settings import ZoneSettingOpportunisticOnion +from cloudflare.types.zones.settings import OpportunisticOnion base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -24,7 +24,7 @@ def test_method_edit(self, client: Cloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="on", ) - assert_matches_type(Optional[ZoneSettingOpportunisticOnion], opportunistic_onion, path=["response"]) + assert_matches_type(Optional[OpportunisticOnion], opportunistic_onion, path=["response"]) @pytest.mark.skip() @parametrize @@ -37,7 +37,7 @@ def test_raw_response_edit(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" opportunistic_onion = response.parse() - assert_matches_type(Optional[ZoneSettingOpportunisticOnion], opportunistic_onion, path=["response"]) + assert_matches_type(Optional[OpportunisticOnion], opportunistic_onion, path=["response"]) @pytest.mark.skip() @parametrize @@ -50,7 +50,7 @@ def test_streaming_response_edit(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" opportunistic_onion = response.parse() - assert_matches_type(Optional[ZoneSettingOpportunisticOnion], opportunistic_onion, path=["response"]) + assert_matches_type(Optional[OpportunisticOnion], opportunistic_onion, path=["response"]) assert cast(Any, response.is_closed) is True @@ -69,7 +69,7 @@ def test_method_get(self, client: Cloudflare) -> None: opportunistic_onion = client.zones.settings.opportunistic_onion.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingOpportunisticOnion], opportunistic_onion, path=["response"]) + assert_matches_type(Optional[OpportunisticOnion], opportunistic_onion, path=["response"]) @pytest.mark.skip() @parametrize @@ -81,7 +81,7 @@ def test_raw_response_get(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" opportunistic_onion = response.parse() - assert_matches_type(Optional[ZoneSettingOpportunisticOnion], opportunistic_onion, path=["response"]) + assert_matches_type(Optional[OpportunisticOnion], opportunistic_onion, path=["response"]) @pytest.mark.skip() @parametrize @@ -93,7 +93,7 @@ def test_streaming_response_get(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" opportunistic_onion = response.parse() - assert_matches_type(Optional[ZoneSettingOpportunisticOnion], opportunistic_onion, path=["response"]) + assert_matches_type(Optional[OpportunisticOnion], opportunistic_onion, path=["response"]) assert cast(Any, response.is_closed) is True @@ -116,7 +116,7 @@ async def test_method_edit(self, async_client: AsyncCloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="on", ) - assert_matches_type(Optional[ZoneSettingOpportunisticOnion], opportunistic_onion, path=["response"]) + assert_matches_type(Optional[OpportunisticOnion], opportunistic_onion, path=["response"]) @pytest.mark.skip() @parametrize @@ -129,7 +129,7 @@ async def test_raw_response_edit(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" opportunistic_onion = await response.parse() - assert_matches_type(Optional[ZoneSettingOpportunisticOnion], opportunistic_onion, path=["response"]) + assert_matches_type(Optional[OpportunisticOnion], opportunistic_onion, path=["response"]) @pytest.mark.skip() @parametrize @@ -142,7 +142,7 @@ async def test_streaming_response_edit(self, async_client: AsyncCloudflare) -> N assert response.http_request.headers.get("X-Stainless-Lang") == "python" opportunistic_onion = await response.parse() - assert_matches_type(Optional[ZoneSettingOpportunisticOnion], opportunistic_onion, path=["response"]) + assert_matches_type(Optional[OpportunisticOnion], opportunistic_onion, path=["response"]) assert cast(Any, response.is_closed) is True @@ -161,7 +161,7 @@ async def test_method_get(self, async_client: AsyncCloudflare) -> None: opportunistic_onion = await async_client.zones.settings.opportunistic_onion.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingOpportunisticOnion], opportunistic_onion, path=["response"]) + assert_matches_type(Optional[OpportunisticOnion], opportunistic_onion, path=["response"]) @pytest.mark.skip() @parametrize @@ -173,7 +173,7 @@ async def test_raw_response_get(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" opportunistic_onion = await response.parse() - assert_matches_type(Optional[ZoneSettingOpportunisticOnion], opportunistic_onion, path=["response"]) + assert_matches_type(Optional[OpportunisticOnion], opportunistic_onion, path=["response"]) @pytest.mark.skip() @parametrize @@ -185,7 +185,7 @@ async def test_streaming_response_get(self, async_client: AsyncCloudflare) -> No assert response.http_request.headers.get("X-Stainless-Lang") == "python" opportunistic_onion = await response.parse() - assert_matches_type(Optional[ZoneSettingOpportunisticOnion], opportunistic_onion, path=["response"]) + assert_matches_type(Optional[OpportunisticOnion], opportunistic_onion, path=["response"]) assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/zones/settings/test_orange_to_orange.py b/tests/api_resources/zones/settings/test_orange_to_orange.py index 1d4c32bd2891..641ff3938972 100644 --- a/tests/api_resources/zones/settings/test_orange_to_orange.py +++ b/tests/api_resources/zones/settings/test_orange_to_orange.py @@ -9,7 +9,7 @@ from cloudflare import Cloudflare, AsyncCloudflare from tests.utils import assert_matches_type -from cloudflare.types.zones.settings import ZoneSettingOrangeToOrange +from cloudflare.types.zones.settings import OrangeToOrange base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -27,7 +27,7 @@ def test_method_edit(self, client: Cloudflare) -> None: "value": "on", }, ) - assert_matches_type(Optional[ZoneSettingOrangeToOrange], orange_to_orange, path=["response"]) + assert_matches_type(Optional[OrangeToOrange], orange_to_orange, path=["response"]) @pytest.mark.skip() @parametrize @@ -39,7 +39,7 @@ def test_method_edit_with_all_params(self, client: Cloudflare) -> None: "value": "on", }, ) - assert_matches_type(Optional[ZoneSettingOrangeToOrange], orange_to_orange, path=["response"]) + assert_matches_type(Optional[OrangeToOrange], orange_to_orange, path=["response"]) @pytest.mark.skip() @parametrize @@ -55,7 +55,7 @@ def test_raw_response_edit(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" orange_to_orange = response.parse() - assert_matches_type(Optional[ZoneSettingOrangeToOrange], orange_to_orange, path=["response"]) + assert_matches_type(Optional[OrangeToOrange], orange_to_orange, path=["response"]) @pytest.mark.skip() @parametrize @@ -71,7 +71,7 @@ def test_streaming_response_edit(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" orange_to_orange = response.parse() - assert_matches_type(Optional[ZoneSettingOrangeToOrange], orange_to_orange, path=["response"]) + assert_matches_type(Optional[OrangeToOrange], orange_to_orange, path=["response"]) assert cast(Any, response.is_closed) is True @@ -93,7 +93,7 @@ def test_method_get(self, client: Cloudflare) -> None: orange_to_orange = client.zones.settings.orange_to_orange.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingOrangeToOrange], orange_to_orange, path=["response"]) + assert_matches_type(Optional[OrangeToOrange], orange_to_orange, path=["response"]) @pytest.mark.skip() @parametrize @@ -105,7 +105,7 @@ def test_raw_response_get(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" orange_to_orange = response.parse() - assert_matches_type(Optional[ZoneSettingOrangeToOrange], orange_to_orange, path=["response"]) + assert_matches_type(Optional[OrangeToOrange], orange_to_orange, path=["response"]) @pytest.mark.skip() @parametrize @@ -117,7 +117,7 @@ def test_streaming_response_get(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" orange_to_orange = response.parse() - assert_matches_type(Optional[ZoneSettingOrangeToOrange], orange_to_orange, path=["response"]) + assert_matches_type(Optional[OrangeToOrange], orange_to_orange, path=["response"]) assert cast(Any, response.is_closed) is True @@ -143,7 +143,7 @@ async def test_method_edit(self, async_client: AsyncCloudflare) -> None: "value": "on", }, ) - assert_matches_type(Optional[ZoneSettingOrangeToOrange], orange_to_orange, path=["response"]) + assert_matches_type(Optional[OrangeToOrange], orange_to_orange, path=["response"]) @pytest.mark.skip() @parametrize @@ -155,7 +155,7 @@ async def test_method_edit_with_all_params(self, async_client: AsyncCloudflare) "value": "on", }, ) - assert_matches_type(Optional[ZoneSettingOrangeToOrange], orange_to_orange, path=["response"]) + assert_matches_type(Optional[OrangeToOrange], orange_to_orange, path=["response"]) @pytest.mark.skip() @parametrize @@ -171,7 +171,7 @@ async def test_raw_response_edit(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" orange_to_orange = await response.parse() - assert_matches_type(Optional[ZoneSettingOrangeToOrange], orange_to_orange, path=["response"]) + assert_matches_type(Optional[OrangeToOrange], orange_to_orange, path=["response"]) @pytest.mark.skip() @parametrize @@ -187,7 +187,7 @@ async def test_streaming_response_edit(self, async_client: AsyncCloudflare) -> N assert response.http_request.headers.get("X-Stainless-Lang") == "python" orange_to_orange = await response.parse() - assert_matches_type(Optional[ZoneSettingOrangeToOrange], orange_to_orange, path=["response"]) + assert_matches_type(Optional[OrangeToOrange], orange_to_orange, path=["response"]) assert cast(Any, response.is_closed) is True @@ -209,7 +209,7 @@ async def test_method_get(self, async_client: AsyncCloudflare) -> None: orange_to_orange = await async_client.zones.settings.orange_to_orange.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingOrangeToOrange], orange_to_orange, path=["response"]) + assert_matches_type(Optional[OrangeToOrange], orange_to_orange, path=["response"]) @pytest.mark.skip() @parametrize @@ -221,7 +221,7 @@ async def test_raw_response_get(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" orange_to_orange = await response.parse() - assert_matches_type(Optional[ZoneSettingOrangeToOrange], orange_to_orange, path=["response"]) + assert_matches_type(Optional[OrangeToOrange], orange_to_orange, path=["response"]) @pytest.mark.skip() @parametrize @@ -233,7 +233,7 @@ async def test_streaming_response_get(self, async_client: AsyncCloudflare) -> No assert response.http_request.headers.get("X-Stainless-Lang") == "python" orange_to_orange = await response.parse() - assert_matches_type(Optional[ZoneSettingOrangeToOrange], orange_to_orange, path=["response"]) + assert_matches_type(Optional[OrangeToOrange], orange_to_orange, path=["response"]) assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/zones/settings/test_origin_error_page_pass_thru.py b/tests/api_resources/zones/settings/test_origin_error_page_pass_thru.py index 1a12caea70f5..0f8db392e890 100644 --- a/tests/api_resources/zones/settings/test_origin_error_page_pass_thru.py +++ b/tests/api_resources/zones/settings/test_origin_error_page_pass_thru.py @@ -9,7 +9,7 @@ from cloudflare import Cloudflare, AsyncCloudflare from tests.utils import assert_matches_type -from cloudflare.types.zones.settings import ZoneSettingOriginErrorPagePassThru +from cloudflare.types.zones.settings import OriginErrorPagePassThru base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -24,9 +24,7 @@ def test_method_edit(self, client: Cloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="on", ) - assert_matches_type( - Optional[ZoneSettingOriginErrorPagePassThru], origin_error_page_pass_thru, path=["response"] - ) + assert_matches_type(Optional[OriginErrorPagePassThru], origin_error_page_pass_thru, path=["response"]) @pytest.mark.skip() @parametrize @@ -39,9 +37,7 @@ def test_raw_response_edit(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" origin_error_page_pass_thru = response.parse() - assert_matches_type( - Optional[ZoneSettingOriginErrorPagePassThru], origin_error_page_pass_thru, path=["response"] - ) + assert_matches_type(Optional[OriginErrorPagePassThru], origin_error_page_pass_thru, path=["response"]) @pytest.mark.skip() @parametrize @@ -54,9 +50,7 @@ def test_streaming_response_edit(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" origin_error_page_pass_thru = response.parse() - assert_matches_type( - Optional[ZoneSettingOriginErrorPagePassThru], origin_error_page_pass_thru, path=["response"] - ) + assert_matches_type(Optional[OriginErrorPagePassThru], origin_error_page_pass_thru, path=["response"]) assert cast(Any, response.is_closed) is True @@ -75,9 +69,7 @@ def test_method_get(self, client: Cloudflare) -> None: origin_error_page_pass_thru = client.zones.settings.origin_error_page_pass_thru.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type( - Optional[ZoneSettingOriginErrorPagePassThru], origin_error_page_pass_thru, path=["response"] - ) + assert_matches_type(Optional[OriginErrorPagePassThru], origin_error_page_pass_thru, path=["response"]) @pytest.mark.skip() @parametrize @@ -89,9 +81,7 @@ def test_raw_response_get(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" origin_error_page_pass_thru = response.parse() - assert_matches_type( - Optional[ZoneSettingOriginErrorPagePassThru], origin_error_page_pass_thru, path=["response"] - ) + assert_matches_type(Optional[OriginErrorPagePassThru], origin_error_page_pass_thru, path=["response"]) @pytest.mark.skip() @parametrize @@ -103,9 +93,7 @@ def test_streaming_response_get(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" origin_error_page_pass_thru = response.parse() - assert_matches_type( - Optional[ZoneSettingOriginErrorPagePassThru], origin_error_page_pass_thru, path=["response"] - ) + assert_matches_type(Optional[OriginErrorPagePassThru], origin_error_page_pass_thru, path=["response"]) assert cast(Any, response.is_closed) is True @@ -128,9 +116,7 @@ async def test_method_edit(self, async_client: AsyncCloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="on", ) - assert_matches_type( - Optional[ZoneSettingOriginErrorPagePassThru], origin_error_page_pass_thru, path=["response"] - ) + assert_matches_type(Optional[OriginErrorPagePassThru], origin_error_page_pass_thru, path=["response"]) @pytest.mark.skip() @parametrize @@ -143,9 +129,7 @@ async def test_raw_response_edit(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" origin_error_page_pass_thru = await response.parse() - assert_matches_type( - Optional[ZoneSettingOriginErrorPagePassThru], origin_error_page_pass_thru, path=["response"] - ) + assert_matches_type(Optional[OriginErrorPagePassThru], origin_error_page_pass_thru, path=["response"]) @pytest.mark.skip() @parametrize @@ -158,9 +142,7 @@ async def test_streaming_response_edit(self, async_client: AsyncCloudflare) -> N assert response.http_request.headers.get("X-Stainless-Lang") == "python" origin_error_page_pass_thru = await response.parse() - assert_matches_type( - Optional[ZoneSettingOriginErrorPagePassThru], origin_error_page_pass_thru, path=["response"] - ) + assert_matches_type(Optional[OriginErrorPagePassThru], origin_error_page_pass_thru, path=["response"]) assert cast(Any, response.is_closed) is True @@ -179,9 +161,7 @@ async def test_method_get(self, async_client: AsyncCloudflare) -> None: origin_error_page_pass_thru = await async_client.zones.settings.origin_error_page_pass_thru.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type( - Optional[ZoneSettingOriginErrorPagePassThru], origin_error_page_pass_thru, path=["response"] - ) + assert_matches_type(Optional[OriginErrorPagePassThru], origin_error_page_pass_thru, path=["response"]) @pytest.mark.skip() @parametrize @@ -193,9 +173,7 @@ async def test_raw_response_get(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" origin_error_page_pass_thru = await response.parse() - assert_matches_type( - Optional[ZoneSettingOriginErrorPagePassThru], origin_error_page_pass_thru, path=["response"] - ) + assert_matches_type(Optional[OriginErrorPagePassThru], origin_error_page_pass_thru, path=["response"]) @pytest.mark.skip() @parametrize @@ -207,9 +185,7 @@ async def test_streaming_response_get(self, async_client: AsyncCloudflare) -> No assert response.http_request.headers.get("X-Stainless-Lang") == "python" origin_error_page_pass_thru = await response.parse() - assert_matches_type( - Optional[ZoneSettingOriginErrorPagePassThru], origin_error_page_pass_thru, path=["response"] - ) + assert_matches_type(Optional[OriginErrorPagePassThru], origin_error_page_pass_thru, path=["response"]) assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/zones/settings/test_polish.py b/tests/api_resources/zones/settings/test_polish.py index 81c7e82e6ae2..e2fc5942cb93 100644 --- a/tests/api_resources/zones/settings/test_polish.py +++ b/tests/api_resources/zones/settings/test_polish.py @@ -9,7 +9,7 @@ from cloudflare import Cloudflare, AsyncCloudflare from tests.utils import assert_matches_type -from cloudflare.types.zones.settings import ZoneSettingPolish +from cloudflare.types.zones.settings import Polish base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -27,7 +27,7 @@ def test_method_edit(self, client: Cloudflare) -> None: "value": "off", }, ) - assert_matches_type(Optional[ZoneSettingPolish], polish, path=["response"]) + assert_matches_type(Optional[Polish], polish, path=["response"]) @pytest.mark.skip() @parametrize @@ -39,7 +39,7 @@ def test_method_edit_with_all_params(self, client: Cloudflare) -> None: "value": "off", }, ) - assert_matches_type(Optional[ZoneSettingPolish], polish, path=["response"]) + assert_matches_type(Optional[Polish], polish, path=["response"]) @pytest.mark.skip() @parametrize @@ -55,7 +55,7 @@ def test_raw_response_edit(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" polish = response.parse() - assert_matches_type(Optional[ZoneSettingPolish], polish, path=["response"]) + assert_matches_type(Optional[Polish], polish, path=["response"]) @pytest.mark.skip() @parametrize @@ -71,7 +71,7 @@ def test_streaming_response_edit(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" polish = response.parse() - assert_matches_type(Optional[ZoneSettingPolish], polish, path=["response"]) + assert_matches_type(Optional[Polish], polish, path=["response"]) assert cast(Any, response.is_closed) is True @@ -93,7 +93,7 @@ def test_method_get(self, client: Cloudflare) -> None: polish = client.zones.settings.polish.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingPolish], polish, path=["response"]) + assert_matches_type(Optional[Polish], polish, path=["response"]) @pytest.mark.skip() @parametrize @@ -105,7 +105,7 @@ def test_raw_response_get(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" polish = response.parse() - assert_matches_type(Optional[ZoneSettingPolish], polish, path=["response"]) + assert_matches_type(Optional[Polish], polish, path=["response"]) @pytest.mark.skip() @parametrize @@ -117,7 +117,7 @@ def test_streaming_response_get(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" polish = response.parse() - assert_matches_type(Optional[ZoneSettingPolish], polish, path=["response"]) + assert_matches_type(Optional[Polish], polish, path=["response"]) assert cast(Any, response.is_closed) is True @@ -143,7 +143,7 @@ async def test_method_edit(self, async_client: AsyncCloudflare) -> None: "value": "off", }, ) - assert_matches_type(Optional[ZoneSettingPolish], polish, path=["response"]) + assert_matches_type(Optional[Polish], polish, path=["response"]) @pytest.mark.skip() @parametrize @@ -155,7 +155,7 @@ async def test_method_edit_with_all_params(self, async_client: AsyncCloudflare) "value": "off", }, ) - assert_matches_type(Optional[ZoneSettingPolish], polish, path=["response"]) + assert_matches_type(Optional[Polish], polish, path=["response"]) @pytest.mark.skip() @parametrize @@ -171,7 +171,7 @@ async def test_raw_response_edit(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" polish = await response.parse() - assert_matches_type(Optional[ZoneSettingPolish], polish, path=["response"]) + assert_matches_type(Optional[Polish], polish, path=["response"]) @pytest.mark.skip() @parametrize @@ -187,7 +187,7 @@ async def test_streaming_response_edit(self, async_client: AsyncCloudflare) -> N assert response.http_request.headers.get("X-Stainless-Lang") == "python" polish = await response.parse() - assert_matches_type(Optional[ZoneSettingPolish], polish, path=["response"]) + assert_matches_type(Optional[Polish], polish, path=["response"]) assert cast(Any, response.is_closed) is True @@ -209,7 +209,7 @@ async def test_method_get(self, async_client: AsyncCloudflare) -> None: polish = await async_client.zones.settings.polish.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingPolish], polish, path=["response"]) + assert_matches_type(Optional[Polish], polish, path=["response"]) @pytest.mark.skip() @parametrize @@ -221,7 +221,7 @@ async def test_raw_response_get(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" polish = await response.parse() - assert_matches_type(Optional[ZoneSettingPolish], polish, path=["response"]) + assert_matches_type(Optional[Polish], polish, path=["response"]) @pytest.mark.skip() @parametrize @@ -233,7 +233,7 @@ async def test_streaming_response_get(self, async_client: AsyncCloudflare) -> No assert response.http_request.headers.get("X-Stainless-Lang") == "python" polish = await response.parse() - assert_matches_type(Optional[ZoneSettingPolish], polish, path=["response"]) + assert_matches_type(Optional[Polish], polish, path=["response"]) assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/zones/settings/test_prefetch_preload.py b/tests/api_resources/zones/settings/test_prefetch_preload.py index 64ef352ed418..ad818f62ba6c 100644 --- a/tests/api_resources/zones/settings/test_prefetch_preload.py +++ b/tests/api_resources/zones/settings/test_prefetch_preload.py @@ -9,7 +9,7 @@ from cloudflare import Cloudflare, AsyncCloudflare from tests.utils import assert_matches_type -from cloudflare.types.zones.settings import ZoneSettingPrefetchPreload +from cloudflare.types.zones.settings import PrefetchPreload base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -24,7 +24,7 @@ def test_method_edit(self, client: Cloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="on", ) - assert_matches_type(Optional[ZoneSettingPrefetchPreload], prefetch_preload, path=["response"]) + assert_matches_type(Optional[PrefetchPreload], prefetch_preload, path=["response"]) @pytest.mark.skip() @parametrize @@ -37,7 +37,7 @@ def test_raw_response_edit(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" prefetch_preload = response.parse() - assert_matches_type(Optional[ZoneSettingPrefetchPreload], prefetch_preload, path=["response"]) + assert_matches_type(Optional[PrefetchPreload], prefetch_preload, path=["response"]) @pytest.mark.skip() @parametrize @@ -50,7 +50,7 @@ def test_streaming_response_edit(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" prefetch_preload = response.parse() - assert_matches_type(Optional[ZoneSettingPrefetchPreload], prefetch_preload, path=["response"]) + assert_matches_type(Optional[PrefetchPreload], prefetch_preload, path=["response"]) assert cast(Any, response.is_closed) is True @@ -69,7 +69,7 @@ def test_method_get(self, client: Cloudflare) -> None: prefetch_preload = client.zones.settings.prefetch_preload.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingPrefetchPreload], prefetch_preload, path=["response"]) + assert_matches_type(Optional[PrefetchPreload], prefetch_preload, path=["response"]) @pytest.mark.skip() @parametrize @@ -81,7 +81,7 @@ def test_raw_response_get(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" prefetch_preload = response.parse() - assert_matches_type(Optional[ZoneSettingPrefetchPreload], prefetch_preload, path=["response"]) + assert_matches_type(Optional[PrefetchPreload], prefetch_preload, path=["response"]) @pytest.mark.skip() @parametrize @@ -93,7 +93,7 @@ def test_streaming_response_get(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" prefetch_preload = response.parse() - assert_matches_type(Optional[ZoneSettingPrefetchPreload], prefetch_preload, path=["response"]) + assert_matches_type(Optional[PrefetchPreload], prefetch_preload, path=["response"]) assert cast(Any, response.is_closed) is True @@ -116,7 +116,7 @@ async def test_method_edit(self, async_client: AsyncCloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="on", ) - assert_matches_type(Optional[ZoneSettingPrefetchPreload], prefetch_preload, path=["response"]) + assert_matches_type(Optional[PrefetchPreload], prefetch_preload, path=["response"]) @pytest.mark.skip() @parametrize @@ -129,7 +129,7 @@ async def test_raw_response_edit(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" prefetch_preload = await response.parse() - assert_matches_type(Optional[ZoneSettingPrefetchPreload], prefetch_preload, path=["response"]) + assert_matches_type(Optional[PrefetchPreload], prefetch_preload, path=["response"]) @pytest.mark.skip() @parametrize @@ -142,7 +142,7 @@ async def test_streaming_response_edit(self, async_client: AsyncCloudflare) -> N assert response.http_request.headers.get("X-Stainless-Lang") == "python" prefetch_preload = await response.parse() - assert_matches_type(Optional[ZoneSettingPrefetchPreload], prefetch_preload, path=["response"]) + assert_matches_type(Optional[PrefetchPreload], prefetch_preload, path=["response"]) assert cast(Any, response.is_closed) is True @@ -161,7 +161,7 @@ async def test_method_get(self, async_client: AsyncCloudflare) -> None: prefetch_preload = await async_client.zones.settings.prefetch_preload.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingPrefetchPreload], prefetch_preload, path=["response"]) + assert_matches_type(Optional[PrefetchPreload], prefetch_preload, path=["response"]) @pytest.mark.skip() @parametrize @@ -173,7 +173,7 @@ async def test_raw_response_get(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" prefetch_preload = await response.parse() - assert_matches_type(Optional[ZoneSettingPrefetchPreload], prefetch_preload, path=["response"]) + assert_matches_type(Optional[PrefetchPreload], prefetch_preload, path=["response"]) @pytest.mark.skip() @parametrize @@ -185,7 +185,7 @@ async def test_streaming_response_get(self, async_client: AsyncCloudflare) -> No assert response.http_request.headers.get("X-Stainless-Lang") == "python" prefetch_preload = await response.parse() - assert_matches_type(Optional[ZoneSettingPrefetchPreload], prefetch_preload, path=["response"]) + assert_matches_type(Optional[PrefetchPreload], prefetch_preload, path=["response"]) assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/zones/settings/test_proxy_read_timeout.py b/tests/api_resources/zones/settings/test_proxy_read_timeout.py index 0741ea010da3..04f4c151d2e6 100644 --- a/tests/api_resources/zones/settings/test_proxy_read_timeout.py +++ b/tests/api_resources/zones/settings/test_proxy_read_timeout.py @@ -9,7 +9,7 @@ from cloudflare import Cloudflare, AsyncCloudflare from tests.utils import assert_matches_type -from cloudflare.types.zones.settings import ZoneSettingProxyReadTimeout +from cloudflare.types.zones.settings import ProxyReadTimeout base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -27,7 +27,7 @@ def test_method_edit(self, client: Cloudflare) -> None: "value": 0, }, ) - assert_matches_type(Optional[ZoneSettingProxyReadTimeout], proxy_read_timeout, path=["response"]) + assert_matches_type(Optional[ProxyReadTimeout], proxy_read_timeout, path=["response"]) @pytest.mark.skip() @parametrize @@ -39,7 +39,7 @@ def test_method_edit_with_all_params(self, client: Cloudflare) -> None: "value": 0, }, ) - assert_matches_type(Optional[ZoneSettingProxyReadTimeout], proxy_read_timeout, path=["response"]) + assert_matches_type(Optional[ProxyReadTimeout], proxy_read_timeout, path=["response"]) @pytest.mark.skip() @parametrize @@ -55,7 +55,7 @@ def test_raw_response_edit(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" proxy_read_timeout = response.parse() - assert_matches_type(Optional[ZoneSettingProxyReadTimeout], proxy_read_timeout, path=["response"]) + assert_matches_type(Optional[ProxyReadTimeout], proxy_read_timeout, path=["response"]) @pytest.mark.skip() @parametrize @@ -71,7 +71,7 @@ def test_streaming_response_edit(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" proxy_read_timeout = response.parse() - assert_matches_type(Optional[ZoneSettingProxyReadTimeout], proxy_read_timeout, path=["response"]) + assert_matches_type(Optional[ProxyReadTimeout], proxy_read_timeout, path=["response"]) assert cast(Any, response.is_closed) is True @@ -93,7 +93,7 @@ def test_method_get(self, client: Cloudflare) -> None: proxy_read_timeout = client.zones.settings.proxy_read_timeout.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingProxyReadTimeout], proxy_read_timeout, path=["response"]) + assert_matches_type(Optional[ProxyReadTimeout], proxy_read_timeout, path=["response"]) @pytest.mark.skip() @parametrize @@ -105,7 +105,7 @@ def test_raw_response_get(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" proxy_read_timeout = response.parse() - assert_matches_type(Optional[ZoneSettingProxyReadTimeout], proxy_read_timeout, path=["response"]) + assert_matches_type(Optional[ProxyReadTimeout], proxy_read_timeout, path=["response"]) @pytest.mark.skip() @parametrize @@ -117,7 +117,7 @@ def test_streaming_response_get(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" proxy_read_timeout = response.parse() - assert_matches_type(Optional[ZoneSettingProxyReadTimeout], proxy_read_timeout, path=["response"]) + assert_matches_type(Optional[ProxyReadTimeout], proxy_read_timeout, path=["response"]) assert cast(Any, response.is_closed) is True @@ -143,7 +143,7 @@ async def test_method_edit(self, async_client: AsyncCloudflare) -> None: "value": 0, }, ) - assert_matches_type(Optional[ZoneSettingProxyReadTimeout], proxy_read_timeout, path=["response"]) + assert_matches_type(Optional[ProxyReadTimeout], proxy_read_timeout, path=["response"]) @pytest.mark.skip() @parametrize @@ -155,7 +155,7 @@ async def test_method_edit_with_all_params(self, async_client: AsyncCloudflare) "value": 0, }, ) - assert_matches_type(Optional[ZoneSettingProxyReadTimeout], proxy_read_timeout, path=["response"]) + assert_matches_type(Optional[ProxyReadTimeout], proxy_read_timeout, path=["response"]) @pytest.mark.skip() @parametrize @@ -171,7 +171,7 @@ async def test_raw_response_edit(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" proxy_read_timeout = await response.parse() - assert_matches_type(Optional[ZoneSettingProxyReadTimeout], proxy_read_timeout, path=["response"]) + assert_matches_type(Optional[ProxyReadTimeout], proxy_read_timeout, path=["response"]) @pytest.mark.skip() @parametrize @@ -187,7 +187,7 @@ async def test_streaming_response_edit(self, async_client: AsyncCloudflare) -> N assert response.http_request.headers.get("X-Stainless-Lang") == "python" proxy_read_timeout = await response.parse() - assert_matches_type(Optional[ZoneSettingProxyReadTimeout], proxy_read_timeout, path=["response"]) + assert_matches_type(Optional[ProxyReadTimeout], proxy_read_timeout, path=["response"]) assert cast(Any, response.is_closed) is True @@ -209,7 +209,7 @@ async def test_method_get(self, async_client: AsyncCloudflare) -> None: proxy_read_timeout = await async_client.zones.settings.proxy_read_timeout.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingProxyReadTimeout], proxy_read_timeout, path=["response"]) + assert_matches_type(Optional[ProxyReadTimeout], proxy_read_timeout, path=["response"]) @pytest.mark.skip() @parametrize @@ -221,7 +221,7 @@ async def test_raw_response_get(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" proxy_read_timeout = await response.parse() - assert_matches_type(Optional[ZoneSettingProxyReadTimeout], proxy_read_timeout, path=["response"]) + assert_matches_type(Optional[ProxyReadTimeout], proxy_read_timeout, path=["response"]) @pytest.mark.skip() @parametrize @@ -233,7 +233,7 @@ async def test_streaming_response_get(self, async_client: AsyncCloudflare) -> No assert response.http_request.headers.get("X-Stainless-Lang") == "python" proxy_read_timeout = await response.parse() - assert_matches_type(Optional[ZoneSettingProxyReadTimeout], proxy_read_timeout, path=["response"]) + assert_matches_type(Optional[ProxyReadTimeout], proxy_read_timeout, path=["response"]) assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/zones/settings/test_pseudo_ipv4.py b/tests/api_resources/zones/settings/test_pseudo_ipv4.py index e0528d564345..a777c5c3bd76 100644 --- a/tests/api_resources/zones/settings/test_pseudo_ipv4.py +++ b/tests/api_resources/zones/settings/test_pseudo_ipv4.py @@ -9,7 +9,7 @@ from cloudflare import Cloudflare, AsyncCloudflare from tests.utils import assert_matches_type -from cloudflare.types.zones.settings import ZoneSettingPseudoIPV4 +from cloudflare.types.zones.settings import PseudoIPV4 base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -24,7 +24,7 @@ def test_method_edit(self, client: Cloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="off", ) - assert_matches_type(Optional[ZoneSettingPseudoIPV4], pseudo_ipv4, path=["response"]) + assert_matches_type(Optional[PseudoIPV4], pseudo_ipv4, path=["response"]) @pytest.mark.skip() @parametrize @@ -37,7 +37,7 @@ def test_raw_response_edit(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" pseudo_ipv4 = response.parse() - assert_matches_type(Optional[ZoneSettingPseudoIPV4], pseudo_ipv4, path=["response"]) + assert_matches_type(Optional[PseudoIPV4], pseudo_ipv4, path=["response"]) @pytest.mark.skip() @parametrize @@ -50,7 +50,7 @@ def test_streaming_response_edit(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" pseudo_ipv4 = response.parse() - assert_matches_type(Optional[ZoneSettingPseudoIPV4], pseudo_ipv4, path=["response"]) + assert_matches_type(Optional[PseudoIPV4], pseudo_ipv4, path=["response"]) assert cast(Any, response.is_closed) is True @@ -69,7 +69,7 @@ def test_method_get(self, client: Cloudflare) -> None: pseudo_ipv4 = client.zones.settings.pseudo_ipv4.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingPseudoIPV4], pseudo_ipv4, path=["response"]) + assert_matches_type(Optional[PseudoIPV4], pseudo_ipv4, path=["response"]) @pytest.mark.skip() @parametrize @@ -81,7 +81,7 @@ def test_raw_response_get(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" pseudo_ipv4 = response.parse() - assert_matches_type(Optional[ZoneSettingPseudoIPV4], pseudo_ipv4, path=["response"]) + assert_matches_type(Optional[PseudoIPV4], pseudo_ipv4, path=["response"]) @pytest.mark.skip() @parametrize @@ -93,7 +93,7 @@ def test_streaming_response_get(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" pseudo_ipv4 = response.parse() - assert_matches_type(Optional[ZoneSettingPseudoIPV4], pseudo_ipv4, path=["response"]) + assert_matches_type(Optional[PseudoIPV4], pseudo_ipv4, path=["response"]) assert cast(Any, response.is_closed) is True @@ -116,7 +116,7 @@ async def test_method_edit(self, async_client: AsyncCloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="off", ) - assert_matches_type(Optional[ZoneSettingPseudoIPV4], pseudo_ipv4, path=["response"]) + assert_matches_type(Optional[PseudoIPV4], pseudo_ipv4, path=["response"]) @pytest.mark.skip() @parametrize @@ -129,7 +129,7 @@ async def test_raw_response_edit(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" pseudo_ipv4 = await response.parse() - assert_matches_type(Optional[ZoneSettingPseudoIPV4], pseudo_ipv4, path=["response"]) + assert_matches_type(Optional[PseudoIPV4], pseudo_ipv4, path=["response"]) @pytest.mark.skip() @parametrize @@ -142,7 +142,7 @@ async def test_streaming_response_edit(self, async_client: AsyncCloudflare) -> N assert response.http_request.headers.get("X-Stainless-Lang") == "python" pseudo_ipv4 = await response.parse() - assert_matches_type(Optional[ZoneSettingPseudoIPV4], pseudo_ipv4, path=["response"]) + assert_matches_type(Optional[PseudoIPV4], pseudo_ipv4, path=["response"]) assert cast(Any, response.is_closed) is True @@ -161,7 +161,7 @@ async def test_method_get(self, async_client: AsyncCloudflare) -> None: pseudo_ipv4 = await async_client.zones.settings.pseudo_ipv4.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingPseudoIPV4], pseudo_ipv4, path=["response"]) + assert_matches_type(Optional[PseudoIPV4], pseudo_ipv4, path=["response"]) @pytest.mark.skip() @parametrize @@ -173,7 +173,7 @@ async def test_raw_response_get(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" pseudo_ipv4 = await response.parse() - assert_matches_type(Optional[ZoneSettingPseudoIPV4], pseudo_ipv4, path=["response"]) + assert_matches_type(Optional[PseudoIPV4], pseudo_ipv4, path=["response"]) @pytest.mark.skip() @parametrize @@ -185,7 +185,7 @@ async def test_streaming_response_get(self, async_client: AsyncCloudflare) -> No assert response.http_request.headers.get("X-Stainless-Lang") == "python" pseudo_ipv4 = await response.parse() - assert_matches_type(Optional[ZoneSettingPseudoIPV4], pseudo_ipv4, path=["response"]) + assert_matches_type(Optional[PseudoIPV4], pseudo_ipv4, path=["response"]) assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/zones/settings/test_response_buffering.py b/tests/api_resources/zones/settings/test_response_buffering.py index 5ffbb57322fd..c41a364275a2 100644 --- a/tests/api_resources/zones/settings/test_response_buffering.py +++ b/tests/api_resources/zones/settings/test_response_buffering.py @@ -9,7 +9,7 @@ from cloudflare import Cloudflare, AsyncCloudflare from tests.utils import assert_matches_type -from cloudflare.types.zones.settings import ZoneSettingBuffering +from cloudflare.types.zones.settings import ResponseBuffering base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -24,7 +24,7 @@ def test_method_edit(self, client: Cloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="on", ) - assert_matches_type(Optional[ZoneSettingBuffering], response_buffering, path=["response"]) + assert_matches_type(Optional[ResponseBuffering], response_buffering, path=["response"]) @pytest.mark.skip() @parametrize @@ -37,7 +37,7 @@ def test_raw_response_edit(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" response_buffering = response.parse() - assert_matches_type(Optional[ZoneSettingBuffering], response_buffering, path=["response"]) + assert_matches_type(Optional[ResponseBuffering], response_buffering, path=["response"]) @pytest.mark.skip() @parametrize @@ -50,7 +50,7 @@ def test_streaming_response_edit(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" response_buffering = response.parse() - assert_matches_type(Optional[ZoneSettingBuffering], response_buffering, path=["response"]) + assert_matches_type(Optional[ResponseBuffering], response_buffering, path=["response"]) assert cast(Any, response.is_closed) is True @@ -69,7 +69,7 @@ def test_method_get(self, client: Cloudflare) -> None: response_buffering = client.zones.settings.response_buffering.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingBuffering], response_buffering, path=["response"]) + assert_matches_type(Optional[ResponseBuffering], response_buffering, path=["response"]) @pytest.mark.skip() @parametrize @@ -81,7 +81,7 @@ def test_raw_response_get(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" response_buffering = response.parse() - assert_matches_type(Optional[ZoneSettingBuffering], response_buffering, path=["response"]) + assert_matches_type(Optional[ResponseBuffering], response_buffering, path=["response"]) @pytest.mark.skip() @parametrize @@ -93,7 +93,7 @@ def test_streaming_response_get(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" response_buffering = response.parse() - assert_matches_type(Optional[ZoneSettingBuffering], response_buffering, path=["response"]) + assert_matches_type(Optional[ResponseBuffering], response_buffering, path=["response"]) assert cast(Any, response.is_closed) is True @@ -116,7 +116,7 @@ async def test_method_edit(self, async_client: AsyncCloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="on", ) - assert_matches_type(Optional[ZoneSettingBuffering], response_buffering, path=["response"]) + assert_matches_type(Optional[ResponseBuffering], response_buffering, path=["response"]) @pytest.mark.skip() @parametrize @@ -129,7 +129,7 @@ async def test_raw_response_edit(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" response_buffering = await response.parse() - assert_matches_type(Optional[ZoneSettingBuffering], response_buffering, path=["response"]) + assert_matches_type(Optional[ResponseBuffering], response_buffering, path=["response"]) @pytest.mark.skip() @parametrize @@ -142,7 +142,7 @@ async def test_streaming_response_edit(self, async_client: AsyncCloudflare) -> N assert response.http_request.headers.get("X-Stainless-Lang") == "python" response_buffering = await response.parse() - assert_matches_type(Optional[ZoneSettingBuffering], response_buffering, path=["response"]) + assert_matches_type(Optional[ResponseBuffering], response_buffering, path=["response"]) assert cast(Any, response.is_closed) is True @@ -161,7 +161,7 @@ async def test_method_get(self, async_client: AsyncCloudflare) -> None: response_buffering = await async_client.zones.settings.response_buffering.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingBuffering], response_buffering, path=["response"]) + assert_matches_type(Optional[ResponseBuffering], response_buffering, path=["response"]) @pytest.mark.skip() @parametrize @@ -173,7 +173,7 @@ async def test_raw_response_get(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" response_buffering = await response.parse() - assert_matches_type(Optional[ZoneSettingBuffering], response_buffering, path=["response"]) + assert_matches_type(Optional[ResponseBuffering], response_buffering, path=["response"]) @pytest.mark.skip() @parametrize @@ -185,7 +185,7 @@ async def test_streaming_response_get(self, async_client: AsyncCloudflare) -> No assert response.http_request.headers.get("X-Stainless-Lang") == "python" response_buffering = await response.parse() - assert_matches_type(Optional[ZoneSettingBuffering], response_buffering, path=["response"]) + assert_matches_type(Optional[ResponseBuffering], response_buffering, path=["response"]) assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/zones/settings/test_rocket_loader.py b/tests/api_resources/zones/settings/test_rocket_loader.py index 0b3c8e8bac3e..353098a9e62d 100644 --- a/tests/api_resources/zones/settings/test_rocket_loader.py +++ b/tests/api_resources/zones/settings/test_rocket_loader.py @@ -9,7 +9,7 @@ from cloudflare import Cloudflare, AsyncCloudflare from tests.utils import assert_matches_type -from cloudflare.types.zones.settings import ZoneSettingRocketLoader +from cloudflare.types.zones.settings import RocketLoader base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -27,7 +27,7 @@ def test_method_edit(self, client: Cloudflare) -> None: "value": "on", }, ) - assert_matches_type(Optional[ZoneSettingRocketLoader], rocket_loader, path=["response"]) + assert_matches_type(Optional[RocketLoader], rocket_loader, path=["response"]) @pytest.mark.skip() @parametrize @@ -39,7 +39,7 @@ def test_method_edit_with_all_params(self, client: Cloudflare) -> None: "value": "on", }, ) - assert_matches_type(Optional[ZoneSettingRocketLoader], rocket_loader, path=["response"]) + assert_matches_type(Optional[RocketLoader], rocket_loader, path=["response"]) @pytest.mark.skip() @parametrize @@ -55,7 +55,7 @@ def test_raw_response_edit(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" rocket_loader = response.parse() - assert_matches_type(Optional[ZoneSettingRocketLoader], rocket_loader, path=["response"]) + assert_matches_type(Optional[RocketLoader], rocket_loader, path=["response"]) @pytest.mark.skip() @parametrize @@ -71,7 +71,7 @@ def test_streaming_response_edit(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" rocket_loader = response.parse() - assert_matches_type(Optional[ZoneSettingRocketLoader], rocket_loader, path=["response"]) + assert_matches_type(Optional[RocketLoader], rocket_loader, path=["response"]) assert cast(Any, response.is_closed) is True @@ -93,7 +93,7 @@ def test_method_get(self, client: Cloudflare) -> None: rocket_loader = client.zones.settings.rocket_loader.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingRocketLoader], rocket_loader, path=["response"]) + assert_matches_type(Optional[RocketLoader], rocket_loader, path=["response"]) @pytest.mark.skip() @parametrize @@ -105,7 +105,7 @@ def test_raw_response_get(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" rocket_loader = response.parse() - assert_matches_type(Optional[ZoneSettingRocketLoader], rocket_loader, path=["response"]) + assert_matches_type(Optional[RocketLoader], rocket_loader, path=["response"]) @pytest.mark.skip() @parametrize @@ -117,7 +117,7 @@ def test_streaming_response_get(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" rocket_loader = response.parse() - assert_matches_type(Optional[ZoneSettingRocketLoader], rocket_loader, path=["response"]) + assert_matches_type(Optional[RocketLoader], rocket_loader, path=["response"]) assert cast(Any, response.is_closed) is True @@ -143,7 +143,7 @@ async def test_method_edit(self, async_client: AsyncCloudflare) -> None: "value": "on", }, ) - assert_matches_type(Optional[ZoneSettingRocketLoader], rocket_loader, path=["response"]) + assert_matches_type(Optional[RocketLoader], rocket_loader, path=["response"]) @pytest.mark.skip() @parametrize @@ -155,7 +155,7 @@ async def test_method_edit_with_all_params(self, async_client: AsyncCloudflare) "value": "on", }, ) - assert_matches_type(Optional[ZoneSettingRocketLoader], rocket_loader, path=["response"]) + assert_matches_type(Optional[RocketLoader], rocket_loader, path=["response"]) @pytest.mark.skip() @parametrize @@ -171,7 +171,7 @@ async def test_raw_response_edit(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" rocket_loader = await response.parse() - assert_matches_type(Optional[ZoneSettingRocketLoader], rocket_loader, path=["response"]) + assert_matches_type(Optional[RocketLoader], rocket_loader, path=["response"]) @pytest.mark.skip() @parametrize @@ -187,7 +187,7 @@ async def test_streaming_response_edit(self, async_client: AsyncCloudflare) -> N assert response.http_request.headers.get("X-Stainless-Lang") == "python" rocket_loader = await response.parse() - assert_matches_type(Optional[ZoneSettingRocketLoader], rocket_loader, path=["response"]) + assert_matches_type(Optional[RocketLoader], rocket_loader, path=["response"]) assert cast(Any, response.is_closed) is True @@ -209,7 +209,7 @@ async def test_method_get(self, async_client: AsyncCloudflare) -> None: rocket_loader = await async_client.zones.settings.rocket_loader.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingRocketLoader], rocket_loader, path=["response"]) + assert_matches_type(Optional[RocketLoader], rocket_loader, path=["response"]) @pytest.mark.skip() @parametrize @@ -221,7 +221,7 @@ async def test_raw_response_get(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" rocket_loader = await response.parse() - assert_matches_type(Optional[ZoneSettingRocketLoader], rocket_loader, path=["response"]) + assert_matches_type(Optional[RocketLoader], rocket_loader, path=["response"]) @pytest.mark.skip() @parametrize @@ -233,7 +233,7 @@ async def test_streaming_response_get(self, async_client: AsyncCloudflare) -> No assert response.http_request.headers.get("X-Stainless-Lang") == "python" rocket_loader = await response.parse() - assert_matches_type(Optional[ZoneSettingRocketLoader], rocket_loader, path=["response"]) + assert_matches_type(Optional[RocketLoader], rocket_loader, path=["response"]) assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/zones/settings/test_security_headers.py b/tests/api_resources/zones/settings/test_security_headers.py index 824e612c0e8d..48477c873b9d 100644 --- a/tests/api_resources/zones/settings/test_security_headers.py +++ b/tests/api_resources/zones/settings/test_security_headers.py @@ -9,7 +9,7 @@ from cloudflare import Cloudflare, AsyncCloudflare from tests.utils import assert_matches_type -from cloudflare.types.zones.settings import ZoneSettingSecurityHeader +from cloudflare.types.zones.settings import SecurityHeaders base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -24,7 +24,7 @@ def test_method_edit(self, client: Cloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value={}, ) - assert_matches_type(Optional[ZoneSettingSecurityHeader], security_header, path=["response"]) + assert_matches_type(Optional[SecurityHeaders], security_header, path=["response"]) @pytest.mark.skip() @parametrize @@ -40,7 +40,7 @@ def test_method_edit_with_all_params(self, client: Cloudflare) -> None: } }, ) - assert_matches_type(Optional[ZoneSettingSecurityHeader], security_header, path=["response"]) + assert_matches_type(Optional[SecurityHeaders], security_header, path=["response"]) @pytest.mark.skip() @parametrize @@ -53,7 +53,7 @@ def test_raw_response_edit(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" security_header = response.parse() - assert_matches_type(Optional[ZoneSettingSecurityHeader], security_header, path=["response"]) + assert_matches_type(Optional[SecurityHeaders], security_header, path=["response"]) @pytest.mark.skip() @parametrize @@ -66,7 +66,7 @@ def test_streaming_response_edit(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" security_header = response.parse() - assert_matches_type(Optional[ZoneSettingSecurityHeader], security_header, path=["response"]) + assert_matches_type(Optional[SecurityHeaders], security_header, path=["response"]) assert cast(Any, response.is_closed) is True @@ -85,7 +85,7 @@ def test_method_get(self, client: Cloudflare) -> None: security_header = client.zones.settings.security_headers.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingSecurityHeader], security_header, path=["response"]) + assert_matches_type(Optional[SecurityHeaders], security_header, path=["response"]) @pytest.mark.skip() @parametrize @@ -97,7 +97,7 @@ def test_raw_response_get(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" security_header = response.parse() - assert_matches_type(Optional[ZoneSettingSecurityHeader], security_header, path=["response"]) + assert_matches_type(Optional[SecurityHeaders], security_header, path=["response"]) @pytest.mark.skip() @parametrize @@ -109,7 +109,7 @@ def test_streaming_response_get(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" security_header = response.parse() - assert_matches_type(Optional[ZoneSettingSecurityHeader], security_header, path=["response"]) + assert_matches_type(Optional[SecurityHeaders], security_header, path=["response"]) assert cast(Any, response.is_closed) is True @@ -132,7 +132,7 @@ async def test_method_edit(self, async_client: AsyncCloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value={}, ) - assert_matches_type(Optional[ZoneSettingSecurityHeader], security_header, path=["response"]) + assert_matches_type(Optional[SecurityHeaders], security_header, path=["response"]) @pytest.mark.skip() @parametrize @@ -148,7 +148,7 @@ async def test_method_edit_with_all_params(self, async_client: AsyncCloudflare) } }, ) - assert_matches_type(Optional[ZoneSettingSecurityHeader], security_header, path=["response"]) + assert_matches_type(Optional[SecurityHeaders], security_header, path=["response"]) @pytest.mark.skip() @parametrize @@ -161,7 +161,7 @@ async def test_raw_response_edit(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" security_header = await response.parse() - assert_matches_type(Optional[ZoneSettingSecurityHeader], security_header, path=["response"]) + assert_matches_type(Optional[SecurityHeaders], security_header, path=["response"]) @pytest.mark.skip() @parametrize @@ -174,7 +174,7 @@ async def test_streaming_response_edit(self, async_client: AsyncCloudflare) -> N assert response.http_request.headers.get("X-Stainless-Lang") == "python" security_header = await response.parse() - assert_matches_type(Optional[ZoneSettingSecurityHeader], security_header, path=["response"]) + assert_matches_type(Optional[SecurityHeaders], security_header, path=["response"]) assert cast(Any, response.is_closed) is True @@ -193,7 +193,7 @@ async def test_method_get(self, async_client: AsyncCloudflare) -> None: security_header = await async_client.zones.settings.security_headers.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingSecurityHeader], security_header, path=["response"]) + assert_matches_type(Optional[SecurityHeaders], security_header, path=["response"]) @pytest.mark.skip() @parametrize @@ -205,7 +205,7 @@ async def test_raw_response_get(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" security_header = await response.parse() - assert_matches_type(Optional[ZoneSettingSecurityHeader], security_header, path=["response"]) + assert_matches_type(Optional[SecurityHeaders], security_header, path=["response"]) @pytest.mark.skip() @parametrize @@ -217,7 +217,7 @@ async def test_streaming_response_get(self, async_client: AsyncCloudflare) -> No assert response.http_request.headers.get("X-Stainless-Lang") == "python" security_header = await response.parse() - assert_matches_type(Optional[ZoneSettingSecurityHeader], security_header, path=["response"]) + assert_matches_type(Optional[SecurityHeaders], security_header, path=["response"]) assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/zones/settings/test_security_level.py b/tests/api_resources/zones/settings/test_security_level.py index 9cb8a9aedc3c..2ea94451ba11 100644 --- a/tests/api_resources/zones/settings/test_security_level.py +++ b/tests/api_resources/zones/settings/test_security_level.py @@ -9,7 +9,7 @@ from cloudflare import Cloudflare, AsyncCloudflare from tests.utils import assert_matches_type -from cloudflare.types.zones.settings import ZoneSettingSecurityLevel +from cloudflare.types.zones.settings import SecurityLevel base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -24,7 +24,7 @@ def test_method_edit(self, client: Cloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="off", ) - assert_matches_type(Optional[ZoneSettingSecurityLevel], security_level, path=["response"]) + assert_matches_type(Optional[SecurityLevel], security_level, path=["response"]) @pytest.mark.skip() @parametrize @@ -37,7 +37,7 @@ def test_raw_response_edit(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" security_level = response.parse() - assert_matches_type(Optional[ZoneSettingSecurityLevel], security_level, path=["response"]) + assert_matches_type(Optional[SecurityLevel], security_level, path=["response"]) @pytest.mark.skip() @parametrize @@ -50,7 +50,7 @@ def test_streaming_response_edit(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" security_level = response.parse() - assert_matches_type(Optional[ZoneSettingSecurityLevel], security_level, path=["response"]) + assert_matches_type(Optional[SecurityLevel], security_level, path=["response"]) assert cast(Any, response.is_closed) is True @@ -69,7 +69,7 @@ def test_method_get(self, client: Cloudflare) -> None: security_level = client.zones.settings.security_level.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingSecurityLevel], security_level, path=["response"]) + assert_matches_type(Optional[SecurityLevel], security_level, path=["response"]) @pytest.mark.skip() @parametrize @@ -81,7 +81,7 @@ def test_raw_response_get(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" security_level = response.parse() - assert_matches_type(Optional[ZoneSettingSecurityLevel], security_level, path=["response"]) + assert_matches_type(Optional[SecurityLevel], security_level, path=["response"]) @pytest.mark.skip() @parametrize @@ -93,7 +93,7 @@ def test_streaming_response_get(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" security_level = response.parse() - assert_matches_type(Optional[ZoneSettingSecurityLevel], security_level, path=["response"]) + assert_matches_type(Optional[SecurityLevel], security_level, path=["response"]) assert cast(Any, response.is_closed) is True @@ -116,7 +116,7 @@ async def test_method_edit(self, async_client: AsyncCloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="off", ) - assert_matches_type(Optional[ZoneSettingSecurityLevel], security_level, path=["response"]) + assert_matches_type(Optional[SecurityLevel], security_level, path=["response"]) @pytest.mark.skip() @parametrize @@ -129,7 +129,7 @@ async def test_raw_response_edit(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" security_level = await response.parse() - assert_matches_type(Optional[ZoneSettingSecurityLevel], security_level, path=["response"]) + assert_matches_type(Optional[SecurityLevel], security_level, path=["response"]) @pytest.mark.skip() @parametrize @@ -142,7 +142,7 @@ async def test_streaming_response_edit(self, async_client: AsyncCloudflare) -> N assert response.http_request.headers.get("X-Stainless-Lang") == "python" security_level = await response.parse() - assert_matches_type(Optional[ZoneSettingSecurityLevel], security_level, path=["response"]) + assert_matches_type(Optional[SecurityLevel], security_level, path=["response"]) assert cast(Any, response.is_closed) is True @@ -161,7 +161,7 @@ async def test_method_get(self, async_client: AsyncCloudflare) -> None: security_level = await async_client.zones.settings.security_level.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingSecurityLevel], security_level, path=["response"]) + assert_matches_type(Optional[SecurityLevel], security_level, path=["response"]) @pytest.mark.skip() @parametrize @@ -173,7 +173,7 @@ async def test_raw_response_get(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" security_level = await response.parse() - assert_matches_type(Optional[ZoneSettingSecurityLevel], security_level, path=["response"]) + assert_matches_type(Optional[SecurityLevel], security_level, path=["response"]) @pytest.mark.skip() @parametrize @@ -185,7 +185,7 @@ async def test_streaming_response_get(self, async_client: AsyncCloudflare) -> No assert response.http_request.headers.get("X-Stainless-Lang") == "python" security_level = await response.parse() - assert_matches_type(Optional[ZoneSettingSecurityLevel], security_level, path=["response"]) + assert_matches_type(Optional[SecurityLevel], security_level, path=["response"]) assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/zones/settings/test_server_side_excludes.py b/tests/api_resources/zones/settings/test_server_side_excludes.py index dcaed8d28533..ee818f4662b0 100644 --- a/tests/api_resources/zones/settings/test_server_side_excludes.py +++ b/tests/api_resources/zones/settings/test_server_side_excludes.py @@ -9,7 +9,7 @@ from cloudflare import Cloudflare, AsyncCloudflare from tests.utils import assert_matches_type -from cloudflare.types.zones.settings import ZoneSettingServerSideExclude +from cloudflare.types.zones.settings import ServerSideExcludes base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -24,7 +24,7 @@ def test_method_edit(self, client: Cloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="on", ) - assert_matches_type(Optional[ZoneSettingServerSideExclude], server_side_exclude, path=["response"]) + assert_matches_type(Optional[ServerSideExcludes], server_side_exclude, path=["response"]) @pytest.mark.skip() @parametrize @@ -37,7 +37,7 @@ def test_raw_response_edit(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" server_side_exclude = response.parse() - assert_matches_type(Optional[ZoneSettingServerSideExclude], server_side_exclude, path=["response"]) + assert_matches_type(Optional[ServerSideExcludes], server_side_exclude, path=["response"]) @pytest.mark.skip() @parametrize @@ -50,7 +50,7 @@ def test_streaming_response_edit(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" server_side_exclude = response.parse() - assert_matches_type(Optional[ZoneSettingServerSideExclude], server_side_exclude, path=["response"]) + assert_matches_type(Optional[ServerSideExcludes], server_side_exclude, path=["response"]) assert cast(Any, response.is_closed) is True @@ -69,7 +69,7 @@ def test_method_get(self, client: Cloudflare) -> None: server_side_exclude = client.zones.settings.server_side_excludes.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingServerSideExclude], server_side_exclude, path=["response"]) + assert_matches_type(Optional[ServerSideExcludes], server_side_exclude, path=["response"]) @pytest.mark.skip() @parametrize @@ -81,7 +81,7 @@ def test_raw_response_get(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" server_side_exclude = response.parse() - assert_matches_type(Optional[ZoneSettingServerSideExclude], server_side_exclude, path=["response"]) + assert_matches_type(Optional[ServerSideExcludes], server_side_exclude, path=["response"]) @pytest.mark.skip() @parametrize @@ -93,7 +93,7 @@ def test_streaming_response_get(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" server_side_exclude = response.parse() - assert_matches_type(Optional[ZoneSettingServerSideExclude], server_side_exclude, path=["response"]) + assert_matches_type(Optional[ServerSideExcludes], server_side_exclude, path=["response"]) assert cast(Any, response.is_closed) is True @@ -116,7 +116,7 @@ async def test_method_edit(self, async_client: AsyncCloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="on", ) - assert_matches_type(Optional[ZoneSettingServerSideExclude], server_side_exclude, path=["response"]) + assert_matches_type(Optional[ServerSideExcludes], server_side_exclude, path=["response"]) @pytest.mark.skip() @parametrize @@ -129,7 +129,7 @@ async def test_raw_response_edit(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" server_side_exclude = await response.parse() - assert_matches_type(Optional[ZoneSettingServerSideExclude], server_side_exclude, path=["response"]) + assert_matches_type(Optional[ServerSideExcludes], server_side_exclude, path=["response"]) @pytest.mark.skip() @parametrize @@ -142,7 +142,7 @@ async def test_streaming_response_edit(self, async_client: AsyncCloudflare) -> N assert response.http_request.headers.get("X-Stainless-Lang") == "python" server_side_exclude = await response.parse() - assert_matches_type(Optional[ZoneSettingServerSideExclude], server_side_exclude, path=["response"]) + assert_matches_type(Optional[ServerSideExcludes], server_side_exclude, path=["response"]) assert cast(Any, response.is_closed) is True @@ -161,7 +161,7 @@ async def test_method_get(self, async_client: AsyncCloudflare) -> None: server_side_exclude = await async_client.zones.settings.server_side_excludes.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingServerSideExclude], server_side_exclude, path=["response"]) + assert_matches_type(Optional[ServerSideExcludes], server_side_exclude, path=["response"]) @pytest.mark.skip() @parametrize @@ -173,7 +173,7 @@ async def test_raw_response_get(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" server_side_exclude = await response.parse() - assert_matches_type(Optional[ZoneSettingServerSideExclude], server_side_exclude, path=["response"]) + assert_matches_type(Optional[ServerSideExcludes], server_side_exclude, path=["response"]) @pytest.mark.skip() @parametrize @@ -185,7 +185,7 @@ async def test_streaming_response_get(self, async_client: AsyncCloudflare) -> No assert response.http_request.headers.get("X-Stainless-Lang") == "python" server_side_exclude = await response.parse() - assert_matches_type(Optional[ZoneSettingServerSideExclude], server_side_exclude, path=["response"]) + assert_matches_type(Optional[ServerSideExcludes], server_side_exclude, path=["response"]) assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/zones/settings/test_sort_query_string_for_cache.py b/tests/api_resources/zones/settings/test_sort_query_string_for_cache.py index 170d7bec92cf..b91c19c9e305 100644 --- a/tests/api_resources/zones/settings/test_sort_query_string_for_cache.py +++ b/tests/api_resources/zones/settings/test_sort_query_string_for_cache.py @@ -9,7 +9,7 @@ from cloudflare import Cloudflare, AsyncCloudflare from tests.utils import assert_matches_type -from cloudflare.types.zones.settings import ZoneSettingSortQueryStringForCache +from cloudflare.types.zones.settings import SortQueryStringForCache base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -24,9 +24,7 @@ def test_method_edit(self, client: Cloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="on", ) - assert_matches_type( - Optional[ZoneSettingSortQueryStringForCache], sort_query_string_for_cache, path=["response"] - ) + assert_matches_type(Optional[SortQueryStringForCache], sort_query_string_for_cache, path=["response"]) @pytest.mark.skip() @parametrize @@ -39,9 +37,7 @@ def test_raw_response_edit(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" sort_query_string_for_cache = response.parse() - assert_matches_type( - Optional[ZoneSettingSortQueryStringForCache], sort_query_string_for_cache, path=["response"] - ) + assert_matches_type(Optional[SortQueryStringForCache], sort_query_string_for_cache, path=["response"]) @pytest.mark.skip() @parametrize @@ -54,9 +50,7 @@ def test_streaming_response_edit(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" sort_query_string_for_cache = response.parse() - assert_matches_type( - Optional[ZoneSettingSortQueryStringForCache], sort_query_string_for_cache, path=["response"] - ) + assert_matches_type(Optional[SortQueryStringForCache], sort_query_string_for_cache, path=["response"]) assert cast(Any, response.is_closed) is True @@ -75,9 +69,7 @@ def test_method_get(self, client: Cloudflare) -> None: sort_query_string_for_cache = client.zones.settings.sort_query_string_for_cache.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type( - Optional[ZoneSettingSortQueryStringForCache], sort_query_string_for_cache, path=["response"] - ) + assert_matches_type(Optional[SortQueryStringForCache], sort_query_string_for_cache, path=["response"]) @pytest.mark.skip() @parametrize @@ -89,9 +81,7 @@ def test_raw_response_get(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" sort_query_string_for_cache = response.parse() - assert_matches_type( - Optional[ZoneSettingSortQueryStringForCache], sort_query_string_for_cache, path=["response"] - ) + assert_matches_type(Optional[SortQueryStringForCache], sort_query_string_for_cache, path=["response"]) @pytest.mark.skip() @parametrize @@ -103,9 +93,7 @@ def test_streaming_response_get(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" sort_query_string_for_cache = response.parse() - assert_matches_type( - Optional[ZoneSettingSortQueryStringForCache], sort_query_string_for_cache, path=["response"] - ) + assert_matches_type(Optional[SortQueryStringForCache], sort_query_string_for_cache, path=["response"]) assert cast(Any, response.is_closed) is True @@ -128,9 +116,7 @@ async def test_method_edit(self, async_client: AsyncCloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="on", ) - assert_matches_type( - Optional[ZoneSettingSortQueryStringForCache], sort_query_string_for_cache, path=["response"] - ) + assert_matches_type(Optional[SortQueryStringForCache], sort_query_string_for_cache, path=["response"]) @pytest.mark.skip() @parametrize @@ -143,9 +129,7 @@ async def test_raw_response_edit(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" sort_query_string_for_cache = await response.parse() - assert_matches_type( - Optional[ZoneSettingSortQueryStringForCache], sort_query_string_for_cache, path=["response"] - ) + assert_matches_type(Optional[SortQueryStringForCache], sort_query_string_for_cache, path=["response"]) @pytest.mark.skip() @parametrize @@ -158,9 +142,7 @@ async def test_streaming_response_edit(self, async_client: AsyncCloudflare) -> N assert response.http_request.headers.get("X-Stainless-Lang") == "python" sort_query_string_for_cache = await response.parse() - assert_matches_type( - Optional[ZoneSettingSortQueryStringForCache], sort_query_string_for_cache, path=["response"] - ) + assert_matches_type(Optional[SortQueryStringForCache], sort_query_string_for_cache, path=["response"]) assert cast(Any, response.is_closed) is True @@ -179,9 +161,7 @@ async def test_method_get(self, async_client: AsyncCloudflare) -> None: sort_query_string_for_cache = await async_client.zones.settings.sort_query_string_for_cache.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type( - Optional[ZoneSettingSortQueryStringForCache], sort_query_string_for_cache, path=["response"] - ) + assert_matches_type(Optional[SortQueryStringForCache], sort_query_string_for_cache, path=["response"]) @pytest.mark.skip() @parametrize @@ -193,9 +173,7 @@ async def test_raw_response_get(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" sort_query_string_for_cache = await response.parse() - assert_matches_type( - Optional[ZoneSettingSortQueryStringForCache], sort_query_string_for_cache, path=["response"] - ) + assert_matches_type(Optional[SortQueryStringForCache], sort_query_string_for_cache, path=["response"]) @pytest.mark.skip() @parametrize @@ -207,9 +185,7 @@ async def test_streaming_response_get(self, async_client: AsyncCloudflare) -> No assert response.http_request.headers.get("X-Stainless-Lang") == "python" sort_query_string_for_cache = await response.parse() - assert_matches_type( - Optional[ZoneSettingSortQueryStringForCache], sort_query_string_for_cache, path=["response"] - ) + assert_matches_type(Optional[SortQueryStringForCache], sort_query_string_for_cache, path=["response"]) assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/zones/settings/test_ssl.py b/tests/api_resources/zones/settings/test_ssl.py index 1a22aa81a7a1..e749d573b71c 100644 --- a/tests/api_resources/zones/settings/test_ssl.py +++ b/tests/api_resources/zones/settings/test_ssl.py @@ -9,7 +9,7 @@ from cloudflare import Cloudflare, AsyncCloudflare from tests.utils import assert_matches_type -from cloudflare.types.zones.settings import ZoneSettingSSL +from cloudflare.types.zones.settings import SSL base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -24,7 +24,7 @@ def test_method_edit(self, client: Cloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="off", ) - assert_matches_type(Optional[ZoneSettingSSL], ssl, path=["response"]) + assert_matches_type(Optional[SSL], ssl, path=["response"]) @pytest.mark.skip() @parametrize @@ -37,7 +37,7 @@ def test_raw_response_edit(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" ssl = response.parse() - assert_matches_type(Optional[ZoneSettingSSL], ssl, path=["response"]) + assert_matches_type(Optional[SSL], ssl, path=["response"]) @pytest.mark.skip() @parametrize @@ -50,7 +50,7 @@ def test_streaming_response_edit(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" ssl = response.parse() - assert_matches_type(Optional[ZoneSettingSSL], ssl, path=["response"]) + assert_matches_type(Optional[SSL], ssl, path=["response"]) assert cast(Any, response.is_closed) is True @@ -69,7 +69,7 @@ def test_method_get(self, client: Cloudflare) -> None: ssl = client.zones.settings.ssl.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingSSL], ssl, path=["response"]) + assert_matches_type(Optional[SSL], ssl, path=["response"]) @pytest.mark.skip() @parametrize @@ -81,7 +81,7 @@ def test_raw_response_get(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" ssl = response.parse() - assert_matches_type(Optional[ZoneSettingSSL], ssl, path=["response"]) + assert_matches_type(Optional[SSL], ssl, path=["response"]) @pytest.mark.skip() @parametrize @@ -93,7 +93,7 @@ def test_streaming_response_get(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" ssl = response.parse() - assert_matches_type(Optional[ZoneSettingSSL], ssl, path=["response"]) + assert_matches_type(Optional[SSL], ssl, path=["response"]) assert cast(Any, response.is_closed) is True @@ -116,7 +116,7 @@ async def test_method_edit(self, async_client: AsyncCloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="off", ) - assert_matches_type(Optional[ZoneSettingSSL], ssl, path=["response"]) + assert_matches_type(Optional[SSL], ssl, path=["response"]) @pytest.mark.skip() @parametrize @@ -129,7 +129,7 @@ async def test_raw_response_edit(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" ssl = await response.parse() - assert_matches_type(Optional[ZoneSettingSSL], ssl, path=["response"]) + assert_matches_type(Optional[SSL], ssl, path=["response"]) @pytest.mark.skip() @parametrize @@ -142,7 +142,7 @@ async def test_streaming_response_edit(self, async_client: AsyncCloudflare) -> N assert response.http_request.headers.get("X-Stainless-Lang") == "python" ssl = await response.parse() - assert_matches_type(Optional[ZoneSettingSSL], ssl, path=["response"]) + assert_matches_type(Optional[SSL], ssl, path=["response"]) assert cast(Any, response.is_closed) is True @@ -161,7 +161,7 @@ async def test_method_get(self, async_client: AsyncCloudflare) -> None: ssl = await async_client.zones.settings.ssl.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingSSL], ssl, path=["response"]) + assert_matches_type(Optional[SSL], ssl, path=["response"]) @pytest.mark.skip() @parametrize @@ -173,7 +173,7 @@ async def test_raw_response_get(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" ssl = await response.parse() - assert_matches_type(Optional[ZoneSettingSSL], ssl, path=["response"]) + assert_matches_type(Optional[SSL], ssl, path=["response"]) @pytest.mark.skip() @parametrize @@ -185,7 +185,7 @@ async def test_streaming_response_get(self, async_client: AsyncCloudflare) -> No assert response.http_request.headers.get("X-Stainless-Lang") == "python" ssl = await response.parse() - assert_matches_type(Optional[ZoneSettingSSL], ssl, path=["response"]) + assert_matches_type(Optional[SSL], ssl, path=["response"]) assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/zones/settings/test_ssl_recommender.py b/tests/api_resources/zones/settings/test_ssl_recommender.py index 5fb5afb20c02..908b7e922cc1 100644 --- a/tests/api_resources/zones/settings/test_ssl_recommender.py +++ b/tests/api_resources/zones/settings/test_ssl_recommender.py @@ -9,7 +9,7 @@ from cloudflare import Cloudflare, AsyncCloudflare from tests.utils import assert_matches_type -from cloudflare.types.zones.settings import ZoneSettingSSLRecommender +from cloudflare.types.zones.settings import SSLRecommender base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -24,7 +24,7 @@ def test_method_edit(self, client: Cloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value={}, ) - assert_matches_type(Optional[ZoneSettingSSLRecommender], ssl_recommender, path=["response"]) + assert_matches_type(Optional[SSLRecommender], ssl_recommender, path=["response"]) @pytest.mark.skip() @parametrize @@ -36,7 +36,7 @@ def test_method_edit_with_all_params(self, client: Cloudflare) -> None: "id": "ssl_recommender", }, ) - assert_matches_type(Optional[ZoneSettingSSLRecommender], ssl_recommender, path=["response"]) + assert_matches_type(Optional[SSLRecommender], ssl_recommender, path=["response"]) @pytest.mark.skip() @parametrize @@ -49,7 +49,7 @@ def test_raw_response_edit(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" ssl_recommender = response.parse() - assert_matches_type(Optional[ZoneSettingSSLRecommender], ssl_recommender, path=["response"]) + assert_matches_type(Optional[SSLRecommender], ssl_recommender, path=["response"]) @pytest.mark.skip() @parametrize @@ -62,7 +62,7 @@ def test_streaming_response_edit(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" ssl_recommender = response.parse() - assert_matches_type(Optional[ZoneSettingSSLRecommender], ssl_recommender, path=["response"]) + assert_matches_type(Optional[SSLRecommender], ssl_recommender, path=["response"]) assert cast(Any, response.is_closed) is True @@ -81,7 +81,7 @@ def test_method_get(self, client: Cloudflare) -> None: ssl_recommender = client.zones.settings.ssl_recommender.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingSSLRecommender], ssl_recommender, path=["response"]) + assert_matches_type(Optional[SSLRecommender], ssl_recommender, path=["response"]) @pytest.mark.skip() @parametrize @@ -93,7 +93,7 @@ def test_raw_response_get(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" ssl_recommender = response.parse() - assert_matches_type(Optional[ZoneSettingSSLRecommender], ssl_recommender, path=["response"]) + assert_matches_type(Optional[SSLRecommender], ssl_recommender, path=["response"]) @pytest.mark.skip() @parametrize @@ -105,7 +105,7 @@ def test_streaming_response_get(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" ssl_recommender = response.parse() - assert_matches_type(Optional[ZoneSettingSSLRecommender], ssl_recommender, path=["response"]) + assert_matches_type(Optional[SSLRecommender], ssl_recommender, path=["response"]) assert cast(Any, response.is_closed) is True @@ -128,7 +128,7 @@ async def test_method_edit(self, async_client: AsyncCloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value={}, ) - assert_matches_type(Optional[ZoneSettingSSLRecommender], ssl_recommender, path=["response"]) + assert_matches_type(Optional[SSLRecommender], ssl_recommender, path=["response"]) @pytest.mark.skip() @parametrize @@ -140,7 +140,7 @@ async def test_method_edit_with_all_params(self, async_client: AsyncCloudflare) "id": "ssl_recommender", }, ) - assert_matches_type(Optional[ZoneSettingSSLRecommender], ssl_recommender, path=["response"]) + assert_matches_type(Optional[SSLRecommender], ssl_recommender, path=["response"]) @pytest.mark.skip() @parametrize @@ -153,7 +153,7 @@ async def test_raw_response_edit(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" ssl_recommender = await response.parse() - assert_matches_type(Optional[ZoneSettingSSLRecommender], ssl_recommender, path=["response"]) + assert_matches_type(Optional[SSLRecommender], ssl_recommender, path=["response"]) @pytest.mark.skip() @parametrize @@ -166,7 +166,7 @@ async def test_streaming_response_edit(self, async_client: AsyncCloudflare) -> N assert response.http_request.headers.get("X-Stainless-Lang") == "python" ssl_recommender = await response.parse() - assert_matches_type(Optional[ZoneSettingSSLRecommender], ssl_recommender, path=["response"]) + assert_matches_type(Optional[SSLRecommender], ssl_recommender, path=["response"]) assert cast(Any, response.is_closed) is True @@ -185,7 +185,7 @@ async def test_method_get(self, async_client: AsyncCloudflare) -> None: ssl_recommender = await async_client.zones.settings.ssl_recommender.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingSSLRecommender], ssl_recommender, path=["response"]) + assert_matches_type(Optional[SSLRecommender], ssl_recommender, path=["response"]) @pytest.mark.skip() @parametrize @@ -197,7 +197,7 @@ async def test_raw_response_get(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" ssl_recommender = await response.parse() - assert_matches_type(Optional[ZoneSettingSSLRecommender], ssl_recommender, path=["response"]) + assert_matches_type(Optional[SSLRecommender], ssl_recommender, path=["response"]) @pytest.mark.skip() @parametrize @@ -209,7 +209,7 @@ async def test_streaming_response_get(self, async_client: AsyncCloudflare) -> No assert response.http_request.headers.get("X-Stainless-Lang") == "python" ssl_recommender = await response.parse() - assert_matches_type(Optional[ZoneSettingSSLRecommender], ssl_recommender, path=["response"]) + assert_matches_type(Optional[SSLRecommender], ssl_recommender, path=["response"]) assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/zones/settings/test_tls_1_3.py b/tests/api_resources/zones/settings/test_tls_1_3.py index 4cf09b010a68..439a0d44ddb0 100644 --- a/tests/api_resources/zones/settings/test_tls_1_3.py +++ b/tests/api_resources/zones/settings/test_tls_1_3.py @@ -9,7 +9,7 @@ from cloudflare import Cloudflare, AsyncCloudflare from tests.utils import assert_matches_type -from cloudflare.types.zones.settings import ZoneSettingTLS1_3 +from cloudflare.types.zones.settings import TLS1_3 base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -24,7 +24,7 @@ def test_method_edit(self, client: Cloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="on", ) - assert_matches_type(Optional[ZoneSettingTLS1_3], tls_1_3, path=["response"]) + assert_matches_type(Optional[TLS1_3], tls_1_3, path=["response"]) @pytest.mark.skip() @parametrize @@ -37,7 +37,7 @@ def test_raw_response_edit(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" tls_1_3 = response.parse() - assert_matches_type(Optional[ZoneSettingTLS1_3], tls_1_3, path=["response"]) + assert_matches_type(Optional[TLS1_3], tls_1_3, path=["response"]) @pytest.mark.skip() @parametrize @@ -50,7 +50,7 @@ def test_streaming_response_edit(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" tls_1_3 = response.parse() - assert_matches_type(Optional[ZoneSettingTLS1_3], tls_1_3, path=["response"]) + assert_matches_type(Optional[TLS1_3], tls_1_3, path=["response"]) assert cast(Any, response.is_closed) is True @@ -69,7 +69,7 @@ def test_method_get(self, client: Cloudflare) -> None: tls_1_3 = client.zones.settings.tls_1_3.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingTLS1_3], tls_1_3, path=["response"]) + assert_matches_type(Optional[TLS1_3], tls_1_3, path=["response"]) @pytest.mark.skip() @parametrize @@ -81,7 +81,7 @@ def test_raw_response_get(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" tls_1_3 = response.parse() - assert_matches_type(Optional[ZoneSettingTLS1_3], tls_1_3, path=["response"]) + assert_matches_type(Optional[TLS1_3], tls_1_3, path=["response"]) @pytest.mark.skip() @parametrize @@ -93,7 +93,7 @@ def test_streaming_response_get(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" tls_1_3 = response.parse() - assert_matches_type(Optional[ZoneSettingTLS1_3], tls_1_3, path=["response"]) + assert_matches_type(Optional[TLS1_3], tls_1_3, path=["response"]) assert cast(Any, response.is_closed) is True @@ -116,7 +116,7 @@ async def test_method_edit(self, async_client: AsyncCloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="on", ) - assert_matches_type(Optional[ZoneSettingTLS1_3], tls_1_3, path=["response"]) + assert_matches_type(Optional[TLS1_3], tls_1_3, path=["response"]) @pytest.mark.skip() @parametrize @@ -129,7 +129,7 @@ async def test_raw_response_edit(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" tls_1_3 = await response.parse() - assert_matches_type(Optional[ZoneSettingTLS1_3], tls_1_3, path=["response"]) + assert_matches_type(Optional[TLS1_3], tls_1_3, path=["response"]) @pytest.mark.skip() @parametrize @@ -142,7 +142,7 @@ async def test_streaming_response_edit(self, async_client: AsyncCloudflare) -> N assert response.http_request.headers.get("X-Stainless-Lang") == "python" tls_1_3 = await response.parse() - assert_matches_type(Optional[ZoneSettingTLS1_3], tls_1_3, path=["response"]) + assert_matches_type(Optional[TLS1_3], tls_1_3, path=["response"]) assert cast(Any, response.is_closed) is True @@ -161,7 +161,7 @@ async def test_method_get(self, async_client: AsyncCloudflare) -> None: tls_1_3 = await async_client.zones.settings.tls_1_3.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingTLS1_3], tls_1_3, path=["response"]) + assert_matches_type(Optional[TLS1_3], tls_1_3, path=["response"]) @pytest.mark.skip() @parametrize @@ -173,7 +173,7 @@ async def test_raw_response_get(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" tls_1_3 = await response.parse() - assert_matches_type(Optional[ZoneSettingTLS1_3], tls_1_3, path=["response"]) + assert_matches_type(Optional[TLS1_3], tls_1_3, path=["response"]) @pytest.mark.skip() @parametrize @@ -185,7 +185,7 @@ async def test_streaming_response_get(self, async_client: AsyncCloudflare) -> No assert response.http_request.headers.get("X-Stainless-Lang") == "python" tls_1_3 = await response.parse() - assert_matches_type(Optional[ZoneSettingTLS1_3], tls_1_3, path=["response"]) + assert_matches_type(Optional[TLS1_3], tls_1_3, path=["response"]) assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/zones/settings/test_tls_client_auth.py b/tests/api_resources/zones/settings/test_tls_client_auth.py index b29d5c2a6f60..6f8c2f049679 100644 --- a/tests/api_resources/zones/settings/test_tls_client_auth.py +++ b/tests/api_resources/zones/settings/test_tls_client_auth.py @@ -9,7 +9,7 @@ from cloudflare import Cloudflare, AsyncCloudflare from tests.utils import assert_matches_type -from cloudflare.types.zones.settings import ZoneSettingTLSClientAuth +from cloudflare.types.zones.settings import TLSClientAuth base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -24,7 +24,7 @@ def test_method_edit(self, client: Cloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="on", ) - assert_matches_type(Optional[ZoneSettingTLSClientAuth], tls_client_auth, path=["response"]) + assert_matches_type(Optional[TLSClientAuth], tls_client_auth, path=["response"]) @pytest.mark.skip() @parametrize @@ -37,7 +37,7 @@ def test_raw_response_edit(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" tls_client_auth = response.parse() - assert_matches_type(Optional[ZoneSettingTLSClientAuth], tls_client_auth, path=["response"]) + assert_matches_type(Optional[TLSClientAuth], tls_client_auth, path=["response"]) @pytest.mark.skip() @parametrize @@ -50,7 +50,7 @@ def test_streaming_response_edit(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" tls_client_auth = response.parse() - assert_matches_type(Optional[ZoneSettingTLSClientAuth], tls_client_auth, path=["response"]) + assert_matches_type(Optional[TLSClientAuth], tls_client_auth, path=["response"]) assert cast(Any, response.is_closed) is True @@ -69,7 +69,7 @@ def test_method_get(self, client: Cloudflare) -> None: tls_client_auth = client.zones.settings.tls_client_auth.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingTLSClientAuth], tls_client_auth, path=["response"]) + assert_matches_type(Optional[TLSClientAuth], tls_client_auth, path=["response"]) @pytest.mark.skip() @parametrize @@ -81,7 +81,7 @@ def test_raw_response_get(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" tls_client_auth = response.parse() - assert_matches_type(Optional[ZoneSettingTLSClientAuth], tls_client_auth, path=["response"]) + assert_matches_type(Optional[TLSClientAuth], tls_client_auth, path=["response"]) @pytest.mark.skip() @parametrize @@ -93,7 +93,7 @@ def test_streaming_response_get(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" tls_client_auth = response.parse() - assert_matches_type(Optional[ZoneSettingTLSClientAuth], tls_client_auth, path=["response"]) + assert_matches_type(Optional[TLSClientAuth], tls_client_auth, path=["response"]) assert cast(Any, response.is_closed) is True @@ -116,7 +116,7 @@ async def test_method_edit(self, async_client: AsyncCloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="on", ) - assert_matches_type(Optional[ZoneSettingTLSClientAuth], tls_client_auth, path=["response"]) + assert_matches_type(Optional[TLSClientAuth], tls_client_auth, path=["response"]) @pytest.mark.skip() @parametrize @@ -129,7 +129,7 @@ async def test_raw_response_edit(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" tls_client_auth = await response.parse() - assert_matches_type(Optional[ZoneSettingTLSClientAuth], tls_client_auth, path=["response"]) + assert_matches_type(Optional[TLSClientAuth], tls_client_auth, path=["response"]) @pytest.mark.skip() @parametrize @@ -142,7 +142,7 @@ async def test_streaming_response_edit(self, async_client: AsyncCloudflare) -> N assert response.http_request.headers.get("X-Stainless-Lang") == "python" tls_client_auth = await response.parse() - assert_matches_type(Optional[ZoneSettingTLSClientAuth], tls_client_auth, path=["response"]) + assert_matches_type(Optional[TLSClientAuth], tls_client_auth, path=["response"]) assert cast(Any, response.is_closed) is True @@ -161,7 +161,7 @@ async def test_method_get(self, async_client: AsyncCloudflare) -> None: tls_client_auth = await async_client.zones.settings.tls_client_auth.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingTLSClientAuth], tls_client_auth, path=["response"]) + assert_matches_type(Optional[TLSClientAuth], tls_client_auth, path=["response"]) @pytest.mark.skip() @parametrize @@ -173,7 +173,7 @@ async def test_raw_response_get(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" tls_client_auth = await response.parse() - assert_matches_type(Optional[ZoneSettingTLSClientAuth], tls_client_auth, path=["response"]) + assert_matches_type(Optional[TLSClientAuth], tls_client_auth, path=["response"]) @pytest.mark.skip() @parametrize @@ -185,7 +185,7 @@ async def test_streaming_response_get(self, async_client: AsyncCloudflare) -> No assert response.http_request.headers.get("X-Stainless-Lang") == "python" tls_client_auth = await response.parse() - assert_matches_type(Optional[ZoneSettingTLSClientAuth], tls_client_auth, path=["response"]) + assert_matches_type(Optional[TLSClientAuth], tls_client_auth, path=["response"]) assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/zones/settings/test_true_client_ip_header.py b/tests/api_resources/zones/settings/test_true_client_ip_header.py index 11556f8be2db..ea3d3532e9c4 100644 --- a/tests/api_resources/zones/settings/test_true_client_ip_header.py +++ b/tests/api_resources/zones/settings/test_true_client_ip_header.py @@ -9,7 +9,7 @@ from cloudflare import Cloudflare, AsyncCloudflare from tests.utils import assert_matches_type -from cloudflare.types.zones.settings import ZoneSettingTrueClientIPHeader +from cloudflare.types.zones.settings import TrueClientIPHeader base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -24,7 +24,7 @@ def test_method_edit(self, client: Cloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="on", ) - assert_matches_type(Optional[ZoneSettingTrueClientIPHeader], true_client_ip_header, path=["response"]) + assert_matches_type(Optional[TrueClientIPHeader], true_client_ip_header, path=["response"]) @pytest.mark.skip() @parametrize @@ -37,7 +37,7 @@ def test_raw_response_edit(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" true_client_ip_header = response.parse() - assert_matches_type(Optional[ZoneSettingTrueClientIPHeader], true_client_ip_header, path=["response"]) + assert_matches_type(Optional[TrueClientIPHeader], true_client_ip_header, path=["response"]) @pytest.mark.skip() @parametrize @@ -50,7 +50,7 @@ def test_streaming_response_edit(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" true_client_ip_header = response.parse() - assert_matches_type(Optional[ZoneSettingTrueClientIPHeader], true_client_ip_header, path=["response"]) + assert_matches_type(Optional[TrueClientIPHeader], true_client_ip_header, path=["response"]) assert cast(Any, response.is_closed) is True @@ -69,7 +69,7 @@ def test_method_get(self, client: Cloudflare) -> None: true_client_ip_header = client.zones.settings.true_client_ip_header.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingTrueClientIPHeader], true_client_ip_header, path=["response"]) + assert_matches_type(Optional[TrueClientIPHeader], true_client_ip_header, path=["response"]) @pytest.mark.skip() @parametrize @@ -81,7 +81,7 @@ def test_raw_response_get(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" true_client_ip_header = response.parse() - assert_matches_type(Optional[ZoneSettingTrueClientIPHeader], true_client_ip_header, path=["response"]) + assert_matches_type(Optional[TrueClientIPHeader], true_client_ip_header, path=["response"]) @pytest.mark.skip() @parametrize @@ -93,7 +93,7 @@ def test_streaming_response_get(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" true_client_ip_header = response.parse() - assert_matches_type(Optional[ZoneSettingTrueClientIPHeader], true_client_ip_header, path=["response"]) + assert_matches_type(Optional[TrueClientIPHeader], true_client_ip_header, path=["response"]) assert cast(Any, response.is_closed) is True @@ -116,7 +116,7 @@ async def test_method_edit(self, async_client: AsyncCloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="on", ) - assert_matches_type(Optional[ZoneSettingTrueClientIPHeader], true_client_ip_header, path=["response"]) + assert_matches_type(Optional[TrueClientIPHeader], true_client_ip_header, path=["response"]) @pytest.mark.skip() @parametrize @@ -129,7 +129,7 @@ async def test_raw_response_edit(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" true_client_ip_header = await response.parse() - assert_matches_type(Optional[ZoneSettingTrueClientIPHeader], true_client_ip_header, path=["response"]) + assert_matches_type(Optional[TrueClientIPHeader], true_client_ip_header, path=["response"]) @pytest.mark.skip() @parametrize @@ -142,7 +142,7 @@ async def test_streaming_response_edit(self, async_client: AsyncCloudflare) -> N assert response.http_request.headers.get("X-Stainless-Lang") == "python" true_client_ip_header = await response.parse() - assert_matches_type(Optional[ZoneSettingTrueClientIPHeader], true_client_ip_header, path=["response"]) + assert_matches_type(Optional[TrueClientIPHeader], true_client_ip_header, path=["response"]) assert cast(Any, response.is_closed) is True @@ -161,7 +161,7 @@ async def test_method_get(self, async_client: AsyncCloudflare) -> None: true_client_ip_header = await async_client.zones.settings.true_client_ip_header.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingTrueClientIPHeader], true_client_ip_header, path=["response"]) + assert_matches_type(Optional[TrueClientIPHeader], true_client_ip_header, path=["response"]) @pytest.mark.skip() @parametrize @@ -173,7 +173,7 @@ async def test_raw_response_get(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" true_client_ip_header = await response.parse() - assert_matches_type(Optional[ZoneSettingTrueClientIPHeader], true_client_ip_header, path=["response"]) + assert_matches_type(Optional[TrueClientIPHeader], true_client_ip_header, path=["response"]) @pytest.mark.skip() @parametrize @@ -185,7 +185,7 @@ async def test_streaming_response_get(self, async_client: AsyncCloudflare) -> No assert response.http_request.headers.get("X-Stainless-Lang") == "python" true_client_ip_header = await response.parse() - assert_matches_type(Optional[ZoneSettingTrueClientIPHeader], true_client_ip_header, path=["response"]) + assert_matches_type(Optional[TrueClientIPHeader], true_client_ip_header, path=["response"]) assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/zones/settings/test_waf.py b/tests/api_resources/zones/settings/test_waf.py index e573fa58ab57..16008e3b6256 100644 --- a/tests/api_resources/zones/settings/test_waf.py +++ b/tests/api_resources/zones/settings/test_waf.py @@ -9,7 +9,7 @@ from cloudflare import Cloudflare, AsyncCloudflare from tests.utils import assert_matches_type -from cloudflare.types.zones.settings import ZoneSettingWAF +from cloudflare.types.zones.settings import WAF base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -24,7 +24,7 @@ def test_method_edit(self, client: Cloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="on", ) - assert_matches_type(Optional[ZoneSettingWAF], waf, path=["response"]) + assert_matches_type(Optional[WAF], waf, path=["response"]) @pytest.mark.skip() @parametrize @@ -37,7 +37,7 @@ def test_raw_response_edit(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" waf = response.parse() - assert_matches_type(Optional[ZoneSettingWAF], waf, path=["response"]) + assert_matches_type(Optional[WAF], waf, path=["response"]) @pytest.mark.skip() @parametrize @@ -50,7 +50,7 @@ def test_streaming_response_edit(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" waf = response.parse() - assert_matches_type(Optional[ZoneSettingWAF], waf, path=["response"]) + assert_matches_type(Optional[WAF], waf, path=["response"]) assert cast(Any, response.is_closed) is True @@ -69,7 +69,7 @@ def test_method_get(self, client: Cloudflare) -> None: waf = client.zones.settings.waf.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingWAF], waf, path=["response"]) + assert_matches_type(Optional[WAF], waf, path=["response"]) @pytest.mark.skip() @parametrize @@ -81,7 +81,7 @@ def test_raw_response_get(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" waf = response.parse() - assert_matches_type(Optional[ZoneSettingWAF], waf, path=["response"]) + assert_matches_type(Optional[WAF], waf, path=["response"]) @pytest.mark.skip() @parametrize @@ -93,7 +93,7 @@ def test_streaming_response_get(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" waf = response.parse() - assert_matches_type(Optional[ZoneSettingWAF], waf, path=["response"]) + assert_matches_type(Optional[WAF], waf, path=["response"]) assert cast(Any, response.is_closed) is True @@ -116,7 +116,7 @@ async def test_method_edit(self, async_client: AsyncCloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="on", ) - assert_matches_type(Optional[ZoneSettingWAF], waf, path=["response"]) + assert_matches_type(Optional[WAF], waf, path=["response"]) @pytest.mark.skip() @parametrize @@ -129,7 +129,7 @@ async def test_raw_response_edit(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" waf = await response.parse() - assert_matches_type(Optional[ZoneSettingWAF], waf, path=["response"]) + assert_matches_type(Optional[WAF], waf, path=["response"]) @pytest.mark.skip() @parametrize @@ -142,7 +142,7 @@ async def test_streaming_response_edit(self, async_client: AsyncCloudflare) -> N assert response.http_request.headers.get("X-Stainless-Lang") == "python" waf = await response.parse() - assert_matches_type(Optional[ZoneSettingWAF], waf, path=["response"]) + assert_matches_type(Optional[WAF], waf, path=["response"]) assert cast(Any, response.is_closed) is True @@ -161,7 +161,7 @@ async def test_method_get(self, async_client: AsyncCloudflare) -> None: waf = await async_client.zones.settings.waf.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingWAF], waf, path=["response"]) + assert_matches_type(Optional[WAF], waf, path=["response"]) @pytest.mark.skip() @parametrize @@ -173,7 +173,7 @@ async def test_raw_response_get(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" waf = await response.parse() - assert_matches_type(Optional[ZoneSettingWAF], waf, path=["response"]) + assert_matches_type(Optional[WAF], waf, path=["response"]) @pytest.mark.skip() @parametrize @@ -185,7 +185,7 @@ async def test_streaming_response_get(self, async_client: AsyncCloudflare) -> No assert response.http_request.headers.get("X-Stainless-Lang") == "python" waf = await response.parse() - assert_matches_type(Optional[ZoneSettingWAF], waf, path=["response"]) + assert_matches_type(Optional[WAF], waf, path=["response"]) assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/zones/settings/test_webp.py b/tests/api_resources/zones/settings/test_webp.py index d8230d7b497f..dfa41054305f 100644 --- a/tests/api_resources/zones/settings/test_webp.py +++ b/tests/api_resources/zones/settings/test_webp.py @@ -9,7 +9,7 @@ from cloudflare import Cloudflare, AsyncCloudflare from tests.utils import assert_matches_type -from cloudflare.types.zones.settings import ZoneSettingWebP +from cloudflare.types.zones.settings import WebP base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -24,7 +24,7 @@ def test_method_edit(self, client: Cloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="off", ) - assert_matches_type(Optional[ZoneSettingWebP], webp, path=["response"]) + assert_matches_type(Optional[WebP], webp, path=["response"]) @pytest.mark.skip() @parametrize @@ -37,7 +37,7 @@ def test_raw_response_edit(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" webp = response.parse() - assert_matches_type(Optional[ZoneSettingWebP], webp, path=["response"]) + assert_matches_type(Optional[WebP], webp, path=["response"]) @pytest.mark.skip() @parametrize @@ -50,7 +50,7 @@ def test_streaming_response_edit(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" webp = response.parse() - assert_matches_type(Optional[ZoneSettingWebP], webp, path=["response"]) + assert_matches_type(Optional[WebP], webp, path=["response"]) assert cast(Any, response.is_closed) is True @@ -69,7 +69,7 @@ def test_method_get(self, client: Cloudflare) -> None: webp = client.zones.settings.webp.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingWebP], webp, path=["response"]) + assert_matches_type(Optional[WebP], webp, path=["response"]) @pytest.mark.skip() @parametrize @@ -81,7 +81,7 @@ def test_raw_response_get(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" webp = response.parse() - assert_matches_type(Optional[ZoneSettingWebP], webp, path=["response"]) + assert_matches_type(Optional[WebP], webp, path=["response"]) @pytest.mark.skip() @parametrize @@ -93,7 +93,7 @@ def test_streaming_response_get(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" webp = response.parse() - assert_matches_type(Optional[ZoneSettingWebP], webp, path=["response"]) + assert_matches_type(Optional[WebP], webp, path=["response"]) assert cast(Any, response.is_closed) is True @@ -116,7 +116,7 @@ async def test_method_edit(self, async_client: AsyncCloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="off", ) - assert_matches_type(Optional[ZoneSettingWebP], webp, path=["response"]) + assert_matches_type(Optional[WebP], webp, path=["response"]) @pytest.mark.skip() @parametrize @@ -129,7 +129,7 @@ async def test_raw_response_edit(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" webp = await response.parse() - assert_matches_type(Optional[ZoneSettingWebP], webp, path=["response"]) + assert_matches_type(Optional[WebP], webp, path=["response"]) @pytest.mark.skip() @parametrize @@ -142,7 +142,7 @@ async def test_streaming_response_edit(self, async_client: AsyncCloudflare) -> N assert response.http_request.headers.get("X-Stainless-Lang") == "python" webp = await response.parse() - assert_matches_type(Optional[ZoneSettingWebP], webp, path=["response"]) + assert_matches_type(Optional[WebP], webp, path=["response"]) assert cast(Any, response.is_closed) is True @@ -161,7 +161,7 @@ async def test_method_get(self, async_client: AsyncCloudflare) -> None: webp = await async_client.zones.settings.webp.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingWebP], webp, path=["response"]) + assert_matches_type(Optional[WebP], webp, path=["response"]) @pytest.mark.skip() @parametrize @@ -173,7 +173,7 @@ async def test_raw_response_get(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" webp = await response.parse() - assert_matches_type(Optional[ZoneSettingWebP], webp, path=["response"]) + assert_matches_type(Optional[WebP], webp, path=["response"]) @pytest.mark.skip() @parametrize @@ -185,7 +185,7 @@ async def test_streaming_response_get(self, async_client: AsyncCloudflare) -> No assert response.http_request.headers.get("X-Stainless-Lang") == "python" webp = await response.parse() - assert_matches_type(Optional[ZoneSettingWebP], webp, path=["response"]) + assert_matches_type(Optional[WebP], webp, path=["response"]) assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/zones/settings/test_websocket.py b/tests/api_resources/zones/settings/test_websocket.py index 7cac8f78a2c9..69d4236b8973 100644 --- a/tests/api_resources/zones/settings/test_websocket.py +++ b/tests/api_resources/zones/settings/test_websocket.py @@ -9,7 +9,7 @@ from cloudflare import Cloudflare, AsyncCloudflare from tests.utils import assert_matches_type -from cloudflare.types.zones.settings import ZoneSettingWebsockets +from cloudflare.types.zones.settings import Websocket base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -24,7 +24,7 @@ def test_method_edit(self, client: Cloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="off", ) - assert_matches_type(Optional[ZoneSettingWebsockets], websocket, path=["response"]) + assert_matches_type(Optional[Websocket], websocket, path=["response"]) @pytest.mark.skip() @parametrize @@ -37,7 +37,7 @@ def test_raw_response_edit(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" websocket = response.parse() - assert_matches_type(Optional[ZoneSettingWebsockets], websocket, path=["response"]) + assert_matches_type(Optional[Websocket], websocket, path=["response"]) @pytest.mark.skip() @parametrize @@ -50,7 +50,7 @@ def test_streaming_response_edit(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" websocket = response.parse() - assert_matches_type(Optional[ZoneSettingWebsockets], websocket, path=["response"]) + assert_matches_type(Optional[Websocket], websocket, path=["response"]) assert cast(Any, response.is_closed) is True @@ -69,7 +69,7 @@ def test_method_get(self, client: Cloudflare) -> None: websocket = client.zones.settings.websocket.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingWebsockets], websocket, path=["response"]) + assert_matches_type(Optional[Websocket], websocket, path=["response"]) @pytest.mark.skip() @parametrize @@ -81,7 +81,7 @@ def test_raw_response_get(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" websocket = response.parse() - assert_matches_type(Optional[ZoneSettingWebsockets], websocket, path=["response"]) + assert_matches_type(Optional[Websocket], websocket, path=["response"]) @pytest.mark.skip() @parametrize @@ -93,7 +93,7 @@ def test_streaming_response_get(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" websocket = response.parse() - assert_matches_type(Optional[ZoneSettingWebsockets], websocket, path=["response"]) + assert_matches_type(Optional[Websocket], websocket, path=["response"]) assert cast(Any, response.is_closed) is True @@ -116,7 +116,7 @@ async def test_method_edit(self, async_client: AsyncCloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="off", ) - assert_matches_type(Optional[ZoneSettingWebsockets], websocket, path=["response"]) + assert_matches_type(Optional[Websocket], websocket, path=["response"]) @pytest.mark.skip() @parametrize @@ -129,7 +129,7 @@ async def test_raw_response_edit(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" websocket = await response.parse() - assert_matches_type(Optional[ZoneSettingWebsockets], websocket, path=["response"]) + assert_matches_type(Optional[Websocket], websocket, path=["response"]) @pytest.mark.skip() @parametrize @@ -142,7 +142,7 @@ async def test_streaming_response_edit(self, async_client: AsyncCloudflare) -> N assert response.http_request.headers.get("X-Stainless-Lang") == "python" websocket = await response.parse() - assert_matches_type(Optional[ZoneSettingWebsockets], websocket, path=["response"]) + assert_matches_type(Optional[Websocket], websocket, path=["response"]) assert cast(Any, response.is_closed) is True @@ -161,7 +161,7 @@ async def test_method_get(self, async_client: AsyncCloudflare) -> None: websocket = await async_client.zones.settings.websocket.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSettingWebsockets], websocket, path=["response"]) + assert_matches_type(Optional[Websocket], websocket, path=["response"]) @pytest.mark.skip() @parametrize @@ -173,7 +173,7 @@ async def test_raw_response_get(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" websocket = await response.parse() - assert_matches_type(Optional[ZoneSettingWebsockets], websocket, path=["response"]) + assert_matches_type(Optional[Websocket], websocket, path=["response"]) @pytest.mark.skip() @parametrize @@ -185,7 +185,7 @@ async def test_streaming_response_get(self, async_client: AsyncCloudflare) -> No assert response.http_request.headers.get("X-Stainless-Lang") == "python" websocket = await response.parse() - assert_matches_type(Optional[ZoneSettingWebsockets], websocket, path=["response"]) + assert_matches_type(Optional[Websocket], websocket, path=["response"]) assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/zones/settings/test_zero_rtt.py b/tests/api_resources/zones/settings/test_zero_rtt.py index 3e05091750aa..e2f1c0decff8 100644 --- a/tests/api_resources/zones/settings/test_zero_rtt.py +++ b/tests/api_resources/zones/settings/test_zero_rtt.py @@ -9,7 +9,7 @@ from cloudflare import Cloudflare, AsyncCloudflare from tests.utils import assert_matches_type -from cloudflare.types.zones.settings import ZoneSetting0rtt +from cloudflare.types.zones.settings import ZeroRTT base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -24,7 +24,7 @@ def test_method_edit(self, client: Cloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="on", ) - assert_matches_type(Optional[ZoneSetting0rtt], zero_rtt, path=["response"]) + assert_matches_type(Optional[ZeroRTT], zero_rtt, path=["response"]) @pytest.mark.skip() @parametrize @@ -37,7 +37,7 @@ def test_raw_response_edit(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" zero_rtt = response.parse() - assert_matches_type(Optional[ZoneSetting0rtt], zero_rtt, path=["response"]) + assert_matches_type(Optional[ZeroRTT], zero_rtt, path=["response"]) @pytest.mark.skip() @parametrize @@ -50,7 +50,7 @@ def test_streaming_response_edit(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" zero_rtt = response.parse() - assert_matches_type(Optional[ZoneSetting0rtt], zero_rtt, path=["response"]) + assert_matches_type(Optional[ZeroRTT], zero_rtt, path=["response"]) assert cast(Any, response.is_closed) is True @@ -69,7 +69,7 @@ def test_method_get(self, client: Cloudflare) -> None: zero_rtt = client.zones.settings.zero_rtt.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSetting0rtt], zero_rtt, path=["response"]) + assert_matches_type(Optional[ZeroRTT], zero_rtt, path=["response"]) @pytest.mark.skip() @parametrize @@ -81,7 +81,7 @@ def test_raw_response_get(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" zero_rtt = response.parse() - assert_matches_type(Optional[ZoneSetting0rtt], zero_rtt, path=["response"]) + assert_matches_type(Optional[ZeroRTT], zero_rtt, path=["response"]) @pytest.mark.skip() @parametrize @@ -93,7 +93,7 @@ def test_streaming_response_get(self, client: Cloudflare) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" zero_rtt = response.parse() - assert_matches_type(Optional[ZoneSetting0rtt], zero_rtt, path=["response"]) + assert_matches_type(Optional[ZeroRTT], zero_rtt, path=["response"]) assert cast(Any, response.is_closed) is True @@ -116,7 +116,7 @@ async def test_method_edit(self, async_client: AsyncCloudflare) -> None: zone_id="023e105f4ecef8ad9ca31a8372d0c353", value="on", ) - assert_matches_type(Optional[ZoneSetting0rtt], zero_rtt, path=["response"]) + assert_matches_type(Optional[ZeroRTT], zero_rtt, path=["response"]) @pytest.mark.skip() @parametrize @@ -129,7 +129,7 @@ async def test_raw_response_edit(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" zero_rtt = await response.parse() - assert_matches_type(Optional[ZoneSetting0rtt], zero_rtt, path=["response"]) + assert_matches_type(Optional[ZeroRTT], zero_rtt, path=["response"]) @pytest.mark.skip() @parametrize @@ -142,7 +142,7 @@ async def test_streaming_response_edit(self, async_client: AsyncCloudflare) -> N assert response.http_request.headers.get("X-Stainless-Lang") == "python" zero_rtt = await response.parse() - assert_matches_type(Optional[ZoneSetting0rtt], zero_rtt, path=["response"]) + assert_matches_type(Optional[ZeroRTT], zero_rtt, path=["response"]) assert cast(Any, response.is_closed) is True @@ -161,7 +161,7 @@ async def test_method_get(self, async_client: AsyncCloudflare) -> None: zero_rtt = await async_client.zones.settings.zero_rtt.get( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[ZoneSetting0rtt], zero_rtt, path=["response"]) + assert_matches_type(Optional[ZeroRTT], zero_rtt, path=["response"]) @pytest.mark.skip() @parametrize @@ -173,7 +173,7 @@ async def test_raw_response_get(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" zero_rtt = await response.parse() - assert_matches_type(Optional[ZoneSetting0rtt], zero_rtt, path=["response"]) + assert_matches_type(Optional[ZeroRTT], zero_rtt, path=["response"]) @pytest.mark.skip() @parametrize @@ -185,7 +185,7 @@ async def test_streaming_response_get(self, async_client: AsyncCloudflare) -> No assert response.http_request.headers.get("X-Stainless-Lang") == "python" zero_rtt = await response.parse() - assert_matches_type(Optional[ZoneSetting0rtt], zero_rtt, path=["response"]) + assert_matches_type(Optional[ZeroRTT], zero_rtt, path=["response"]) assert cast(Any, response.is_closed) is True