# Shared Types
```python
from cloudflare.types import (
ASN,
AuditLog,
CertificateCA,
CertificateRequestType,
CloudflareTunnel,
ErrorData,
Identifier,
LoadBalancerPreview,
Member,
PaginationInfo,
Permission,
PermissionGrant,
RatePlan,
ResponseInfo,
Result,
Role,
SortDirection,
Subscription,
SubscriptionComponent,
SubscriptionZone,
Token,
TokenConditionCIDRList,
TokenPolicy,
TokenValue,
)
```
# Accounts
Types:
```python
from cloudflare.types.accounts import Account, AccountDeleteResponse
```
Methods:
- client.accounts.create(\*\*params) -> Optional[Account]
- client.accounts.update(\*, account_id, \*\*params) -> Optional[Account]
- client.accounts.list(\*\*params) -> SyncV4PagePaginationArray[Account]
- client.accounts.delete(\*, account_id) -> Optional[AccountDeleteResponse]
- client.accounts.get(\*, account_id) -> Optional[Account]
## Members
Types:
```python
from cloudflare.types.accounts import Status, MemberDeleteResponse
```
Methods:
- client.accounts.members.create(\*, account_id, \*\*params) -> Optional[Member]
- client.accounts.members.update(member_id, \*, account_id, \*\*params) -> Optional[Member]
- client.accounts.members.list(\*, account_id, \*\*params) -> SyncV4PagePaginationArray[Member]
- client.accounts.members.delete(member_id, \*, account_id) -> Optional[MemberDeleteResponse]
- client.accounts.members.get(member_id, \*, account_id) -> Optional[Member]
## Roles
Methods:
- client.accounts.roles.list(\*, account_id, \*\*params) -> SyncV4PagePaginationArray[Role]
- client.accounts.roles.get(role_id, \*, account_id) -> Optional[Role]
## Subscriptions
Types:
```python
from cloudflare.types.accounts import SubscriptionDeleteResponse
```
Methods:
- client.accounts.subscriptions.create(\*, account_id, \*\*params) -> Subscription
- client.accounts.subscriptions.update(subscription_identifier, \*, account_id, \*\*params) -> Subscription
- client.accounts.subscriptions.delete(subscription_identifier, \*, account_id) -> SubscriptionDeleteResponse
- client.accounts.subscriptions.get(\*, account_id) -> SyncSinglePage[Subscription]
## Tokens
Types:
```python
from cloudflare.types.accounts import TokenCreateResponse, TokenDeleteResponse, TokenVerifyResponse
```
Methods:
- client.accounts.tokens.create(\*, account_id, \*\*params) -> Optional[TokenCreateResponse]
- client.accounts.tokens.update(token_id, \*, account_id, \*\*params) -> Optional[Token]
- client.accounts.tokens.list(\*, account_id, \*\*params) -> SyncV4PagePaginationArray[Token]
- client.accounts.tokens.delete(token_id, \*, account_id) -> Optional[TokenDeleteResponse]
- client.accounts.tokens.get(token_id, \*, account_id) -> Optional[Token]
- client.accounts.tokens.verify(\*, account_id) -> Optional[TokenVerifyResponse]
### PermissionGroups
Types:
```python
from cloudflare.types.accounts.tokens import PermissionGroupListResponse, PermissionGroupGetResponse
```
Methods:
- client.accounts.tokens.permission_groups.list(\*, account_id) -> SyncSinglePage[PermissionGroupListResponse]
- client.accounts.tokens.permission_groups.get(\*, account_id) -> SyncSinglePage[PermissionGroupGetResponse]
### Value
Methods:
- client.accounts.tokens.value.update(token_id, \*, account_id, \*\*params) -> str
## Logs
### Audit
Types:
```python
from cloudflare.types.accounts.logs import AuditListResponse
```
Methods:
- client.accounts.logs.audit.list(\*, account_id, \*\*params) -> SyncCursorLimitPagination[AuditListResponse]
# OriginCACertificates
Types:
```python
from cloudflare.types.origin_ca_certificates import (
OriginCACertificate,
OriginCACertificateDeleteResponse,
)
```
Methods:
- client.origin_ca_certificates.create(\*\*params) -> Optional[OriginCACertificate]
- client.origin_ca_certificates.list(\*\*params) -> SyncV4PagePaginationArray[OriginCACertificate]
- client.origin_ca_certificates.delete(certificate_id) -> Optional[OriginCACertificateDeleteResponse]
- client.origin_ca_certificates.get(certificate_id) -> Optional[OriginCACertificate]
# IPs
Types:
```python
from cloudflare.types.ips import IPs, IPListResponse
```
Methods:
- client.ips.list(\*\*params) -> Optional[IPListResponse]
# Memberships
Types:
```python
from cloudflare.types.memberships import (
Membership,
MembershipUpdateResponse,
MembershipDeleteResponse,
MembershipGetResponse,
)
```
Methods:
- client.memberships.update(membership_id, \*\*params) -> Optional[MembershipUpdateResponse]
- client.memberships.list(\*\*params) -> SyncV4PagePaginationArray[Membership]
- client.memberships.delete(membership_id) -> Optional[MembershipDeleteResponse]
- client.memberships.get(membership_id) -> Optional[MembershipGetResponse]
# User
Types:
```python
from cloudflare.types.user import UserEditResponse, UserGetResponse
```
Methods:
- client.user.edit(\*\*params) -> Optional[UserEditResponse]
- client.user.get() -> Optional[UserGetResponse]
## AuditLogs
Methods:
- client.user.audit_logs.list(\*\*params) -> SyncV4PagePaginationArray[AuditLog]
## Billing
### History
Types:
```python
from cloudflare.types.user.billing import BillingHistory
```
Methods:
- client.user.billing.history.list(\*\*params) -> SyncV4PagePaginationArray[BillingHistory]
### Profile
Types:
```python
from cloudflare.types.user.billing import ProfileGetResponse
```
Methods:
- client.user.billing.profile.get() -> ProfileGetResponse
## Invites
Types:
```python
from cloudflare.types.user import Invite
```
Methods:
- client.user.invites.list() -> SyncSinglePage[Invite]
- client.user.invites.edit(invite_id, \*\*params) -> Optional[Invite]
- client.user.invites.get(invite_id) -> Optional[Invite]
## Organizations
Types:
```python
from cloudflare.types.user import Organization, OrganizationDeleteResponse
```
Methods:
- client.user.organizations.list(\*\*params) -> SyncV4PagePaginationArray[Organization]
- client.user.organizations.delete(organization_id) -> OrganizationDeleteResponse
- client.user.organizations.get(organization_id) -> object
## Subscriptions
Types:
```python
from cloudflare.types.user import SubscriptionUpdateResponse, SubscriptionDeleteResponse
```
Methods:
- client.user.subscriptions.update(identifier, \*\*params) -> SubscriptionUpdateResponse
- client.user.subscriptions.delete(identifier) -> SubscriptionDeleteResponse
- client.user.subscriptions.get() -> SyncSinglePage[Subscription]
## Tokens
Types:
```python
from cloudflare.types.user import TokenCreateResponse, TokenDeleteResponse, TokenVerifyResponse
```
Methods:
- client.user.tokens.create(\*\*params) -> Optional[TokenCreateResponse]
- client.user.tokens.update(token_id, \*\*params) -> Optional[Token]
- client.user.tokens.list(\*\*params) -> SyncV4PagePaginationArray[Token]
- client.user.tokens.delete(token_id) -> Optional[TokenDeleteResponse]
- client.user.tokens.get(token_id) -> Optional[Token]
- client.user.tokens.verify() -> Optional[TokenVerifyResponse]
### PermissionGroups
Types:
```python
from cloudflare.types.user.tokens import PermissionGroupListResponse
```
Methods:
- client.user.tokens.permission_groups.list() -> SyncSinglePage[PermissionGroupListResponse]
### Value
Methods:
- client.user.tokens.value.update(token_id, \*\*params) -> str
# Zones
Types:
```python
from cloudflare.types.zones import Type, Zone, ZoneDeleteResponse
```
Methods:
- client.zones.create(\*\*params) -> Optional[Zone]
- client.zones.list(\*\*params) -> SyncV4PagePaginationArray[Zone]
- client.zones.delete(\*, zone_id) -> Optional[ZoneDeleteResponse]
- client.zones.edit(\*, zone_id, \*\*params) -> Optional[Zone]
- client.zones.get(\*, zone_id) -> Optional[Zone]
## ActivationCheck
Types:
```python
from cloudflare.types.zones import ActivationCheckTriggerResponse
```
Methods:
- client.zones.activation_check.trigger(\*, zone_id) -> Optional[ActivationCheckTriggerResponse]
## Settings
Types:
```python
from cloudflare.types.zones import (
AdvancedDDoS,
Aegis,
AlwaysOnline,
AlwaysUseHTTPS,
AutomaticHTTPSRewrites,
AutomaticPlatformOptimization,
Brotli,
BrowserCacheTTL,
BrowserCheck,
CacheLevel,
ChallengeTTL,
Ciphers,
DevelopmentMode,
EarlyHints,
EmailObfuscation,
FontSettings,
H2Prioritization,
HotlinkProtection,
HTTP2,
HTTP3,
ImageResizing,
IPGeolocation,
IPV6,
MinTLSVersion,
Mirage,
NEL,
OpportunisticEncryption,
OpportunisticOnion,
OrangeToOrange,
OriginErrorPagePassThru,
OriginMaxHTTPVersion,
Polish,
PrefetchPreload,
ProxyReadTimeout,
PseudoIPV4,
ResponseBuffering,
RocketLoader,
SecurityHeaders,
SecurityLevel,
ServerSideExcludes,
SortQueryStringForCache,
SSL,
SSLRecommender,
TLS1_3,
TLSClientAuth,
TrueClientIPHeader,
WAF,
WebP,
Websocket,
ZeroRTT,
SettingEditResponse,
SettingGetResponse,
)
```
Methods:
- client.zones.settings.edit(setting_id, \*, zone_id, \*\*params) -> Optional[SettingEditResponse]
- client.zones.settings.get(setting_id, \*, zone_id) -> Optional[SettingGetResponse]
## CustomNameservers
Types:
```python
from cloudflare.types.zones import CustomNameserverUpdateResponse, CustomNameserverGetResponse
```
Methods:
- client.zones.custom_nameservers.update(\*, zone_id, \*\*params) -> SyncSinglePage[CustomNameserverUpdateResponse]
- client.zones.custom_nameservers.get(\*, zone_id) -> CustomNameserverGetResponse
## Holds
Types:
```python
from cloudflare.types.zones import ZoneHold
```
Methods:
- client.zones.holds.create(\*, zone_id, \*\*params) -> ZoneHold
- client.zones.holds.delete(\*, zone_id, \*\*params) -> ZoneHold
- client.zones.holds.edit(\*, zone_id, \*\*params) -> ZoneHold
- client.zones.holds.get(\*, zone_id) -> ZoneHold
## Plans
Types:
```python
from cloudflare.types.zones import AvailableRatePlan
```
Methods:
- client.zones.plans.list(\*, zone_id) -> SyncSinglePage[AvailableRatePlan]
- client.zones.plans.get(plan_identifier, \*, zone_id) -> AvailableRatePlan
## RatePlans
Types:
```python
from cloudflare.types.zones import RatePlanGetResponse
```
Methods:
- client.zones.rate_plans.get(\*, zone_id) -> SyncSinglePage[RatePlanGetResponse]
# LoadBalancers
Types:
```python
from cloudflare.types.load_balancers import (
AdaptiveRouting,
CheckRegion,
DefaultPools,
FilterOptions,
Header,
Host,
LoadBalancer,
LoadShedding,
LocationStrategy,
NotificationFilter,
Origin,
OriginSteering,
RandomSteering,
Rules,
SessionAffinity,
SessionAffinityAttributes,
SteeringPolicy,
LoadBalancerDeleteResponse,
)
```
Methods:
- client.load_balancers.create(\*, zone_id, \*\*params) -> LoadBalancer
- client.load_balancers.update(load_balancer_id, \*, zone_id, \*\*params) -> LoadBalancer
- client.load_balancers.list(\*, zone_id) -> SyncSinglePage[LoadBalancer]
- client.load_balancers.delete(load_balancer_id, \*, zone_id) -> LoadBalancerDeleteResponse
- client.load_balancers.edit(load_balancer_id, \*, zone_id, \*\*params) -> LoadBalancer
- client.load_balancers.get(load_balancer_id, \*, zone_id) -> LoadBalancer
## Monitors
Types:
```python
from cloudflare.types.load_balancers import Monitor, MonitorDeleteResponse
```
Methods:
- client.load_balancers.monitors.create(\*, account_id, \*\*params) -> Monitor
- client.load_balancers.monitors.update(monitor_id, \*, account_id, \*\*params) -> Monitor
- client.load_balancers.monitors.list(\*, account_id) -> SyncSinglePage[Monitor]
- client.load_balancers.monitors.delete(monitor_id, \*, account_id) -> MonitorDeleteResponse
- client.load_balancers.monitors.edit(monitor_id, \*, account_id, \*\*params) -> Monitor
- client.load_balancers.monitors.get(monitor_id, \*, account_id) -> Monitor
### Previews
Types:
```python
from cloudflare.types.load_balancers.monitors import PreviewCreateResponse
```
Methods:
- client.load_balancers.monitors.previews.create(monitor_id, \*, account_id, \*\*params) -> PreviewCreateResponse
### References
Types:
```python
from cloudflare.types.load_balancers.monitors import ReferenceGetResponse
```
Methods:
- client.load_balancers.monitors.references.get(monitor_id, \*, account_id) -> SyncSinglePage[ReferenceGetResponse]
## Pools
Types:
```python
from cloudflare.types.load_balancers import Pool, PoolDeleteResponse
```
Methods:
- client.load_balancers.pools.create(\*, account_id, \*\*params) -> Pool
- client.load_balancers.pools.update(pool_id, \*, account_id, \*\*params) -> Pool
- client.load_balancers.pools.list(\*, account_id, \*\*params) -> SyncSinglePage[Pool]
- client.load_balancers.pools.delete(pool_id, \*, account_id) -> PoolDeleteResponse
- client.load_balancers.pools.bulk_edit(\*, account_id, \*\*params) -> SyncSinglePage[Pool]
- client.load_balancers.pools.edit(pool_id, \*, account_id, \*\*params) -> Pool
- client.load_balancers.pools.get(pool_id, \*, account_id) -> Pool
### Health
Types:
```python
from cloudflare.types.load_balancers.pools import HealthCreateResponse, HealthGetResponse
```
Methods:
- client.load_balancers.pools.health.create(pool_id, \*, account_id, \*\*params) -> HealthCreateResponse
- client.load_balancers.pools.health.get(pool_id, \*, account_id) -> HealthGetResponse
### References
Types:
```python
from cloudflare.types.load_balancers.pools import ReferenceGetResponse
```
Methods:
- client.load_balancers.pools.references.get(pool_id, \*, account_id) -> SyncSinglePage[ReferenceGetResponse]
## Previews
Types:
```python
from cloudflare.types.load_balancers import PreviewGetResponse
```
Methods:
- client.load_balancers.previews.get(preview_id, \*, account_id) -> PreviewGetResponse
## Regions
Types:
```python
from cloudflare.types.load_balancers import RegionListResponse, RegionGetResponse
```
Methods:
- client.load_balancers.regions.list(\*, account_id, \*\*params) -> RegionListResponse
- client.load_balancers.regions.get(region_id, \*, account_id) -> RegionGetResponse
## Searches
Types:
```python
from cloudflare.types.load_balancers import SearchListResponse
```
Methods:
- client.load_balancers.searches.list(\*, account_id, \*\*params) -> SyncV4PagePagination[SearchListResponse]
# Cache
Types:
```python
from cloudflare.types.cache import CachePurgeResponse
```
Methods:
- client.cache.purge(\*, zone_id, \*\*params) -> Optional[CachePurgeResponse]
## CacheReserve
Types:
```python
from cloudflare.types.cache import (
CacheReserve,
CacheReserveClear,
State,
CacheReserveClearResponse,
CacheReserveEditResponse,
CacheReserveGetResponse,
CacheReserveStatusResponse,
)
```
Methods:
- client.cache.cache_reserve.clear(\*, zone_id, \*\*params) -> Optional[CacheReserveClearResponse]
- client.cache.cache_reserve.edit(\*, zone_id, \*\*params) -> Optional[CacheReserveEditResponse]
- client.cache.cache_reserve.get(\*, zone_id) -> Optional[CacheReserveGetResponse]
- client.cache.cache_reserve.status(\*, zone_id) -> Optional[CacheReserveStatusResponse]
## SmartTieredCache
Types:
```python
from cloudflare.types.cache import (
SmartTieredCacheDeleteResponse,
SmartTieredCacheEditResponse,
SmartTieredCacheGetResponse,
)
```
Methods:
- client.cache.smart_tiered_cache.delete(\*, zone_id) -> Optional[SmartTieredCacheDeleteResponse]
- client.cache.smart_tiered_cache.edit(\*, zone_id, \*\*params) -> Optional[SmartTieredCacheEditResponse]
- client.cache.smart_tiered_cache.get(\*, zone_id) -> Optional[SmartTieredCacheGetResponse]
## Variants
Types:
```python
from cloudflare.types.cache import (
CacheVariant,
VariantDeleteResponse,
VariantEditResponse,
VariantGetResponse,
)
```
Methods:
- client.cache.variants.delete(\*, zone_id) -> Optional[VariantDeleteResponse]
- client.cache.variants.edit(\*, zone_id, \*\*params) -> Optional[VariantEditResponse]
- client.cache.variants.get(\*, zone_id) -> Optional[VariantGetResponse]
## RegionalTieredCache
Types:
```python
from cloudflare.types.cache import (
RegionalTieredCache,
RegionalTieredCacheEditResponse,
RegionalTieredCacheGetResponse,
)
```
Methods:
- client.cache.regional_tiered_cache.edit(\*, zone_id, \*\*params) -> Optional[RegionalTieredCacheEditResponse]
- client.cache.regional_tiered_cache.get(\*, zone_id) -> Optional[RegionalTieredCacheGetResponse]
# SSL
## Analyze
Methods:
- client.ssl.analyze.create(\*, zone_id, \*\*params) -> object
## CertificatePacks
Types:
```python
from cloudflare.types.ssl import (
Host,
RequestValidity,
Status,
ValidationMethod,
CertificatePackCreateResponse,
CertificatePackDeleteResponse,
CertificatePackEditResponse,
)
```
Methods:
- client.ssl.certificate_packs.create(\*, zone_id, \*\*params) -> Optional[CertificatePackCreateResponse]
- client.ssl.certificate_packs.list(\*, zone_id, \*\*params) -> SyncSinglePage[object]
- client.ssl.certificate_packs.delete(certificate_pack_id, \*, zone_id) -> Optional[CertificatePackDeleteResponse]
- client.ssl.certificate_packs.edit(certificate_pack_id, \*, zone_id, \*\*params) -> Optional[CertificatePackEditResponse]
- client.ssl.certificate_packs.get(certificate_pack_id, \*, zone_id) -> object
### Quota
Types:
```python
from cloudflare.types.ssl.certificate_packs import QuotaGetResponse
```
Methods:
- client.ssl.certificate_packs.quota.get(\*, zone_id) -> Optional[QuotaGetResponse]
## Recommendations
Types:
```python
from cloudflare.types.ssl import RecommendationGetResponse
```
Methods:
- client.ssl.recommendations.get(\*, zone_id) -> Optional[RecommendationGetResponse]
## Universal
### Settings
Types:
```python
from cloudflare.types.ssl.universal import UniversalSSLSettings
```
Methods:
- client.ssl.universal.settings.edit(\*, zone_id, \*\*params) -> Optional[UniversalSSLSettings]
- client.ssl.universal.settings.get(\*, zone_id) -> Optional[UniversalSSLSettings]
## Verification
Types:
```python
from cloudflare.types.ssl import Verification, VerificationEditResponse, VerificationGetResponse
```
Methods:
- client.ssl.verification.edit(certificate_pack_id, \*, zone_id, \*\*params) -> Optional[VerificationEditResponse]
- client.ssl.verification.get(\*, zone_id, \*\*params) -> Optional[VerificationGetResponse]
# ACM
## TotalTLS
Types:
```python
from cloudflare.types.acm import CertificateAuthority, TotalTLSCreateResponse, TotalTLSGetResponse
```
Methods:
- client.acm.total_tls.create(\*, zone_id, \*\*params) -> Optional[TotalTLSCreateResponse]
- client.acm.total_tls.get(\*, zone_id) -> Optional[TotalTLSGetResponse]
# Argo
## SmartRouting
Types:
```python
from cloudflare.types.argo import SmartRoutingEditResponse, SmartRoutingGetResponse
```
Methods:
- client.argo.smart_routing.edit(\*, zone_id, \*\*params) -> SmartRoutingEditResponse
- client.argo.smart_routing.get(\*, zone_id) -> SmartRoutingGetResponse
## TieredCaching
Types:
```python
from cloudflare.types.argo import TieredCachingEditResponse, TieredCachingGetResponse
```
Methods:
- client.argo.tiered_caching.edit(\*, zone_id, \*\*params) -> Optional[TieredCachingEditResponse]
- client.argo.tiered_caching.get(\*, zone_id) -> Optional[TieredCachingGetResponse]
# CertificateAuthorities
## HostnameAssociations
Types:
```python
from cloudflare.types.certificate_authorities import (
HostnameAssociation,
TLSHostnameAssociation,
HostnameAssociationUpdateResponse,
HostnameAssociationGetResponse,
)
```
Methods:
- client.certificate_authorities.hostname_associations.update(\*, zone_id, \*\*params) -> Optional[HostnameAssociationUpdateResponse]
- client.certificate_authorities.hostname_associations.get(\*, zone_id, \*\*params) -> Optional[HostnameAssociationGetResponse]
# ClientCertificates
Types:
```python
from cloudflare.types.client_certificates import ClientCertificate
```
Methods:
- client.client_certificates.create(\*, zone_id, \*\*params) -> Optional[ClientCertificate]
- client.client_certificates.list(\*, zone_id, \*\*params) -> SyncV4PagePaginationArray[ClientCertificate]
- client.client_certificates.delete(client_certificate_id, \*, zone_id) -> Optional[ClientCertificate]
- client.client_certificates.edit(client_certificate_id, \*, zone_id) -> Optional[ClientCertificate]
- client.client_certificates.get(client_certificate_id, \*, zone_id) -> Optional[ClientCertificate]
# CustomCertificates
Types:
```python
from cloudflare.types.custom_certificates import (
CustomCertificate,
GeoRestrictions,
Status,
CustomCertificateDeleteResponse,
)
```
Methods:
- client.custom_certificates.create(\*, zone_id, \*\*params) -> Optional[CustomCertificate]
- client.custom_certificates.list(\*, zone_id, \*\*params) -> SyncV4PagePaginationArray[CustomCertificate]
- client.custom_certificates.delete(custom_certificate_id, \*, zone_id) -> Optional[CustomCertificateDeleteResponse]
- client.custom_certificates.edit(custom_certificate_id, \*, zone_id, \*\*params) -> Optional[CustomCertificate]
- client.custom_certificates.get(custom_certificate_id, \*, zone_id) -> Optional[CustomCertificate]
## Prioritize
Methods:
- client.custom_certificates.prioritize.update(\*, zone_id, \*\*params) -> SyncSinglePage[CustomCertificate]
# CustomHostnames
Types:
```python
from cloudflare.types.custom_hostnames import (
BundleMethod,
CustomHostname,
DCVMethod,
DomainValidationType,
CustomHostnameCreateResponse,
CustomHostnameListResponse,
CustomHostnameDeleteResponse,
CustomHostnameEditResponse,
CustomHostnameGetResponse,
)
```
Methods:
- client.custom_hostnames.create(\*, zone_id, \*\*params) -> Optional[CustomHostnameCreateResponse]
- client.custom_hostnames.list(\*, zone_id, \*\*params) -> SyncV4PagePaginationArray[CustomHostnameListResponse]
- client.custom_hostnames.delete(custom_hostname_id, \*, zone_id) -> CustomHostnameDeleteResponse
- client.custom_hostnames.edit(custom_hostname_id, \*, zone_id, \*\*params) -> Optional[CustomHostnameEditResponse]
- client.custom_hostnames.get(custom_hostname_id, \*, zone_id) -> Optional[CustomHostnameGetResponse]
## FallbackOrigin
Types:
```python
from cloudflare.types.custom_hostnames import (
FallbackOriginUpdateResponse,
FallbackOriginDeleteResponse,
FallbackOriginGetResponse,
)
```
Methods:
- client.custom_hostnames.fallback_origin.update(\*, zone_id, \*\*params) -> Optional[FallbackOriginUpdateResponse]
- client.custom_hostnames.fallback_origin.delete(\*, zone_id) -> Optional[FallbackOriginDeleteResponse]
- client.custom_hostnames.fallback_origin.get(\*, zone_id) -> Optional[FallbackOriginGetResponse]
## CertificatePack
### Certificates
Types:
```python
from cloudflare.types.custom_hostnames.certificate_pack import (
CertificateUpdateResponse,
CertificateDeleteResponse,
)
```
Methods:
- client.custom_hostnames.certificate_pack.certificates.update(certificate_id, \*, zone_id, custom_hostname_id, certificate_pack_id, \*\*params) -> Optional[CertificateUpdateResponse]
- client.custom_hostnames.certificate_pack.certificates.delete(certificate_id, \*, zone_id, custom_hostname_id, certificate_pack_id) -> CertificateDeleteResponse
# CustomNameservers
Types:
```python
from cloudflare.types.custom_nameservers import CustomNameserver, CustomNameserverDeleteResponse
```
Methods:
- client.custom_nameservers.create(\*, account_id, \*\*params) -> Optional[CustomNameserver]
- client.custom_nameservers.delete(custom_ns_id, \*, account_id) -> SyncSinglePage[CustomNameserverDeleteResponse]
- client.custom_nameservers.get(\*, account_id) -> SyncSinglePage[CustomNameserver]
# DNSFirewall
Types:
```python
from cloudflare.types.dns_firewall import (
AttackMitigation,
FirewallIPs,
UpstreamIPs,
DNSFirewallCreateResponse,
DNSFirewallListResponse,
DNSFirewallDeleteResponse,
DNSFirewallEditResponse,
DNSFirewallGetResponse,
)
```
Methods:
- client.dns_firewall.create(\*, account_id, \*\*params) -> Optional[DNSFirewallCreateResponse]
- client.dns_firewall.list(\*, account_id, \*\*params) -> SyncV4PagePaginationArray[DNSFirewallListResponse]
- client.dns_firewall.delete(dns_firewall_id, \*, account_id) -> Optional[DNSFirewallDeleteResponse]
- client.dns_firewall.edit(dns_firewall_id, \*, account_id, \*\*params) -> Optional[DNSFirewallEditResponse]
- client.dns_firewall.get(dns_firewall_id, \*, account_id) -> Optional[DNSFirewallGetResponse]
## Analytics
### Reports
Methods:
- client.dns_firewall.analytics.reports.get(dns_firewall_id, \*, account_id, \*\*params) -> Optional[Report]
#### Bytimes
Methods:
- client.dns_firewall.analytics.reports.bytimes.get(dns_firewall_id, \*, account_id, \*\*params) -> Optional[ByTime]
## ReverseDNS
Types:
```python
from cloudflare.types.dns_firewall import ReverseDNSEditResponse, ReverseDNSGetResponse
```
Methods:
- client.dns_firewall.reverse_dns.edit(dns_firewall_id, \*, account_id, \*\*params) -> Optional[ReverseDNSEditResponse]
- client.dns_firewall.reverse_dns.get(dns_firewall_id, \*, account_id) -> Optional[ReverseDNSGetResponse]
# DNS
Types:
```python
from cloudflare.types.dns import DNSAnalyticsNominalMetric, DNSAnalyticsQuery
```
## DNSSEC
Types:
```python
from cloudflare.types.dns import DNSSEC, DNSSECDeleteResponse
```
Methods:
- client.dns.dnssec.delete(\*, zone_id) -> str
- client.dns.dnssec.edit(\*, zone_id, \*\*params) -> Optional[DNSSEC]
- client.dns.dnssec.get(\*, zone_id) -> Optional[DNSSEC]
## Records
Types:
```python
from cloudflare.types.dns import (
ARecord,
AAAARecord,
BatchPatch,
BatchPut,
CAARecord,
CERTRecord,
CNAMERecord,
DNSKEYRecord,
DSRecord,
HTTPSRecord,
LOCRecord,
MXRecord,
NAPTRRecord,
NSRecord,
PTRRecord,
Record,
RecordResponse,
RecordTags,
SMIMEARecord,
SRVRecord,
SSHFPRecord,
SVCBRecord,
TLSARecord,
TTL,
TXTRecord,
URIRecord,
RecordDeleteResponse,
RecordBatchResponse,
RecordExportResponse,
RecordImportResponse,
RecordScanResponse,
)
```
Methods:
- client.dns.records.create(\*, zone_id, \*\*params) -> Optional[RecordResponse]
- client.dns.records.update(dns_record_id, \*, zone_id, \*\*params) -> Optional[RecordResponse]
- client.dns.records.list(\*, zone_id, \*\*params) -> SyncV4PagePaginationArray[RecordResponse]
- client.dns.records.delete(dns_record_id, \*, zone_id) -> Optional[RecordDeleteResponse]
- client.dns.records.batch(\*, zone_id, \*\*params) -> Optional[RecordBatchResponse]
- client.dns.records.edit(dns_record_id, \*, zone_id, \*\*params) -> Optional[RecordResponse]
- client.dns.records.export(\*, zone_id) -> str
- client.dns.records.get(dns_record_id, \*, zone_id) -> Optional[RecordResponse]
- client.dns.records.import\_(\*, zone_id, \*\*params) -> Optional[RecordImportResponse]
- client.dns.records.scan(\*, zone_id, \*\*params) -> Optional[RecordScanResponse]
## Settings
Types:
```python
from cloudflare.types.dns import DNSSetting
```
### Zone
Types:
```python
from cloudflare.types.dns.settings import ZoneEditResponse, ZoneGetResponse
```
Methods:
- client.dns.settings.zone.edit(\*, zone_id, \*\*params) -> Optional[ZoneEditResponse]
- client.dns.settings.zone.get(\*, zone_id) -> Optional[ZoneGetResponse]
### Account
Types:
```python
from cloudflare.types.dns.settings import AccountEditResponse, AccountGetResponse
```
Methods:
- client.dns.settings.account.edit(\*, account_id, \*\*params) -> Optional[AccountEditResponse]
- client.dns.settings.account.get(\*, account_id) -> Optional[AccountGetResponse]
#### Views
Types:
```python
from cloudflare.types.dns.settings.account import (
ViewCreateResponse,
ViewListResponse,
ViewDeleteResponse,
ViewEditResponse,
ViewGetResponse,
)
```
Methods:
- client.dns.settings.account.views.create(\*, account_id, \*\*params) -> Optional[ViewCreateResponse]
- client.dns.settings.account.views.list(\*, account_id, \*\*params) -> SyncV4PagePaginationArray[ViewListResponse]
- client.dns.settings.account.views.delete(view_id, \*, account_id) -> Optional[ViewDeleteResponse]
- client.dns.settings.account.views.edit(view_id, \*, account_id, \*\*params) -> Optional[ViewEditResponse]
- client.dns.settings.account.views.get(view_id, \*, account_id) -> Optional[ViewGetResponse]
## Analytics
### Reports
Types:
```python
from cloudflare.types.dns.analytics import Report
```
Methods:
- client.dns.analytics.reports.get(\*, zone_id, \*\*params) -> Optional[Report]
#### Bytimes
Types:
```python
from cloudflare.types.dns.analytics.reports import ByTime
```
Methods:
- client.dns.analytics.reports.bytimes.get(\*, zone_id, \*\*params) -> Optional[ByTime]
## ZoneTransfers
### ForceAXFR
Types:
```python
from cloudflare.types.dns.zone_transfers import ForceAXFR
```
Methods:
- client.dns.zone_transfers.force_axfr.create(\*, zone_id, \*\*params) -> str
### Incoming
Types:
```python
from cloudflare.types.dns.zone_transfers import (
Incoming,
IncomingCreateResponse,
IncomingUpdateResponse,
IncomingDeleteResponse,
IncomingGetResponse,
)
```
Methods:
- client.dns.zone_transfers.incoming.create(\*, zone_id, \*\*params) -> Optional[IncomingCreateResponse]
- client.dns.zone_transfers.incoming.update(\*, zone_id, \*\*params) -> Optional[IncomingUpdateResponse]
- client.dns.zone_transfers.incoming.delete(\*, zone_id) -> Optional[IncomingDeleteResponse]
- client.dns.zone_transfers.incoming.get(\*, zone_id) -> Optional[IncomingGetResponse]
### Outgoing
Types:
```python
from cloudflare.types.dns.zone_transfers import (
DisableTransfer,
EnableTransfer,
Outgoing,
OutgoingStatus,
OutgoingCreateResponse,
OutgoingUpdateResponse,
OutgoingDeleteResponse,
OutgoingForceNotifyResponse,
OutgoingGetResponse,
)
```
Methods:
- client.dns.zone_transfers.outgoing.create(\*, zone_id, \*\*params) -> Optional[OutgoingCreateResponse]
- client.dns.zone_transfers.outgoing.update(\*, zone_id, \*\*params) -> Optional[OutgoingUpdateResponse]
- client.dns.zone_transfers.outgoing.delete(\*, zone_id) -> Optional[OutgoingDeleteResponse]
- client.dns.zone_transfers.outgoing.disable(\*, zone_id, \*\*params) -> str
- client.dns.zone_transfers.outgoing.enable(\*, zone_id, \*\*params) -> str
- client.dns.zone_transfers.outgoing.force_notify(\*, zone_id, \*\*params) -> str
- client.dns.zone_transfers.outgoing.get(\*, zone_id) -> Optional[OutgoingGetResponse]
#### Status
Methods:
- client.dns.zone_transfers.outgoing.status.get(\*, zone_id) -> str
### ACLs
Types:
```python
from cloudflare.types.dns.zone_transfers import ACL, ACLDeleteResponse
```
Methods:
- client.dns.zone_transfers.acls.create(\*, account_id, \*\*params) -> Optional[ACL]
- client.dns.zone_transfers.acls.update(acl_id, \*, account_id, \*\*params) -> Optional[ACL]
- client.dns.zone_transfers.acls.list(\*, account_id) -> SyncSinglePage[ACL]
- client.dns.zone_transfers.acls.delete(acl_id, \*, account_id) -> Optional[ACLDeleteResponse]
- client.dns.zone_transfers.acls.get(acl_id, \*, account_id) -> Optional[ACL]
### Peers
Types:
```python
from cloudflare.types.dns.zone_transfers import Peer, PeerDeleteResponse
```
Methods:
- client.dns.zone_transfers.peers.create(\*, account_id, \*\*params) -> Optional[Peer]
- client.dns.zone_transfers.peers.update(peer_id, \*, account_id, \*\*params) -> Optional[Peer]
- client.dns.zone_transfers.peers.list(\*, account_id) -> SyncSinglePage[Peer]
- client.dns.zone_transfers.peers.delete(peer_id, \*, account_id) -> Optional[PeerDeleteResponse]
- client.dns.zone_transfers.peers.get(peer_id, \*, account_id) -> Optional[Peer]
### TSIGs
Types:
```python
from cloudflare.types.dns.zone_transfers import TSIG, TSIGDeleteResponse
```
Methods:
- client.dns.zone_transfers.tsigs.create(\*, account_id, \*\*params) -> Optional[TSIG]
- client.dns.zone_transfers.tsigs.update(tsig_id, \*, account_id, \*\*params) -> Optional[TSIG]
- client.dns.zone_transfers.tsigs.list(\*, account_id) -> SyncSinglePage[TSIG]
- client.dns.zone_transfers.tsigs.delete(tsig_id, \*, account_id) -> Optional[TSIGDeleteResponse]
- client.dns.zone_transfers.tsigs.get(tsig_id, \*, account_id) -> Optional[TSIG]
# EmailSecurity
## Investigate
Types:
```python
from cloudflare.types.email_security import InvestigateListResponse, InvestigateGetResponse
```
Methods:
- client.email_security.investigate.list(\*, account_id, \*\*params) -> SyncV4PagePaginationArray[InvestigateListResponse]
- client.email_security.investigate.get(postfix_id, \*, account_id) -> InvestigateGetResponse
### Detections
Types:
```python
from cloudflare.types.email_security.investigate import DetectionGetResponse
```
Methods:
- client.email_security.investigate.detections.get(postfix_id, \*, account_id) -> DetectionGetResponse
### Preview
Types:
```python
from cloudflare.types.email_security.investigate import PreviewCreateResponse, PreviewGetResponse
```
Methods:
- client.email_security.investigate.preview.create(\*, account_id, \*\*params) -> PreviewCreateResponse
- client.email_security.investigate.preview.get(postfix_id, \*, account_id) -> PreviewGetResponse
### Raw
Types:
```python
from cloudflare.types.email_security.investigate import RawGetResponse
```
Methods:
- client.email_security.investigate.raw.get(postfix_id, \*, account_id) -> RawGetResponse
### Trace
Types:
```python
from cloudflare.types.email_security.investigate import TraceGetResponse
```
Methods:
- client.email_security.investigate.trace.get(postfix_id, \*, account_id) -> TraceGetResponse
### Move
Types:
```python
from cloudflare.types.email_security.investigate import MoveCreateResponse, MoveBulkResponse
```
Methods:
- client.email_security.investigate.move.create(postfix_id, \*, account_id, \*\*params) -> SyncSinglePage[MoveCreateResponse]
- client.email_security.investigate.move.bulk(\*, account_id, \*\*params) -> SyncSinglePage[MoveBulkResponse]
### Reclassify
Methods:
- client.email_security.investigate.reclassify.create(postfix_id, \*, account_id, \*\*params) -> object
### Release
Types:
```python
from cloudflare.types.email_security.investigate import ReleaseBulkResponse
```
Methods:
- client.email_security.investigate.release.bulk(\*, account_id, \*\*params) -> SyncSinglePage[ReleaseBulkResponse]
## Settings
### AllowPolicies
Types:
```python
from cloudflare.types.email_security.settings import (
AllowPolicyCreateResponse,
AllowPolicyListResponse,
AllowPolicyDeleteResponse,
AllowPolicyEditResponse,
AllowPolicyGetResponse,
)
```
Methods:
- client.email_security.settings.allow_policies.create(\*, account_id, \*\*params) -> AllowPolicyCreateResponse
- client.email_security.settings.allow_policies.list(\*, account_id, \*\*params) -> SyncV4PagePaginationArray[AllowPolicyListResponse]
- client.email_security.settings.allow_policies.delete(policy_id, \*, account_id) -> AllowPolicyDeleteResponse
- client.email_security.settings.allow_policies.edit(policy_id, \*, account_id, \*\*params) -> AllowPolicyEditResponse
- client.email_security.settings.allow_policies.get(policy_id, \*, account_id) -> AllowPolicyGetResponse
### BlockSenders
Types:
```python
from cloudflare.types.email_security.settings import (
BlockSenderCreateResponse,
BlockSenderListResponse,
BlockSenderDeleteResponse,
BlockSenderEditResponse,
BlockSenderGetResponse,
)
```
Methods:
- client.email_security.settings.block_senders.create(\*, account_id, \*\*params) -> BlockSenderCreateResponse
- client.email_security.settings.block_senders.list(\*, account_id, \*\*params) -> SyncV4PagePaginationArray[BlockSenderListResponse]
- client.email_security.settings.block_senders.delete(pattern_id, \*, account_id) -> BlockSenderDeleteResponse
- client.email_security.settings.block_senders.edit(pattern_id, \*, account_id, \*\*params) -> BlockSenderEditResponse
- client.email_security.settings.block_senders.get(pattern_id, \*, account_id) -> BlockSenderGetResponse
### Domains
Types:
```python
from cloudflare.types.email_security.settings import (
DomainListResponse,
DomainDeleteResponse,
DomainBulkDeleteResponse,
DomainEditResponse,
DomainGetResponse,
)
```
Methods:
- client.email_security.settings.domains.list(\*, account_id, \*\*params) -> SyncV4PagePaginationArray[DomainListResponse]
- client.email_security.settings.domains.delete(domain_id, \*, account_id) -> DomainDeleteResponse
- client.email_security.settings.domains.bulk_delete(\*, account_id) -> SyncSinglePage[DomainBulkDeleteResponse]
- client.email_security.settings.domains.edit(domain_id, \*, account_id, \*\*params) -> DomainEditResponse
- client.email_security.settings.domains.get(domain_id, \*, account_id) -> DomainGetResponse
### ImpersonationRegistry
Types:
```python
from cloudflare.types.email_security.settings import (
ImpersonationRegistryCreateResponse,
ImpersonationRegistryListResponse,
ImpersonationRegistryDeleteResponse,
ImpersonationRegistryEditResponse,
ImpersonationRegistryGetResponse,
)
```
Methods:
- client.email_security.settings.impersonation_registry.create(\*, account_id, \*\*params) -> ImpersonationRegistryCreateResponse
- client.email_security.settings.impersonation_registry.list(\*, account_id, \*\*params) -> SyncV4PagePaginationArray[ImpersonationRegistryListResponse]
- client.email_security.settings.impersonation_registry.delete(display_name_id, \*, account_id) -> ImpersonationRegistryDeleteResponse
- client.email_security.settings.impersonation_registry.edit(display_name_id, \*, account_id, \*\*params) -> ImpersonationRegistryEditResponse
- client.email_security.settings.impersonation_registry.get(display_name_id, \*, account_id) -> ImpersonationRegistryGetResponse
### TrustedDomains
Types:
```python
from cloudflare.types.email_security.settings import (
TrustedDomainCreateResponse,
TrustedDomainListResponse,
TrustedDomainDeleteResponse,
TrustedDomainEditResponse,
TrustedDomainGetResponse,
)
```
Methods:
- client.email_security.settings.trusted_domains.create(\*, account_id, \*\*params) -> TrustedDomainCreateResponse
- client.email_security.settings.trusted_domains.list(\*, account_id, \*\*params) -> SyncV4PagePaginationArray[TrustedDomainListResponse]
- client.email_security.settings.trusted_domains.delete(trusted_domain_id, \*, account_id) -> TrustedDomainDeleteResponse
- client.email_security.settings.trusted_domains.edit(trusted_domain_id, \*, account_id, \*\*params) -> TrustedDomainEditResponse
- client.email_security.settings.trusted_domains.get(trusted_domain_id, \*, account_id) -> TrustedDomainGetResponse
## Submissions
Types:
```python
from cloudflare.types.email_security import SubmissionListResponse
```
Methods:
- client.email_security.submissions.list(\*, account_id, \*\*params) -> SyncV4PagePaginationArray[SubmissionListResponse]
# EmailRouting
Types:
```python
from cloudflare.types.email_routing import Settings
```
Methods:
- client.email_routing.disable(\*, zone_id, \*\*params) -> Optional[Settings]
- client.email_routing.enable(\*, zone_id, \*\*params) -> Optional[Settings]
- client.email_routing.get(\*, zone_id) -> Optional[Settings]
## DNS
Types:
```python
from cloudflare.types.email_routing import DNSRecord, DNSGetResponse
```
Methods:
- client.email_routing.dns.create(\*, zone_id, \*\*params) -> Optional[Settings]
- client.email_routing.dns.delete(\*, zone_id) -> SyncSinglePage[DNSRecord]
- client.email_routing.dns.edit(\*, zone_id, \*\*params) -> Optional[Settings]
- client.email_routing.dns.get(\*, zone_id, \*\*params) -> DNSGetResponse
## Rules
Types:
```python
from cloudflare.types.email_routing import Action, EmailRoutingRule, Matcher
```
Methods:
- client.email_routing.rules.create(\*, zone_id, \*\*params) -> Optional[EmailRoutingRule]
- client.email_routing.rules.update(rule_identifier, \*, zone_id, \*\*params) -> Optional[EmailRoutingRule]
- client.email_routing.rules.list(\*, zone_id, \*\*params) -> SyncV4PagePaginationArray[EmailRoutingRule]
- client.email_routing.rules.delete(rule_identifier, \*, zone_id) -> Optional[EmailRoutingRule]
- client.email_routing.rules.get(rule_identifier, \*, zone_id) -> Optional[EmailRoutingRule]
### CatchAlls
Types:
```python
from cloudflare.types.email_routing.rules import (
CatchAllAction,
CatchAllMatcher,
CatchAllUpdateResponse,
CatchAllGetResponse,
)
```
Methods:
- client.email_routing.rules.catch_alls.update(\*, zone_id, \*\*params) -> Optional[CatchAllUpdateResponse]
- client.email_routing.rules.catch_alls.get(\*, zone_id) -> Optional[CatchAllGetResponse]
## Addresses
Types:
```python
from cloudflare.types.email_routing import Address
```
Methods:
- client.email_routing.addresses.create(\*, account_id, \*\*params) -> Optional[Address]
- client.email_routing.addresses.list(\*, account_id, \*\*params) -> SyncV4PagePaginationArray[Address]
- client.email_routing.addresses.delete(destination_address_identifier, \*, account_id) -> Optional[Address]
- client.email_routing.addresses.get(destination_address_identifier, \*, account_id) -> Optional[Address]
# Filters
Types:
```python
from cloudflare.types.filters import FirewallFilter
```
Methods:
- client.filters.create(\*, zone_id, \*\*params) -> SyncSinglePage[FirewallFilter]
- client.filters.update(filter_id, \*, zone_id, \*\*params) -> FirewallFilter
- client.filters.list(\*, zone_id, \*\*params) -> SyncV4PagePaginationArray[FirewallFilter]
- client.filters.delete(filter_id, \*, zone_id) -> FirewallFilter
- client.filters.bulk_delete(\*, zone_id) -> SyncSinglePage[FirewallFilter]
- client.filters.bulk_update(\*, zone_id) -> SyncSinglePage[FirewallFilter]
- client.filters.get(filter_id, \*, zone_id) -> FirewallFilter
# Firewall
## Lockdowns
Types:
```python
from cloudflare.types.firewall import (
Configuration,
Lockdown,
LockdownCIDRConfiguration,
LockdownIPConfiguration,
LockdownURL,
LockdownDeleteResponse,
)
```
Methods:
- client.firewall.lockdowns.create(\*, zone_id, \*\*params) -> Lockdown
- client.firewall.lockdowns.update(lock_downs_id, \*, zone_id, \*\*params) -> Lockdown
- client.firewall.lockdowns.list(\*, zone_id, \*\*params) -> SyncV4PagePaginationArray[Lockdown]
- client.firewall.lockdowns.delete(lock_downs_id, \*, zone_id) -> Optional[LockdownDeleteResponse]
- client.firewall.lockdowns.get(lock_downs_id, \*, zone_id) -> Lockdown
## Rules
Types:
```python
from cloudflare.types.firewall import DeletedFilter, FirewallRule, Product
```
Methods:
- client.firewall.rules.create(\*, zone_id, \*\*params) -> SyncSinglePage[FirewallRule]
- client.firewall.rules.update(rule_id, \*, zone_id, \*\*params) -> FirewallRule
- client.firewall.rules.list(\*, zone_id, \*\*params) -> SyncV4PagePaginationArray[FirewallRule]
- client.firewall.rules.delete(rule_id, \*, zone_id) -> FirewallRule
- client.firewall.rules.bulk_delete(\*, zone_id) -> SyncSinglePage[FirewallRule]
- client.firewall.rules.bulk_edit(\*, zone_id, \*\*params) -> SyncSinglePage[FirewallRule]
- client.firewall.rules.bulk_update(\*, zone_id, \*\*params) -> SyncSinglePage[FirewallRule]
- client.firewall.rules.edit(rule_id, \*, zone_id) -> SyncSinglePage[FirewallRule]
- client.firewall.rules.get(rule_id, \*, zone_id) -> FirewallRule
## AccessRules
Types:
```python
from cloudflare.types.firewall import (
AccessRuleCIDRConfiguration,
AccessRuleIPConfiguration,
ASNConfiguration,
CountryConfiguration,
IPV6Configuration,
AccessRuleCreateResponse,
AccessRuleListResponse,
AccessRuleDeleteResponse,
AccessRuleEditResponse,
AccessRuleGetResponse,
)
```
Methods:
- client.firewall.access_rules.create(\*, account_id, zone_id, \*\*params) -> AccessRuleCreateResponse
- client.firewall.access_rules.list(\*, account_id, zone_id, \*\*params) -> SyncV4PagePaginationArray[AccessRuleListResponse]
- client.firewall.access_rules.delete(rule_id, \*, account_id, zone_id) -> Optional[AccessRuleDeleteResponse]
- client.firewall.access_rules.edit(rule_id, \*, account_id, zone_id, \*\*params) -> AccessRuleEditResponse
- client.firewall.access_rules.get(rule_id, \*, account_id, zone_id) -> AccessRuleGetResponse
## UARules
Types:
```python
from cloudflare.types.firewall import (
UARuleCreateResponse,
UARuleUpdateResponse,
UARuleListResponse,
UARuleDeleteResponse,
UARuleGetResponse,
)
```
Methods:
- client.firewall.ua_rules.create(\*, zone_id, \*\*params) -> UARuleCreateResponse
- client.firewall.ua_rules.update(ua_rule_id, \*, zone_id, \*\*params) -> UARuleUpdateResponse
- client.firewall.ua_rules.list(\*, zone_id, \*\*params) -> SyncV4PagePaginationArray[UARuleListResponse]
- client.firewall.ua_rules.delete(ua_rule_id, \*, zone_id) -> UARuleDeleteResponse
- client.firewall.ua_rules.get(ua_rule_id, \*, zone_id) -> UARuleGetResponse
## WAF
### Overrides
Types:
```python
from cloudflare.types.firewall.waf import (
Override,
OverrideURL,
RewriteAction,
WAFRule,
OverrideDeleteResponse,
)
```
Methods:
- client.firewall.waf.overrides.create(\*, zone_id, \*\*params) -> Override
- client.firewall.waf.overrides.update(overrides_id, \*, zone_id, \*\*params) -> Override
- client.firewall.waf.overrides.list(\*, zone_id, \*\*params) -> SyncV4PagePaginationArray[Override]
- client.firewall.waf.overrides.delete(overrides_id, \*, zone_id) -> Optional[OverrideDeleteResponse]
- client.firewall.waf.overrides.get(overrides_id, \*, zone_id) -> Override
### Packages
Types:
```python
from cloudflare.types.firewall.waf import PackageGetResponse
```
Methods:
- client.firewall.waf.packages.list(\*, zone_id, \*\*params) -> SyncV4PagePaginationArray[object]
- client.firewall.waf.packages.get(package_id, \*, zone_id) -> PackageGetResponse
#### Groups
Types:
```python
from cloudflare.types.firewall.waf.packages import Group, GroupEditResponse, GroupGetResponse
```
Methods:
- client.firewall.waf.packages.groups.list(package_id, \*, zone_id, \*\*params) -> SyncV4PagePaginationArray[Group]
- client.firewall.waf.packages.groups.edit(group_id, \*, zone_id, package_id, \*\*params) -> GroupEditResponse
- client.firewall.waf.packages.groups.get(group_id, \*, zone_id, package_id) -> GroupGetResponse
#### Rules
Types:
```python
from cloudflare.types.firewall.waf.packages import (
AllowedModesAnomaly,
WAFRuleGroup,
RuleListResponse,
RuleEditResponse,
RuleGetResponse,
)
```
Methods:
- client.firewall.waf.packages.rules.list(package_id, \*, zone_id, \*\*params) -> SyncV4PagePaginationArray[RuleListResponse]
- client.firewall.waf.packages.rules.edit(rule_id, \*, zone_id, package_id, \*\*params) -> RuleEditResponse
- client.firewall.waf.packages.rules.get(rule_id, \*, zone_id, package_id) -> RuleGetResponse
# Healthchecks
Types:
```python
from cloudflare.types.healthchecks import (
CheckRegion,
Healthcheck,
HTTPConfiguration,
QueryHealthcheck,
TCPConfiguration,
HealthcheckDeleteResponse,
)
```
Methods:
- client.healthchecks.create(\*, zone_id, \*\*params) -> Healthcheck
- client.healthchecks.update(healthcheck_id, \*, zone_id, \*\*params) -> Healthcheck
- client.healthchecks.list(\*, zone_id, \*\*params) -> SyncV4PagePaginationArray[Healthcheck]
- client.healthchecks.delete(healthcheck_id, \*, zone_id) -> HealthcheckDeleteResponse
- client.healthchecks.edit(healthcheck_id, \*, zone_id, \*\*params) -> Healthcheck
- client.healthchecks.get(healthcheck_id, \*, zone_id) -> Healthcheck
## Previews
Types:
```python
from cloudflare.types.healthchecks import PreviewDeleteResponse
```
Methods:
- client.healthchecks.previews.create(\*, zone_id, \*\*params) -> Healthcheck
- client.healthchecks.previews.delete(healthcheck_id, \*, zone_id) -> PreviewDeleteResponse
- client.healthchecks.previews.get(healthcheck_id, \*, zone_id) -> Healthcheck
# KeylessCertificates
Types:
```python
from cloudflare.types.keyless_certificates import (
KeylessCertificate,
Tunnel,
KeylessCertificateDeleteResponse,
)
```
Methods:
- client.keyless_certificates.create(\*, zone_id, \*\*params) -> Optional[KeylessCertificate]
- client.keyless_certificates.list(\*, zone_id) -> SyncSinglePage[KeylessCertificate]
- client.keyless_certificates.delete(keyless_certificate_id, \*, zone_id) -> Optional[KeylessCertificateDeleteResponse]
- client.keyless_certificates.edit(keyless_certificate_id, \*, zone_id, \*\*params) -> Optional[KeylessCertificate]
- client.keyless_certificates.get(keyless_certificate_id, \*, zone_id) -> Optional[KeylessCertificate]
# Logpush
## Datasets
### Fields
Methods:
- client.logpush.datasets.fields.get(dataset_id, \*, account_id, zone_id) -> object
### Jobs
Methods:
- client.logpush.datasets.jobs.get(dataset_id, \*, account_id, zone_id) -> SyncSinglePage[Optional[LogpushJob]]
## Edge
Types:
```python
from cloudflare.types.logpush import InstantLogpushJob
```
Methods:
- client.logpush.edge.create(\*, zone_id, \*\*params) -> Optional[InstantLogpushJob]
- client.logpush.edge.get(\*, zone_id) -> SyncSinglePage[Optional[InstantLogpushJob]]
## Jobs
Types:
```python
from cloudflare.types.logpush import LogpushJob, OutputOptions, JobDeleteResponse
```
Methods:
- client.logpush.jobs.create(\*, account_id, zone_id, \*\*params) -> Optional[LogpushJob]
- client.logpush.jobs.update(job_id, \*, account_id, zone_id, \*\*params) -> Optional[LogpushJob]
- client.logpush.jobs.list(\*, account_id, zone_id) -> SyncSinglePage[Optional[LogpushJob]]
- client.logpush.jobs.delete(job_id, \*, account_id, zone_id) -> Optional[JobDeleteResponse]
- client.logpush.jobs.get(job_id, \*, account_id, zone_id) -> Optional[LogpushJob]
## Ownership
Types:
```python
from cloudflare.types.logpush import OwnershipValidation, OwnershipCreateResponse
```
Methods:
- client.logpush.ownership.create(\*, account_id, zone_id, \*\*params) -> Optional[OwnershipCreateResponse]
- client.logpush.ownership.validate(\*, account_id, zone_id, \*\*params) -> Optional[OwnershipValidation]
## Validate
Types:
```python
from cloudflare.types.logpush import (
ValidateDestinationResponse,
ValidateDestinationExistsResponse,
ValidateOriginResponse,
)
```
Methods:
- client.logpush.validate.destination(\*, account_id, zone_id, \*\*params) -> Optional[ValidateDestinationResponse]
- client.logpush.validate.destination_exists(\*, account_id, zone_id, \*\*params) -> Optional[ValidateDestinationExistsResponse]
- client.logpush.validate.origin(\*, account_id, zone_id, \*\*params) -> Optional[ValidateOriginResponse]
# Logs
## Control
### Retention
Types:
```python
from cloudflare.types.logs.control import RetentionCreateResponse, RetentionGetResponse
```
Methods:
- client.logs.control.retention.create(\*, zone_id, \*\*params) -> Optional[RetentionCreateResponse]
- client.logs.control.retention.get(\*, zone_id) -> Optional[RetentionGetResponse]
### Cmb
#### Config
Types:
```python
from cloudflare.types.logs.control.cmb import CmbConfig
```
Methods:
- client.logs.control.cmb.config.create(\*, account_id, \*\*params) -> Optional[CmbConfig]
- client.logs.control.cmb.config.delete(\*, account_id) -> object
- client.logs.control.cmb.config.get(\*, account_id) -> Optional[CmbConfig]
## RayID
Types:
```python
from cloudflare.types.logs import RayIDGetResponse
```
Methods:
- client.logs.rayid.get(rayid, \*, zone_id, \*\*params) -> RayIDGetResponse
## Received
Types:
```python
from cloudflare.types.logs import ReceivedGetResponse
```
Methods:
- client.logs.received.get(\*, zone_id, \*\*params) -> ReceivedGetResponse
### Fields
Types:
```python
from cloudflare.types.logs.received import FieldGetResponse
```
Methods:
- client.logs.received.fields.get(\*, zone_id) -> FieldGetResponse
# OriginTLSClientAuth
Types:
```python
from cloudflare.types.origin_tls_client_auth import (
ZoneAuthenticatedOriginPull,
OriginTLSClientAuthCreateResponse,
OriginTLSClientAuthListResponse,
OriginTLSClientAuthDeleteResponse,
OriginTLSClientAuthGetResponse,
)
```
Methods:
- client.origin_tls_client_auth.create(\*, zone_id, \*\*params) -> Optional[OriginTLSClientAuthCreateResponse]
- client.origin_tls_client_auth.list(\*, zone_id) -> SyncSinglePage[OriginTLSClientAuthListResponse]
- client.origin_tls_client_auth.delete(certificate_id, \*, zone_id) -> Optional[OriginTLSClientAuthDeleteResponse]
- client.origin_tls_client_auth.get(certificate_id, \*, zone_id) -> Optional[OriginTLSClientAuthGetResponse]
## Hostnames
Types:
```python
from cloudflare.types.origin_tls_client_auth import AuthenticatedOriginPull, HostnameUpdateResponse
```
Methods:
- client.origin_tls_client_auth.hostnames.update(\*, zone_id, \*\*params) -> SyncSinglePage[HostnameUpdateResponse]
- client.origin_tls_client_auth.hostnames.get(hostname, \*, zone_id) -> Optional[AuthenticatedOriginPull]
### Certificates
Types:
```python
from cloudflare.types.origin_tls_client_auth.hostnames import (
Certificate,
CertificateCreateResponse,
CertificateListResponse,
CertificateDeleteResponse,
CertificateGetResponse,
)
```
Methods:
- client.origin_tls_client_auth.hostnames.certificates.create(\*, zone_id, \*\*params) -> Optional[CertificateCreateResponse]
- client.origin_tls_client_auth.hostnames.certificates.list(\*, zone_id) -> SyncSinglePage[CertificateListResponse]
- client.origin_tls_client_auth.hostnames.certificates.delete(certificate_id, \*, zone_id) -> Optional[CertificateDeleteResponse]
- client.origin_tls_client_auth.hostnames.certificates.get(certificate_id, \*, zone_id) -> Optional[CertificateGetResponse]
## Settings
Types:
```python
from cloudflare.types.origin_tls_client_auth import SettingUpdateResponse, SettingGetResponse
```
Methods:
- client.origin_tls_client_auth.settings.update(\*, zone_id, \*\*params) -> Optional[SettingUpdateResponse]
- client.origin_tls_client_auth.settings.get(\*, zone_id) -> Optional[SettingGetResponse]
# PageRules
Types:
```python
from cloudflare.types.page_rules import (
PageRule,
Target,
PageRuleListResponse,
PageRuleDeleteResponse,
)
```
Methods:
- client.page_rules.create(\*, zone_id, \*\*params) -> Optional[PageRule]
- client.page_rules.update(pagerule_id, \*, zone_id, \*\*params) -> Optional[PageRule]
- client.page_rules.list(\*, zone_id, \*\*params) -> Optional[PageRuleListResponse]
- client.page_rules.delete(pagerule_id, \*, zone_id) -> Optional[PageRuleDeleteResponse]
- client.page_rules.edit(pagerule_id, \*, zone_id, \*\*params) -> Optional[PageRule]
- client.page_rules.get(pagerule_id, \*, zone_id) -> Optional[PageRule]
# RateLimits
Types:
```python
from cloudflare.types.rate_limits import Action, RateLimit, RateLimitDeleteResponse
```
Methods:
- client.rate_limits.create(\*, zone_id, \*\*params) -> RateLimit
- client.rate_limits.list(\*, zone_id, \*\*params) -> SyncV4PagePaginationArray[RateLimit]
- client.rate_limits.delete(rate_limit_id, \*, zone_id) -> RateLimitDeleteResponse
- client.rate_limits.edit(rate_limit_id, \*, zone_id, \*\*params) -> RateLimit
- client.rate_limits.get(rate_limit_id, \*, zone_id) -> RateLimit
# WaitingRooms
Types:
```python
from cloudflare.types.waiting_rooms import (
AdditionalRoutes,
CookieAttributes,
Query,
WaitingRoom,
WaitingRoomDeleteResponse,
)
```
Methods:
- client.waiting_rooms.create(\*, zone_id, \*\*params) -> WaitingRoom
- client.waiting_rooms.update(waiting_room_id, \*, zone_id, \*\*params) -> WaitingRoom
- client.waiting_rooms.list(\*, account_id, zone_id, \*\*params) -> SyncV4PagePaginationArray[WaitingRoom]
- client.waiting_rooms.delete(waiting_room_id, \*, zone_id) -> WaitingRoomDeleteResponse
- client.waiting_rooms.edit(waiting_room_id, \*, zone_id, \*\*params) -> WaitingRoom
- client.waiting_rooms.get(waiting_room_id, \*, zone_id) -> WaitingRoom
## Page
Types:
```python
from cloudflare.types.waiting_rooms import PagePreviewResponse
```
Methods:
- client.waiting_rooms.page.preview(\*, zone_id, \*\*params) -> PagePreviewResponse
## Events
Types:
```python
from cloudflare.types.waiting_rooms import Event, EventDeleteResponse
```
Methods:
- client.waiting_rooms.events.create(waiting_room_id, \*, zone_id, \*\*params) -> Event
- client.waiting_rooms.events.update(event_id, \*, zone_id, waiting_room_id, \*\*params) -> Event
- client.waiting_rooms.events.list(waiting_room_id, \*, zone_id, \*\*params) -> SyncV4PagePaginationArray[Event]
- client.waiting_rooms.events.delete(event_id, \*, zone_id, waiting_room_id) -> EventDeleteResponse
- client.waiting_rooms.events.edit(event_id, \*, zone_id, waiting_room_id, \*\*params) -> Event
- client.waiting_rooms.events.get(event_id, \*, zone_id, waiting_room_id) -> Event
### Details
Types:
```python
from cloudflare.types.waiting_rooms.events import EventQuery, DetailGetResponse
```
Methods:
- client.waiting_rooms.events.details.get(event_id, \*, zone_id, waiting_room_id) -> DetailGetResponse
## Rules
Types:
```python
from cloudflare.types.waiting_rooms import WaitingRoomRule
```
Methods:
- client.waiting_rooms.rules.create(waiting_room_id, \*, zone_id, \*\*params) -> SyncSinglePage[WaitingRoomRule]
- client.waiting_rooms.rules.update(waiting_room_id, \*, zone_id, \*\*params) -> SyncSinglePage[WaitingRoomRule]
- client.waiting_rooms.rules.delete(rule_id, \*, zone_id, waiting_room_id) -> SyncSinglePage[WaitingRoomRule]
- client.waiting_rooms.rules.edit(rule_id, \*, zone_id, waiting_room_id, \*\*params) -> SyncSinglePage[WaitingRoomRule]
- client.waiting_rooms.rules.get(waiting_room_id, \*, zone_id) -> SyncSinglePage[WaitingRoomRule]
## Statuses
Types:
```python
from cloudflare.types.waiting_rooms import StatusGetResponse
```
Methods:
- client.waiting_rooms.statuses.get(waiting_room_id, \*, zone_id) -> StatusGetResponse
## Settings
Types:
```python
from cloudflare.types.waiting_rooms import (
Setting,
SettingUpdateResponse,
SettingEditResponse,
SettingGetResponse,
)
```
Methods:
- client.waiting_rooms.settings.update(\*, zone_id, \*\*params) -> SettingUpdateResponse
- client.waiting_rooms.settings.edit(\*, zone_id, \*\*params) -> SettingEditResponse
- client.waiting_rooms.settings.get(\*, zone_id) -> SettingGetResponse
# Web3
## Hostnames
Types:
```python
from cloudflare.types.web3 import Hostname, HostnameDeleteResponse
```
Methods:
- client.web3.hostnames.create(\*, zone_id, \*\*params) -> Hostname
- client.web3.hostnames.list(\*, zone_id) -> SyncSinglePage[Hostname]
- client.web3.hostnames.delete(identifier, \*, zone_id) -> Optional[HostnameDeleteResponse]
- client.web3.hostnames.edit(identifier, \*, zone_id, \*\*params) -> Hostname
- client.web3.hostnames.get(identifier, \*, zone_id) -> Hostname
### IPFSUniversalPaths
#### ContentLists
Types:
```python
from cloudflare.types.web3.hostnames.ipfs_universal_paths import ContentList
```
Methods:
- client.web3.hostnames.ipfs_universal_paths.content_lists.update(identifier, \*, zone_id, \*\*params) -> ContentList
- client.web3.hostnames.ipfs_universal_paths.content_lists.get(identifier, \*, zone_id) -> ContentList
##### Entries
Types:
```python
from cloudflare.types.web3.hostnames.ipfs_universal_paths.content_lists import (
EntryCreateResponse,
EntryUpdateResponse,
EntryListResponse,
EntryDeleteResponse,
EntryGetResponse,
)
```
Methods:
- client.web3.hostnames.ipfs_universal_paths.content_lists.entries.create(identifier, \*, zone_id, \*\*params) -> EntryCreateResponse
- client.web3.hostnames.ipfs_universal_paths.content_lists.entries.update(content_list_entry_identifier, \*, zone_id, identifier, \*\*params) -> EntryUpdateResponse
- client.web3.hostnames.ipfs_universal_paths.content_lists.entries.list(identifier, \*, zone_id) -> Optional[EntryListResponse]
- client.web3.hostnames.ipfs_universal_paths.content_lists.entries.delete(content_list_entry_identifier, \*, zone_id, identifier) -> Optional[EntryDeleteResponse]
- client.web3.hostnames.ipfs_universal_paths.content_lists.entries.get(content_list_entry_identifier, \*, zone_id, identifier) -> EntryGetResponse
# Workers
Types:
```python
from cloudflare.types.workers import MigrationStep, SingleStepMigration, WorkerMetadata
```
## Routes
Types:
```python
from cloudflare.types.workers import (
RouteCreateResponse,
RouteUpdateResponse,
RouteListResponse,
RouteDeleteResponse,
RouteGetResponse,
)
```
Methods:
- client.workers.routes.create(\*, zone_id, \*\*params) -> RouteCreateResponse
- client.workers.routes.update(route_id, \*, zone_id, \*\*params) -> RouteUpdateResponse
- client.workers.routes.list(\*, zone_id) -> SyncSinglePage[RouteListResponse]
- client.workers.routes.delete(route_id, \*, zone_id) -> RouteDeleteResponse
- client.workers.routes.get(route_id, \*, zone_id) -> RouteGetResponse
## Assets
### Upload
Types:
```python
from cloudflare.types.workers.assets import UploadCreateResponse
```
Methods:
- client.workers.assets.upload.create(\*, account_id, \*\*params) -> Optional[UploadCreateResponse]
## Scripts
Types:
```python
from cloudflare.types.workers import Script, ScriptSetting, ScriptUpdateResponse, ScriptGetResponse
```
Methods:
- client.workers.scripts.update(script_name, \*, account_id, \*\*params) -> ScriptUpdateResponse
- client.workers.scripts.list(\*, account_id) -> SyncSinglePage[Script]
- client.workers.scripts.delete(script_name, \*, account_id, \*\*params) -> object
- client.workers.scripts.get(script_name, \*, account_id) -> str
### Assets
#### Upload
Types:
```python
from cloudflare.types.workers.scripts.assets import UploadCreateResponse
```
Methods:
- client.workers.scripts.assets.upload.create(script_name, \*, account_id, \*\*params) -> Optional[UploadCreateResponse]
### Subdomain
Types:
```python
from cloudflare.types.workers.scripts import (
SubdomainCreateResponse,
SubdomainDeleteResponse,
SubdomainGetResponse,
)
```
Methods:
- client.workers.scripts.subdomain.create(script_name, \*, account_id, \*\*params) -> SubdomainCreateResponse
- client.workers.scripts.subdomain.delete(script_name, \*, account_id) -> SubdomainDeleteResponse
- client.workers.scripts.subdomain.get(script_name, \*, account_id) -> SubdomainGetResponse
### Schedules
Types:
```python
from cloudflare.types.workers.scripts import ScheduleUpdateResponse, ScheduleGetResponse
```
Methods:
- client.workers.scripts.schedules.update(script_name, \*, account_id, \*\*params) -> ScheduleUpdateResponse
- client.workers.scripts.schedules.get(script_name, \*, account_id) -> ScheduleGetResponse
### Tail
Types:
```python
from cloudflare.types.workers.scripts import (
ConsumerScript,
TailCreateResponse,
TailDeleteResponse,
TailGetResponse,
)
```
Methods:
- client.workers.scripts.tail.create(script_name, \*, account_id, \*\*params) -> TailCreateResponse
- client.workers.scripts.tail.delete(id, \*, account_id, script_name) -> TailDeleteResponse
- client.workers.scripts.tail.get(script_name, \*, account_id) -> TailGetResponse
### Content
Methods:
- client.workers.scripts.content.update(script_name, \*, account_id, \*\*params) -> Script
- client.workers.scripts.content.get(script_name, \*, account_id) -> BinaryAPIResponse
### Settings
Methods:
- client.workers.scripts.settings.edit(script_name, \*, account_id, \*\*params) -> ScriptSetting
- client.workers.scripts.settings.get(script_name, \*, account_id) -> ScriptSetting
### Deployments
Types:
```python
from cloudflare.types.workers.scripts import (
Deployment,
DeploymentCreateResponse,
DeploymentGetResponse,
)
```
Methods:
- client.workers.scripts.deployments.create(script_name, \*, account_id, \*\*params) -> Optional[DeploymentCreateResponse]
- client.workers.scripts.deployments.get(script_name, \*, account_id) -> Optional[DeploymentGetResponse]
### Versions
Types:
```python
from cloudflare.types.workers.scripts import (
VersionCreateResponse,
VersionListResponse,
VersionGetResponse,
)
```
Methods:
- client.workers.scripts.versions.create(script_name, \*, account_id, \*\*params) -> VersionCreateResponse
- client.workers.scripts.versions.list(script_name, \*, account_id, \*\*params) -> SyncV4PagePagination[VersionListResponse]
- client.workers.scripts.versions.get(version_id, \*, account_id, script_name) -> VersionGetResponse
### Secrets
Types:
```python
from cloudflare.types.workers.scripts import (
SecretUpdateResponse,
SecretListResponse,
SecretGetResponse,
)
```
Methods:
- client.workers.scripts.secrets.update(script_name, \*, account_id, \*\*params) -> Optional[SecretUpdateResponse]
- client.workers.scripts.secrets.list(script_name, \*, account_id) -> SyncSinglePage[SecretListResponse]
- client.workers.scripts.secrets.delete(secret_name, \*, account_id, script_name) -> object
- client.workers.scripts.secrets.get(secret_name, \*, account_id, script_name) -> Optional[SecretGetResponse]
### ScriptAndVersionSettings
Types:
```python
from cloudflare.types.workers.scripts import (
ScriptAndVersionSettingEditResponse,
ScriptAndVersionSettingGetResponse,
)
```
Methods:
- client.workers.scripts.script_and_version_settings.edit(script_name, \*, account_id, \*\*params) -> ScriptAndVersionSettingEditResponse
- client.workers.scripts.script_and_version_settings.get(script_name, \*, account_id) -> ScriptAndVersionSettingGetResponse
## AccountSettings
Types:
```python
from cloudflare.types.workers import AccountSettingUpdateResponse, AccountSettingGetResponse
```
Methods:
- client.workers.account_settings.update(\*, account_id, \*\*params) -> AccountSettingUpdateResponse
- client.workers.account_settings.get(\*, account_id) -> AccountSettingGetResponse
## Domains
Types:
```python
from cloudflare.types.workers import Domain
```
Methods:
- client.workers.domains.update(\*, account_id, \*\*params) -> Optional[Domain]
- client.workers.domains.list(\*, account_id, \*\*params) -> SyncSinglePage[Domain]
- client.workers.domains.delete(domain_id, \*, account_id) -> None
- client.workers.domains.get(domain_id, \*, account_id) -> Optional[Domain]
## Subdomains
Types:
```python
from cloudflare.types.workers import SubdomainUpdateResponse, SubdomainGetResponse
```
Methods:
- client.workers.subdomains.update(\*, account_id, \*\*params) -> SubdomainUpdateResponse
- client.workers.subdomains.get(\*, account_id) -> SubdomainGetResponse
## Observability
### Telemetry
Types:
```python
from cloudflare.types.workers.observability import (
TelemetryKeysResponse,
TelemetryQueryResponse,
TelemetryValuesResponse,
)
```
Methods:
- client.workers.observability.telemetry.keys(\*, account_id, \*\*params) -> SyncSinglePage[TelemetryKeysResponse]
- client.workers.observability.telemetry.query(\*, account_id, \*\*params) -> TelemetryQueryResponse
- client.workers.observability.telemetry.values(\*, account_id, \*\*params) -> SyncSinglePage[TelemetryValuesResponse]
# KV
## Namespaces
Types:
```python
from cloudflare.types.kv import (
Namespace,
NamespaceDeleteResponse,
NamespaceBulkDeleteResponse,
NamespaceBulkGetResponse,
NamespaceBulkUpdateResponse,
)
```
Methods:
- client.kv.namespaces.create(\*, account_id, \*\*params) -> Optional[Namespace]
- client.kv.namespaces.update(namespace_id, \*, account_id, \*\*params) -> Namespace
- client.kv.namespaces.list(\*, account_id, \*\*params) -> SyncV4PagePaginationArray[Namespace]
- client.kv.namespaces.delete(namespace_id, \*, account_id) -> Optional[NamespaceDeleteResponse]
- client.kv.namespaces.bulk_delete(namespace_id, \*, account_id, \*\*params) -> Optional[NamespaceBulkDeleteResponse]
- client.kv.namespaces.bulk_get(namespace_id, \*, account_id, \*\*params) -> Optional[NamespaceBulkGetResponse]
- client.kv.namespaces.bulk_update(namespace_id, \*, account_id, \*\*params) -> Optional[NamespaceBulkUpdateResponse]
- client.kv.namespaces.get(namespace_id, \*, account_id) -> Optional[Namespace]
### Keys
Types:
```python
from cloudflare.types.kv.namespaces import (
Key,
KeyBulkDeleteResponse,
KeyBulkGetResponse,
KeyBulkUpdateResponse,
)
```
Methods:
- client.kv.namespaces.keys.list(namespace_id, \*, account_id, \*\*params) -> SyncCursorLimitPagination[Key]
- client.kv.namespaces.keys.bulk_delete(namespace_id, \*, account_id, \*\*params) -> Optional[KeyBulkDeleteResponse]
- client.kv.namespaces.keys.bulk_get(namespace_id, \*, account_id, \*\*params) -> Optional[KeyBulkGetResponse]
- client.kv.namespaces.keys.bulk_update(namespace_id, \*, account_id, \*\*params) -> Optional[KeyBulkUpdateResponse]
### Metadata
Types:
```python
from cloudflare.types.kv.namespaces import MetadataGetResponse
```
Methods:
- client.kv.namespaces.metadata.get(key_name, \*, account_id, namespace_id) -> Optional[MetadataGetResponse]
### Values
Types:
```python
from cloudflare.types.kv.namespaces import ValueUpdateResponse, ValueDeleteResponse
```
Methods:
- client.kv.namespaces.values.update(key_name, \*, account_id, namespace_id, \*\*params) -> Optional[ValueUpdateResponse]
- client.kv.namespaces.values.delete(key_name, \*, account_id, namespace_id) -> Optional[ValueDeleteResponse]
- client.kv.namespaces.values.get(key_name, \*, account_id, namespace_id) -> BinaryAPIResponse
# DurableObjects
## Namespaces
Types:
```python
from cloudflare.types.durable_objects import Namespace
```
Methods:
- client.durable_objects.namespaces.list(\*, account_id) -> SyncSinglePage[Namespace]
### Objects
Types:
```python
from cloudflare.types.durable_objects.namespaces import DurableObject
```
Methods:
- client.durable_objects.namespaces.objects.list(id, \*, account_id, \*\*params) -> SyncCursorLimitPagination[DurableObject]
# Queues
Types:
```python
from cloudflare.types.queues import Queue, QueueDeleteResponse
```
Methods:
- client.queues.create(\*, account_id, \*\*params) -> Optional[Queue]
- client.queues.update(queue_id, \*, account_id, \*\*params) -> Optional[Queue]
- client.queues.list(\*, account_id) -> SyncSinglePage[Queue]
- client.queues.delete(queue_id, \*, account_id) -> QueueDeleteResponse
- client.queues.edit(queue_id, \*, account_id, \*\*params) -> Optional[Queue]
- client.queues.get(queue_id, \*, account_id) -> Optional[Queue]
## Consumers
Types:
```python
from cloudflare.types.queues import Consumer, ConsumerDeleteResponse
```
Methods:
- client.queues.consumers.create(queue_id, \*, account_id, \*\*params) -> Optional[Consumer]
- client.queues.consumers.update(consumer_id, \*, account_id, queue_id, \*\*params) -> Optional[Consumer]
- client.queues.consumers.delete(consumer_id, \*, account_id, queue_id) -> ConsumerDeleteResponse
- client.queues.consumers.get(queue_id, \*, account_id) -> SyncSinglePage[Consumer]
## Messages
Types:
```python
from cloudflare.types.queues import (
MessageAckResponse,
MessageBulkPushResponse,
MessagePullResponse,
MessagePushResponse,
)
```
Methods:
- client.queues.messages.ack(queue_id, \*, account_id, \*\*params) -> Optional[MessageAckResponse]
- client.queues.messages.bulk_push(queue_id, \*, account_id, \*\*params) -> MessageBulkPushResponse
- client.queues.messages.pull(queue_id, \*, account_id, \*\*params) -> Optional[MessagePullResponse]
- client.queues.messages.push(queue_id, \*, account_id, \*\*params) -> MessagePushResponse
## Purge
Types:
```python
from cloudflare.types.queues import PurgeStatusResponse
```
Methods:
- client.queues.purge.start(queue_id, \*, account_id, \*\*params) -> Optional[Queue]
- client.queues.purge.status(queue_id, \*, account_id) -> Optional[PurgeStatusResponse]
# APIGateway
## Configurations
Types:
```python
from cloudflare.types.api_gateway import Configuration, ConfigurationUpdateResponse
```
Methods:
- client.api_gateway.configurations.update(\*, zone_id, \*\*params) -> ConfigurationUpdateResponse
- client.api_gateway.configurations.get(\*, zone_id, \*\*params) -> Configuration
## Discovery
Types:
```python
from cloudflare.types.api_gateway import DiscoveryOperation, DiscoveryGetResponse
```
Methods:
- client.api_gateway.discovery.get(\*, zone_id) -> DiscoveryGetResponse
### Operations
Types:
```python
from cloudflare.types.api_gateway.discovery import OperationBulkEditResponse, OperationEditResponse
```
Methods:
- client.api_gateway.discovery.operations.list(\*, zone_id, \*\*params) -> SyncV4PagePaginationArray[DiscoveryOperation]
- client.api_gateway.discovery.operations.bulk_edit(\*, zone_id, \*\*params) -> OperationBulkEditResponse
- client.api_gateway.discovery.operations.edit(operation_id, \*, zone_id, \*\*params) -> OperationEditResponse
## Operations
Types:
```python
from cloudflare.types.api_gateway import (
APIShield,
OperationCreateResponse,
OperationListResponse,
OperationDeleteResponse,
OperationBulkCreateResponse,
OperationBulkDeleteResponse,
OperationGetResponse,
)
```
Methods:
- client.api_gateway.operations.create(\*, zone_id, \*\*params) -> OperationCreateResponse
- client.api_gateway.operations.list(\*, zone_id, \*\*params) -> SyncV4PagePaginationArray[OperationListResponse]
- client.api_gateway.operations.delete(operation_id, \*, zone_id) -> OperationDeleteResponse
- client.api_gateway.operations.bulk_create(\*, zone_id, \*\*params) -> SyncSinglePage[OperationBulkCreateResponse]
- client.api_gateway.operations.bulk_delete(\*, zone_id) -> OperationBulkDeleteResponse
- client.api_gateway.operations.get(operation_id, \*, zone_id, \*\*params) -> OperationGetResponse
### SchemaValidation
Types:
```python
from cloudflare.types.api_gateway.operations import (
SettingsMultipleRequest,
SchemaValidationUpdateResponse,
SchemaValidationGetResponse,
)
```
Methods:
- client.api_gateway.operations.schema_validation.update(operation_id, \*, zone_id, \*\*params) -> SchemaValidationUpdateResponse
- client.api_gateway.operations.schema_validation.edit(\*, zone_id, \*\*params) -> SettingsMultipleRequest
- client.api_gateway.operations.schema_validation.get(operation_id, \*, zone_id) -> SchemaValidationGetResponse
## Schemas
Types:
```python
from cloudflare.types.api_gateway import SchemaListResponse
```
Methods:
- client.api_gateway.schemas.list(\*, zone_id, \*\*params) -> SchemaListResponse
## Settings
Types:
```python
from cloudflare.types.api_gateway import Settings
```
### SchemaValidation
Methods:
- client.api_gateway.settings.schema_validation.update(\*, zone_id, \*\*params) -> Settings
- client.api_gateway.settings.schema_validation.edit(\*, zone_id, \*\*params) -> Settings
- client.api_gateway.settings.schema_validation.get(\*, zone_id) -> Settings
## UserSchemas
Types:
```python
from cloudflare.types.api_gateway import (
Message,
PublicSchema,
SchemaUpload,
UserSchemaDeleteResponse,
)
```
Methods:
- client.api_gateway.user_schemas.create(\*, zone_id, \*\*params) -> SchemaUpload
- client.api_gateway.user_schemas.list(\*, zone_id, \*\*params) -> SyncV4PagePaginationArray[PublicSchema]
- client.api_gateway.user_schemas.delete(schema_id, \*, zone_id) -> UserSchemaDeleteResponse
- client.api_gateway.user_schemas.edit(schema_id, \*, zone_id, \*\*params) -> PublicSchema
- client.api_gateway.user_schemas.get(schema_id, \*, zone_id, \*\*params) -> PublicSchema
### Operations
Types:
```python
from cloudflare.types.api_gateway.user_schemas import OperationListResponse
```
Methods:
- client.api_gateway.user_schemas.operations.list(schema_id, \*, zone_id, \*\*params) -> SyncV4PagePaginationArray[OperationListResponse]
### Hosts
Types:
```python
from cloudflare.types.api_gateway.user_schemas import HostListResponse
```
Methods:
- client.api_gateway.user_schemas.hosts.list(\*, zone_id, \*\*params) -> SyncV4PagePaginationArray[HostListResponse]
## ExpressionTemplate
### Fallthrough
Types:
```python
from cloudflare.types.api_gateway.expression_template import FallthroughCreateResponse
```
Methods:
- client.api_gateway.expression_template.fallthrough.create(\*, zone_id, \*\*params) -> FallthroughCreateResponse
# ManagedTransforms
Types:
```python
from cloudflare.types.managed_transforms import (
ManagedTransformListResponse,
ManagedTransformEditResponse,
)
```
Methods:
- client.managed_transforms.list(\*, zone_id) -> ManagedTransformListResponse
- client.managed_transforms.delete(\*, zone_id) -> None
- client.managed_transforms.edit(\*, zone_id, \*\*params) -> ManagedTransformEditResponse
# PageShield
Types:
```python
from cloudflare.types.page_shield import Setting, PageShieldUpdateResponse
```
Methods:
- client.page_shield.update(\*, zone_id, \*\*params) -> Optional[PageShieldUpdateResponse]
- client.page_shield.get(\*, zone_id) -> Optional[Setting]
## Policies
Types:
```python
from cloudflare.types.page_shield import (
Policy,
PolicyCreateResponse,
PolicyUpdateResponse,
PolicyListResponse,
PolicyGetResponse,
)
```
Methods:
- client.page_shield.policies.create(\*, zone_id, \*\*params) -> Optional[PolicyCreateResponse]
- client.page_shield.policies.update(policy_id, \*, zone_id, \*\*params) -> Optional[PolicyUpdateResponse]
- client.page_shield.policies.list(\*, zone_id) -> SyncSinglePage[PolicyListResponse]
- client.page_shield.policies.delete(policy_id, \*, zone_id) -> None
- client.page_shield.policies.get(policy_id, \*, zone_id) -> Optional[PolicyGetResponse]
## Connections
Types:
```python
from cloudflare.types.page_shield import Connection
```
Methods:
- client.page_shield.connections.list(\*, zone_id, \*\*params) -> SyncSinglePage[Connection]
- client.page_shield.connections.get(connection_id, \*, zone_id) -> Optional[Connection]
## Scripts
Types:
```python
from cloudflare.types.page_shield import Script, ScriptGetResponse
```
Methods:
- client.page_shield.scripts.list(\*, zone_id, \*\*params) -> SyncSinglePage[Script]
- client.page_shield.scripts.get(script_id, \*, zone_id) -> Optional[ScriptGetResponse]
## Cookies
Types:
```python
from cloudflare.types.page_shield import CookieListResponse, CookieGetResponse
```
Methods:
- client.page_shield.cookies.list(\*, zone_id, \*\*params) -> SyncSinglePage[CookieListResponse]
- client.page_shield.cookies.get(cookie_id, \*, zone_id) -> Optional[CookieGetResponse]
# Rulesets
Types:
```python
from cloudflare.types.rulesets import (
Kind,
Phase,
Ruleset,
RulesetCreateResponse,
RulesetUpdateResponse,
RulesetListResponse,
RulesetGetResponse,
)
```
Methods:
- client.rulesets.create(\*, account_id, zone_id, \*\*params) -> RulesetCreateResponse
- client.rulesets.update(ruleset_id, \*, account_id, zone_id, \*\*params) -> RulesetUpdateResponse
- client.rulesets.list(\*, account_id, zone_id, \*\*params) -> SyncCursorPagination[RulesetListResponse]
- client.rulesets.delete(ruleset_id, \*, account_id, zone_id) -> None
- client.rulesets.get(ruleset_id, \*, account_id, zone_id) -> RulesetGetResponse
## Phases
Types:
```python
from cloudflare.types.rulesets import PhaseUpdateResponse, PhaseGetResponse
```
Methods:
- client.rulesets.phases.update(ruleset_phase, \*, account_id, zone_id, \*\*params) -> PhaseUpdateResponse
- client.rulesets.phases.get(ruleset_phase, \*, account_id, zone_id) -> PhaseGetResponse
### Versions
Types:
```python
from cloudflare.types.rulesets.phases import VersionListResponse, VersionGetResponse
```
Methods:
- client.rulesets.phases.versions.list(ruleset_phase, \*, account_id, zone_id) -> SyncSinglePage[VersionListResponse]
- client.rulesets.phases.versions.get(ruleset_version, \*, ruleset_phase, account_id, zone_id) -> VersionGetResponse
## Rules
Types:
```python
from cloudflare.types.rulesets import (
BlockRule,
CompressResponseRule,
DDoSDynamicRule,
ExecuteRule,
ForceConnectionCloseRule,
LogCustomFieldRule,
LogRule,
Logging,
ManagedChallengeRule,
RedirectRule,
RewriteRule,
RewriteURIPart,
RouteRule,
RulesetRule,
ScoreRule,
ServeErrorRule,
SetCacheSettingsRule,
SetConfigRule,
SkipRule,
RuleCreateResponse,
RuleDeleteResponse,
RuleEditResponse,
)
```
Methods:
- client.rulesets.rules.create(ruleset_id, \*, account_id, zone_id, \*\*params) -> RuleCreateResponse
- client.rulesets.rules.delete(rule_id, \*, ruleset_id, account_id, zone_id) -> RuleDeleteResponse
- client.rulesets.rules.edit(rule_id, \*, ruleset_id, account_id, zone_id, \*\*params) -> RuleEditResponse
## Versions
Types:
```python
from cloudflare.types.rulesets import VersionListResponse, VersionGetResponse
```
Methods:
- client.rulesets.versions.list(ruleset_id, \*, account_id, zone_id) -> SyncSinglePage[VersionListResponse]
- client.rulesets.versions.delete(ruleset_version, \*, ruleset_id, account_id, zone_id) -> None
- client.rulesets.versions.get(ruleset_version, \*, ruleset_id, account_id, zone_id) -> VersionGetResponse
# URLNormalization
Types:
```python
from cloudflare.types.url_normalization import (
URLNormalizationUpdateResponse,
URLNormalizationGetResponse,
)
```
Methods:
- client.url_normalization.update(\*, zone_id, \*\*params) -> URLNormalizationUpdateResponse
- client.url_normalization.delete(\*, zone_id) -> None
- client.url_normalization.get(\*, zone_id) -> URLNormalizationGetResponse
# Spectrum
Types:
```python
from cloudflare.types.spectrum import DNS, EdgeIPs, OriginDNS, OriginPort
```
## Analytics
### Aggregates
#### Currents
Types:
```python
from cloudflare.types.spectrum.analytics.aggregates import CurrentGetResponse
```
Methods:
- client.spectrum.analytics.aggregates.currents.get(\*, zone_id, \*\*params) -> Optional[CurrentGetResponse]
### Events
Types:
```python
from cloudflare.types.spectrum.analytics import Dimension
```
#### Bytimes
Types:
```python
from cloudflare.types.spectrum.analytics.events import BytimeGetResponse
```
Methods:
- client.spectrum.analytics.events.bytimes.get(\*, zone_id, \*\*params) -> Optional[BytimeGetResponse]
#### Summaries
Types:
```python
from cloudflare.types.spectrum.analytics.events import SummaryGetResponse
```
Methods:
- client.spectrum.analytics.events.summaries.get(\*, zone_id, \*\*params) -> Optional[SummaryGetResponse]
## Apps
Types:
```python
from cloudflare.types.spectrum import (
AppCreateResponse,
AppUpdateResponse,
AppListResponse,
AppDeleteResponse,
AppGetResponse,
)
```
Methods:
- client.spectrum.apps.create(\*, zone_id, \*\*params) -> Optional[AppCreateResponse]
- client.spectrum.apps.update(app_id, \*, zone_id, \*\*params) -> Optional[AppUpdateResponse]
- client.spectrum.apps.list(\*, zone_id, \*\*params) -> SyncV4PagePaginationArray[Optional[AppListResponse]]
- client.spectrum.apps.delete(app_id, \*, zone_id) -> Optional[AppDeleteResponse]
- client.spectrum.apps.get(app_id, \*, zone_id) -> Optional[AppGetResponse]
# Addressing
## RegionalHostnames
Types:
```python
from cloudflare.types.addressing import (
RegionalHostnameCreateResponse,
RegionalHostnameListResponse,
RegionalHostnameDeleteResponse,
RegionalHostnameEditResponse,
RegionalHostnameGetResponse,
)
```
Methods:
- client.addressing.regional_hostnames.create(\*, zone_id, \*\*params) -> Optional[RegionalHostnameCreateResponse]
- client.addressing.regional_hostnames.list(\*, zone_id) -> SyncSinglePage[RegionalHostnameListResponse]
- client.addressing.regional_hostnames.delete(hostname, \*, zone_id) -> RegionalHostnameDeleteResponse
- client.addressing.regional_hostnames.edit(hostname, \*, zone_id, \*\*params) -> Optional[RegionalHostnameEditResponse]
- client.addressing.regional_hostnames.get(hostname, \*, zone_id) -> Optional[RegionalHostnameGetResponse]
### Regions
Types:
```python
from cloudflare.types.addressing.regional_hostnames import RegionListResponse
```
Methods:
- client.addressing.regional_hostnames.regions.list(\*, account_id) -> SyncSinglePage[RegionListResponse]
## Services
Types:
```python
from cloudflare.types.addressing import ServiceListResponse
```
Methods:
- client.addressing.services.list(\*, account_id) -> SyncSinglePage[ServiceListResponse]
## AddressMaps
Types:
```python
from cloudflare.types.addressing import (
AddressMap,
Kind,
AddressMapCreateResponse,
AddressMapDeleteResponse,
AddressMapGetResponse,
)
```
Methods:
- client.addressing.address_maps.create(\*, account_id, \*\*params) -> Optional[AddressMapCreateResponse]
- client.addressing.address_maps.list(\*, account_id) -> SyncSinglePage[AddressMap]
- client.addressing.address_maps.delete(address_map_id, \*, account_id) -> AddressMapDeleteResponse
- client.addressing.address_maps.edit(address_map_id, \*, account_id, \*\*params) -> Optional[AddressMap]
- client.addressing.address_maps.get(address_map_id, \*, account_id) -> Optional[AddressMapGetResponse]
### Accounts
Types:
```python
from cloudflare.types.addressing.address_maps import AccountUpdateResponse, AccountDeleteResponse
```
Methods:
- client.addressing.address_maps.accounts.update(address_map_id, \*, account_id, \*\*params) -> AccountUpdateResponse
- client.addressing.address_maps.accounts.delete(address_map_id, \*, account_id) -> AccountDeleteResponse
### IPs
Types:
```python
from cloudflare.types.addressing.address_maps import IPUpdateResponse, IPDeleteResponse
```
Methods:
- client.addressing.address_maps.ips.update(ip_address, \*, account_id, address_map_id, \*\*params) -> IPUpdateResponse
- client.addressing.address_maps.ips.delete(ip_address, \*, account_id, address_map_id) -> IPDeleteResponse
### Zones
Types:
```python
from cloudflare.types.addressing.address_maps import ZoneUpdateResponse, ZoneDeleteResponse
```
Methods:
- client.addressing.address_maps.zones.update(address_map_id, \*, zone_id, account_id, \*\*params) -> ZoneUpdateResponse
- client.addressing.address_maps.zones.delete(address_map_id, \*, zone_id, account_id) -> ZoneDeleteResponse
## LOADocuments
Types:
```python
from cloudflare.types.addressing import LOADocumentCreateResponse
```
Methods:
- client.addressing.loa_documents.create(\*, account_id, \*\*params) -> Optional[LOADocumentCreateResponse]
- client.addressing.loa_documents.get(loa_document_id, \*, account_id) -> BinaryAPIResponse
## Prefixes
Types:
```python
from cloudflare.types.addressing import Prefix, PrefixDeleteResponse
```
Methods:
- client.addressing.prefixes.create(\*, account_id, \*\*params) -> Optional[Prefix]
- client.addressing.prefixes.list(\*, account_id) -> SyncSinglePage[Prefix]
- client.addressing.prefixes.delete(prefix_id, \*, account_id) -> PrefixDeleteResponse
- client.addressing.prefixes.edit(prefix_id, \*, account_id, \*\*params) -> Optional[Prefix]
- client.addressing.prefixes.get(prefix_id, \*, account_id) -> Optional[Prefix]
### ServiceBindings
Types:
```python
from cloudflare.types.addressing.prefixes import ServiceBinding, ServiceBindingDeleteResponse
```
Methods:
- client.addressing.prefixes.service_bindings.create(prefix_id, \*, account_id, \*\*params) -> Optional[ServiceBinding]
- client.addressing.prefixes.service_bindings.list(prefix_id, \*, account_id) -> SyncSinglePage[ServiceBinding]
- client.addressing.prefixes.service_bindings.delete(binding_id, \*, account_id, prefix_id) -> ServiceBindingDeleteResponse
- client.addressing.prefixes.service_bindings.get(binding_id, \*, account_id, prefix_id) -> Optional[ServiceBinding]
### BGPPrefixes
Types:
```python
from cloudflare.types.addressing.prefixes import BGPPrefix
```
Methods:
- client.addressing.prefixes.bgp_prefixes.create(prefix_id, \*, account_id, \*\*params) -> Optional[BGPPrefix]
- client.addressing.prefixes.bgp_prefixes.list(prefix_id, \*, account_id) -> SyncSinglePage[BGPPrefix]
- client.addressing.prefixes.bgp_prefixes.edit(bgp_prefix_id, \*, account_id, prefix_id, \*\*params) -> Optional[BGPPrefix]
- client.addressing.prefixes.bgp_prefixes.get(bgp_prefix_id, \*, account_id, prefix_id) -> Optional[BGPPrefix]
### AdvertisementStatus
Types:
```python
from cloudflare.types.addressing.prefixes import (
AdvertisementStatusEditResponse,
AdvertisementStatusGetResponse,
)
```
Methods:
- client.addressing.prefixes.advertisement_status.edit(prefix_id, \*, account_id, \*\*params) -> Optional[AdvertisementStatusEditResponse]
- client.addressing.prefixes.advertisement_status.get(prefix_id, \*, account_id) -> Optional[AdvertisementStatusGetResponse]
### Delegations
Types:
```python
from cloudflare.types.addressing.prefixes import Delegations, DelegationDeleteResponse
```
Methods:
- client.addressing.prefixes.delegations.create(prefix_id, \*, account_id, \*\*params) -> Optional[Delegations]
- client.addressing.prefixes.delegations.list(prefix_id, \*, account_id) -> SyncSinglePage[Delegations]
- client.addressing.prefixes.delegations.delete(delegation_id, \*, account_id, prefix_id) -> Optional[DelegationDeleteResponse]
# AuditLogs
Methods:
- client.audit_logs.list(\*, account_id, \*\*params) -> SyncV4PagePaginationArray[AuditLog]
# Billing
## Profiles
Types:
```python
from cloudflare.types.billing import ProfileGetResponse
```
Methods:
- client.billing.profiles.get(\*, account_id) -> ProfileGetResponse
# BrandProtection
Types:
```python
from cloudflare.types.brand_protection import (
Info,
RuleMatch,
ScanStatus,
Submit,
URLInfoModelResults,
)
```
Methods:
- client.brand_protection.submit(\*, account_id, \*\*params) -> Optional[Submit]
- client.brand_protection.url_info(\*, account_id, \*\*params) -> Optional[Info]
# Diagnostics
## Traceroutes
Types:
```python
from cloudflare.types.diagnostics import Traceroute
```
Methods:
- client.diagnostics.traceroutes.create(\*, account_id, \*\*params) -> SyncSinglePage[Traceroute]
# Images
## V1
Types:
```python
from cloudflare.types.images import Image, V1ListResponse, V1DeleteResponse
```
Methods:
- client.images.v1.create(\*, account_id, \*\*params) -> Image
- client.images.v1.list(\*, account_id, \*\*params) -> SyncV4PagePagination[V1ListResponse]
- client.images.v1.delete(image_id, \*, account_id) -> V1DeleteResponse
- client.images.v1.edit(image_id, \*, account_id, \*\*params) -> Image
- client.images.v1.get(image_id, \*, account_id) -> Image
### Keys
Types:
```python
from cloudflare.types.images.v1 import Key, KeyUpdateResponse, KeyListResponse, KeyDeleteResponse
```
Methods:
- client.images.v1.keys.update(signing_key_name, \*, account_id) -> KeyUpdateResponse
- client.images.v1.keys.list(\*, account_id) -> KeyListResponse
- client.images.v1.keys.delete(signing_key_name, \*, account_id) -> KeyDeleteResponse
### Stats
Types:
```python
from cloudflare.types.images.v1 import Stat
```
Methods:
- client.images.v1.stats.get(\*, account_id) -> Stat
### Variants
Types:
```python
from cloudflare.types.images.v1 import (
Variant,
VariantCreateResponse,
VariantDeleteResponse,
VariantEditResponse,
VariantGetResponse,
)
```
Methods:
- client.images.v1.variants.create(\*, account_id, \*\*params) -> VariantCreateResponse
- client.images.v1.variants.list(\*, account_id) -> Variant
- client.images.v1.variants.delete(variant_id, \*, account_id) -> VariantDeleteResponse
- client.images.v1.variants.edit(variant_id, \*, account_id, \*\*params) -> VariantEditResponse
- client.images.v1.variants.get(variant_id, \*, account_id) -> VariantGetResponse
### Blobs
Methods:
- client.images.v1.blobs.get(image_id, \*, account_id) -> BinaryAPIResponse
## V2
Types:
```python
from cloudflare.types.images import V2ListResponse
```
Methods:
- client.images.v2.list(\*, account_id, \*\*params) -> V2ListResponse
### DirectUploads
Types:
```python
from cloudflare.types.images.v2 import DirectUploadCreateResponse
```
Methods:
- client.images.v2.direct_uploads.create(\*, account_id, \*\*params) -> DirectUploadCreateResponse
# Intel
## ASN
Methods:
- client.intel.asn.get(asn, \*, account_id) -> Optional[ASN]
### Subnets
Types:
```python
from cloudflare.types.intel.asn import SubnetGetResponse
```
Methods:
- client.intel.asn.subnets.get(asn, \*, account_id) -> SubnetGetResponse
## DNS
Types:
```python
from cloudflare.types.intel import DNS
```
Methods:
- client.intel.dns.list(\*, account_id, \*\*params) -> SyncV4PagePagination[Optional[DNS]]
## Domains
Types:
```python
from cloudflare.types.intel import Domain
```
Methods:
- client.intel.domains.get(\*, account_id, \*\*params) -> Optional[Domain]
### Bulks
Types:
```python
from cloudflare.types.intel.domains import BulkGetResponse
```
Methods:
- client.intel.domains.bulks.get(\*, account_id, \*\*params) -> Optional[BulkGetResponse]
## DomainHistory
Types:
```python
from cloudflare.types.intel import DomainHistory, DomainHistoryGetResponse
```
Methods:
- client.intel.domain_history.get(\*, account_id, \*\*params) -> Optional[DomainHistoryGetResponse]
## IPs
Types:
```python
from cloudflare.types.intel import IP, IPGetResponse
```
Methods:
- client.intel.ips.get(\*, account_id, \*\*params) -> Optional[IPGetResponse]
## IPLists
Types:
```python
from cloudflare.types.intel import IPList
```
Methods:
- client.intel.ip_lists.get(\*, account_id) -> SyncSinglePage[IPList]
## Miscategorizations
Types:
```python
from cloudflare.types.intel import MiscategorizationCreateResponse
```
Methods:
- client.intel.miscategorizations.create(\*, account_id, \*\*params) -> MiscategorizationCreateResponse
## Whois
Types:
```python
from cloudflare.types.intel import Whois, WhoisGetResponse
```
Methods:
- client.intel.whois.get(\*, account_id, \*\*params) -> Optional[WhoisGetResponse]
## IndicatorFeeds
Types:
```python
from cloudflare.types.intel import (
IndicatorFeedCreateResponse,
IndicatorFeedUpdateResponse,
IndicatorFeedListResponse,
IndicatorFeedDataResponse,
IndicatorFeedGetResponse,
)
```
Methods:
- client.intel.indicator_feeds.create(\*, account_id, \*\*params) -> Optional[IndicatorFeedCreateResponse]
- client.intel.indicator_feeds.update(feed_id, \*, account_id, \*\*params) -> Optional[IndicatorFeedUpdateResponse]
- client.intel.indicator_feeds.list(\*, account_id) -> SyncSinglePage[IndicatorFeedListResponse]
- client.intel.indicator_feeds.data(feed_id, \*, account_id) -> str
- client.intel.indicator_feeds.get(feed_id, \*, account_id) -> Optional[IndicatorFeedGetResponse]
### Snapshots
Types:
```python
from cloudflare.types.intel.indicator_feeds import SnapshotUpdateResponse
```
Methods:
- client.intel.indicator_feeds.snapshots.update(feed_id, \*, account_id, \*\*params) -> Optional[SnapshotUpdateResponse]
### Permissions
Types:
```python
from cloudflare.types.intel.indicator_feeds import (
PermissionCreateResponse,
PermissionListResponse,
PermissionDeleteResponse,
)
```
Methods:
- client.intel.indicator_feeds.permissions.create(\*, account_id, \*\*params) -> Optional[PermissionCreateResponse]
- client.intel.indicator_feeds.permissions.list(\*, account_id) -> Optional[PermissionListResponse]
- client.intel.indicator_feeds.permissions.delete(\*, account_id, \*\*params) -> Optional[PermissionDeleteResponse]
### Downloads
Types:
```python
from cloudflare.types.intel.indicator_feeds import DownloadGetResponse
```
Methods:
- client.intel.indicator_feeds.downloads.get(feed_id, \*, account_id) -> Optional[DownloadGetResponse]
## Sinkholes
Types:
```python
from cloudflare.types.intel import Sinkhole
```
Methods:
- client.intel.sinkholes.list(\*, account_id) -> SyncSinglePage[Sinkhole]
## AttackSurfaceReport
### IssueTypes
Types:
```python
from cloudflare.types.intel.attack_surface_report import IssueTypeGetResponse
```
Methods:
- client.intel.attack_surface_report.issue_types.get(\*, account_id) -> SyncSinglePage[IssueTypeGetResponse]
### Issues
Types:
```python
from cloudflare.types.intel.attack_surface_report import (
IssueType,
SeverityQueryParam,
IssueListResponse,
IssueClassResponse,
IssueDismissResponse,
IssueSeverityResponse,
IssueTypeResponse,
)
```
Methods:
- client.intel.attack_surface_report.issues.list(\*, account_id, \*\*params) -> SyncV4PagePagination[Optional[IssueListResponse]]
- client.intel.attack*surface_report.issues.class*(\*, account_id, \*\*params) -> Optional[IssueClassResponse]
- client.intel.attack_surface_report.issues.dismiss(issue_id, \*, account_id, \*\*params) -> IssueDismissResponse
- client.intel.attack_surface_report.issues.severity(\*, account_id, \*\*params) -> Optional[IssueSeverityResponse]
- client.intel.attack_surface_report.issues.type(\*, account_id, \*\*params) -> Optional[IssueTypeResponse]
# MagicTransit
Types:
```python
from cloudflare.types.magic_transit import HealthCheck, HealthCheckRate, HealthCheckType
```
## Apps
Types:
```python
from cloudflare.types.magic_transit import (
AppCreateResponse,
AppUpdateResponse,
AppListResponse,
AppDeleteResponse,
AppEditResponse,
)
```
Methods:
- client.magic_transit.apps.create(\*, account_id, \*\*params) -> Optional[AppCreateResponse]
- client.magic_transit.apps.update(account_app_id, \*, account_id, \*\*params) -> Optional[AppUpdateResponse]
- client.magic_transit.apps.list(\*, account_id) -> SyncSinglePage[AppListResponse]
- client.magic_transit.apps.delete(account_app_id, \*, account_id) -> Optional[AppDeleteResponse]
- client.magic_transit.apps.edit(account_app_id, \*, account_id, \*\*params) -> Optional[AppEditResponse]
## CfInterconnects
Types:
```python
from cloudflare.types.magic_transit import (
CfInterconnectUpdateResponse,
CfInterconnectListResponse,
CfInterconnectBulkUpdateResponse,
CfInterconnectGetResponse,
)
```
Methods:
- client.magic_transit.cf_interconnects.update(cf_interconnect_id, \*, account_id, \*\*params) -> CfInterconnectUpdateResponse
- client.magic_transit.cf_interconnects.list(\*, account_id) -> CfInterconnectListResponse
- client.magic_transit.cf_interconnects.bulk_update(\*, account_id, \*\*params) -> CfInterconnectBulkUpdateResponse
- client.magic_transit.cf_interconnects.get(cf_interconnect_id, \*, account_id) -> CfInterconnectGetResponse
## GRETunnels
Types:
```python
from cloudflare.types.magic_transit import (
GRETunnelCreateResponse,
GRETunnelUpdateResponse,
GRETunnelListResponse,
GRETunnelDeleteResponse,
GRETunnelBulkUpdateResponse,
GRETunnelGetResponse,
)
```
Methods:
- client.magic_transit.gre_tunnels.create(\*, account_id, \*\*params) -> GRETunnelCreateResponse
- client.magic_transit.gre_tunnels.update(gre_tunnel_id, \*, account_id, \*\*params) -> GRETunnelUpdateResponse
- client.magic_transit.gre_tunnels.list(\*, account_id) -> GRETunnelListResponse
- client.magic_transit.gre_tunnels.delete(gre_tunnel_id, \*, account_id) -> GRETunnelDeleteResponse
- client.magic_transit.gre_tunnels.bulk_update(\*, account_id, \*\*params) -> GRETunnelBulkUpdateResponse
- client.magic_transit.gre_tunnels.get(gre_tunnel_id, \*, account_id) -> GRETunnelGetResponse
## IPSECTunnels
Types:
```python
from cloudflare.types.magic_transit import (
PSKMetadata,
IPSECTunnelCreateResponse,
IPSECTunnelUpdateResponse,
IPSECTunnelListResponse,
IPSECTunnelDeleteResponse,
IPSECTunnelBulkUpdateResponse,
IPSECTunnelGetResponse,
IPSECTunnelPSKGenerateResponse,
)
```
Methods:
- client.magic_transit.ipsec_tunnels.create(\*, account_id, \*\*params) -> IPSECTunnelCreateResponse
- client.magic_transit.ipsec_tunnels.update(ipsec_tunnel_id, \*, account_id, \*\*params) -> IPSECTunnelUpdateResponse
- client.magic_transit.ipsec_tunnels.list(\*, account_id) -> IPSECTunnelListResponse
- client.magic_transit.ipsec_tunnels.delete(ipsec_tunnel_id, \*, account_id) -> IPSECTunnelDeleteResponse
- client.magic_transit.ipsec_tunnels.bulk_update(\*, account_id, \*\*params) -> IPSECTunnelBulkUpdateResponse
- client.magic_transit.ipsec_tunnels.get(ipsec_tunnel_id, \*, account_id) -> IPSECTunnelGetResponse
- client.magic_transit.ipsec_tunnels.psk_generate(ipsec_tunnel_id, \*, account_id, \*\*params) -> IPSECTunnelPSKGenerateResponse
## Routes
Types:
```python
from cloudflare.types.magic_transit import (
Scope,
RouteCreateResponse,
RouteUpdateResponse,
RouteListResponse,
RouteDeleteResponse,
RouteBulkUpdateResponse,
RouteEmptyResponse,
RouteGetResponse,
)
```
Methods:
- client.magic_transit.routes.create(\*, account_id, \*\*params) -> RouteCreateResponse
- client.magic_transit.routes.update(route_id, \*, account_id, \*\*params) -> RouteUpdateResponse
- client.magic_transit.routes.list(\*, account_id) -> RouteListResponse
- client.magic_transit.routes.delete(route_id, \*, account_id) -> RouteDeleteResponse
- client.magic_transit.routes.bulk_update(\*, account_id, \*\*params) -> RouteBulkUpdateResponse
- client.magic_transit.routes.empty(\*, account_id) -> RouteEmptyResponse
- client.magic_transit.routes.get(route_id, \*, account_id) -> RouteGetResponse
## Sites
Types:
```python
from cloudflare.types.magic_transit import Site, SiteLocation
```
Methods:
- client.magic_transit.sites.create(\*, account_id, \*\*params) -> Site
- client.magic_transit.sites.update(site_id, \*, account_id, \*\*params) -> Site
- client.magic_transit.sites.list(\*, account_id, \*\*params) -> SyncSinglePage[Site]
- client.magic_transit.sites.delete(site_id, \*, account_id) -> Site
- client.magic_transit.sites.edit(site_id, \*, account_id, \*\*params) -> Site
- client.magic_transit.sites.get(site_id, \*, account_id) -> Site
### ACLs
Types:
```python
from cloudflare.types.magic_transit.sites import ACL, ACLConfiguration, AllowedProtocol, Subnet
```
Methods:
- client.magic_transit.sites.acls.create(site_id, \*, account_id, \*\*params) -> ACL
- client.magic_transit.sites.acls.update(acl_id, \*, account_id, site_id, \*\*params) -> ACL
- client.magic_transit.sites.acls.list(site_id, \*, account_id) -> SyncSinglePage[ACL]
- client.magic_transit.sites.acls.delete(acl_id, \*, account_id, site_id) -> ACL
- client.magic_transit.sites.acls.edit(acl_id, \*, account_id, site_id, \*\*params) -> ACL
- client.magic_transit.sites.acls.get(acl_id, \*, account_id, site_id) -> ACL
### LANs
Types:
```python
from cloudflare.types.magic_transit.sites import (
DHCPRelay,
DHCPServer,
LAN,
LANStaticAddressing,
Nat,
RoutedSubnet,
)
```
Methods:
- client.magic_transit.sites.lans.create(site_id, \*, account_id, \*\*params) -> SyncSinglePage[LAN]
- client.magic_transit.sites.lans.update(lan_id, \*, account_id, site_id, \*\*params) -> LAN
- client.magic_transit.sites.lans.list(site_id, \*, account_id) -> SyncSinglePage[LAN]
- client.magic_transit.sites.lans.delete(lan_id, \*, account_id, site_id) -> LAN
- client.magic_transit.sites.lans.edit(lan_id, \*, account_id, site_id, \*\*params) -> LAN
- client.magic_transit.sites.lans.get(lan_id, \*, account_id, site_id) -> LAN
### WANs
Types:
```python
from cloudflare.types.magic_transit.sites import WAN, WANStaticAddressing
```
Methods:
- client.magic_transit.sites.wans.create(site_id, \*, account_id, \*\*params) -> SyncSinglePage[WAN]
- client.magic_transit.sites.wans.update(wan_id, \*, account_id, site_id, \*\*params) -> WAN
- client.magic_transit.sites.wans.list(site_id, \*, account_id) -> SyncSinglePage[WAN]
- client.magic_transit.sites.wans.delete(wan_id, \*, account_id, site_id) -> WAN
- client.magic_transit.sites.wans.edit(wan_id, \*, account_id, site_id, \*\*params) -> WAN
- client.magic_transit.sites.wans.get(wan_id, \*, account_id, site_id) -> WAN
## Connectors
Types:
```python
from cloudflare.types.magic_transit import (
ConnectorUpdateResponse,
ConnectorListResponse,
ConnectorEditResponse,
ConnectorGetResponse,
)
```
Methods:
- client.magic_transit.connectors.update(connector_id, \*, account_id, \*\*params) -> ConnectorUpdateResponse
- client.magic_transit.connectors.list(\*, account_id) -> SyncSinglePage[ConnectorListResponse]
- client.magic_transit.connectors.edit(connector_id, \*, account_id, \*\*params) -> ConnectorEditResponse
- client.magic_transit.connectors.get(connector_id, \*, account_id) -> ConnectorGetResponse
### Events
Types:
```python
from cloudflare.types.magic_transit.connectors import EventListResponse, EventGetResponse
```
Methods:
- client.magic_transit.connectors.events.list(connector_id, \*, account_id, \*\*params) -> EventListResponse
- client.magic_transit.connectors.events.get(event_n, \*, account_id, connector_id, event_t) -> EventGetResponse
#### Latest
Types:
```python
from cloudflare.types.magic_transit.connectors.events import LatestListResponse
```
Methods:
- client.magic_transit.connectors.events.latest.list(connector_id, \*, account_id) -> LatestListResponse
### Snapshots
Types:
```python
from cloudflare.types.magic_transit.connectors import SnapshotListResponse, SnapshotGetResponse
```
Methods:
- client.magic_transit.connectors.snapshots.list(connector_id, \*, account_id, \*\*params) -> SnapshotListResponse
- client.magic_transit.connectors.snapshots.get(snapshot_t, \*, account_id, connector_id) -> SnapshotGetResponse
#### Latest
Types:
```python
from cloudflare.types.magic_transit.connectors.snapshots import LatestListResponse
```
Methods:
- client.magic_transit.connectors.snapshots.latest.list(connector_id, \*, account_id) -> LatestListResponse
## PCAPs
Types:
```python
from cloudflare.types.magic_transit import (
PCAP,
PCAPFilter,
PCAPCreateResponse,
PCAPListResponse,
PCAPGetResponse,
)
```
Methods:
- client.magic_transit.pcaps.create(\*, account_id, \*\*params) -> PCAPCreateResponse
- client.magic_transit.pcaps.list(\*, account_id) -> SyncSinglePage[PCAPListResponse]
- client.magic_transit.pcaps.get(pcap_id, \*, account_id) -> PCAPGetResponse
- client.magic_transit.pcaps.stop(pcap_id, \*, account_id) -> None
### Ownership
Types:
```python
from cloudflare.types.magic_transit.pcaps import Ownership
```
Methods:
- client.magic_transit.pcaps.ownership.create(\*, account_id, \*\*params) -> Ownership
- client.magic_transit.pcaps.ownership.delete(ownership_id, \*, account_id) -> None
- client.magic_transit.pcaps.ownership.get(\*, account_id) -> SyncSinglePage[Ownership]
- client.magic_transit.pcaps.ownership.validate(\*, account_id, \*\*params) -> Ownership
### Download
Methods:
- client.magic_transit.pcaps.download.get(pcap_id, \*, account_id) -> BinaryAPIResponse
# MagicNetworkMonitoring
## VPCFlows
### Tokens
Types:
```python
from cloudflare.types.magic_network_monitoring.vpc_flows import TokenCreateResponse
```
Methods:
- client.magic_network_monitoring.vpc_flows.tokens.create(\*, account_id) -> str
## Configs
Types:
```python
from cloudflare.types.magic_network_monitoring import Configuration
```
Methods:
- client.magic_network_monitoring.configs.create(\*, account_id, \*\*params) -> Configuration
- client.magic_network_monitoring.configs.update(\*, account_id, \*\*params) -> Configuration
- client.magic_network_monitoring.configs.delete(\*, account_id) -> Configuration
- client.magic_network_monitoring.configs.edit(\*, account_id, \*\*params) -> Configuration
- client.magic_network_monitoring.configs.get(\*, account_id) -> Configuration
### Full
Methods:
- client.magic_network_monitoring.configs.full.get(\*, account_id) -> Configuration
## Rules
Types:
```python
from cloudflare.types.magic_network_monitoring import MagicNetworkMonitoringRule
```
Methods:
- client.magic_network_monitoring.rules.create(\*, account_id, \*\*params) -> Optional[MagicNetworkMonitoringRule]
- client.magic_network_monitoring.rules.update(\*, account_id, \*\*params) -> Optional[MagicNetworkMonitoringRule]
- client.magic_network_monitoring.rules.list(\*, account_id) -> SyncSinglePage[Optional[MagicNetworkMonitoringRule]]
- client.magic_network_monitoring.rules.delete(rule_id, \*, account_id) -> Optional[MagicNetworkMonitoringRule]
- client.magic_network_monitoring.rules.edit(rule_id, \*, account_id, \*\*params) -> Optional[MagicNetworkMonitoringRule]
- client.magic_network_monitoring.rules.get(rule_id, \*, account_id) -> Optional[MagicNetworkMonitoringRule]
### Advertisements
Types:
```python
from cloudflare.types.magic_network_monitoring.rules import Advertisement
```
Methods:
- client.magic_network_monitoring.rules.advertisements.edit(rule_id, \*, account_id, \*\*params) -> Optional[Advertisement]
# MagicCloudNetworking
## CatalogSyncs
Types:
```python
from cloudflare.types.magic_cloud_networking import (
CatalogSyncCreateResponse,
CatalogSyncUpdateResponse,
CatalogSyncListResponse,
CatalogSyncDeleteResponse,
CatalogSyncEditResponse,
CatalogSyncGetResponse,
CatalogSyncRefreshResponse,
)
```
Methods:
- client.magic_cloud_networking.catalog_syncs.create(\*, account_id, \*\*params) -> CatalogSyncCreateResponse
- client.magic_cloud_networking.catalog_syncs.update(sync_id, \*, account_id, \*\*params) -> CatalogSyncUpdateResponse
- client.magic_cloud_networking.catalog_syncs.list(\*, account_id) -> SyncSinglePage[CatalogSyncListResponse]
- client.magic_cloud_networking.catalog_syncs.delete(sync_id, \*, account_id, \*\*params) -> CatalogSyncDeleteResponse
- client.magic_cloud_networking.catalog_syncs.edit(sync_id, \*, account_id, \*\*params) -> CatalogSyncEditResponse
- client.magic_cloud_networking.catalog_syncs.get(sync_id, \*, account_id) -> CatalogSyncGetResponse
- client.magic_cloud_networking.catalog_syncs.refresh(sync_id, \*, account_id) -> str
### PrebuiltPolicies
Types:
```python
from cloudflare.types.magic_cloud_networking.catalog_syncs import PrebuiltPolicyListResponse
```
Methods:
- client.magic_cloud_networking.catalog_syncs.prebuilt_policies.list(\*, account_id, \*\*params) -> SyncSinglePage[PrebuiltPolicyListResponse]
## OnRamps
Types:
```python
from cloudflare.types.magic_cloud_networking import (
OnRampCreateResponse,
OnRampUpdateResponse,
OnRampListResponse,
OnRampDeleteResponse,
OnRampApplyResponse,
OnRampEditResponse,
OnRampGetResponse,
OnRampPlanResponse,
)
```
Methods:
- client.magic_cloud_networking.on_ramps.create(\*, account_id, \*\*params) -> OnRampCreateResponse
- client.magic_cloud_networking.on_ramps.update(onramp_id, \*, account_id, \*\*params) -> OnRampUpdateResponse
- client.magic_cloud_networking.on_ramps.list(\*, account_id, \*\*params) -> SyncSinglePage[OnRampListResponse]
- client.magic_cloud_networking.on_ramps.delete(onramp_id, \*, account_id, \*\*params) -> OnRampDeleteResponse
- client.magic_cloud_networking.on_ramps.apply(onramp_id, \*, account_id) -> OnRampApplyResponse
- client.magic_cloud_networking.on_ramps.edit(onramp_id, \*, account_id, \*\*params) -> OnRampEditResponse
- client.magic_cloud_networking.on_ramps.export(onramp_id, \*, account_id) -> BinaryAPIResponse
- client.magic_cloud_networking.on_ramps.get(onramp_id, \*, account_id, \*\*params) -> OnRampGetResponse
- client.magic_cloud_networking.on_ramps.plan(onramp_id, \*, account_id) -> OnRampPlanResponse
### AddressSpaces
Types:
```python
from cloudflare.types.magic_cloud_networking.on_ramps import (
AddressSpaceUpdateResponse,
AddressSpaceListResponse,
AddressSpaceEditResponse,
)
```
Methods:
- client.magic_cloud_networking.on_ramps.address_spaces.update(\*, account_id, \*\*params) -> AddressSpaceUpdateResponse
- client.magic_cloud_networking.on_ramps.address_spaces.list(\*, account_id) -> AddressSpaceListResponse
- client.magic_cloud_networking.on_ramps.address_spaces.edit(\*, account_id, \*\*params) -> AddressSpaceEditResponse
## CloudIntegrations
Types:
```python
from cloudflare.types.magic_cloud_networking import (
CloudIntegrationCreateResponse,
CloudIntegrationUpdateResponse,
CloudIntegrationListResponse,
CloudIntegrationDeleteResponse,
CloudIntegrationDiscoverResponse,
CloudIntegrationDiscoverAllResponse,
CloudIntegrationEditResponse,
CloudIntegrationGetResponse,
CloudIntegrationInitialSetupResponse,
)
```
Methods:
- client.magic_cloud_networking.cloud_integrations.create(\*, account_id, \*\*params) -> CloudIntegrationCreateResponse
- client.magic_cloud_networking.cloud_integrations.update(provider_id, \*, account_id, \*\*params) -> CloudIntegrationUpdateResponse
- client.magic_cloud_networking.cloud_integrations.list(\*, account_id, \*\*params) -> SyncSinglePage[CloudIntegrationListResponse]
- client.magic_cloud_networking.cloud_integrations.delete(provider_id, \*, account_id) -> CloudIntegrationDeleteResponse
- client.magic_cloud_networking.cloud_integrations.discover(provider_id, \*, account_id, \*\*params) -> CloudIntegrationDiscoverResponse
- client.magic_cloud_networking.cloud_integrations.discover_all(\*, account_id) -> CloudIntegrationDiscoverAllResponse
- client.magic_cloud_networking.cloud_integrations.edit(provider_id, \*, account_id, \*\*params) -> CloudIntegrationEditResponse
- client.magic_cloud_networking.cloud_integrations.get(provider_id, \*, account_id, \*\*params) -> CloudIntegrationGetResponse
- client.magic_cloud_networking.cloud_integrations.initial_setup(provider_id, \*, account_id) -> CloudIntegrationInitialSetupResponse
## Resources
Types:
```python
from cloudflare.types.magic_cloud_networking import (
ResourceListResponse,
ResourceGetResponse,
ResourcePolicyPreviewResponse,
)
```
Methods:
- client.magic_cloud_networking.resources.list(\*, account_id, \*\*params) -> SyncV4PagePaginationArray[ResourceListResponse]
- client.magic_cloud_networking.resources.export(\*, account_id, \*\*params) -> BinaryAPIResponse
- client.magic_cloud_networking.resources.get(resource_id, \*, account_id, \*\*params) -> ResourceGetResponse
- client.magic_cloud_networking.resources.policy_preview(\*, account_id, \*\*params) -> str
# NetworkInterconnects
## CNIs
Types:
```python
from cloudflare.types.network_interconnects import (
CNICreateResponse,
CNIUpdateResponse,
CNIListResponse,
CNIGetResponse,
)
```
Methods:
- client.network_interconnects.cnis.create(\*, account_id, \*\*params) -> CNICreateResponse
- client.network_interconnects.cnis.update(cni, \*, account_id, \*\*params) -> CNIUpdateResponse
- client.network_interconnects.cnis.list(\*, account_id, \*\*params) -> CNIListResponse
- client.network_interconnects.cnis.delete(cni, \*, account_id) -> None
- client.network_interconnects.cnis.get(cni, \*, account_id) -> CNIGetResponse
## Interconnects
Types:
```python
from cloudflare.types.network_interconnects import (
InterconnectCreateResponse,
InterconnectListResponse,
InterconnectGetResponse,
InterconnectStatusResponse,
)
```
Methods:
- client.network_interconnects.interconnects.create(\*, account_id, \*\*params) -> InterconnectCreateResponse
- client.network_interconnects.interconnects.list(\*, account_id, \*\*params) -> InterconnectListResponse
- client.network_interconnects.interconnects.delete(icon, \*, account_id) -> None
- client.network_interconnects.interconnects.get(icon, \*, account_id) -> InterconnectGetResponse
- client.network_interconnects.interconnects.loa(icon, \*, account_id) -> None
- client.network_interconnects.interconnects.status(icon, \*, account_id) -> InterconnectStatusResponse
## Settings
Types:
```python
from cloudflare.types.network_interconnects import SettingUpdateResponse, SettingGetResponse
```
Methods:
- client.network_interconnects.settings.update(\*, account_id, \*\*params) -> SettingUpdateResponse
- client.network_interconnects.settings.get(\*, account_id) -> SettingGetResponse
## Slots
Types:
```python
from cloudflare.types.network_interconnects import SlotListResponse, SlotGetResponse
```
Methods:
- client.network_interconnects.slots.list(\*, account_id, \*\*params) -> SlotListResponse
- client.network_interconnects.slots.get(slot, \*, account_id) -> SlotGetResponse
# MTLSCertificates
Types:
```python
from cloudflare.types.mtls_certificates import MTLSCertificate, MTLSCertificateCreateResponse
```
Methods:
- client.mtls_certificates.create(\*, account_id, \*\*params) -> Optional[MTLSCertificateCreateResponse]
- client.mtls_certificates.list(\*, account_id) -> SyncSinglePage[MTLSCertificate]
- client.mtls_certificates.delete(mtls_certificate_id, \*, account_id) -> Optional[MTLSCertificate]
- client.mtls_certificates.get(mtls_certificate_id, \*, account_id) -> Optional[MTLSCertificate]
## Associations
Types:
```python
from cloudflare.types.mtls_certificates import CertificateAsssociation
```
Methods:
- client.mtls_certificates.associations.get(mtls_certificate_id, \*, account_id) -> SyncSinglePage[CertificateAsssociation]
# Pages
## Projects
Types:
```python
from cloudflare.types.pages import Deployment, Project, Stage
```
Methods:
- client.pages.projects.create(\*, account_id, \*\*params) -> Project
- client.pages.projects.list(\*, account_id) -> SyncSinglePage[Deployment]
- client.pages.projects.delete(project_name, \*, account_id) -> object
- client.pages.projects.edit(project_name, \*, account_id, \*\*params) -> Project
- client.pages.projects.get(project_name, \*, account_id) -> Project
- client.pages.projects.purge_build_cache(project_name, \*, account_id) -> object
### Deployments
Methods:
- client.pages.projects.deployments.create(project_name, \*, account_id, \*\*params) -> Deployment
- client.pages.projects.deployments.list(project_name, \*, account_id, \*\*params) -> SyncSinglePage[Deployment]
- client.pages.projects.deployments.delete(deployment_id, \*, account_id, project_name) -> object
- client.pages.projects.deployments.get(deployment_id, \*, account_id, project_name) -> Deployment
- client.pages.projects.deployments.retry(deployment_id, \*, account_id, project_name, \*\*params) -> Deployment
- client.pages.projects.deployments.rollback(deployment_id, \*, account_id, project_name, \*\*params) -> Deployment
#### History
##### Logs
Types:
```python
from cloudflare.types.pages.projects.deployments.history import LogGetResponse
```
Methods:
- client.pages.projects.deployments.history.logs.get(deployment_id, \*, account_id, project_name) -> LogGetResponse
### Domains
Types:
```python
from cloudflare.types.pages.projects import (
DomainCreateResponse,
DomainListResponse,
DomainEditResponse,
DomainGetResponse,
)
```
Methods:
- client.pages.projects.domains.create(project_name, \*, account_id, \*\*params) -> Optional[DomainCreateResponse]
- client.pages.projects.domains.list(project_name, \*, account_id) -> SyncSinglePage[DomainListResponse]
- client.pages.projects.domains.delete(domain_name, \*, account_id, project_name) -> object
- client.pages.projects.domains.edit(domain_name, \*, account_id, project_name, \*\*params) -> Optional[DomainEditResponse]
- client.pages.projects.domains.get(domain_name, \*, account_id, project_name) -> Optional[DomainGetResponse]
# Registrar
## Domains
Types:
```python
from cloudflare.types.registrar import Domain
```
Methods:
- client.registrar.domains.update(domain_name, \*, account_id, \*\*params) -> object
- client.registrar.domains.list(\*, account_id) -> SyncSinglePage[Domain]
- client.registrar.domains.get(domain_name, \*, account_id) -> object
# RequestTracers
## Traces
Types:
```python
from cloudflare.types.request_tracers import Trace, TraceItem, TraceCreateResponse
```
Methods:
- client.request_tracers.traces.create(\*, account_id, \*\*params) -> Optional[TraceCreateResponse]
# Rules
## Lists
Types:
```python
from cloudflare.types.rules import (
Hostname,
ListsList,
Redirect,
ListCreateResponse,
ListUpdateResponse,
ListListResponse,
ListDeleteResponse,
ListGetResponse,
)
```
Methods:
- client.rules.lists.create(\*, account_id, \*\*params) -> ListCreateResponse
- client.rules.lists.update(list_id, \*, account_id, \*\*params) -> ListUpdateResponse
- client.rules.lists.list(\*, account_id) -> ListListResponse
- client.rules.lists.delete(list_id, \*, account_id) -> ListDeleteResponse
- client.rules.lists.get(list_id, \*, account_id) -> ListGetResponse
### BulkOperations
Types:
```python
from cloudflare.types.rules.lists import BulkOperationGetResponse
```
Methods:
- client.rules.lists.bulk_operations.get(operation_id, \*, account_id) -> BulkOperationGetResponse
### Items
Types:
```python
from cloudflare.types.rules.lists import (
ListCursor,
ListItem,
ItemCreateResponse,
ItemUpdateResponse,
ItemListResponse,
ItemDeleteResponse,
ItemGetResponse,
)
```
Methods:
- client.rules.lists.items.create(list_id, \*, account_id, \*\*params) -> ItemCreateResponse
- client.rules.lists.items.update(list_id, \*, account_id, \*\*params) -> ItemUpdateResponse
- client.rules.lists.items.list(list_id, \*, account_id, \*\*params) -> ItemListResponse
- client.rules.lists.items.delete(list_id, \*, account_id) -> ItemDeleteResponse
- client.rules.lists.items.get(item_id, \*, account_id, list_id) -> ItemGetResponse
# Stream
Types:
```python
from cloudflare.types.stream import AllowedOrigins, Video
```
Methods:
- client.stream.create(\*, account_id, \*\*params) -> None
- client.stream.list(\*, account_id, \*\*params) -> SyncSinglePage[Video]
- client.stream.delete(identifier, \*, account_id) -> None
- client.stream.edit(identifier, \*, account_id, \*\*params) -> Optional[Video]
- client.stream.get(identifier, \*, account_id) -> Optional[Video]
## AudioTracks
Types:
```python
from cloudflare.types.stream import Audio, AudioTrackDeleteResponse
```
Methods:
- client.stream.audio_tracks.delete(audio_identifier, \*, account_id, identifier) -> str
- client.stream.audio_tracks.copy(identifier, \*, account_id, \*\*params) -> Optional[Audio]
- client.stream.audio_tracks.edit(audio_identifier, \*, account_id, identifier, \*\*params) -> Optional[Audio]
- client.stream.audio_tracks.get(identifier, \*, account_id) -> SyncSinglePage[Audio]
## Videos
Types:
```python
from cloudflare.types.stream import VideoStorageUsageResponse
```
Methods:
- client.stream.videos.storage_usage(\*, account_id, \*\*params) -> Optional[VideoStorageUsageResponse]
## Clip
Types:
```python
from cloudflare.types.stream import Clip
```
Methods:
- client.stream.clip.create(\*, account_id, \*\*params) -> Optional[Clip]
## Copy
Methods:
- client.stream.copy.create(\*, account_id, \*\*params) -> Optional[Video]
## DirectUpload
Types:
```python
from cloudflare.types.stream import DirectUploadCreateResponse
```
Methods:
- client.stream.direct_upload.create(\*, account_id, \*\*params) -> Optional[DirectUploadCreateResponse]
## Keys
Types:
```python
from cloudflare.types.stream import Keys, KeyDeleteResponse, KeyGetResponse
```
Methods:
- client.stream.keys.create(\*, account_id, \*\*params) -> Optional[Keys]
- client.stream.keys.delete(identifier, \*, account_id) -> str
- client.stream.keys.get(\*, account_id) -> SyncSinglePage[KeyGetResponse]
## LiveInputs
Types:
```python
from cloudflare.types.stream import LiveInput, LiveInputListResponse
```
Methods:
- client.stream.live_inputs.create(\*, account_id, \*\*params) -> Optional[LiveInput]
- client.stream.live_inputs.update(live_input_identifier, \*, account_id, \*\*params) -> Optional[LiveInput]
- client.stream.live_inputs.list(\*, account_id, \*\*params) -> Optional[LiveInputListResponse]
- client.stream.live_inputs.delete(live_input_identifier, \*, account_id) -> None
- client.stream.live_inputs.get(live_input_identifier, \*, account_id) -> Optional[LiveInput]
### Outputs
Types:
```python
from cloudflare.types.stream.live_inputs import Output
```
Methods:
- client.stream.live_inputs.outputs.create(live_input_identifier, \*, account_id, \*\*params) -> Optional[Output]
- client.stream.live_inputs.outputs.update(output_identifier, \*, account_id, live_input_identifier, \*\*params) -> Optional[Output]
- client.stream.live_inputs.outputs.list(live_input_identifier, \*, account_id) -> SyncSinglePage[Output]
- client.stream.live_inputs.outputs.delete(output_identifier, \*, account_id, live_input_identifier) -> None
## Watermarks
Types:
```python
from cloudflare.types.stream import Watermark, WatermarkDeleteResponse
```
Methods:
- client.stream.watermarks.create(\*, account_id, \*\*params) -> Optional[Watermark]
- client.stream.watermarks.list(\*, account_id) -> SyncSinglePage[Watermark]
- client.stream.watermarks.delete(identifier, \*, account_id) -> str
- client.stream.watermarks.get(identifier, \*, account_id) -> Optional[Watermark]
## Webhooks
Types:
```python
from cloudflare.types.stream import WebhookDeleteResponse
```
Methods:
- client.stream.webhooks.update(\*, account_id, \*\*params) -> object
- client.stream.webhooks.delete(\*, account_id) -> str
- client.stream.webhooks.get(\*, account_id) -> object
## Captions
Types:
```python
from cloudflare.types.stream import Caption
```
Methods:
- client.stream.captions.get(identifier, \*, account_id) -> SyncSinglePage[Caption]
### Language
Types:
```python
from cloudflare.types.stream.captions import LanguageDeleteResponse
```
Methods:
- client.stream.captions.language.create(language, \*, account_id, identifier) -> Optional[Caption]
- client.stream.captions.language.update(language, \*, account_id, identifier, \*\*params) -> Optional[Caption]
- client.stream.captions.language.delete(language, \*, account_id, identifier) -> str
- client.stream.captions.language.get(language, \*, account_id, identifier) -> Optional[Caption]
#### Vtt
Types:
```python
from cloudflare.types.stream.captions.language import VttGetResponse
```
Methods:
- client.stream.captions.language.vtt.get(language, \*, account_id, identifier) -> str
## Downloads
Types:
```python
from cloudflare.types.stream import DownloadDeleteResponse
```
Methods:
- client.stream.downloads.create(identifier, \*, account_id, \*\*params) -> object
- client.stream.downloads.delete(identifier, \*, account_id) -> str
- client.stream.downloads.get(identifier, \*, account_id) -> object
## Embed
Types:
```python
from cloudflare.types.stream import EmbedGetResponse
```
Methods:
- client.stream.embed.get(identifier, \*, account_id) -> str
## Token
Types:
```python
from cloudflare.types.stream import TokenCreateResponse
```
Methods:
- client.stream.token.create(identifier, \*, account_id, \*\*params) -> Optional[TokenCreateResponse]
# Alerting
## AvailableAlerts
Types:
```python
from cloudflare.types.alerting import AvailableAlertListResponse
```
Methods:
- client.alerting.available_alerts.list(\*, account_id) -> Optional[AvailableAlertListResponse]
## Destinations
### Eligible
Types:
```python
from cloudflare.types.alerting.destinations import EligibleGetResponse
```
Methods:
- client.alerting.destinations.eligible.get(\*, account_id) -> Optional[EligibleGetResponse]
### Pagerduty
Types:
```python
from cloudflare.types.alerting.destinations import (
Pagerduty,
PagerdutyCreateResponse,
PagerdutyDeleteResponse,
PagerdutyLinkResponse,
)
```
Methods:
- client.alerting.destinations.pagerduty.create(\*, account_id) -> Optional[PagerdutyCreateResponse]
- client.alerting.destinations.pagerduty.delete(\*, account_id) -> PagerdutyDeleteResponse
- client.alerting.destinations.pagerduty.get(\*, account_id) -> SyncSinglePage[Pagerduty]
- client.alerting.destinations.pagerduty.link(token_id, \*, account_id) -> Optional[PagerdutyLinkResponse]
### Webhooks
Types:
```python
from cloudflare.types.alerting.destinations import (
Webhooks,
WebhookCreateResponse,
WebhookUpdateResponse,
WebhookDeleteResponse,
)
```
Methods:
- client.alerting.destinations.webhooks.create(\*, account_id, \*\*params) -> Optional[WebhookCreateResponse]
- client.alerting.destinations.webhooks.update(webhook_id, \*, account_id, \*\*params) -> Optional[WebhookUpdateResponse]
- client.alerting.destinations.webhooks.list(\*, account_id) -> SyncSinglePage[Webhooks]
- client.alerting.destinations.webhooks.delete(webhook_id, \*, account_id) -> WebhookDeleteResponse
- client.alerting.destinations.webhooks.get(webhook_id, \*, account_id) -> Optional[Webhooks]
## History
Types:
```python
from cloudflare.types.alerting import History
```
Methods:
- client.alerting.history.list(\*, account_id, \*\*params) -> SyncV4PagePaginationArray[History]
## Policies
Types:
```python
from cloudflare.types.alerting import (
Mechanism,
Policy,
PolicyFilter,
PolicyCreateResponse,
PolicyUpdateResponse,
PolicyDeleteResponse,
)
```
Methods:
- client.alerting.policies.create(\*, account_id, \*\*params) -> Optional[PolicyCreateResponse]
- client.alerting.policies.update(policy_id, \*, account_id, \*\*params) -> Optional[PolicyUpdateResponse]
- client.alerting.policies.list(\*, account_id) -> SyncSinglePage[Policy]
- client.alerting.policies.delete(policy_id, \*, account_id) -> PolicyDeleteResponse
- client.alerting.policies.get(policy_id, \*, account_id) -> Optional[Policy]
# D1
Types:
```python
from cloudflare.types.d1 import D1
```
## Database
Types:
```python
from cloudflare.types.d1 import (
QueryResult,
DatabaseListResponse,
DatabaseExportResponse,
DatabaseImportResponse,
DatabaseRawResponse,
)
```
Methods:
- client.d1.database.create(\*, account_id, \*\*params) -> D1
- client.d1.database.update(database_id, \*, account_id, \*\*params) -> D1
- client.d1.database.list(\*, account_id, \*\*params) -> SyncV4PagePaginationArray[DatabaseListResponse]
- client.d1.database.delete(database_id, \*, account_id) -> object
- client.d1.database.edit(database_id, \*, account_id, \*\*params) -> D1
- client.d1.database.export(database_id, \*, account_id, \*\*params) -> DatabaseExportResponse
- client.d1.database.get(database_id, \*, account_id) -> D1
- client.d1.database.import\_(database_id, \*, account_id, \*\*params) -> DatabaseImportResponse
- client.d1.database.query(database_id, \*, account_id, \*\*params) -> SyncSinglePage[QueryResult]
- client.d1.database.raw(database_id, \*, account_id, \*\*params) -> SyncSinglePage[DatabaseRawResponse]
# R2
## Buckets
Types:
```python
from cloudflare.types.r2 import Bucket, BucketListResponse
```
Methods:
- client.r2.buckets.create(\*, account_id, \*\*params) -> Bucket
- client.r2.buckets.list(\*, account_id, \*\*params) -> BucketListResponse
- client.r2.buckets.delete(bucket_name, \*, account_id) -> object
- client.r2.buckets.edit(bucket_name, \*, account_id) -> Bucket
- client.r2.buckets.get(bucket_name, \*, account_id) -> Bucket
### Lifecycle
Types:
```python
from cloudflare.types.r2.buckets import LifecycleGetResponse
```
Methods:
- client.r2.buckets.lifecycle.update(bucket_name, \*, account_id, \*\*params) -> object
- client.r2.buckets.lifecycle.get(bucket_name, \*, account_id) -> LifecycleGetResponse
### CORS
Types:
```python
from cloudflare.types.r2.buckets import CORSGetResponse
```
Methods:
- client.r2.buckets.cors.update(bucket_name, \*, account_id, \*\*params) -> object
- client.r2.buckets.cors.delete(bucket_name, \*, account_id) -> object
- client.r2.buckets.cors.get(bucket_name, \*, account_id) -> CORSGetResponse
### Domains
#### Custom
Types:
```python
from cloudflare.types.r2.buckets.domains import (
CustomCreateResponse,
CustomUpdateResponse,
CustomListResponse,
CustomDeleteResponse,
CustomGetResponse,
)
```
Methods:
- client.r2.buckets.domains.custom.create(bucket_name, \*, account_id, \*\*params) -> CustomCreateResponse
- client.r2.buckets.domains.custom.update(domain, \*, account_id, bucket_name, \*\*params) -> CustomUpdateResponse
- client.r2.buckets.domains.custom.list(bucket_name, \*, account_id) -> CustomListResponse
- client.r2.buckets.domains.custom.delete(domain, \*, account_id, bucket_name) -> CustomDeleteResponse
- client.r2.buckets.domains.custom.get(domain, \*, account_id, bucket_name) -> CustomGetResponse
#### Managed
Types:
```python
from cloudflare.types.r2.buckets.domains import ManagedUpdateResponse, ManagedListResponse
```
Methods:
- client.r2.buckets.domains.managed.update(bucket_name, \*, account_id, \*\*params) -> ManagedUpdateResponse
- client.r2.buckets.domains.managed.list(bucket_name, \*, account_id) -> ManagedListResponse
### EventNotifications
Types:
```python
from cloudflare.types.r2.buckets import EventNotificationListResponse, EventNotificationGetResponse
```
Methods:
- client.r2.buckets.event_notifications.update(queue_id, \*, account_id, bucket_name, \*\*params) -> object
- client.r2.buckets.event_notifications.list(bucket_name, \*, account_id) -> EventNotificationListResponse
- client.r2.buckets.event_notifications.delete(queue_id, \*, account_id, bucket_name) -> object
- client.r2.buckets.event_notifications.get(queue_id, \*, account_id, bucket_name) -> EventNotificationGetResponse
### Locks
Types:
```python
from cloudflare.types.r2.buckets import LockGetResponse
```
Methods:
- client.r2.buckets.locks.update(bucket_name, \*, account_id, \*\*params) -> object
- client.r2.buckets.locks.get(bucket_name, \*, account_id) -> LockGetResponse
### Metrics
Types:
```python
from cloudflare.types.r2.buckets import MetricListResponse
```
Methods:
- client.r2.buckets.metrics.list(\*, account_id) -> MetricListResponse
### Sippy
Types:
```python
from cloudflare.types.r2.buckets import Provider, Sippy, SippyDeleteResponse
```
Methods:
- client.r2.buckets.sippy.update(bucket_name, \*, account_id, \*\*params) -> Sippy
- client.r2.buckets.sippy.delete(bucket_name, \*, account_id) -> SippyDeleteResponse
- client.r2.buckets.sippy.get(bucket_name, \*, account_id) -> Sippy
## TemporaryCredentials
Types:
```python
from cloudflare.types.r2 import TemporaryCredential, TemporaryCredentialCreateResponse
```
Methods:
- client.r2.temporary_credentials.create(\*, account_id, \*\*params) -> TemporaryCredentialCreateResponse
## SuperSlurper
### Jobs
Types:
```python
from cloudflare.types.r2.super_slurper import (
JobCreateResponse,
JobListResponse,
JobAbortResponse,
JobAbortAllResponse,
JobGetResponse,
JobPauseResponse,
JobProgressResponse,
JobResumeResponse,
)
```
Methods:
- client.r2.super_slurper.jobs.create(\*, account_id, \*\*params) -> Optional[JobCreateResponse]
- client.r2.super_slurper.jobs.list(\*, account_id, \*\*params) -> SyncSinglePage[JobListResponse]
- client.r2.super_slurper.jobs.abort(job_id, \*, account_id) -> str
- client.r2.super_slurper.jobs.abort_all(\*, account_id) -> str
- client.r2.super_slurper.jobs.get(job_id, \*, account_id) -> Optional[JobGetResponse]
- client.r2.super_slurper.jobs.pause(job_id, \*, account_id) -> str
- client.r2.super_slurper.jobs.progress(job_id, \*, account_id) -> Optional[JobProgressResponse]
- client.r2.super_slurper.jobs.resume(job_id, \*, account_id) -> str
#### Logs
Types:
```python
from cloudflare.types.r2.super_slurper.jobs import LogListResponse
```
Methods:
- client.r2.super_slurper.jobs.logs.list(job_id, \*, account_id, \*\*params) -> SyncSinglePage[LogListResponse]
### ConnectivityPrecheck
Types:
```python
from cloudflare.types.r2.super_slurper import (
ConnectivityPrecheckSourceResponse,
ConnectivityPrecheckTargetResponse,
)
```
Methods:
- client.r2.super_slurper.connectivity_precheck.source(\*, account_id, \*\*params) -> Optional[ConnectivityPrecheckSourceResponse]
- client.r2.super_slurper.connectivity_precheck.target(\*, account_id, \*\*params) -> Optional[ConnectivityPrecheckTargetResponse]
# WorkersForPlatforms
## Dispatch
### Namespaces
Types:
```python
from cloudflare.types.workers_for_platforms.dispatch import (
NamespaceCreateResponse,
NamespaceListResponse,
NamespaceGetResponse,
)
```
Methods:
- client.workers_for_platforms.dispatch.namespaces.create(\*, account_id, \*\*params) -> Optional[NamespaceCreateResponse]
- client.workers_for_platforms.dispatch.namespaces.list(\*, account_id) -> SyncSinglePage[NamespaceListResponse]
- client.workers_for_platforms.dispatch.namespaces.delete(dispatch_namespace, \*, account_id) -> object
- client.workers_for_platforms.dispatch.namespaces.get(dispatch_namespace, \*, account_id) -> Optional[NamespaceGetResponse]
#### Scripts
Types:
```python
from cloudflare.types.workers_for_platforms.dispatch.namespaces import Script, ScriptUpdateResponse
```
Methods:
- client.workers_for_platforms.dispatch.namespaces.scripts.update(script_name, \*, account_id, dispatch_namespace, \*\*params) -> ScriptUpdateResponse
- client.workers_for_platforms.dispatch.namespaces.scripts.delete(script_name, \*, account_id, dispatch_namespace, \*\*params) -> object
- client.workers_for_platforms.dispatch.namespaces.scripts.get(script_name, \*, account_id, dispatch_namespace) -> Script
##### AssetUpload
Types:
```python
from cloudflare.types.workers_for_platforms.dispatch.namespaces.scripts import (
AssetUploadCreateResponse,
)
```
Methods:
- client.workers_for_platforms.dispatch.namespaces.scripts.asset_upload.create(script_name, \*, account_id, dispatch_namespace, \*\*params) -> Optional[AssetUploadCreateResponse]
##### Content
Methods:
- client.workers_for_platforms.dispatch.namespaces.scripts.content.update(script_name, \*, account_id, dispatch_namespace, \*\*params) -> Script
- client.workers_for_platforms.dispatch.namespaces.scripts.content.get(script_name, \*, account_id, dispatch_namespace) -> BinaryAPIResponse
##### Settings
Types:
```python
from cloudflare.types.workers_for_platforms.dispatch.namespaces.scripts import (
SettingEditResponse,
SettingGetResponse,
)
```
Methods:
- client.workers_for_platforms.dispatch.namespaces.scripts.settings.edit(script_name, \*, account_id, dispatch_namespace, \*\*params) -> Optional[SettingEditResponse]
- client.workers_for_platforms.dispatch.namespaces.scripts.settings.get(script_name, \*, account_id, dispatch_namespace) -> Optional[SettingGetResponse]
##### Bindings
Types:
```python
from cloudflare.types.workers_for_platforms.dispatch.namespaces.scripts import BindingGetResponse
```
Methods:
- client.workers_for_platforms.dispatch.namespaces.scripts.bindings.get(script_name, \*, account_id, dispatch_namespace) -> SyncSinglePage[BindingGetResponse]
##### Secrets
Types:
```python
from cloudflare.types.workers_for_platforms.dispatch.namespaces.scripts import (
SecretUpdateResponse,
SecretListResponse,
SecretGetResponse,
)
```
Methods:
- client.workers_for_platforms.dispatch.namespaces.scripts.secrets.update(script_name, \*, account_id, dispatch_namespace, \*\*params) -> SecretUpdateResponse
- client.workers_for_platforms.dispatch.namespaces.scripts.secrets.list(script_name, \*, account_id, dispatch_namespace) -> SyncSinglePage[SecretListResponse]
- client.workers_for_platforms.dispatch.namespaces.scripts.secrets.delete(secret_name, \*, account_id, dispatch_namespace, script_name) -> object
- client.workers_for_platforms.dispatch.namespaces.scripts.secrets.get(secret_name, \*, account_id, dispatch_namespace, script_name) -> SecretGetResponse
##### Tags
Types:
```python
from cloudflare.types.workers_for_platforms.dispatch.namespaces.scripts import (
TagUpdateResponse,
TagListResponse,
)
```
Methods:
- client.workers_for_platforms.dispatch.namespaces.scripts.tags.update(script_name, \*, account_id, dispatch_namespace, \*\*params) -> SyncSinglePage[TagUpdateResponse]
- client.workers_for_platforms.dispatch.namespaces.scripts.tags.list(script_name, \*, account_id, dispatch_namespace) -> SyncSinglePage[TagListResponse]
- client.workers_for_platforms.dispatch.namespaces.scripts.tags.delete(tag, \*, account_id, dispatch_namespace, script_name) -> object
# ZeroTrust
## Devices
Types:
```python
from cloudflare.types.zero_trust import Device, DeviceGetResponse
```
Methods:
- client.zero_trust.devices.list(\*, account_id) -> SyncSinglePage[Device]
- client.zero_trust.devices.get(device_id, \*, account_id) -> Optional[DeviceGetResponse]
### Devices
Types:
```python
from cloudflare.types.zero_trust.devices import DeviceListResponse, DeviceGetResponse
```
Methods:
- client.zero*trust.devices.devices.list(\*, account_id, \*\*params) -> SyncCursorPagination[DeviceListResponse]
- client.zero*trust.devices.devices.delete(device_id, \*, account_id) -> object
- client.zero*trust.devices.devices.get(device_id, \*, account_id) -> DeviceGetResponse
- client.zero*trust.devices.devices.revoke(device_id, \*, account_id) -> object
### Resilience
#### GlobalWARPOverride
Types:
```python
from cloudflare.types.zero_trust.devices.resilience import (
GlobalWARPOverrideCreateResponse,
GlobalWARPOverrideGetResponse,
)
```
Methods:
- client.zero_trust.devices.resilience.global_warp_override.create(\*, account_id, \*\*params) -> Optional[GlobalWARPOverrideCreateResponse]
- client.zero_trust.devices.resilience.global_warp_override.get(\*, account_id) -> Optional[GlobalWARPOverrideGetResponse]
### Registrations
Types:
```python
from cloudflare.types.zero_trust.devices import RegistrationListResponse, RegistrationGetResponse
```
Methods:
- client.zero_trust.devices.registrations.list(\*, account_id, \*\*params) -> SyncCursorPagination[RegistrationListResponse]
- client.zero_trust.devices.registrations.delete(registration_id, \*, account_id) -> object
- client.zero_trust.devices.registrations.bulk_delete(\*, account_id, \*\*params) -> object
- client.zero_trust.devices.registrations.get(registration_id, \*, account_id) -> RegistrationGetResponse
- client.zero_trust.devices.registrations.revoke(\*, account_id, \*\*params) -> object
- client.zero_trust.devices.registrations.unrevoke(\*, account_id, \*\*params) -> object
### DEXTests
Types:
```python
from cloudflare.types.zero_trust.devices import (
SchemaData,
SchemaHTTP,
DEXTestCreateResponse,
DEXTestUpdateResponse,
DEXTestListResponse,
DEXTestDeleteResponse,
DEXTestGetResponse,
)
```
Methods:
- client.zero_trust.devices.dex_tests.create(\*, account_id, \*\*params) -> Optional[DEXTestCreateResponse]
- client.zero_trust.devices.dex_tests.update(dex_test_id, \*, account_id, \*\*params) -> Optional[DEXTestUpdateResponse]
- client.zero_trust.devices.dex_tests.list(\*, account_id) -> SyncSinglePage[DEXTestListResponse]
- client.zero_trust.devices.dex_tests.delete(dex_test_id, \*, account_id) -> Optional[DEXTestDeleteResponse]
- client.zero_trust.devices.dex_tests.get(dex_test_id, \*, account_id) -> Optional[DEXTestGetResponse]
### Networks
Types:
```python
from cloudflare.types.zero_trust.devices import DeviceNetwork
```
Methods:
- client.zero_trust.devices.networks.create(\*, account_id, \*\*params) -> Optional[DeviceNetwork]
- client.zero_trust.devices.networks.update(network_id, \*, account_id, \*\*params) -> Optional[DeviceNetwork]
- client.zero_trust.devices.networks.list(\*, account_id) -> SyncSinglePage[DeviceNetwork]
- client.zero_trust.devices.networks.delete(network_id, \*, account_id) -> SyncSinglePage[DeviceNetwork]
- client.zero_trust.devices.networks.get(network_id, \*, account_id) -> Optional[DeviceNetwork]
### FleetStatus
Types:
```python
from cloudflare.types.zero_trust.devices import FleetStatusGetResponse
```
Methods:
- client.zero_trust.devices.fleet_status.get(device_id, \*, account_id, \*\*params) -> FleetStatusGetResponse
### Policies
Types:
```python
from cloudflare.types.zero_trust.devices import (
DevicePolicyCertificates,
FallbackDomain,
FallbackDomainPolicy,
SettingsPolicy,
SplitTunnelExclude,
SplitTunnelInclude,
)
```
#### Default
Types:
```python
from cloudflare.types.zero_trust.devices.policies import DefaultEditResponse, DefaultGetResponse
```
Methods:
- client.zero_trust.devices.policies.default.edit(\*, account_id, \*\*params) -> Optional[DefaultEditResponse]
- client.zero_trust.devices.policies.default.get(\*, account_id) -> Optional[DefaultGetResponse]
##### Excludes
Methods:
- client.zero_trust.devices.policies.default.excludes.update(\*, account_id, \*\*params) -> SyncSinglePage[SplitTunnelExclude]
- client.zero_trust.devices.policies.default.excludes.get(\*, account_id) -> SyncSinglePage[SplitTunnelExclude]
##### Includes
Methods:
- client.zero_trust.devices.policies.default.includes.update(\*, account_id, \*\*params) -> SyncSinglePage[SplitTunnelInclude]
- client.zero_trust.devices.policies.default.includes.get(\*, account_id) -> SyncSinglePage[SplitTunnelInclude]
##### FallbackDomains
Methods:
- client.zero_trust.devices.policies.default.fallback_domains.update(\*, account_id, \*\*params) -> SyncSinglePage[FallbackDomain]
- client.zero_trust.devices.policies.default.fallback_domains.get(\*, account_id) -> SyncSinglePage[FallbackDomain]
##### Certificates
Methods:
- client.zero_trust.devices.policies.default.certificates.edit(\*, zone_id, \*\*params) -> Optional[DevicePolicyCertificates]
- client.zero_trust.devices.policies.default.certificates.get(\*, zone_id) -> Optional[DevicePolicyCertificates]
#### Custom
Methods:
- client.zero_trust.devices.policies.custom.create(\*, account_id, \*\*params) -> Optional[SettingsPolicy]
- client.zero_trust.devices.policies.custom.list(\*, account_id) -> SyncSinglePage[SettingsPolicy]
- client.zero_trust.devices.policies.custom.delete(policy_id, \*, account_id) -> SyncSinglePage[SettingsPolicy]
- client.zero_trust.devices.policies.custom.edit(policy_id, \*, account_id, \*\*params) -> Optional[SettingsPolicy]
- client.zero_trust.devices.policies.custom.get(policy_id, \*, account_id) -> Optional[SettingsPolicy]
##### Excludes
Methods:
- client.zero_trust.devices.policies.custom.excludes.update(policy_id, \*, account_id, \*\*params) -> SyncSinglePage[SplitTunnelExclude]
- client.zero_trust.devices.policies.custom.excludes.get(policy_id, \*, account_id) -> SyncSinglePage[SplitTunnelExclude]
##### Includes
Methods:
- client.zero_trust.devices.policies.custom.includes.update(policy_id, \*, account_id, \*\*params) -> SyncSinglePage[SplitTunnelInclude]
- client.zero_trust.devices.policies.custom.includes.get(policy_id, \*, account_id) -> SyncSinglePage[SplitTunnelInclude]
##### FallbackDomains
Methods:
- client.zero_trust.devices.policies.custom.fallback_domains.update(policy_id, \*, account_id, \*\*params) -> SyncSinglePage[FallbackDomain]
- client.zero_trust.devices.policies.custom.fallback_domains.get(policy_id, \*, account_id) -> SyncSinglePage[FallbackDomain]
### Posture
Types:
```python
from cloudflare.types.zero_trust.devices import (
CarbonblackInput,
ClientCertificateInput,
CrowdstrikeInput,
DeviceInput,
DeviceMatch,
DevicePostureRule,
DiskEncryptionInput,
DomainJoinedInput,
FileInput,
FirewallInput,
IntuneInput,
KolideInput,
OSVersionInput,
SentineloneInput,
SentineloneS2sInput,
TaniumInput,
UniqueClientIDInput,
WorkspaceOneInput,
PostureDeleteResponse,
)
```
Methods:
- client.zero_trust.devices.posture.create(\*, account_id, \*\*params) -> Optional[DevicePostureRule]
- client.zero_trust.devices.posture.update(rule_id, \*, account_id, \*\*params) -> Optional[DevicePostureRule]
- client.zero_trust.devices.posture.list(\*, account_id) -> SyncSinglePage[DevicePostureRule]
- client.zero_trust.devices.posture.delete(rule_id, \*, account_id) -> Optional[PostureDeleteResponse]
- client.zero_trust.devices.posture.get(rule_id, \*, account_id) -> Optional[DevicePostureRule]
#### Integrations
Types:
```python
from cloudflare.types.zero_trust.devices.posture import Integration, IntegrationDeleteResponse
```
Methods:
- client.zero_trust.devices.posture.integrations.create(\*, account_id, \*\*params) -> Optional[Integration]
- client.zero_trust.devices.posture.integrations.list(\*, account_id) -> SyncSinglePage[Integration]
- client.zero_trust.devices.posture.integrations.delete(integration_id, \*, account_id) -> Optional[IntegrationDeleteResponse]
- client.zero_trust.devices.posture.integrations.edit(integration_id, \*, account_id, \*\*params) -> Optional[Integration]
- client.zero_trust.devices.posture.integrations.get(integration_id, \*, account_id) -> Optional[Integration]
### Revoke
Types:
```python
from cloudflare.types.zero_trust.devices import RevokeCreateResponse
```
Methods:
- client.zero_trust.devices.revoke.create(\*, account_id, \*\*params) -> Optional[RevokeCreateResponse]
### Settings
Types:
```python
from cloudflare.types.zero_trust.devices import DeviceSettings
```
Methods:
- client.zero_trust.devices.settings.update(\*, account_id, \*\*params) -> Optional[DeviceSettings]
- client.zero_trust.devices.settings.delete(\*, account_id) -> Optional[DeviceSettings]
- client.zero_trust.devices.settings.edit(\*, account_id, \*\*params) -> Optional[DeviceSettings]
- client.zero_trust.devices.settings.get(\*, account_id) -> Optional[DeviceSettings]
### Unrevoke
Types:
```python
from cloudflare.types.zero_trust.devices import UnrevokeCreateResponse
```
Methods:
- client.zero_trust.devices.unrevoke.create(\*, account_id, \*\*params) -> Optional[UnrevokeCreateResponse]
### OverrideCodes
Types:
```python
from cloudflare.types.zero_trust.devices import OverrideCodeGetResponse
```
Methods:
- client.zero_trust.devices.override_codes.list(device_id, \*, account_id) -> SyncSinglePage[object]
- client.zero_trust.devices.override_codes.get(registration_id, \*, account_id) -> OverrideCodeGetResponse
## IdentityProviders
Types:
```python
from cloudflare.types.zero_trust import (
AzureAD,
GenericOAuthConfig,
IdentityProvider,
IdentityProviderSCIMConfig,
IdentityProviderType,
IdentityProviderListResponse,
IdentityProviderDeleteResponse,
)
```
Methods:
- client.zero_trust.identity_providers.create(\*, account_id, zone_id, \*\*params) -> Optional[IdentityProvider]
- client.zero_trust.identity_providers.update(identity_provider_id, \*, account_id, zone_id, \*\*params) -> Optional[IdentityProvider]
- client.zero_trust.identity_providers.list(\*, account_id, zone_id, \*\*params) -> SyncSinglePage[IdentityProviderListResponse]
- client.zero_trust.identity_providers.delete(identity_provider_id, \*, account_id, zone_id) -> Optional[IdentityProviderDeleteResponse]
- client.zero_trust.identity_providers.get(identity_provider_id, \*, account_id, zone_id) -> Optional[IdentityProvider]
### SCIM
#### Groups
Methods:
- client.zero_trust.identity_providers.scim.groups.list(identity_provider_id, \*, account_id, \*\*params) -> SyncSinglePage[ZeroTrustGroup]
#### Users
Methods:
- client.zero_trust.identity_providers.scim.users.list(identity_provider_id, \*, account_id, \*\*params) -> SyncSinglePage[AccessUser]
## Organizations
Types:
```python
from cloudflare.types.zero_trust import LoginDesign, Organization, OrganizationRevokeUsersResponse
```
Methods:
- client.zero_trust.organizations.create(\*, account_id, zone_id, \*\*params) -> Optional[Organization]
- client.zero_trust.organizations.update(\*, account_id, zone_id, \*\*params) -> Optional[Organization]
- client.zero_trust.organizations.list(\*, account_id, zone_id) -> Optional[Organization]
- client.zero_trust.organizations.revoke_users(\*, account_id, zone_id, \*\*params) -> Optional[OrganizationRevokeUsersResponse]
### DOH
Types:
```python
from cloudflare.types.zero_trust.organizations import DOHUpdateResponse, DOHGetResponse
```
Methods:
- client.zero_trust.organizations.doh.update(\*, account_id, \*\*params) -> Optional[DOHUpdateResponse]
- client.zero_trust.organizations.doh.get(\*, account_id) -> Optional[DOHGetResponse]
## Seats
Types:
```python
from cloudflare.types.zero_trust import Seat
```
Methods:
- client.zero_trust.seats.edit(\*, account_id, \*\*params) -> SyncSinglePage[Seat]
## Access
### GatewayCA
Types:
```python
from cloudflare.types.zero_trust.access import (
GatewayCACreateResponse,
GatewayCAListResponse,
GatewayCADeleteResponse,
)
```
Methods:
- client.zero_trust.access.gateway_ca.create(\*, account_id) -> Optional[GatewayCACreateResponse]
- client.zero_trust.access.gateway_ca.list(\*, account_id) -> SyncSinglePage[GatewayCAListResponse]
- client.zero_trust.access.gateway_ca.delete(certificate_id, \*, account_id) -> Optional[GatewayCADeleteResponse]
### Infrastructure
#### Targets
Types:
```python
from cloudflare.types.zero_trust.access.infrastructure import (
TargetCreateResponse,
TargetUpdateResponse,
TargetListResponse,
TargetBulkUpdateResponse,
TargetGetResponse,
)
```
Methods:
- client.zero_trust.access.infrastructure.targets.create(\*, account_id, \*\*params) -> Optional[TargetCreateResponse]
- client.zero_trust.access.infrastructure.targets.update(target_id, \*, account_id, \*\*params) -> Optional[TargetUpdateResponse]
- client.zero_trust.access.infrastructure.targets.list(\*, account_id, \*\*params) -> SyncV4PagePaginationArray[TargetListResponse]
- client.zero_trust.access.infrastructure.targets.delete(target_id, \*, account_id) -> None
- client.zero_trust.access.infrastructure.targets.bulk_delete(\*, account_id) -> None
- client.zero_trust.access.infrastructure.targets.bulk_delete_v2(\*, account_id, \*\*params) -> None
- client.zero_trust.access.infrastructure.targets.bulk_update(\*, account_id, \*\*params) -> SyncSinglePage[TargetBulkUpdateResponse]
- client.zero_trust.access.infrastructure.targets.get(target_id, \*, account_id) -> Optional[TargetGetResponse]
### Applications
Types:
```python
from cloudflare.types.zero_trust.access import (
AllowedHeaders,
AllowedIdPs,
AllowedMethods,
AllowedOrigins,
AppID,
Application,
ApplicationPolicy,
ApplicationSCIMConfig,
ApplicationType,
CORSHeaders,
Decision,
OIDCSaaSApp,
SaaSAppNameIDFormat,
SAMLSaaSApp,
SCIMConfigAuthenticationHTTPBasic,
SCIMConfigAuthenticationOAuthBearerToken,
SCIMConfigAuthenticationOauth2,
SCIMConfigMapping,
SelfHostedDomains,
ApplicationCreateResponse,
ApplicationUpdateResponse,
ApplicationListResponse,
ApplicationDeleteResponse,
ApplicationGetResponse,
)
```
Methods:
- client.zero_trust.access.applications.create(\*, account_id, zone_id, \*\*params) -> Optional[ApplicationCreateResponse]
- client.zero_trust.access.applications.update(app_id, \*, account_id, zone_id, \*\*params) -> Optional[ApplicationUpdateResponse]
- client.zero_trust.access.applications.list(\*, account_id, zone_id, \*\*params) -> SyncSinglePage[ApplicationListResponse]
- client.zero_trust.access.applications.delete(app_id, \*, account_id, zone_id) -> Optional[ApplicationDeleteResponse]
- client.zero_trust.access.applications.get(app_id, \*, account_id, zone_id) -> Optional[ApplicationGetResponse]
- client.zero_trust.access.applications.revoke_tokens(app_id, \*, account_id, zone_id) -> object
#### CAs
Types:
```python
from cloudflare.types.zero_trust.access.applications import CA, CADeleteResponse
```
Methods:
- client.zero_trust.access.applications.cas.create(app_id, \*, account_id, zone_id) -> Optional[CA]
- client.zero_trust.access.applications.cas.list(\*, account_id, zone_id) -> SyncSinglePage[CA]
- client.zero_trust.access.applications.cas.delete(app_id, \*, account_id, zone_id) -> Optional[CADeleteResponse]
- client.zero_trust.access.applications.cas.get(app_id, \*, account_id, zone_id) -> Optional[CA]
#### UserPolicyChecks
Types:
```python
from cloudflare.types.zero_trust.access.applications import (
UserPolicyCheckGeo,
UserPolicyCheckListResponse,
)
```
Methods:
- client.zero_trust.access.applications.user_policy_checks.list(app_id, \*, account_id, zone_id) -> Optional[UserPolicyCheckListResponse]
#### Policies
Types:
```python
from cloudflare.types.zero_trust.access.applications import (
AccessDevicePostureRule,
AccessRule,
AnyValidServiceTokenRule,
AuthenticationMethodRule,
AzureGroupRule,
CertificateRule,
CountryRule,
DomainRule,
EmailListRule,
EmailRule,
EveryoneRule,
ExternalEvaluationRule,
GitHubOrganizationRule,
GroupRule,
GSuiteGroupRule,
IPListRule,
IPRule,
OktaGroupRule,
SAMLGroupRule,
ServiceTokenRule,
PolicyCreateResponse,
PolicyUpdateResponse,
PolicyListResponse,
PolicyDeleteResponse,
PolicyGetResponse,
)
```
Methods:
- client.zero_trust.access.applications.policies.create(app_id, \*, account_id, zone_id, \*\*params) -> Optional[PolicyCreateResponse]
- client.zero_trust.access.applications.policies.update(policy_id, \*, app_id, account_id, zone_id, \*\*params) -> Optional[PolicyUpdateResponse]
- client.zero_trust.access.applications.policies.list(app_id, \*, account_id, zone_id) -> SyncSinglePage[PolicyListResponse]
- client.zero_trust.access.applications.policies.delete(policy_id, \*, app_id, account_id, zone_id) -> Optional[PolicyDeleteResponse]
- client.zero_trust.access.applications.policies.get(policy_id, \*, app_id, account_id, zone_id) -> Optional[PolicyGetResponse]
#### PolicyTests
Types:
```python
from cloudflare.types.zero_trust.access.applications import (
PolicyTestCreateResponse,
PolicyTestGetResponse,
)
```
Methods:
- client.zero_trust.access.applications.policy_tests.create(\*, account_id, \*\*params) -> Optional[PolicyTestCreateResponse]
- client.zero_trust.access.applications.policy_tests.get(policy_test_id, \*, account_id) -> Optional[PolicyTestGetResponse]
##### Users
Types:
```python
from cloudflare.types.zero_trust.access.applications.policy_tests import UserListResponse
```
Methods:
- client.zero_trust.access.applications.policy_tests.users.list(policy_test_id, \*, account_id, \*\*params) -> SyncV4PagePaginationArray[UserListResponse]
#### Settings
Types:
```python
from cloudflare.types.zero_trust.access.applications import (
SettingUpdateResponse,
SettingEditResponse,
)
```
Methods:
- client.zero_trust.access.applications.settings.update(app_id, \*, account_id, zone_id, \*\*params) -> Optional[SettingUpdateResponse]
- client.zero_trust.access.applications.settings.edit(app_id, \*, account_id, zone_id, \*\*params) -> Optional[SettingEditResponse]
### Certificates
Types:
```python
from cloudflare.types.zero_trust.access import (
AssociatedHostnames,
Certificate,
CertificateDeleteResponse,
)
```
Methods:
- client.zero_trust.access.certificates.create(\*, account_id, zone_id, \*\*params) -> Optional[Certificate]
- client.zero_trust.access.certificates.update(certificate_id, \*, account_id, zone_id, \*\*params) -> Optional[Certificate]
- client.zero_trust.access.certificates.list(\*, account_id, zone_id) -> SyncSinglePage[Certificate]
- client.zero_trust.access.certificates.delete(certificate_id, \*, account_id, zone_id) -> Optional[CertificateDeleteResponse]
- client.zero_trust.access.certificates.get(certificate_id, \*, account_id, zone_id) -> Optional[Certificate]
#### Settings
Types:
```python
from cloudflare.types.zero_trust.access.certificates import CertificateSettings
```
Methods:
- client.zero_trust.access.certificates.settings.update(\*, account_id, zone_id, \*\*params) -> SyncSinglePage[CertificateSettings]
- client.zero_trust.access.certificates.settings.get(\*, account_id, zone_id) -> SyncSinglePage[CertificateSettings]
### Groups
Types:
```python
from cloudflare.types.zero_trust.access import (
ZeroTrustGroup,
GroupCreateResponse,
GroupUpdateResponse,
GroupListResponse,
GroupDeleteResponse,
GroupGetResponse,
)
```
Methods:
- client.zero_trust.access.groups.create(\*, account_id, zone_id, \*\*params) -> Optional[GroupCreateResponse]
- client.zero_trust.access.groups.update(group_id, \*, account_id, zone_id, \*\*params) -> Optional[GroupUpdateResponse]
- client.zero_trust.access.groups.list(\*, account_id, zone_id, \*\*params) -> SyncSinglePage[GroupListResponse]
- client.zero_trust.access.groups.delete(group_id, \*, account_id, zone_id) -> Optional[GroupDeleteResponse]
- client.zero_trust.access.groups.get(group_id, \*, account_id, zone_id) -> Optional[GroupGetResponse]
### ServiceTokens
Types:
```python
from cloudflare.types.zero_trust.access import (
ServiceToken,
ServiceTokenCreateResponse,
ServiceTokenRotateResponse,
)
```
Methods:
- client.zero_trust.access.service_tokens.create(\*, account_id, zone_id, \*\*params) -> Optional[ServiceTokenCreateResponse]
- client.zero_trust.access.service_tokens.update(service_token_id, \*, account_id, zone_id, \*\*params) -> Optional[ServiceToken]
- client.zero_trust.access.service_tokens.list(\*, account_id, zone_id, \*\*params) -> SyncSinglePage[ServiceToken]
- client.zero_trust.access.service_tokens.delete(service_token_id, \*, account_id, zone_id) -> Optional[ServiceToken]
- client.zero_trust.access.service_tokens.get(service_token_id, \*, account_id, zone_id) -> Optional[ServiceToken]
- client.zero_trust.access.service_tokens.refresh(service_token_id, \*, account_id) -> Optional[ServiceToken]
- client.zero_trust.access.service_tokens.rotate(service_token_id, \*, account_id) -> Optional[ServiceTokenRotateResponse]
### Bookmarks
Types:
```python
from cloudflare.types.zero_trust.access import Bookmark, BookmarkDeleteResponse
```
Methods:
- client.zero_trust.access.bookmarks.create(bookmark_id, \*, account_id, \*\*params) -> Optional[Bookmark]
- client.zero_trust.access.bookmarks.update(bookmark_id, \*, account_id, \*\*params) -> Optional[Bookmark]
- client.zero_trust.access.bookmarks.list(\*, account_id) -> SyncSinglePage[Bookmark]
- client.zero_trust.access.bookmarks.delete(bookmark_id, \*, account_id) -> Optional[BookmarkDeleteResponse]
- client.zero_trust.access.bookmarks.get(bookmark_id, \*, account_id) -> Optional[Bookmark]
### Keys
Types:
```python
from cloudflare.types.zero_trust.access import KeyUpdateResponse, KeyGetResponse, KeyRotateResponse
```
Methods:
- client.zero_trust.access.keys.update(\*, account_id, \*\*params) -> Optional[KeyUpdateResponse]
- client.zero_trust.access.keys.get(\*, account_id) -> Optional[KeyGetResponse]
- client.zero_trust.access.keys.rotate(\*, account_id) -> Optional[KeyRotateResponse]
### Logs
#### AccessRequests
Types:
```python
from cloudflare.types.zero_trust.access.logs import AccessRequestListResponse
```
Methods:
- client.zero_trust.access.logs.access_requests.list(\*, account_id, \*\*params) -> Optional[AccessRequestListResponse]
#### SCIM
Types:
```python
from cloudflare.types.zero_trust.access.logs import AccessRequest
```
##### Updates
Types:
```python
from cloudflare.types.zero_trust.access.logs.scim import UpdateListResponse
```
Methods:
- client.zero_trust.access.logs.scim.updates.list(\*, account_id, \*\*params) -> SyncSinglePage[UpdateListResponse]
### Users
Types:
```python
from cloudflare.types.zero_trust.access import AccessUser, UserListResponse
```
Methods:
- client.zero_trust.access.users.list(\*, account_id, \*\*params) -> SyncSinglePage[UserListResponse]
#### ActiveSessions
Types:
```python
from cloudflare.types.zero_trust.access.users import (
ActiveSessionListResponse,
ActiveSessionGetResponse,
)
```
Methods:
- client.zero_trust.access.users.active_sessions.list(user_id, \*, account_id) -> SyncSinglePage[ActiveSessionListResponse]
- client.zero_trust.access.users.active_sessions.get(nonce, \*, account_id, user_id) -> Optional[ActiveSessionGetResponse]
#### LastSeenIdentity
Types:
```python
from cloudflare.types.zero_trust.access.users import Identity
```
Methods:
- client.zero_trust.access.users.last_seen_identity.get(user_id, \*, account_id) -> Optional[Identity]
#### FailedLogins
Types:
```python
from cloudflare.types.zero_trust.access.users import FailedLoginListResponse
```
Methods:
- client.zero_trust.access.users.failed_logins.list(user_id, \*, account_id) -> SyncSinglePage[FailedLoginListResponse]
### CustomPages
Types:
```python
from cloudflare.types.zero_trust.access import (
CustomPage,
CustomPageWithoutHTML,
CustomPageDeleteResponse,
)
```
Methods:
- client.zero_trust.access.custom_pages.create(\*, account_id, \*\*params) -> Optional[CustomPageWithoutHTML]
- client.zero_trust.access.custom_pages.update(custom_page_id, \*, account_id, \*\*params) -> Optional[CustomPageWithoutHTML]
- client.zero_trust.access.custom_pages.list(\*, account_id) -> SyncSinglePage[CustomPageWithoutHTML]
- client.zero_trust.access.custom_pages.delete(custom_page_id, \*, account_id) -> Optional[CustomPageDeleteResponse]
- client.zero_trust.access.custom_pages.get(custom_page_id, \*, account_id) -> Optional[CustomPage]
### Tags
Types:
```python
from cloudflare.types.zero_trust.access import Tag, TagDeleteResponse
```
Methods:
- client.zero_trust.access.tags.create(\*, account_id, \*\*params) -> Optional[Tag]
- client.zero_trust.access.tags.update(tag_name, \*, account_id, \*\*params) -> Optional[Tag]
- client.zero_trust.access.tags.list(\*, account_id) -> SyncSinglePage[Tag]
- client.zero_trust.access.tags.delete(tag_name, \*, account_id) -> Optional[TagDeleteResponse]
- client.zero_trust.access.tags.get(tag_name, \*, account_id) -> Optional[Tag]
### Policies
Types:
```python
from cloudflare.types.zero_trust.access import (
ApprovalGroup,
Policy,
PolicyCreateResponse,
PolicyUpdateResponse,
PolicyListResponse,
PolicyDeleteResponse,
PolicyGetResponse,
)
```
Methods:
- client.zero_trust.access.policies.create(\*, account_id, \*\*params) -> Optional[PolicyCreateResponse]
- client.zero_trust.access.policies.update(policy_id, \*, account_id, \*\*params) -> Optional[PolicyUpdateResponse]
- client.zero_trust.access.policies.list(\*, account_id) -> SyncSinglePage[PolicyListResponse]
- client.zero_trust.access.policies.delete(policy_id, \*, account_id) -> Optional[PolicyDeleteResponse]
- client.zero_trust.access.policies.get(policy_id, \*, account_id) -> Optional[PolicyGetResponse]
## DEX
Types:
```python
from cloudflare.types.zero_trust import (
DigitalExperienceMonitor,
NetworkPath,
NetworkPathResponse,
Percentiles,
)
```
### WARPChangeEvents
Types:
```python
from cloudflare.types.zero_trust.dex import WARPChangeEventGetResponse
```
Methods:
- client.zero_trust.dex.warp_change_events.get(\*, account_id, \*\*params) -> Optional[WARPChangeEventGetResponse]
### Commands
Types:
```python
from cloudflare.types.zero_trust.dex import CommandCreateResponse, CommandListResponse
```
Methods:
- client.zero_trust.dex.commands.create(\*, account_id, \*\*params) -> Optional[CommandCreateResponse]
- client.zero_trust.dex.commands.list(\*, account_id, \*\*params) -> SyncV4PagePagination[Optional[CommandListResponse]]
#### Devices
Types:
```python
from cloudflare.types.zero_trust.dex.commands import DeviceListResponse
```
Methods:
- client.zero_trust.dex.commands.devices.list(\*, account_id, \*\*params) -> SyncV4PagePagination[Optional[DeviceListResponse]]
#### Downloads
Methods:
- client.zero_trust.dex.commands.downloads.get(filename, \*, account_id, command_id) -> BinaryAPIResponse
#### Quota
Types:
```python
from cloudflare.types.zero_trust.dex.commands import QuotaGetResponse
```
Methods:
- client.zero_trust.dex.commands.quota.get(\*, account_id) -> Optional[QuotaGetResponse]
### Colos
Methods:
- client.zero_trust.dex.colos.list(\*, account_id, \*\*params) -> SyncSinglePage[object]
### FleetStatus
Types:
```python
from cloudflare.types.zero_trust.dex import LiveStat, FleetStatusLiveResponse
```
Methods:
- client.zero_trust.dex.fleet_status.live(\*, account_id, \*\*params) -> Optional[FleetStatusLiveResponse]
- client.zero_trust.dex.fleet_status.over_time(\*, account_id, \*\*params) -> None
#### Devices
Types:
```python
from cloudflare.types.zero_trust.dex.fleet_status import DeviceListResponse
```
Methods:
- client.zero_trust.dex.fleet_status.devices.list(\*, account_id, \*\*params) -> SyncV4PagePaginationArray[DeviceListResponse]
### HTTPTests
Types:
```python
from cloudflare.types.zero_trust.dex import HTTPDetails
```
Methods:
- client.zero_trust.dex.http_tests.get(test_id, \*, account_id, \*\*params) -> Optional[HTTPDetails]
#### Percentiles
Types:
```python
from cloudflare.types.zero_trust.dex.http_tests import HTTPDetailsPercentiles, TestStatOverTime
```
Methods:
- client.zero_trust.dex.http_tests.percentiles.get(test_id, \*, account_id, \*\*params) -> Optional[HTTPDetailsPercentiles]
### Tests
Types:
```python
from cloudflare.types.zero_trust.dex import AggregateTimePeriod, Tests
```
Methods:
- client.zero_trust.dex.tests.list(\*, account_id, \*\*params) -> SyncV4PagePagination[Optional[Tests]]
#### UniqueDevices
Types:
```python
from cloudflare.types.zero_trust.dex.tests import UniqueDevices
```
Methods:
- client.zero_trust.dex.tests.unique_devices.list(\*, account_id, \*\*params) -> Optional[UniqueDevices]
### TracerouteTestResults
#### NetworkPath
Types:
```python
from cloudflare.types.zero_trust.dex.traceroute_test_results import NetworkPathGetResponse
```
Methods:
- client.zero_trust.dex.traceroute_test_results.network_path.get(test_result_id, \*, account_id) -> Optional[NetworkPathGetResponse]
### TracerouteTests
Types:
```python
from cloudflare.types.zero_trust.dex import Traceroute, TracerouteTestPercentilesResponse
```
Methods:
- client.zero_trust.dex.traceroute_tests.get(test_id, \*, account_id, \*\*params) -> Optional[Traceroute]
- client.zero_trust.dex.traceroute_tests.network_path(test_id, \*, account_id, \*\*params) -> Optional[NetworkPathResponse]
- client.zero_trust.dex.traceroute_tests.percentiles(test_id, \*, account_id, \*\*params) -> Optional[TracerouteTestPercentilesResponse]
## Tunnels
Types:
```python
from cloudflare.types.zero_trust import Connection, TunnelListResponse
```
Methods:
- client.zero_trust.tunnels.list(\*, account_id, \*\*params) -> SyncV4PagePaginationArray[TunnelListResponse]
### Cloudflared
Types:
```python
from cloudflare.types.zero_trust.tunnels import (
CloudflaredCreateResponse,
CloudflaredListResponse,
CloudflaredDeleteResponse,
CloudflaredEditResponse,
CloudflaredGetResponse,
)
```
Methods:
- client.zero_trust.tunnels.cloudflared.create(\*, account_id, \*\*params) -> CloudflaredCreateResponse
- client.zero_trust.tunnels.cloudflared.list(\*, account_id, \*\*params) -> SyncV4PagePaginationArray[CloudflaredListResponse]
- client.zero_trust.tunnels.cloudflared.delete(tunnel_id, \*, account_id) -> CloudflaredDeleteResponse
- client.zero_trust.tunnels.cloudflared.edit(tunnel_id, \*, account_id, \*\*params) -> CloudflaredEditResponse
- client.zero_trust.tunnels.cloudflared.get(tunnel_id, \*, account_id) -> CloudflaredGetResponse
#### Configurations
Types:
```python
from cloudflare.types.zero_trust.tunnels.cloudflared import (
ConfigurationUpdateResponse,
ConfigurationGetResponse,
)
```
Methods:
- client.zero_trust.tunnels.cloudflared.configurations.update(tunnel_id, \*, account_id, \*\*params) -> Optional[ConfigurationUpdateResponse]
- client.zero_trust.tunnels.cloudflared.configurations.get(tunnel_id, \*, account_id) -> Optional[ConfigurationGetResponse]
#### Connections
Types:
```python
from cloudflare.types.zero_trust.tunnels.cloudflared import Client
```
Methods:
- client.zero_trust.tunnels.cloudflared.connections.delete(tunnel_id, \*, account_id, \*\*params) -> object
- client.zero_trust.tunnels.cloudflared.connections.get(tunnel_id, \*, account_id) -> SyncSinglePage[Client]
#### Token
Types:
```python
from cloudflare.types.zero_trust.tunnels.cloudflared import TokenGetResponse
```
Methods:
- client.zero_trust.tunnels.cloudflared.token.get(tunnel_id, \*, account_id) -> str
#### Connectors
Methods:
- client.zero_trust.tunnels.cloudflared.connectors.get(connector_id, \*, account_id, tunnel_id) -> Client
#### Management
Types:
```python
from cloudflare.types.zero_trust.tunnels.cloudflared import ManagementCreateResponse
```
Methods:
- client.zero_trust.tunnels.cloudflared.management.create(tunnel_id, \*, account_id, \*\*params) -> str
### WARPConnector
Types:
```python
from cloudflare.types.zero_trust.tunnels import (
WARPConnectorCreateResponse,
WARPConnectorListResponse,
WARPConnectorDeleteResponse,
WARPConnectorEditResponse,
WARPConnectorGetResponse,
)
```
Methods:
- client.zero_trust.tunnels.warp_connector.create(\*, account_id, \*\*params) -> WARPConnectorCreateResponse
- client.zero_trust.tunnels.warp_connector.list(\*, account_id, \*\*params) -> SyncV4PagePaginationArray[WARPConnectorListResponse]
- client.zero_trust.tunnels.warp_connector.delete(tunnel_id, \*, account_id) -> WARPConnectorDeleteResponse
- client.zero_trust.tunnels.warp_connector.edit(tunnel_id, \*, account_id, \*\*params) -> WARPConnectorEditResponse
- client.zero_trust.tunnels.warp_connector.get(tunnel_id, \*, account_id) -> WARPConnectorGetResponse
#### Token
Types:
```python
from cloudflare.types.zero_trust.tunnels.warp_connector import TokenGetResponse
```
Methods:
- client.zero_trust.tunnels.warp_connector.token.get(tunnel_id, \*, account_id) -> str
## ConnectivitySettings
Types:
```python
from cloudflare.types.zero_trust import (
ConnectivitySettingEditResponse,
ConnectivitySettingGetResponse,
)
```
Methods:
- client.zero_trust.connectivity_settings.edit(\*, account_id, \*\*params) -> ConnectivitySettingEditResponse
- client.zero_trust.connectivity_settings.get(\*, account_id) -> ConnectivitySettingGetResponse
## DLP
### Datasets
Types:
```python
from cloudflare.types.zero_trust.dlp import Dataset, DatasetArray, DatasetCreation
```
Methods:
- client.zero_trust.dlp.datasets.create(\*, account_id, \*\*params) -> Optional[DatasetCreation]
- client.zero_trust.dlp.datasets.update(dataset_id, \*, account_id, \*\*params) -> Optional[Dataset]
- client.zero_trust.dlp.datasets.list(\*, account_id) -> SyncSinglePage[Dataset]
- client.zero_trust.dlp.datasets.delete(dataset_id, \*, account_id) -> None
- client.zero_trust.dlp.datasets.get(dataset_id, \*, account_id) -> Optional[Dataset]
#### Upload
Types:
```python
from cloudflare.types.zero_trust.dlp.datasets import NewVersion
```
Methods:
- client.zero_trust.dlp.datasets.upload.create(dataset_id, \*, account_id) -> Optional[NewVersion]
- client.zero_trust.dlp.datasets.upload.edit(version, \*, account_id, dataset_id, \*\*params) -> Optional[Dataset]
#### Versions
Types:
```python
from cloudflare.types.zero_trust.dlp.datasets import VersionCreateResponse
```
Methods:
- client.zero_trust.dlp.datasets.versions.create(version, \*, account_id, dataset_id, \*\*params) -> SyncSinglePage[VersionCreateResponse]
##### Entries
Types:
```python
from cloudflare.types.zero_trust.dlp.datasets.versions import EntryCreateResponse
```
Methods:
- client.zero_trust.dlp.datasets.versions.entries.create(entry_id, \*, account_id, dataset_id, version, \*\*params) -> Optional[EntryCreateResponse]
### Patterns
Types:
```python
from cloudflare.types.zero_trust.dlp import PatternValidateResponse
```
Methods:
- client.zero_trust.dlp.patterns.validate(\*, account_id, \*\*params) -> Optional[PatternValidateResponse]
### PayloadLogs
Types:
```python
from cloudflare.types.zero_trust.dlp import PayloadLogUpdateResponse, PayloadLogGetResponse
```
Methods:
- client.zero_trust.dlp.payload_logs.update(\*, account_id, \*\*params) -> Optional[PayloadLogUpdateResponse]
- client.zero_trust.dlp.payload_logs.get(\*, account_id) -> Optional[PayloadLogGetResponse]
### Email
#### AccountMapping
Types:
```python
from cloudflare.types.zero_trust.dlp.email import (
AccountMappingCreateResponse,
AccountMappingGetResponse,
)
```
Methods:
- client.zero_trust.dlp.email.account_mapping.create(\*, account_id, \*\*params) -> Optional[AccountMappingCreateResponse]
- client.zero_trust.dlp.email.account_mapping.get(\*, account_id) -> Optional[AccountMappingGetResponse]
#### Rules
Types:
```python
from cloudflare.types.zero_trust.dlp.email import (
RuleCreateResponse,
RuleUpdateResponse,
RuleListResponse,
RuleDeleteResponse,
RuleBulkEditResponse,
RuleGetResponse,
)
```
Methods:
- client.zero_trust.dlp.email.rules.create(\*, account_id, \*\*params) -> Optional[RuleCreateResponse]
- client.zero_trust.dlp.email.rules.update(rule_id, \*, account_id, \*\*params) -> Optional[RuleUpdateResponse]
- client.zero_trust.dlp.email.rules.list(\*, account_id) -> SyncSinglePage[RuleListResponse]
- client.zero_trust.dlp.email.rules.delete(rule_id, \*, account_id) -> Optional[RuleDeleteResponse]
- client.zero_trust.dlp.email.rules.bulk_edit(\*, account_id, \*\*params) -> Optional[RuleBulkEditResponse]
- client.zero_trust.dlp.email.rules.get(rule_id, \*, account_id) -> Optional[RuleGetResponse]
### Profiles
Types:
```python
from cloudflare.types.zero_trust.dlp import ContextAwareness, Profile, SkipConfiguration
```
Methods:
- client.zero_trust.dlp.profiles.list(\*, account_id, \*\*params) -> SyncSinglePage[Profile]
- client.zero_trust.dlp.profiles.get(profile_id, \*, account_id) -> Optional[Profile]
#### Custom
Types:
```python
from cloudflare.types.zero_trust.dlp.profiles import CustomProfile, Pattern
```
Methods:
- client.zero_trust.dlp.profiles.custom.create(\*, account_id, \*\*params) -> Optional[Profile]
- client.zero_trust.dlp.profiles.custom.update(profile_id, \*, account_id, \*\*params) -> Optional[Profile]
- client.zero_trust.dlp.profiles.custom.delete(profile_id, \*, account_id) -> object
- client.zero_trust.dlp.profiles.custom.get(profile_id, \*, account_id) -> Optional[Profile]
#### Predefined
Types:
```python
from cloudflare.types.zero_trust.dlp.profiles import PredefinedProfile
```
Methods:
- client.zero_trust.dlp.profiles.predefined.update(profile_id, \*, account_id, \*\*params) -> Optional[Profile]
- client.zero_trust.dlp.profiles.predefined.get(profile_id, \*, account_id) -> Optional[Profile]
### Limits
Types:
```python
from cloudflare.types.zero_trust.dlp import LimitListResponse
```
Methods:
- client.zero_trust.dlp.limits.list(\*, account_id) -> Optional[LimitListResponse]
### Entries
Types:
```python
from cloudflare.types.zero_trust.dlp import (
EntryCreateResponse,
EntryUpdateResponse,
EntryListResponse,
EntryGetResponse,
)
```
Methods:
- client.zero_trust.dlp.entries.create(\*, account_id, \*\*params) -> Optional[EntryCreateResponse]
- client.zero_trust.dlp.entries.update(entry_id, \*, account_id, \*\*params) -> Optional[EntryUpdateResponse]
- client.zero_trust.dlp.entries.list(\*, account_id) -> SyncSinglePage[EntryListResponse]
- client.zero_trust.dlp.entries.delete(entry_id, \*, account_id) -> object
- client.zero_trust.dlp.entries.get(entry_id, \*, account_id) -> Optional[EntryGetResponse]
## Gateway
Types:
```python
from cloudflare.types.zero_trust import GatewayCreateResponse, GatewayListResponse
```
Methods:
- client.zero_trust.gateway.create(\*, account_id) -> Optional[GatewayCreateResponse]
- client.zero_trust.gateway.list(\*, account_id) -> Optional[GatewayListResponse]
### AuditSSHSettings
Types:
```python
from cloudflare.types.zero_trust.gateway import GatewaySettings
```
Methods:
- client.zero_trust.gateway.audit_ssh_settings.update(\*, account_id, \*\*params) -> Optional[GatewaySettings]
- client.zero_trust.gateway.audit_ssh_settings.get(\*, account_id) -> Optional[GatewaySettings]
- client.zero_trust.gateway.audit_ssh_settings.rotate_seed(\*, account_id) -> Optional[GatewaySettings]
### Categories
Types:
```python
from cloudflare.types.zero_trust.gateway import Category
```
Methods:
- client.zero_trust.gateway.categories.list(\*, account_id) -> SyncSinglePage[Category]
### AppTypes
Types:
```python
from cloudflare.types.zero_trust.gateway import AppType
```
Methods:
- client.zero_trust.gateway.app_types.list(\*, account_id) -> SyncSinglePage[AppType]
### Configurations
Types:
```python
from cloudflare.types.zero_trust.gateway import (
ActivityLogSettings,
AntiVirusSettings,
BlockPageSettings,
BodyScanningSettings,
BrowserIsolationSettings,
CustomCertificateSettings,
ExtendedEmailMatching,
FipsSettings,
GatewayConfigurationSettings,
NotificationSettings,
ProtocolDetection,
TLSSettings,
ConfigurationUpdateResponse,
ConfigurationEditResponse,
ConfigurationGetResponse,
)
```
Methods:
- client.zero_trust.gateway.configurations.update(\*, account_id, \*\*params) -> Optional[ConfigurationUpdateResponse]
- client.zero_trust.gateway.configurations.edit(\*, account_id, \*\*params) -> Optional[ConfigurationEditResponse]
- client.zero_trust.gateway.configurations.get(\*, account_id) -> Optional[ConfigurationGetResponse]
#### CustomCertificate
Methods:
- client.zero_trust.gateway.configurations.custom_certificate.get(\*, account_id) -> Optional[CustomCertificateSettings]
### Lists
Types:
```python
from cloudflare.types.zero_trust.gateway import GatewayItem, GatewayList, ListCreateResponse
```
Methods:
- client.zero_trust.gateway.lists.create(\*, account_id, \*\*params) -> Optional[ListCreateResponse]
- client.zero_trust.gateway.lists.update(list_id, \*, account_id, \*\*params) -> Optional[GatewayList]
- client.zero_trust.gateway.lists.list(\*, account_id, \*\*params) -> SyncSinglePage[GatewayList]
- client.zero_trust.gateway.lists.delete(list_id, \*, account_id) -> object
- client.zero_trust.gateway.lists.edit(list_id, \*, account_id, \*\*params) -> Optional[GatewayList]
- client.zero_trust.gateway.lists.get(list_id, \*, account_id) -> Optional[GatewayList]
#### Items
Types:
```python
from cloudflare.types.zero_trust.gateway.lists import ItemListResponse
```
Methods:
- client.zero_trust.gateway.lists.items.list(list_id, \*, account_id) -> SyncSinglePage[ItemListResponse]
### Locations
Types:
```python
from cloudflare.types.zero_trust.gateway import (
DOHEndpoint,
DOTEndpoint,
Endpoint,
IPNetwork,
IPV4Endpoint,
IPV6Endpoint,
IPV6Network,
Location,
)
```
Methods:
- client.zero_trust.gateway.locations.create(\*, account_id, \*\*params) -> Optional[Location]
- client.zero_trust.gateway.locations.update(location_id, \*, account_id, \*\*params) -> Optional[Location]
- client.zero_trust.gateway.locations.list(\*, account_id) -> SyncSinglePage[Location]
- client.zero_trust.gateway.locations.delete(location_id, \*, account_id) -> object
- client.zero_trust.gateway.locations.get(location_id, \*, account_id) -> Optional[Location]
### Logging
Types:
```python
from cloudflare.types.zero_trust.gateway import LoggingSetting
```
Methods:
- client.zero_trust.gateway.logging.update(\*, account_id, \*\*params) -> Optional[LoggingSetting]
- client.zero_trust.gateway.logging.get(\*, account_id) -> Optional[LoggingSetting]
### ProxyEndpoints
Types:
```python
from cloudflare.types.zero_trust.gateway import GatewayIPs, ProxyEndpoint
```
Methods:
- client.zero_trust.gateway.proxy_endpoints.create(\*, account_id, \*\*params) -> Optional[ProxyEndpoint]
- client.zero_trust.gateway.proxy_endpoints.list(\*, account_id) -> Optional[ProxyEndpoint]
- client.zero_trust.gateway.proxy_endpoints.delete(proxy_endpoint_id, \*, account_id) -> object
- client.zero_trust.gateway.proxy_endpoints.edit(proxy_endpoint_id, \*, account_id, \*\*params) -> Optional[ProxyEndpoint]
- client.zero_trust.gateway.proxy_endpoints.get(proxy_endpoint_id, \*, account_id) -> SyncSinglePage[ProxyEndpoint]
### Rules
Types:
```python
from cloudflare.types.zero_trust.gateway import (
DNSResolverSettingsV4,
DNSResolverSettingsV6,
GatewayFilter,
GatewayRule,
RuleSetting,
Schedule,
)
```
Methods:
- client.zero_trust.gateway.rules.create(\*, account_id, \*\*params) -> Optional[GatewayRule]
- client.zero_trust.gateway.rules.update(rule_id, \*, account_id, \*\*params) -> Optional[GatewayRule]
- client.zero_trust.gateway.rules.list(\*, account_id) -> SyncSinglePage[GatewayRule]
- client.zero_trust.gateway.rules.delete(rule_id, \*, account_id) -> object
- client.zero_trust.gateway.rules.get(rule_id, \*, account_id) -> Optional[GatewayRule]
- client.zero_trust.gateway.rules.reset_expiration(rule_id, \*, account_id) -> Optional[GatewayRule]
### Certificates
Types:
```python
from cloudflare.types.zero_trust.gateway import (
CertificateCreateResponse,
CertificateListResponse,
CertificateDeleteResponse,
CertificateActivateResponse,
CertificateDeactivateResponse,
CertificateGetResponse,
)
```
Methods:
- client.zero_trust.gateway.certificates.create(\*, account_id, \*\*params) -> Optional[CertificateCreateResponse]
- client.zero_trust.gateway.certificates.list(\*, account_id) -> SyncSinglePage[CertificateListResponse]
- client.zero_trust.gateway.certificates.delete(certificate_id, \*, account_id) -> Optional[CertificateDeleteResponse]
- client.zero_trust.gateway.certificates.activate(certificate_id, \*, account_id, \*\*params) -> Optional[CertificateActivateResponse]
- client.zero_trust.gateway.certificates.deactivate(certificate_id, \*, account_id, \*\*params) -> Optional[CertificateDeactivateResponse]
- client.zero_trust.gateway.certificates.get(certificate_id, \*, account_id) -> Optional[CertificateGetResponse]
## Networks
### Routes
Types:
```python
from cloudflare.types.zero_trust.networks import NetworkRoute, Route, Teamnet
```
Methods:
- client.zero_trust.networks.routes.create(\*, account_id, \*\*params) -> Route
- client.zero_trust.networks.routes.list(\*, account_id, \*\*params) -> SyncV4PagePaginationArray[Teamnet]
- client.zero_trust.networks.routes.delete(route_id, \*, account_id) -> Route
- client.zero_trust.networks.routes.edit(route_id, \*, account_id, \*\*params) -> Route
- client.zero_trust.networks.routes.get(route_id, \*, account_id) -> Route
#### IPs
Methods:
- client.zero_trust.networks.routes.ips.get(ip, \*, account_id, \*\*params) -> Teamnet
#### Networks
Methods:
- client.zero_trust.networks.routes.networks.create(ip_network_encoded, \*, account_id, \*\*params) -> Route
- client.zero_trust.networks.routes.networks.delete(ip_network_encoded, \*, account_id, \*\*params) -> Route
- client.zero_trust.networks.routes.networks.edit(ip_network_encoded, \*, account_id) -> Route
### VirtualNetworks
Types:
```python
from cloudflare.types.zero_trust.networks import VirtualNetwork
```
Methods:
- client.zero_trust.networks.virtual_networks.create(\*, account_id, \*\*params) -> VirtualNetwork
- client.zero_trust.networks.virtual_networks.list(\*, account_id, \*\*params) -> SyncSinglePage[VirtualNetwork]
- client.zero_trust.networks.virtual_networks.delete(virtual_network_id, \*, account_id) -> VirtualNetwork
- client.zero_trust.networks.virtual_networks.edit(virtual_network_id, \*, account_id, \*\*params) -> VirtualNetwork
- client.zero_trust.networks.virtual_networks.get(virtual_network_id, \*, account_id) -> VirtualNetwork
### Subnets
Types:
```python
from cloudflare.types.zero_trust.networks import SubnetListResponse
```
Methods:
- client.zero_trust.networks.subnets.list(\*, account_id, \*\*params) -> SyncV4PagePaginationArray[SubnetListResponse]
#### CloudflareSource
Types:
```python
from cloudflare.types.zero_trust.networks.subnets import CloudflareSourceUpdateResponse
```
Methods:
- client.zero_trust.networks.subnets.cloudflare_source.update(address_family, \*, account_id, \*\*params) -> CloudflareSourceUpdateResponse
## RiskScoring
Types:
```python
from cloudflare.types.zero_trust import RiskScoringGetResponse
```
Methods:
- client.zero_trust.risk_scoring.get(user_id, \*, account_id) -> Optional[RiskScoringGetResponse]
- client.zero_trust.risk_scoring.reset(user_id, \*, account_id) -> object
### Behaviours
Types:
```python
from cloudflare.types.zero_trust.risk_scoring import BehaviourUpdateResponse, BehaviourGetResponse
```
Methods:
- client.zero_trust.risk_scoring.behaviours.update(\*, account_id, \*\*params) -> Optional[BehaviourUpdateResponse]
- client.zero_trust.risk_scoring.behaviours.get(\*, account_id) -> Optional[BehaviourGetResponse]
### Summary
Types:
```python
from cloudflare.types.zero_trust.risk_scoring import SummaryGetResponse
```
Methods:
- client.zero_trust.risk_scoring.summary.get(\*, account_id) -> Optional[SummaryGetResponse]
### Integrations
Types:
```python
from cloudflare.types.zero_trust.risk_scoring import (
IntegrationCreateResponse,
IntegrationUpdateResponse,
IntegrationListResponse,
IntegrationGetResponse,
)
```
Methods:
- client.zero_trust.risk_scoring.integrations.create(\*, account_id, \*\*params) -> Optional[IntegrationCreateResponse]
- client.zero_trust.risk_scoring.integrations.update(integration_id, \*, account_id, \*\*params) -> Optional[IntegrationUpdateResponse]
- client.zero_trust.risk_scoring.integrations.list(\*, account_id) -> SyncSinglePage[IntegrationListResponse]
- client.zero_trust.risk_scoring.integrations.delete(integration_id, \*, account_id) -> object
- client.zero_trust.risk_scoring.integrations.get(integration_id, \*, account_id) -> Optional[IntegrationGetResponse]
#### References
Types:
```python
from cloudflare.types.zero_trust.risk_scoring.integrations import ReferenceGetResponse
```
Methods:
- client.zero_trust.risk_scoring.integrations.references.get(reference_id, \*, account_id) -> Optional[ReferenceGetResponse]
# Turnstile
## Widgets
Types:
```python
from cloudflare.types.turnstile import Widget, WidgetDomain, WidgetListResponse
```
Methods:
- client.turnstile.widgets.create(\*, account_id, \*\*params) -> Optional[Widget]
- client.turnstile.widgets.update(sitekey, \*, account_id, \*\*params) -> Optional[Widget]
- client.turnstile.widgets.list(\*, account_id, \*\*params) -> SyncV4PagePaginationArray[WidgetListResponse]
- client.turnstile.widgets.delete(sitekey, \*, account_id) -> Optional[Widget]
- client.turnstile.widgets.get(sitekey, \*, account_id) -> Optional[Widget]
- client.turnstile.widgets.rotate_secret(sitekey, \*, account_id, \*\*params) -> Optional[Widget]
# Hyperdrive
Types:
```python
from cloudflare.types.hyperdrive import Configuration, Hyperdrive
```
## Configs
Methods:
- client.hyperdrive.configs.create(\*, account_id, \*\*params) -> Hyperdrive
- client.hyperdrive.configs.update(hyperdrive_id, \*, account_id, \*\*params) -> Hyperdrive
- client.hyperdrive.configs.list(\*, account_id) -> SyncSinglePage[Hyperdrive]
- client.hyperdrive.configs.delete(hyperdrive_id, \*, account_id) -> object
- client.hyperdrive.configs.edit(hyperdrive_id, \*, account_id, \*\*params) -> Hyperdrive
- client.hyperdrive.configs.get(hyperdrive_id, \*, account_id) -> Hyperdrive
# RUM
## SiteInfo
Types:
```python
from cloudflare.types.rum import Site, SiteInfoDeleteResponse
```
Methods:
- client.rum.site_info.create(\*, account_id, \*\*params) -> Optional[Site]
- client.rum.site_info.update(site_id, \*, account_id, \*\*params) -> Optional[Site]
- client.rum.site_info.list(\*, account_id, \*\*params) -> SyncV4PagePaginationArray[Site]
- client.rum.site_info.delete(site_id, \*, account_id) -> Optional[SiteInfoDeleteResponse]
- client.rum.site_info.get(site_id, \*, account_id) -> Optional[Site]
## Rules
Types:
```python
from cloudflare.types.rum import (
RUMRule,
RuleListResponse,
RuleDeleteResponse,
RuleBulkCreateResponse,
)
```
Methods:
- client.rum.rules.create(ruleset_id, \*, account_id, \*\*params) -> Optional[RUMRule]
- client.rum.rules.update(rule_id, \*, account_id, ruleset_id, \*\*params) -> Optional[RUMRule]
- client.rum.rules.list(ruleset_id, \*, account_id) -> Optional[RuleListResponse]
- client.rum.rules.delete(rule_id, \*, account_id, ruleset_id) -> Optional[RuleDeleteResponse]
- client.rum.rules.bulk_create(ruleset_id, \*, account_id, \*\*params) -> Optional[RuleBulkCreateResponse]
# Vectorize
## Indexes
Types:
```python
from cloudflare.types.vectorize import (
CreateIndex,
IndexDeleteVectorsByID,
IndexDimensionConfiguration,
IndexInsert,
IndexQuery,
IndexUpsert,
IndexDeleteResponse,
IndexDeleteByIDsResponse,
IndexInfoResponse,
IndexInsertResponse,
IndexQueryResponse,
IndexUpsertResponse,
)
```
Methods:
- client.vectorize.indexes.create(\*, account_id, \*\*params) -> Optional[CreateIndex]
- client.vectorize.indexes.list(\*, account_id) -> SyncSinglePage[CreateIndex]
- client.vectorize.indexes.delete(index_name, \*, account_id) -> Optional[IndexDeleteResponse]
- client.vectorize.indexes.delete_by_ids(index_name, \*, account_id, \*\*params) -> Optional[IndexDeleteByIDsResponse]
- client.vectorize.indexes.get(index_name, \*, account_id) -> Optional[CreateIndex]
- client.vectorize.indexes.get_by_ids(index_name, \*, account_id, \*\*params) -> object
- client.vectorize.indexes.info(index_name, \*, account_id) -> Optional[IndexInfoResponse]
- client.vectorize.indexes.insert(index_name, \*, account_id, \*\*params) -> Optional[IndexInsertResponse]
- client.vectorize.indexes.query(index_name, \*, account_id, \*\*params) -> Optional[IndexQueryResponse]
- client.vectorize.indexes.upsert(index_name, \*, account_id, \*\*params) -> Optional[IndexUpsertResponse]
### MetadataIndex
Types:
```python
from cloudflare.types.vectorize.indexes import (
MetadataIndexCreateResponse,
MetadataIndexListResponse,
MetadataIndexDeleteResponse,
)
```
Methods:
- client.vectorize.indexes.metadata_index.create(index_name, \*, account_id, \*\*params) -> Optional[MetadataIndexCreateResponse]
- client.vectorize.indexes.metadata_index.list(index_name, \*, account_id) -> Optional[MetadataIndexListResponse]
- client.vectorize.indexes.metadata_index.delete(index_name, \*, account_id, \*\*params) -> Optional[MetadataIndexDeleteResponse]
# URLScanner
Types:
```python
from cloudflare.types.url_scanner import URLScannerDomain, URLScannerTask
```
## Responses
Types:
```python
from cloudflare.types.url_scanner import ResponseGetResponse
```
Methods:
- client.url_scanner.responses.get(response_id, \*, account_id) -> str
## Scans
Types:
```python
from cloudflare.types.url_scanner import (
ScanCreateResponse,
ScanListResponse,
ScanBulkCreateResponse,
ScanDOMResponse,
ScanGetResponse,
ScanHARResponse,
)
```
Methods:
- client.url_scanner.scans.create(\*, account_id, \*\*params) -> ScanCreateResponse
- client.url_scanner.scans.list(\*, account_id, \*\*params) -> ScanListResponse
- client.url_scanner.scans.bulk_create(\*, account_id, \*\*params) -> ScanBulkCreateResponse
- client.url_scanner.scans.dom(scan_id, \*, account_id) -> str
- client.url_scanner.scans.get(scan_id, \*, account_id) -> ScanGetResponse
- client.url_scanner.scans.har(scan_id, \*, account_id) -> ScanHARResponse
- client.url_scanner.scans.screenshot(scan_id, \*, account_id, \*\*params) -> BinaryAPIResponse
# Radar
## AI
### ToMarkdown
Types:
```python
from cloudflare.types.radar.ai import ToMarkdownCreateResponse
```
Methods:
- client.radar.ai.to_markdown.create(\*, account_id, \*\*params) -> SyncSinglePage[ToMarkdownCreateResponse]
### Inference
#### Summary
Types:
```python
from cloudflare.types.radar.ai.inference import SummaryModelResponse, SummaryTaskResponse
```
Methods:
- client.radar.ai.inference.summary.model(\*\*params) -> SummaryModelResponse
- client.radar.ai.inference.summary.task(\*\*params) -> SummaryTaskResponse
#### TimeseriesGroups
##### Summary
Types:
```python
from cloudflare.types.radar.ai.inference.timeseries_groups import (
SummaryModelResponse,
SummaryTaskResponse,
)
```
Methods:
- client.radar.ai.inference.timeseries_groups.summary.model(\*\*params) -> SummaryModelResponse
- client.radar.ai.inference.timeseries_groups.summary.task(\*\*params) -> SummaryTaskResponse
### Bots
#### Summary
Types:
```python
from cloudflare.types.radar.ai.bots import SummaryUserAgentResponse
```
Methods:
- client.radar.ai.bots.summary.user_agent(\*\*params) -> SummaryUserAgentResponse
### TimeseriesGroups
Types:
```python
from cloudflare.types.radar.ai import TimeseriesGroupUserAgentResponse
```
Methods:
- client.radar.ai.timeseries_groups.user_agent(\*\*params) -> TimeseriesGroupUserAgentResponse
## Annotations
Types:
```python
from cloudflare.types.radar import AnnotationListResponse
```
Methods:
- client.radar.annotations.list(\*\*params) -> AnnotationListResponse
### Outages
Types:
```python
from cloudflare.types.radar.annotations import OutageGetResponse, OutageLocationsResponse
```
Methods:
- client.radar.annotations.outages.get(\*\*params) -> OutageGetResponse
- client.radar.annotations.outages.locations(\*\*params) -> OutageLocationsResponse
## BGP
Types:
```python
from cloudflare.types.radar import BGPTimeseriesResponse
```
Methods:
- client.radar.bgp.timeseries(\*\*params) -> BGPTimeseriesResponse
### Leaks
#### Events
Types:
```python
from cloudflare.types.radar.bgp.leaks import EventListResponse
```
Methods:
- client.radar.bgp.leaks.events.list(\*\*params) -> SyncV4PagePagination[EventListResponse]
### Top
Types:
```python
from cloudflare.types.radar.bgp import TopPrefixesResponse
```
Methods:
- client.radar.bgp.top.prefixes(\*\*params) -> TopPrefixesResponse
#### Ases
Types:
```python
from cloudflare.types.radar.bgp.top import AseGetResponse, AsePrefixesResponse
```
Methods:
- client.radar.bgp.top.ases.get(\*\*params) -> AseGetResponse
- client.radar.bgp.top.ases.prefixes(\*\*params) -> AsePrefixesResponse
### Hijacks
#### Events
Types:
```python
from cloudflare.types.radar.bgp.hijacks import EventListResponse
```
Methods:
- client.radar.bgp.hijacks.events.list(\*\*params) -> SyncV4PagePagination[EventListResponse]
### Routes
Types:
```python
from cloudflare.types.radar.bgp import (
RouteAsesResponse,
RouteMoasResponse,
RoutePfx2asResponse,
RouteRealtimeResponse,
RouteStatsResponse,
)
```
Methods:
- client.radar.bgp.routes.ases(\*\*params) -> RouteAsesResponse
- client.radar.bgp.routes.moas(\*\*params) -> RouteMoasResponse
- client.radar.bgp.routes.pfx2as(\*\*params) -> RoutePfx2asResponse
- client.radar.bgp.routes.realtime(\*\*params) -> RouteRealtimeResponse
- client.radar.bgp.routes.stats(\*\*params) -> RouteStatsResponse
### IPs
Types:
```python
from cloudflare.types.radar.bgp import IPTimeseriesResponse
```
Methods:
- client.radar.bgp.ips.timeseries(\*\*params) -> IPTimeseriesResponse
## Datasets
Types:
```python
from cloudflare.types.radar import DatasetListResponse, DatasetDownloadResponse, DatasetGetResponse
```
Methods:
- client.radar.datasets.list(\*\*params) -> DatasetListResponse
- client.radar.datasets.download(\*\*params) -> DatasetDownloadResponse
- client.radar.datasets.get(alias) -> str
## DNS
Types:
```python
from cloudflare.types.radar import DNSTimeseriesResponse
```
Methods:
- client.radar.dns.timeseries(\*\*params) -> DNSTimeseriesResponse
### Top
Types:
```python
from cloudflare.types.radar.dns import TopAsesResponse, TopLocationsResponse
```
Methods:
- client.radar.dns.top.ases(\*\*params) -> TopAsesResponse
- client.radar.dns.top.locations(\*\*params) -> TopLocationsResponse
### Summary
Types:
```python
from cloudflare.types.radar.dns import (
SummaryCacheHitResponse,
SummaryDNSSECResponse,
SummaryDNSSECAwareResponse,
SummaryDNSSECE2EResponse,
SummaryIPVersionResponse,
SummaryMatchingAnswerResponse,
SummaryProtocolResponse,
SummaryQueryTypeResponse,
SummaryResponseCodeResponse,
SummaryResponseTTLResponse,
)
```
Methods:
- client.radar.dns.summary.cache_hit(\*\*params) -> SummaryCacheHitResponse
- client.radar.dns.summary.dnssec(\*\*params) -> SummaryDNSSECResponse
- client.radar.dns.summary.dnssec_aware(\*\*params) -> SummaryDNSSECAwareResponse
- client.radar.dns.summary.dnssec_e2e(\*\*params) -> SummaryDNSSECE2EResponse
- client.radar.dns.summary.ip_version(\*\*params) -> SummaryIPVersionResponse
- client.radar.dns.summary.matching_answer(\*\*params) -> SummaryMatchingAnswerResponse
- client.radar.dns.summary.protocol(\*\*params) -> SummaryProtocolResponse
- client.radar.dns.summary.query_type(\*\*params) -> SummaryQueryTypeResponse
- client.radar.dns.summary.response_code(\*\*params) -> SummaryResponseCodeResponse
- client.radar.dns.summary.response_ttl(\*\*params) -> SummaryResponseTTLResponse
### TimeseriesGroups
Types:
```python
from cloudflare.types.radar.dns import (
TimeseriesGroupCacheHitResponse,
TimeseriesGroupDNSSECResponse,
TimeseriesGroupDNSSECAwareResponse,
TimeseriesGroupDNSSECE2EResponse,
TimeseriesGroupIPVersionResponse,
TimeseriesGroupMatchingAnswerResponse,
TimeseriesGroupProtocolResponse,
TimeseriesGroupQueryTypeResponse,
TimeseriesGroupResponseCodeResponse,
TimeseriesGroupResponseTTLResponse,
)
```
Methods:
- client.radar.dns.timeseries_groups.cache_hit(\*\*params) -> TimeseriesGroupCacheHitResponse
- client.radar.dns.timeseries_groups.dnssec(\*\*params) -> TimeseriesGroupDNSSECResponse
- client.radar.dns.timeseries_groups.dnssec_aware(\*\*params) -> TimeseriesGroupDNSSECAwareResponse
- client.radar.dns.timeseries_groups.dnssec_e2e(\*\*params) -> TimeseriesGroupDNSSECE2EResponse
- client.radar.dns.timeseries_groups.ip_version(\*\*params) -> TimeseriesGroupIPVersionResponse
- client.radar.dns.timeseries_groups.matching_answer(\*\*params) -> TimeseriesGroupMatchingAnswerResponse
- client.radar.dns.timeseries_groups.protocol(\*\*params) -> TimeseriesGroupProtocolResponse
- client.radar.dns.timeseries_groups.query_type(\*\*params) -> TimeseriesGroupQueryTypeResponse
- client.radar.dns.timeseries_groups.response_code(\*\*params) -> TimeseriesGroupResponseCodeResponse
- client.radar.dns.timeseries_groups.response_ttl(\*\*params) -> TimeseriesGroupResponseTTLResponse
## Netflows
Types:
```python
from cloudflare.types.radar import NetflowSummaryResponse, NetflowTimeseriesResponse
```
Methods:
- client.radar.netflows.summary(\*\*params) -> NetflowSummaryResponse
- client.radar.netflows.timeseries(\*\*params) -> NetflowTimeseriesResponse
### Top
Types:
```python
from cloudflare.types.radar.netflows import TopAsesResponse, TopLocationsResponse
```
Methods:
- client.radar.netflows.top.ases(\*\*params) -> TopAsesResponse
- client.radar.netflows.top.locations(\*\*params) -> TopLocationsResponse
## Search
Types:
```python
from cloudflare.types.radar import SearchGlobalResponse
```
Methods:
- client.radar.search.global\_(\*\*params) -> SearchGlobalResponse
## VerifiedBots
### Top
Types:
```python
from cloudflare.types.radar.verified_bots import TopBotsResponse, TopCategoriesResponse
```
Methods:
- client.radar.verified_bots.top.bots(\*\*params) -> TopBotsResponse
- client.radar.verified_bots.top.categories(\*\*params) -> TopCategoriesResponse
## AS112
Types:
```python
from cloudflare.types.radar import AS112TimeseriesResponse
```
Methods:
- client.radar.as112.timeseries(\*\*params) -> AS112TimeseriesResponse
### Summary
Types:
```python
from cloudflare.types.radar.as112 import (
SummaryDNSSECResponse,
SummaryEdnsResponse,
SummaryIPVersionResponse,
SummaryProtocolResponse,
SummaryQueryTypeResponse,
SummaryResponseCodesResponse,
)
```
Methods:
- client.radar.as112.summary.dnssec(\*\*params) -> SummaryDNSSECResponse
- client.radar.as112.summary.edns(\*\*params) -> SummaryEdnsResponse
- client.radar.as112.summary.ip_version(\*\*params) -> SummaryIPVersionResponse
- client.radar.as112.summary.protocol(\*\*params) -> SummaryProtocolResponse
- client.radar.as112.summary.query_type(\*\*params) -> SummaryQueryTypeResponse
- client.radar.as112.summary.response_codes(\*\*params) -> SummaryResponseCodesResponse
### TimeseriesGroups
Types:
```python
from cloudflare.types.radar.as112 import (
TimeseriesGroupDNSSECResponse,
TimeseriesGroupEdnsResponse,
TimeseriesGroupIPVersionResponse,
TimeseriesGroupProtocolResponse,
TimeseriesGroupQueryTypeResponse,
TimeseriesGroupResponseCodesResponse,
)
```
Methods:
- client.radar.as112.timeseries_groups.dnssec(\*\*params) -> TimeseriesGroupDNSSECResponse
- client.radar.as112.timeseries_groups.edns(\*\*params) -> TimeseriesGroupEdnsResponse
- client.radar.as112.timeseries_groups.ip_version(\*\*params) -> TimeseriesGroupIPVersionResponse
- client.radar.as112.timeseries_groups.protocol(\*\*params) -> TimeseriesGroupProtocolResponse
- client.radar.as112.timeseries_groups.query_type(\*\*params) -> TimeseriesGroupQueryTypeResponse
- client.radar.as112.timeseries_groups.response_codes(\*\*params) -> TimeseriesGroupResponseCodesResponse
### Top
Types:
```python
from cloudflare.types.radar.as112 import (
TopDNSSECResponse,
TopEdnsResponse,
TopIPVersionResponse,
TopLocationsResponse,
)
```
Methods:
- client.radar.as112.top.dnssec(dnssec, \*\*params) -> TopDNSSECResponse
- client.radar.as112.top.edns(edns, \*\*params) -> TopEdnsResponse
- client.radar.as112.top.ip_version(ip_version, \*\*params) -> TopIPVersionResponse
- client.radar.as112.top.locations(\*\*params) -> TopLocationsResponse
## Email
Types:
```python
from cloudflare.types.radar import RadarEmailSeries, RadarEmailSummary
```
### Routing
#### Summary
Types:
```python
from cloudflare.types.radar.email.routing import (
SummaryARCResponse,
SummaryDKIMResponse,
SummaryDMARCResponse,
SummaryEncryptedResponse,
SummaryIPVersionResponse,
SummarySPFResponse,
)
```
Methods:
- client.radar.email.routing.summary.arc(\*\*params) -> SummaryARCResponse
- client.radar.email.routing.summary.dkim(\*\*params) -> SummaryDKIMResponse
- client.radar.email.routing.summary.dmarc(\*\*params) -> SummaryDMARCResponse
- client.radar.email.routing.summary.encrypted(\*\*params) -> SummaryEncryptedResponse
- client.radar.email.routing.summary.ip_version(\*\*params) -> SummaryIPVersionResponse
- client.radar.email.routing.summary.spf(\*\*params) -> SummarySPFResponse
#### TimeseriesGroups
Types:
```python
from cloudflare.types.radar.email.routing import (
TimeseriesGroupARCResponse,
TimeseriesGroupDKIMResponse,
TimeseriesGroupDMARCResponse,
TimeseriesGroupEncryptedResponse,
TimeseriesGroupIPVersionResponse,
TimeseriesGroupSPFResponse,
)
```
Methods:
- client.radar.email.routing.timeseries_groups.arc(\*\*params) -> TimeseriesGroupARCResponse
- client.radar.email.routing.timeseries_groups.dkim(\*\*params) -> TimeseriesGroupDKIMResponse
- client.radar.email.routing.timeseries_groups.dmarc(\*\*params) -> TimeseriesGroupDMARCResponse
- client.radar.email.routing.timeseries_groups.encrypted(\*\*params) -> TimeseriesGroupEncryptedResponse
- client.radar.email.routing.timeseries_groups.ip_version(\*\*params) -> TimeseriesGroupIPVersionResponse
- client.radar.email.routing.timeseries_groups.spf(\*\*params) -> TimeseriesGroupSPFResponse
### Security
#### Top
##### Tlds
Types:
```python
from cloudflare.types.radar.email.security.top import TldGetResponse
```
Methods:
- client.radar.email.security.top.tlds.get(\*\*params) -> TldGetResponse
###### Malicious
Types:
```python
from cloudflare.types.radar.email.security.top.tlds import MaliciousGetResponse
```
Methods:
- client.radar.email.security.top.tlds.malicious.get(malicious, \*\*params) -> MaliciousGetResponse
###### Spam
Types:
```python
from cloudflare.types.radar.email.security.top.tlds import SpamGetResponse
```
Methods:
- client.radar.email.security.top.tlds.spam.get(spam, \*\*params) -> SpamGetResponse
###### Spoof
Types:
```python
from cloudflare.types.radar.email.security.top.tlds import SpoofGetResponse
```
Methods:
- client.radar.email.security.top.tlds.spoof.get(spoof, \*\*params) -> SpoofGetResponse
#### Summary
Types:
```python
from cloudflare.types.radar.email.security import (
SummaryARCResponse,
SummaryDKIMResponse,
SummaryDMARCResponse,
SummaryMaliciousResponse,
SummarySpamResponse,
SummarySPFResponse,
SummarySpoofResponse,
SummaryThreatCategoryResponse,
SummaryTLSVersionResponse,
)
```
Methods:
- client.radar.email.security.summary.arc(\*\*params) -> SummaryARCResponse
- client.radar.email.security.summary.dkim(\*\*params) -> SummaryDKIMResponse
- client.radar.email.security.summary.dmarc(\*\*params) -> SummaryDMARCResponse
- client.radar.email.security.summary.malicious(\*\*params) -> SummaryMaliciousResponse
- client.radar.email.security.summary.spam(\*\*params) -> SummarySpamResponse
- client.radar.email.security.summary.spf(\*\*params) -> SummarySPFResponse
- client.radar.email.security.summary.spoof(\*\*params) -> SummarySpoofResponse
- client.radar.email.security.summary.threat_category(\*\*params) -> SummaryThreatCategoryResponse
- client.radar.email.security.summary.tls_version(\*\*params) -> SummaryTLSVersionResponse
#### TimeseriesGroups
Types:
```python
from cloudflare.types.radar.email.security import (
TimeseriesGroupARCResponse,
TimeseriesGroupDKIMResponse,
TimeseriesGroupDMARCResponse,
TimeseriesGroupMaliciousResponse,
TimeseriesGroupSpamResponse,
TimeseriesGroupSPFResponse,
TimeseriesGroupSpoofResponse,
TimeseriesGroupThreatCategoryResponse,
TimeseriesGroupTLSVersionResponse,
)
```
Methods:
- client.radar.email.security.timeseries_groups.arc(\*\*params) -> TimeseriesGroupARCResponse
- client.radar.email.security.timeseries_groups.dkim(\*\*params) -> TimeseriesGroupDKIMResponse
- client.radar.email.security.timeseries_groups.dmarc(\*\*params) -> TimeseriesGroupDMARCResponse
- client.radar.email.security.timeseries_groups.malicious(\*\*params) -> TimeseriesGroupMaliciousResponse
- client.radar.email.security.timeseries_groups.spam(\*\*params) -> TimeseriesGroupSpamResponse
- client.radar.email.security.timeseries_groups.spf(\*\*params) -> TimeseriesGroupSPFResponse
- client.radar.email.security.timeseries_groups.spoof(\*\*params) -> TimeseriesGroupSpoofResponse
- client.radar.email.security.timeseries_groups.threat_category(\*\*params) -> TimeseriesGroupThreatCategoryResponse
- client.radar.email.security.timeseries_groups.tls_version(\*\*params) -> TimeseriesGroupTLSVersionResponse
## Attacks
### Layer3
Types:
```python
from cloudflare.types.radar.attacks import Layer3TimeseriesResponse
```
Methods:
- client.radar.attacks.layer3.timeseries(\*\*params) -> Layer3TimeseriesResponse
#### Summary
Types:
```python
from cloudflare.types.radar.attacks.layer3 import (
SummaryBitrateResponse,
SummaryDurationResponse,
SummaryIndustryResponse,
SummaryIPVersionResponse,
SummaryProtocolResponse,
SummaryVectorResponse,
SummaryVerticalResponse,
)
```
Methods:
- client.radar.attacks.layer3.summary.bitrate(\*\*params) -> SummaryBitrateResponse
- client.radar.attacks.layer3.summary.duration(\*\*params) -> SummaryDurationResponse
- client.radar.attacks.layer3.summary.industry(\*\*params) -> SummaryIndustryResponse
- client.radar.attacks.layer3.summary.ip_version(\*\*params) -> SummaryIPVersionResponse
- client.radar.attacks.layer3.summary.protocol(\*\*params) -> SummaryProtocolResponse
- client.radar.attacks.layer3.summary.vector(\*\*params) -> SummaryVectorResponse
- client.radar.attacks.layer3.summary.vertical(\*\*params) -> SummaryVerticalResponse
#### TimeseriesGroups
Types:
```python
from cloudflare.types.radar.attacks.layer3 import (
TimeseriesGroupBitrateResponse,
TimeseriesGroupDurationResponse,
TimeseriesGroupIndustryResponse,
TimeseriesGroupIPVersionResponse,
TimeseriesGroupProtocolResponse,
TimeseriesGroupVectorResponse,
TimeseriesGroupVerticalResponse,
)
```
Methods:
- client.radar.attacks.layer3.timeseries_groups.bitrate(\*\*params) -> TimeseriesGroupBitrateResponse
- client.radar.attacks.layer3.timeseries_groups.duration(\*\*params) -> TimeseriesGroupDurationResponse
- client.radar.attacks.layer3.timeseries_groups.industry(\*\*params) -> TimeseriesGroupIndustryResponse
- client.radar.attacks.layer3.timeseries_groups.ip_version(\*\*params) -> TimeseriesGroupIPVersionResponse
- client.radar.attacks.layer3.timeseries_groups.protocol(\*\*params) -> TimeseriesGroupProtocolResponse
- client.radar.attacks.layer3.timeseries_groups.vector(\*\*params) -> TimeseriesGroupVectorResponse
- client.radar.attacks.layer3.timeseries_groups.vertical(\*\*params) -> TimeseriesGroupVerticalResponse
#### Top
Types:
```python
from cloudflare.types.radar.attacks.layer3 import (
TopAttacksResponse,
TopIndustryResponse,
TopVerticalResponse,
)
```
Methods:
- client.radar.attacks.layer3.top.attacks(\*\*params) -> TopAttacksResponse
- client.radar.attacks.layer3.top.industry(\*\*params) -> TopIndustryResponse
- client.radar.attacks.layer3.top.vertical(\*\*params) -> TopVerticalResponse
##### Locations
Types:
```python
from cloudflare.types.radar.attacks.layer3.top import LocationOriginResponse, LocationTargetResponse
```
Methods:
- client.radar.attacks.layer3.top.locations.origin(\*\*params) -> LocationOriginResponse
- client.radar.attacks.layer3.top.locations.target(\*\*params) -> LocationTargetResponse
### Layer7
Types:
```python
from cloudflare.types.radar.attacks import Layer7TimeseriesResponse
```
Methods:
- client.radar.attacks.layer7.timeseries(\*\*params) -> Layer7TimeseriesResponse
#### Summary
Types:
```python
from cloudflare.types.radar.attacks.layer7 import (
SummaryHTTPMethodResponse,
SummaryHTTPVersionResponse,
SummaryIndustryResponse,
SummaryIPVersionResponse,
SummaryManagedRulesResponse,
SummaryMitigationProductResponse,
SummaryVerticalResponse,
)
```
Methods:
- client.radar.attacks.layer7.summary.http_method(\*\*params) -> SummaryHTTPMethodResponse
- client.radar.attacks.layer7.summary.http_version(\*\*params) -> SummaryHTTPVersionResponse
- client.radar.attacks.layer7.summary.industry(\*\*params) -> SummaryIndustryResponse
- client.radar.attacks.layer7.summary.ip_version(\*\*params) -> SummaryIPVersionResponse
- client.radar.attacks.layer7.summary.managed_rules(\*\*params) -> SummaryManagedRulesResponse
- client.radar.attacks.layer7.summary.mitigation_product(\*\*params) -> SummaryMitigationProductResponse
- client.radar.attacks.layer7.summary.vertical(\*\*params) -> SummaryVerticalResponse
#### TimeseriesGroups
Types:
```python
from cloudflare.types.radar.attacks.layer7 import (
TimeseriesGroupHTTPMethodResponse,
TimeseriesGroupHTTPVersionResponse,
TimeseriesGroupIndustryResponse,
TimeseriesGroupIPVersionResponse,
TimeseriesGroupManagedRulesResponse,
TimeseriesGroupMitigationProductResponse,
TimeseriesGroupVerticalResponse,
)
```
Methods:
- client.radar.attacks.layer7.timeseries_groups.http_method(\*\*params) -> TimeseriesGroupHTTPMethodResponse
- client.radar.attacks.layer7.timeseries_groups.http_version(\*\*params) -> TimeseriesGroupHTTPVersionResponse
- client.radar.attacks.layer7.timeseries_groups.industry(\*\*params) -> TimeseriesGroupIndustryResponse
- client.radar.attacks.layer7.timeseries_groups.ip_version(\*\*params) -> TimeseriesGroupIPVersionResponse
- client.radar.attacks.layer7.timeseries_groups.managed_rules(\*\*params) -> TimeseriesGroupManagedRulesResponse
- client.radar.attacks.layer7.timeseries_groups.mitigation_product(\*\*params) -> TimeseriesGroupMitigationProductResponse
- client.radar.attacks.layer7.timeseries_groups.vertical(\*\*params) -> TimeseriesGroupVerticalResponse
#### Top
Types:
```python
from cloudflare.types.radar.attacks.layer7 import (
TopAttacksResponse,
TopIndustryResponse,
TopVerticalResponse,
)
```
Methods:
- client.radar.attacks.layer7.top.attacks(\*\*params) -> TopAttacksResponse
- client.radar.attacks.layer7.top.industry(\*\*params) -> TopIndustryResponse
- client.radar.attacks.layer7.top.vertical(\*\*params) -> TopVerticalResponse
##### Locations
Types:
```python
from cloudflare.types.radar.attacks.layer7.top import LocationOriginResponse, LocationTargetResponse
```
Methods:
- client.radar.attacks.layer7.top.locations.origin(\*\*params) -> LocationOriginResponse
- client.radar.attacks.layer7.top.locations.target(\*\*params) -> LocationTargetResponse
##### Ases
Types:
```python
from cloudflare.types.radar.attacks.layer7.top import AseOriginResponse
```
Methods:
- client.radar.attacks.layer7.top.ases.origin(\*\*params) -> AseOriginResponse
## Entities
Types:
```python
from cloudflare.types.radar import EntityGetResponse
```
Methods:
- client.radar.entities.get(\*\*params) -> EntityGetResponse
### ASNs
Types:
```python
from cloudflare.types.radar.entities import (
ASNListResponse,
ASNGetResponse,
ASNIPResponse,
ASNRelResponse,
)
```
Methods:
- client.radar.entities.asns.list(\*\*params) -> ASNListResponse
- client.radar.entities.asns.get(asn, \*\*params) -> ASNGetResponse
- client.radar.entities.asns.ip(\*\*params) -> ASNIPResponse
- client.radar.entities.asns.rel(asn, \*\*params) -> ASNRelResponse
### Locations
Types:
```python
from cloudflare.types.radar.entities import LocationListResponse, LocationGetResponse
```
Methods:
- client.radar.entities.locations.list(\*\*params) -> LocationListResponse
- client.radar.entities.locations.get(location, \*\*params) -> LocationGetResponse
## HTTP
Types:
```python
from cloudflare.types.radar import HTTPTimeseriesResponse
```
Methods:
- client.radar.http.timeseries(\*\*params) -> HTTPTimeseriesResponse
### Locations
Types:
```python
from cloudflare.types.radar.http import LocationGetResponse
```
Methods:
- client.radar.http.locations.get(\*\*params) -> LocationGetResponse
#### BotClass
Types:
```python
from cloudflare.types.radar.http.locations import BotClassGetResponse
```
Methods:
- client.radar.http.locations.bot_class.get(bot_class, \*\*params) -> BotClassGetResponse
#### DeviceType
Types:
```python
from cloudflare.types.radar.http.locations import DeviceTypeGetResponse
```
Methods:
- client.radar.http.locations.device_type.get(device_type, \*\*params) -> DeviceTypeGetResponse
#### HTTPProtocol
Types:
```python
from cloudflare.types.radar.http.locations import HTTPProtocolGetResponse
```
Methods:
- client.radar.http.locations.http_protocol.get(http_protocol, \*\*params) -> HTTPProtocolGetResponse
#### HTTPMethod
Types:
```python
from cloudflare.types.radar.http.locations import HTTPMethodGetResponse
```
Methods:
- client.radar.http.locations.http_method.get(http_version, \*\*params) -> HTTPMethodGetResponse
#### IPVersion
Types:
```python
from cloudflare.types.radar.http.locations import IPVersionGetResponse
```
Methods:
- client.radar.http.locations.ip_version.get(ip_version, \*\*params) -> IPVersionGetResponse
#### OS
Types:
```python
from cloudflare.types.radar.http.locations import OSGetResponse
```
Methods:
- client.radar.http.locations.os.get(os, \*\*params) -> OSGetResponse
#### TLSVersion
Types:
```python
from cloudflare.types.radar.http.locations import TLSVersionGetResponse
```
Methods:
- client.radar.http.locations.tls_version.get(tls_version, \*\*params) -> TLSVersionGetResponse
#### BrowserFamily
Types:
```python
from cloudflare.types.radar.http.locations import BrowserFamilyGetResponse
```
Methods:
- client.radar.http.locations.browser_family.get(browser_family, \*\*params) -> BrowserFamilyGetResponse
### Ases
Types:
```python
from cloudflare.types.radar.http import AseGetResponse
```
Methods:
- client.radar.http.ases.get(\*\*params) -> AseGetResponse
#### BotClass
Types:
```python
from cloudflare.types.radar.http.ases import BotClassGetResponse
```
Methods:
- client.radar.http.ases.bot_class.get(bot_class, \*\*params) -> BotClassGetResponse
#### DeviceType
Types:
```python
from cloudflare.types.radar.http.ases import DeviceTypeGetResponse
```
Methods:
- client.radar.http.ases.device_type.get(device_type, \*\*params) -> DeviceTypeGetResponse
#### HTTPProtocol
Types:
```python
from cloudflare.types.radar.http.ases import HTTPProtocolGetResponse
```
Methods:
- client.radar.http.ases.http_protocol.get(http_protocol, \*\*params) -> HTTPProtocolGetResponse
#### HTTPMethod
Types:
```python
from cloudflare.types.radar.http.ases import HTTPMethodGetResponse
```
Methods:
- client.radar.http.ases.http_method.get(http_version, \*\*params) -> HTTPMethodGetResponse
#### IPVersion
Types:
```python
from cloudflare.types.radar.http.ases import IPVersionGetResponse
```
Methods:
- client.radar.http.ases.ip_version.get(ip_version, \*\*params) -> IPVersionGetResponse
#### OS
Types:
```python
from cloudflare.types.radar.http.ases import OSGetResponse
```
Methods:
- client.radar.http.ases.os.get(os, \*\*params) -> OSGetResponse
#### TLSVersion
Types:
```python
from cloudflare.types.radar.http.ases import TLSVersionGetResponse
```
Methods:
- client.radar.http.ases.tls_version.get(tls_version, \*\*params) -> TLSVersionGetResponse
#### BrowserFamily
Types:
```python
from cloudflare.types.radar.http.ases import BrowserFamilyGetResponse
```
Methods:
- client.radar.http.ases.browser_family.get(browser_family, \*\*params) -> BrowserFamilyGetResponse
### Summary
Types:
```python
from cloudflare.types.radar.http import (
SummaryBotClassResponse,
SummaryDeviceTypeResponse,
SummaryHTTPProtocolResponse,
SummaryHTTPVersionResponse,
SummaryIPVersionResponse,
SummaryOSResponse,
SummaryPostQuantumResponse,
SummaryTLSVersionResponse,
)
```
Methods:
- client.radar.http.summary.bot_class(\*\*params) -> SummaryBotClassResponse
- client.radar.http.summary.device_type(\*\*params) -> SummaryDeviceTypeResponse
- client.radar.http.summary.http_protocol(\*\*params) -> SummaryHTTPProtocolResponse
- client.radar.http.summary.http_version(\*\*params) -> SummaryHTTPVersionResponse
- client.radar.http.summary.ip_version(\*\*params) -> SummaryIPVersionResponse
- client.radar.http.summary.os(\*\*params) -> SummaryOSResponse
- client.radar.http.summary.post_quantum(\*\*params) -> SummaryPostQuantumResponse
- client.radar.http.summary.tls_version(\*\*params) -> SummaryTLSVersionResponse
### TimeseriesGroups
Types:
```python
from cloudflare.types.radar.http import (
TimeseriesGroupBotClassResponse,
TimeseriesGroupBrowserResponse,
TimeseriesGroupBrowserFamilyResponse,
TimeseriesGroupDeviceTypeResponse,
TimeseriesGroupHTTPProtocolResponse,
TimeseriesGroupHTTPVersionResponse,
TimeseriesGroupIPVersionResponse,
TimeseriesGroupOSResponse,
TimeseriesGroupPostQuantumResponse,
TimeseriesGroupTLSVersionResponse,
)
```
Methods:
- client.radar.http.timeseries_groups.bot_class(\*\*params) -> TimeseriesGroupBotClassResponse
- client.radar.http.timeseries_groups.browser(\*\*params) -> TimeseriesGroupBrowserResponse
- client.radar.http.timeseries_groups.browser_family(\*\*params) -> TimeseriesGroupBrowserFamilyResponse
- client.radar.http.timeseries_groups.device_type(\*\*params) -> TimeseriesGroupDeviceTypeResponse
- client.radar.http.timeseries_groups.http_protocol(\*\*params) -> TimeseriesGroupHTTPProtocolResponse
- client.radar.http.timeseries_groups.http_version(\*\*params) -> TimeseriesGroupHTTPVersionResponse
- client.radar.http.timeseries_groups.ip_version(\*\*params) -> TimeseriesGroupIPVersionResponse
- client.radar.http.timeseries_groups.os(\*\*params) -> TimeseriesGroupOSResponse
- client.radar.http.timeseries_groups.post_quantum(\*\*params) -> TimeseriesGroupPostQuantumResponse
- client.radar.http.timeseries_groups.tls_version(\*\*params) -> TimeseriesGroupTLSVersionResponse
### Top
Types:
```python
from cloudflare.types.radar.http import TopBrowserResponse, TopBrowserFamilyResponse
```
Methods:
- client.radar.http.top.browser(\*\*params) -> TopBrowserResponse
- client.radar.http.top.browser_family(\*\*params) -> TopBrowserFamilyResponse
## Quality
### IQI
Types:
```python
from cloudflare.types.radar.quality import IQISummaryResponse, IQITimeseriesGroupsResponse
```
Methods:
- client.radar.quality.iqi.summary(\*\*params) -> IQISummaryResponse
- client.radar.quality.iqi.timeseries_groups(\*\*params) -> IQITimeseriesGroupsResponse
### Speed
Types:
```python
from cloudflare.types.radar.quality import SpeedHistogramResponse, SpeedSummaryResponse
```
Methods:
- client.radar.quality.speed.histogram(\*\*params) -> SpeedHistogramResponse
- client.radar.quality.speed.summary(\*\*params) -> SpeedSummaryResponse
#### Top
Types:
```python
from cloudflare.types.radar.quality.speed import TopAsesResponse, TopLocationsResponse
```
Methods:
- client.radar.quality.speed.top.ases(\*\*params) -> TopAsesResponse
- client.radar.quality.speed.top.locations(\*\*params) -> TopLocationsResponse
## Ranking
Types:
```python
from cloudflare.types.radar import RankingTimeseriesGroupsResponse, RankingTopResponse
```
Methods:
- client.radar.ranking.timeseries_groups(\*\*params) -> RankingTimeseriesGroupsResponse
- client.radar.ranking.top(\*\*params) -> RankingTopResponse
### Domain
Types:
```python
from cloudflare.types.radar.ranking import DomainGetResponse
```
Methods:
- client.radar.ranking.domain.get(domain, \*\*params) -> DomainGetResponse
### InternetServices
Types:
```python
from cloudflare.types.radar.ranking import (
InternetServiceCategoriesResponse,
InternetServiceTimeseriesGroupsResponse,
InternetServiceTopResponse,
)
```
Methods:
- client.radar.ranking.internet_services.categories(\*\*params) -> InternetServiceCategoriesResponse
- client.radar.ranking.internet_services.timeseries_groups(\*\*params) -> InternetServiceTimeseriesGroupsResponse
- client.radar.ranking.internet_services.top(\*\*params) -> InternetServiceTopResponse
## TrafficAnomalies
Types:
```python
from cloudflare.types.radar import TrafficAnomalyGetResponse
```
Methods:
- client.radar.traffic_anomalies.get(\*\*params) -> TrafficAnomalyGetResponse
### Locations
Types:
```python
from cloudflare.types.radar.traffic_anomalies import LocationGetResponse
```
Methods:
- client.radar.traffic_anomalies.locations.get(\*\*params) -> LocationGetResponse
## TCPResetsTimeouts
Types:
```python
from cloudflare.types.radar import (
TCPResetsTimeoutSummaryResponse,
TCPResetsTimeoutTimeseriesGroupsResponse,
)
```
Methods:
- client.radar.tcp_resets_timeouts.summary(\*\*params) -> TCPResetsTimeoutSummaryResponse
- client.radar.tcp_resets_timeouts.timeseries_groups(\*\*params) -> TCPResetsTimeoutTimeseriesGroupsResponse
## RobotsTXT
### Top
Types:
```python
from cloudflare.types.radar.robots_txt import TopDomainCategoriesResponse
```
Methods:
- client.radar.robots_txt.top.domain_categories(\*\*params) -> TopDomainCategoriesResponse
#### UserAgents
Types:
```python
from cloudflare.types.radar.robots_txt.top import UserAgentDirectiveResponse
```
Methods:
- client.radar.robots_txt.top.user_agents.directive(\*\*params) -> UserAgentDirectiveResponse
## LeakedCredentials
### Summary
Types:
```python
from cloudflare.types.radar.leaked_credentials import (
SummaryBotClassResponse,
SummaryCompromisedResponse,
)
```
Methods:
- client.radar.leaked_credentials.summary.bot_class(\*\*params) -> SummaryBotClassResponse
- client.radar.leaked_credentials.summary.compromised(\*\*params) -> SummaryCompromisedResponse
### TimeseriesGroups
Types:
```python
from cloudflare.types.radar.leaked_credentials import (
TimeseriesGroupBotClassResponse,
TimeseriesGroupCompromisedResponse,
)
```
Methods:
- client.radar.leaked_credentials.timeseries_groups.bot_class(\*\*params) -> TimeseriesGroupBotClassResponse
- client.radar.leaked_credentials.timeseries_groups.compromised(\*\*params) -> TimeseriesGroupCompromisedResponse
# BotManagement
Types:
```python
from cloudflare.types.bot_management import (
BotFightModeConfiguration,
SubscriptionConfiguration,
SuperBotFightModeDefinitelyConfiguration,
SuperBotFightModeLikelyConfiguration,
BotManagementUpdateResponse,
BotManagementGetResponse,
)
```
Methods:
- client.bot_management.update(\*, zone_id, \*\*params) -> Optional[BotManagementUpdateResponse]
- client.bot_management.get(\*, zone_id) -> Optional[BotManagementGetResponse]
# OriginPostQuantumEncryption
Types:
```python
from cloudflare.types.origin_post_quantum_encryption import (
OriginPostQuantumEncryptionUpdateResponse,
OriginPostQuantumEncryptionGetResponse,
)
```
Methods:
- client.origin_post_quantum_encryption.update(\*, zone_id, \*\*params) -> Optional[OriginPostQuantumEncryptionUpdateResponse]
- client.origin_post_quantum_encryption.get(\*, zone_id) -> Optional[OriginPostQuantumEncryptionGetResponse]
# Zaraz
Types:
```python
from cloudflare.types.zaraz import ButtonTextTranslation, NeoEvent
```
Methods:
- client.zaraz.update(\*, zone_id, \*\*params) -> Workflow
## Config
Types:
```python
from cloudflare.types.zaraz import Configuration
```
Methods:
- client.zaraz.config.update(\*, zone_id, \*\*params) -> Configuration
- client.zaraz.config.get(\*, zone_id) -> Configuration
## Default
Methods:
- client.zaraz.default.get(\*, zone_id) -> Configuration
## Export
Methods:
- client.zaraz.export.get(\*, zone_id) -> Configuration
## History
Types:
```python
from cloudflare.types.zaraz import HistoryListResponse
```
Methods:
- client.zaraz.history.update(\*, zone_id, \*\*params) -> Configuration
- client.zaraz.history.list(\*, zone_id, \*\*params) -> SyncSinglePage[HistoryListResponse]
### Configs
Types:
```python
from cloudflare.types.zaraz.history import ConfigGetResponse
```
Methods:
- client.zaraz.history.configs.get(\*, zone_id, \*\*params) -> ConfigGetResponse
## Publish
Types:
```python
from cloudflare.types.zaraz import PublishCreateResponse
```
Methods:
- client.zaraz.publish.create(\*, zone_id, \*\*params) -> str
## Workflow
Types:
```python
from cloudflare.types.zaraz import Workflow
```
Methods:
- client.zaraz.workflow.get(\*, zone_id) -> Workflow
# Speed
Types:
```python
from cloudflare.types.speed import LabeledRegion, LighthouseReport, Trend
```
## Schedule
Types:
```python
from cloudflare.types.speed import Schedule, ScheduleCreateResponse, ScheduleDeleteResponse
```
Methods:
- client.speed.schedule.create(url, \*, zone_id, \*\*params) -> Optional[ScheduleCreateResponse]
- client.speed.schedule.delete(url, \*, zone_id, \*\*params) -> Optional[ScheduleDeleteResponse]
- client.speed.schedule.get(url, \*, zone_id, \*\*params) -> Optional[Schedule]
## Availabilities
Types:
```python
from cloudflare.types.speed import Availability
```
Methods:
- client.speed.availabilities.list(\*, zone_id) -> Optional[Availability]
## Pages
Types:
```python
from cloudflare.types.speed import PageListResponse
```
Methods:
- client.speed.pages.list(\*, zone_id) -> SyncSinglePage[PageListResponse]
- client.speed.pages.trend(url, \*, zone_id, \*\*params) -> Optional[Trend]
### Tests
Types:
```python
from cloudflare.types.speed.pages import Test, TestDeleteResponse
```
Methods:
- client.speed.pages.tests.create(url, \*, zone_id, \*\*params) -> Optional[Test]
- client.speed.pages.tests.list(url, \*, zone_id, \*\*params) -> SyncV4PagePaginationArray[Test]
- client.speed.pages.tests.delete(url, \*, zone_id, \*\*params) -> Optional[TestDeleteResponse]
- client.speed.pages.tests.get(test_id, \*, zone_id, url) -> Optional[Test]
# DCVDelegation
Types:
```python
from cloudflare.types.dcv_delegation import DCVDelegationUUID
```
Methods:
- client.dcv_delegation.get(\*, zone_id) -> Optional[DCVDelegationUUID]
# Hostnames
## Settings
### TLS
Types:
```python
from cloudflare.types.hostnames.settings import (
Setting,
SettingValue,
TLSDeleteResponse,
TLSGetResponse,
)
```
Methods:
- client.hostnames.settings.tls.update(hostname, \*, zone_id, setting_id, \*\*params) -> Optional[Setting]
- client.hostnames.settings.tls.delete(hostname, \*, zone_id, setting_id) -> Optional[TLSDeleteResponse]
- client.hostnames.settings.tls.get(setting_id, \*, zone_id) -> SyncSinglePage[TLSGetResponse]
# Snippets
Types:
```python
from cloudflare.types.snippets import Snippet, SnippetDeleteResponse
```
Methods:
- client.snippets.update(snippet_name, \*, zone_id, \*\*params) -> Optional[Snippet]
- client.snippets.list(\*, zone_id) -> SyncSinglePage[Snippet]
- client.snippets.delete(snippet_name, \*, zone_id) -> SnippetDeleteResponse
- client.snippets.get(snippet_name, \*, zone_id) -> Optional[Snippet]
## Content
Methods:
- client.snippets.content.get(snippet_name, \*, zone_id) -> BinaryAPIResponse
## Rules
Types:
```python
from cloudflare.types.snippets import RuleUpdateResponse, RuleListResponse, RuleDeleteResponse
```
Methods:
- client.snippets.rules.update(\*, zone_id, \*\*params) -> SyncSinglePage[RuleUpdateResponse]
- client.snippets.rules.list(\*, zone_id) -> SyncSinglePage[RuleListResponse]
- client.snippets.rules.delete(\*, zone_id) -> RuleDeleteResponse
# Calls
## SFU
Types:
```python
from cloudflare.types.calls import (
SFUCreateResponse,
SFUUpdateResponse,
SFUListResponse,
SFUDeleteResponse,
SFUGetResponse,
)
```
Methods:
- client.calls.sfu.create(\*, account_id, \*\*params) -> Optional[SFUCreateResponse]
- client.calls.sfu.update(app_id, \*, account_id, \*\*params) -> Optional[SFUUpdateResponse]
- client.calls.sfu.list(\*, account_id) -> SyncSinglePage[SFUListResponse]
- client.calls.sfu.delete(app_id, \*, account_id) -> Optional[SFUDeleteResponse]
- client.calls.sfu.get(app_id, \*, account_id) -> Optional[SFUGetResponse]
## TURN
Types:
```python
from cloudflare.types.calls import (
TURNCreateResponse,
TURNUpdateResponse,
TURNListResponse,
TURNDeleteResponse,
TURNGetResponse,
)
```
Methods:
- client.calls.turn.create(\*, account_id, \*\*params) -> TURNCreateResponse
- client.calls.turn.update(key_id, \*, account_id, \*\*params) -> Optional[TURNUpdateResponse]
- client.calls.turn.list(\*, account_id) -> SyncSinglePage[TURNListResponse]
- client.calls.turn.delete(key_id, \*, account_id) -> Optional[TURNDeleteResponse]
- client.calls.turn.get(key_id, \*, account_id) -> Optional[TURNGetResponse]
# CloudforceOne
## Scans
### Results
Types:
```python
from cloudflare.types.cloudforce_one.scans import ScanResult, ResultGetResponse
```
Methods:
- client.cloudforce_one.scans.results.get(config_id, \*, account_id) -> ResultGetResponse
### Config
Types:
```python
from cloudflare.types.cloudforce_one.scans import (
ConfigCreateResponse,
ConfigListResponse,
ConfigEditResponse,
)
```
Methods:
- client.cloudforce_one.scans.config.create(\*, account_id, \*\*params) -> Optional[ConfigCreateResponse]
- client.cloudforce_one.scans.config.list(\*, account_id) -> SyncSinglePage[ConfigListResponse]
- client.cloudforce_one.scans.config.delete(config_id, \*, account_id) -> object
- client.cloudforce_one.scans.config.edit(config_id, \*, account_id, \*\*params) -> Optional[ConfigEditResponse]
## Requests
Types:
```python
from cloudflare.types.cloudforce_one import (
Item,
ListItem,
Quota,
RequestConstants,
RequestTypes,
RequestDeleteResponse,
RequestTypesResponse,
)
```
Methods:
- client.cloudforce_one.requests.create(\*, account_id, \*\*params) -> Optional[Item]
- client.cloudforce_one.requests.update(request_id, \*, account_id, \*\*params) -> Optional[Item]
- client.cloudforce_one.requests.list(\*, account_id, \*\*params) -> SyncSinglePage[ListItem]
- client.cloudforce_one.requests.delete(request_id, \*, account_id) -> RequestDeleteResponse
- client.cloudforce_one.requests.constants(\*, account_id) -> Optional[RequestConstants]
- client.cloudforce_one.requests.get(request_id, \*, account_id) -> Optional[Item]
- client.cloudforce_one.requests.quota(\*, account_id) -> Optional[Quota]
- client.cloudforce_one.requests.types(\*, account_id) -> SyncSinglePage[RequestTypesResponse]
### Message
Types:
```python
from cloudflare.types.cloudforce_one.requests import Message, MessageDeleteResponse
```
Methods:
- client.cloudforce_one.requests.message.create(request_id, \*, account_id, \*\*params) -> Optional[Message]
- client.cloudforce_one.requests.message.update(message_id, \*, account_id, request_id, \*\*params) -> Optional[Message]
- client.cloudforce_one.requests.message.delete(message_id, \*, account_id, request_id) -> MessageDeleteResponse
- client.cloudforce_one.requests.message.get(request_id, \*, account_id, \*\*params) -> SyncSinglePage[Message]
### Priority
Types:
```python
from cloudflare.types.cloudforce_one.requests import (
Label,
Priority,
PriorityEdit,
PriorityDeleteResponse,
)
```
Methods:
- client.cloudforce_one.requests.priority.create(\*, account_id, \*\*params) -> Optional[Priority]
- client.cloudforce_one.requests.priority.update(priority_id, \*, account_id, \*\*params) -> Optional[Item]
- client.cloudforce_one.requests.priority.delete(priority_id, \*, account_id) -> PriorityDeleteResponse
- client.cloudforce_one.requests.priority.get(priority_id, \*, account_id) -> Optional[Item]
- client.cloudforce_one.requests.priority.quota(\*, account_id) -> Optional[Quota]
### Assets
Types:
```python
from cloudflare.types.cloudforce_one.requests import (
AssetCreateResponse,
AssetUpdateResponse,
AssetDeleteResponse,
AssetGetResponse,
)
```
Methods:
- client.cloudforce_one.requests.assets.create(request_id, \*, account_id, \*\*params) -> SyncSinglePage[AssetCreateResponse]
- client.cloudforce_one.requests.assets.update(asset_id, \*, account_id, request_id, \*\*params) -> Optional[AssetUpdateResponse]
- client.cloudforce_one.requests.assets.delete(asset_id, \*, account_id, request_id) -> AssetDeleteResponse
- client.cloudforce_one.requests.assets.get(asset_id, \*, account_id, request_id) -> SyncSinglePage[AssetGetResponse]
## ThreatEvents
Types:
```python
from cloudflare.types.cloudforce_one import (
ThreatEventCreateResponse,
ThreatEventListResponse,
ThreatEventDeleteResponse,
ThreatEventBulkCreateResponse,
ThreatEventEditResponse,
ThreatEventGetResponse,
)
```
Methods:
- client.cloudforce_one.threat_events.create(\*, path_account_id, \*\*params) -> ThreatEventCreateResponse
- client.cloudforce_one.threat_events.list(\*, account_id, \*\*params) -> ThreatEventListResponse
- client.cloudforce_one.threat_events.delete(event_id, \*, account_id) -> ThreatEventDeleteResponse
- client.cloudforce_one.threat_events.bulk_create(\*, account_id, \*\*params) -> ThreatEventBulkCreateResponse
- client.cloudforce_one.threat_events.edit(event_id, \*, account_id, \*\*params) -> ThreatEventEditResponse
- client.cloudforce_one.threat_events.get(event_id, \*, account_id) -> ThreatEventGetResponse
### Attackers
Types:
```python
from cloudflare.types.cloudforce_one.threat_events import AttackerListResponse
```
Methods:
- client.cloudforce_one.threat_events.attackers.list(\*, account_id) -> AttackerListResponse
### Categories
Types:
```python
from cloudflare.types.cloudforce_one.threat_events import (
CategoryCreateResponse,
CategoryListResponse,
CategoryDeleteResponse,
CategoryEditResponse,
CategoryGetResponse,
)
```
Methods:
- client.cloudforce_one.threat_events.categories.create(\*, account_id, \*\*params) -> CategoryCreateResponse
- client.cloudforce_one.threat_events.categories.list(\*, account_id) -> CategoryListResponse
- client.cloudforce_one.threat_events.categories.delete(category_id, \*, account_id) -> CategoryDeleteResponse
- client.cloudforce_one.threat_events.categories.edit(category_id, \*, account_id, \*\*params) -> CategoryEditResponse
- client.cloudforce_one.threat_events.categories.get(category_id, \*, account_id) -> CategoryGetResponse
### Countries
Types:
```python
from cloudflare.types.cloudforce_one.threat_events import CountryListResponse
```
Methods:
- client.cloudforce_one.threat_events.countries.list(\*, account_id) -> CountryListResponse
### Crons
Types:
```python
from cloudflare.types.cloudforce_one.threat_events import CronListResponse, CronEditResponse
```
Methods:
- client.cloudforce_one.threat_events.crons.list(\*, account_id) -> CronListResponse
- client.cloudforce_one.threat_events.crons.edit(\*, account_id) -> CronEditResponse
### Datasets
Types:
```python
from cloudflare.types.cloudforce_one.threat_events import (
DatasetCreateResponse,
DatasetListResponse,
DatasetEditResponse,
DatasetGetResponse,
DatasetRawResponse,
)
```
Methods:
- client.cloudforce_one.threat_events.datasets.create(\*, account_id, \*\*params) -> DatasetCreateResponse
- client.cloudforce_one.threat_events.datasets.list(\*, account_id) -> DatasetListResponse
- client.cloudforce_one.threat_events.datasets.edit(dataset_id, \*, account_id, \*\*params) -> DatasetEditResponse
- client.cloudforce_one.threat_events.datasets.get(dataset_id, \*, account_id) -> DatasetGetResponse
- client.cloudforce_one.threat_events.datasets.raw(event_id, \*, account_id, dataset_id) -> DatasetRawResponse
#### Health
Types:
```python
from cloudflare.types.cloudforce_one.threat_events.datasets import HealthGetResponse
```
Methods:
- client.cloudforce_one.threat_events.datasets.health.get(dataset_id, \*, account_id) -> HealthGetResponse
### IndicatorTypes
Types:
```python
from cloudflare.types.cloudforce_one.threat_events import IndicatorTypeListResponse
```
Methods:
- client.cloudforce_one.threat_events.indicator_types.list(\*, account_id) -> IndicatorTypeListResponse
### Raw
Types:
```python
from cloudflare.types.cloudforce_one.threat_events import RawEditResponse, RawGetResponse
```
Methods:
- client.cloudforce_one.threat_events.raw.edit(raw_id, \*, account_id, event_id, \*\*params) -> RawEditResponse
- client.cloudforce_one.threat_events.raw.get(raw_id, \*, account_id, event_id) -> RawGetResponse
### Relate
Types:
```python
from cloudflare.types.cloudforce_one.threat_events import RelateDeleteResponse
```
Methods:
- client.cloudforce_one.threat_events.relate.delete(event_id, \*, account_id) -> RelateDeleteResponse
### Tags
Types:
```python
from cloudflare.types.cloudforce_one.threat_events import TagCreateResponse
```
Methods:
- client.cloudforce_one.threat_events.tags.create(\*, account_id, \*\*params) -> TagCreateResponse
### EventTags
Types:
```python
from cloudflare.types.cloudforce_one.threat_events import (
EventTagCreateResponse,
EventTagDeleteResponse,
)
```
Methods:
- client.cloudforce_one.threat_events.event_tags.create(event_id, \*, account_id, \*\*params) -> EventTagCreateResponse
- client.cloudforce_one.threat_events.event_tags.delete(event_id, \*, account_id) -> EventTagDeleteResponse
### TargetIndustries
Types:
```python
from cloudflare.types.cloudforce_one.threat_events import TargetIndustryListResponse
```
Methods:
- client.cloudforce_one.threat_events.target_industries.list(\*, account_id) -> TargetIndustryListResponse
### Insights
Types:
```python
from cloudflare.types.cloudforce_one.threat_events import (
InsightCreateResponse,
InsightDeleteResponse,
InsightEditResponse,
InsightGetResponse,
)
```
Methods:
- client.cloudforce_one.threat_events.insights.create(event_id, \*, account_id, \*\*params) -> InsightCreateResponse
- client.cloudforce_one.threat_events.insights.delete(insight_id, \*, account_id, event_id) -> InsightDeleteResponse
- client.cloudforce_one.threat_events.insights.edit(insight_id, \*, account_id, event_id, \*\*params) -> InsightEditResponse
- client.cloudforce_one.threat_events.insights.get(insight_id, \*, account_id, event_id) -> InsightGetResponse
# AIGateway
Types:
```python
from cloudflare.types.ai_gateway import (
AIGatewayCreateResponse,
AIGatewayUpdateResponse,
AIGatewayListResponse,
AIGatewayDeleteResponse,
AIGatewayGetResponse,
)
```
Methods:
- client.ai_gateway.create(\*, account_id, \*\*params) -> AIGatewayCreateResponse
- client.ai_gateway.update(id, \*, account_id, \*\*params) -> AIGatewayUpdateResponse
- client.ai_gateway.list(\*, account_id, \*\*params) -> SyncV4PagePaginationArray[AIGatewayListResponse]
- client.ai_gateway.delete(id, \*, account_id) -> AIGatewayDeleteResponse
- client.ai_gateway.get(id, \*, account_id) -> AIGatewayGetResponse
## EvaluationTypes
Types:
```python
from cloudflare.types.ai_gateway import EvaluationTypeListResponse
```
Methods:
- client.ai_gateway.evaluation_types.list(\*, account_id, \*\*params) -> SyncV4PagePaginationArray[EvaluationTypeListResponse]
## Logs
Types:
```python
from cloudflare.types.ai_gateway import LogListResponse, LogDeleteResponse, LogGetResponse
```
Methods:
- client.ai_gateway.logs.list(gateway_id, \*, account_id, \*\*params) -> SyncV4PagePaginationArray[LogListResponse]
- client.ai_gateway.logs.delete(gateway_id, \*, account_id, \*\*params) -> LogDeleteResponse
- client.ai_gateway.logs.edit(id, \*, account_id, gateway_id, \*\*params) -> object
- client.ai_gateway.logs.get(id, \*, account_id, gateway_id) -> LogGetResponse
- client.ai_gateway.logs.request(id, \*, account_id, gateway_id) -> object
- client.ai_gateway.logs.response(id, \*, account_id, gateway_id) -> object
## Datasets
Types:
```python
from cloudflare.types.ai_gateway import (
DatasetCreateResponse,
DatasetUpdateResponse,
DatasetListResponse,
DatasetDeleteResponse,
DatasetGetResponse,
)
```
Methods:
- client.ai_gateway.datasets.create(gateway_id, \*, account_id, \*\*params) -> DatasetCreateResponse
- client.ai_gateway.datasets.update(id, \*, account_id, gateway_id, \*\*params) -> DatasetUpdateResponse
- client.ai_gateway.datasets.list(gateway_id, \*, account_id, \*\*params) -> SyncV4PagePaginationArray[DatasetListResponse]
- client.ai_gateway.datasets.delete(id, \*, account_id, gateway_id) -> DatasetDeleteResponse
- client.ai_gateway.datasets.get(id, \*, account_id, gateway_id) -> DatasetGetResponse
## Evaluations
Types:
```python
from cloudflare.types.ai_gateway import (
EvaluationCreateResponse,
EvaluationListResponse,
EvaluationDeleteResponse,
EvaluationGetResponse,
)
```
Methods:
- client.ai_gateway.evaluations.create(gateway_id, \*, account_id, \*\*params) -> EvaluationCreateResponse
- client.ai_gateway.evaluations.list(gateway_id, \*, account_id, \*\*params) -> SyncV4PagePaginationArray[EvaluationListResponse]
- client.ai_gateway.evaluations.delete(id, \*, account_id, gateway_id) -> EvaluationDeleteResponse
- client.ai_gateway.evaluations.get(id, \*, account_id, gateway_id) -> EvaluationGetResponse
## URLs
Types:
```python
from cloudflare.types.ai_gateway import URLGetResponse
```
Methods:
- client.ai_gateway.urls.get(provider, \*, account_id, gateway_id) -> str
# IAM
## PermissionGroups
Types:
```python
from cloudflare.types.iam import PermissionGroupListResponse, PermissionGroupGetResponse
```
Methods:
- client.iam.permission_groups.list(\*, account_id, \*\*params) -> SyncV4PagePaginationArray[PermissionGroupListResponse]
- client.iam.permission_groups.get(permission_group_id, \*, account_id) -> PermissionGroupGetResponse
## ResourceGroups
Types:
```python
from cloudflare.types.iam import (
ResourceGroupCreateResponse,
ResourceGroupUpdateResponse,
ResourceGroupListResponse,
ResourceGroupDeleteResponse,
ResourceGroupGetResponse,
)
```
Methods:
- client.iam.resource_groups.create(\*, account_id, \*\*params) -> ResourceGroupCreateResponse
- client.iam.resource_groups.update(resource_group_id, \*, account_id, \*\*params) -> ResourceGroupUpdateResponse
- client.iam.resource_groups.list(\*, account_id, \*\*params) -> SyncV4PagePaginationArray[ResourceGroupListResponse]
- client.iam.resource_groups.delete(resource_group_id, \*, account_id) -> Optional[ResourceGroupDeleteResponse]
- client.iam.resource_groups.get(resource_group_id, \*, account_id) -> ResourceGroupGetResponse
## UserGroups
Types:
```python
from cloudflare.types.iam import (
UserGroupCreateResponse,
UserGroupUpdateResponse,
UserGroupListResponse,
UserGroupDeleteResponse,
UserGroupGetResponse,
)
```
Methods:
- client.iam.user_groups.create(\*, account_id, \*\*params) -> Optional[UserGroupCreateResponse]
- client.iam.user_groups.update(user_group_id, \*, account_id, \*\*params) -> Optional[UserGroupUpdateResponse]
- client.iam.user_groups.list(\*, account_id, \*\*params) -> SyncV4PagePaginationArray[UserGroupListResponse]
- client.iam.user_groups.delete(user_group_id, \*, account_id) -> Optional[UserGroupDeleteResponse]
- client.iam.user_groups.get(user_group_id, \*, account_id) -> Optional[UserGroupGetResponse]
### Members
Types:
```python
from cloudflare.types.iam.user_groups import (
MemberCreateResponse,
MemberUpdateResponse,
MemberListResponse,
MemberDeleteResponse,
)
```
Methods:
- client.iam.user_groups.members.create(user_group_id, \*, account_id, \*\*params) -> Optional[MemberCreateResponse]
- client.iam.user_groups.members.update(user_group_id, \*, account_id, \*\*params) -> SyncSinglePage[MemberUpdateResponse]
- client.iam.user_groups.members.list(user_group_id, \*, account_id, \*\*params) -> SyncV4PagePaginationArray[MemberListResponse]
- client.iam.user_groups.members.delete(member_id, \*, account_id, user_group_id) -> Optional[MemberDeleteResponse]
# CloudConnector
## Rules
Types:
```python
from cloudflare.types.cloud_connector import RuleUpdateResponse, RuleListResponse
```
Methods:
- client.cloud_connector.rules.update(\*, zone_id, \*\*params) -> SyncSinglePage[RuleUpdateResponse]
- client.cloud_connector.rules.list(\*, zone_id) -> SyncSinglePage[RuleListResponse]
# BotnetFeed
## ASN
Types:
```python
from cloudflare.types.botnet_feed import ASNDayReportResponse, ASNFullReportResponse
```
Methods:
- client.botnet_feed.asn.day_report(asn_id, \*, account_id, \*\*params) -> Optional[ASNDayReportResponse]
- client.botnet_feed.asn.full_report(asn_id, \*, account_id) -> Optional[ASNFullReportResponse]
## Configs
### ASN
Types:
```python
from cloudflare.types.botnet_feed.configs import ASNDeleteResponse, ASNGetResponse
```
Methods:
- client.botnet_feed.configs.asn.delete(asn_id, \*, account_id) -> Optional[ASNDeleteResponse]
- client.botnet_feed.configs.asn.get(\*, account_id) -> Optional[ASNGetResponse]
# SecurityTXT
Types:
```python
from cloudflare.types.security_txt import (
SecurityTXTUpdateResponse,
SecurityTXTDeleteResponse,
SecurityTXTGetResponse,
)
```
Methods:
- client.security_txt.update(\*, zone_id, \*\*params) -> SecurityTXTUpdateResponse
- client.security_txt.delete(\*, zone_id) -> SecurityTXTDeleteResponse
- client.security_txt.get(\*, zone_id) -> Optional[SecurityTXTGetResponse]
# Workflows
Types:
```python
from cloudflare.types.workflows import (
WorkflowUpdateResponse,
WorkflowListResponse,
WorkflowDeleteResponse,
WorkflowGetResponse,
)
```
Methods:
- client.workflows.update(workflow_name, \*, account_id, \*\*params) -> WorkflowUpdateResponse
- client.workflows.list(\*, account_id, \*\*params) -> SyncV4PagePaginationArray[WorkflowListResponse]
- client.workflows.delete(workflow_name, \*, account_id) -> WorkflowDeleteResponse
- client.workflows.get(workflow_name, \*, account_id) -> WorkflowGetResponse
## Instances
Types:
```python
from cloudflare.types.workflows import (
InstanceCreateResponse,
InstanceListResponse,
InstanceBulkResponse,
InstanceGetResponse,
)
```
Methods:
- client.workflows.instances.create(workflow_name, \*, account_id, \*\*params) -> InstanceCreateResponse
- client.workflows.instances.list(workflow_name, \*, account_id, \*\*params) -> SyncV4PagePaginationArray[InstanceListResponse]
- client.workflows.instances.bulk(workflow_name, \*, account_id, \*\*params) -> SyncSinglePage[InstanceBulkResponse]
- client.workflows.instances.get(instance_id, \*, account_id, workflow_name) -> InstanceGetResponse
### Status
Types:
```python
from cloudflare.types.workflows.instances import StatusEditResponse
```
Methods:
- client.workflows.instances.status.edit(instance_id, \*, account_id, workflow_name, \*\*params) -> StatusEditResponse
### Events
Methods:
- client.workflows.instances.events.create(event_type, \*, account_id, workflow_name, instance_id, \*\*params) -> object
## Versions
Types:
```python
from cloudflare.types.workflows import VersionListResponse, VersionGetResponse
```
Methods:
- client.workflows.versions.list(workflow_name, \*, account_id, \*\*params) -> SyncV4PagePaginationArray[VersionListResponse]
- client.workflows.versions.get(version_id, \*, account_id, workflow_name) -> VersionGetResponse
# ResourceSharing
Types:
```python
from cloudflare.types.resource_sharing import (
ResourceSharingCreateResponse,
ResourceSharingUpdateResponse,
ResourceSharingListResponse,
ResourceSharingDeleteResponse,
ResourceSharingGetResponse,
)
```
Methods:
- client.resource_sharing.create(\*, account_id, \*\*params) -> Optional[ResourceSharingCreateResponse]
- client.resource_sharing.update(share_id, \*, account_id, \*\*params) -> Optional[ResourceSharingUpdateResponse]
- client.resource_sharing.list(\*, account_id, \*\*params) -> SyncV4PagePaginationArray[ResourceSharingListResponse]
- client.resource_sharing.delete(share_id, \*, account_id) -> Optional[ResourceSharingDeleteResponse]
- client.resource_sharing.get(share_id, \*, account_id) -> Optional[ResourceSharingGetResponse]
## Recipients
Types:
```python
from cloudflare.types.resource_sharing import (
RecipientCreateResponse,
RecipientListResponse,
RecipientDeleteResponse,
RecipientGetResponse,
)
```
Methods:
- client.resource_sharing.recipients.create(share_id, \*, path_account_id, \*\*params) -> Optional[RecipientCreateResponse]
- client.resource_sharing.recipients.list(share_id, \*, account_id, \*\*params) -> SyncV4PagePaginationArray[RecipientListResponse]
- client.resource_sharing.recipients.delete(recipient_id, \*, account_id, share_id) -> Optional[RecipientDeleteResponse]
- client.resource_sharing.recipients.get(recipient_id, \*, account_id, share_id) -> Optional[RecipientGetResponse]
## Resources
Types:
```python
from cloudflare.types.resource_sharing import (
ResourceCreateResponse,
ResourceUpdateResponse,
ResourceListResponse,
ResourceDeleteResponse,
ResourceGetResponse,
)
```
Methods:
- client.resource_sharing.resources.create(share_id, \*, account_id, \*\*params) -> Optional[ResourceCreateResponse]
- client.resource_sharing.resources.update(resource_id, \*, account_id, share_id, \*\*params) -> Optional[ResourceUpdateResponse]
- client.resource_sharing.resources.list(share_id, \*, account_id, \*\*params) -> SyncV4PagePaginationArray[ResourceListResponse]
- client.resource_sharing.resources.delete(resource_id, \*, account_id, share_id) -> Optional[ResourceDeleteResponse]
- client.resource_sharing.resources.get(resource_id, \*, account_id, share_id) -> Optional[ResourceGetResponse]
# LeakedCredentialChecks
Types:
```python
from cloudflare.types.leaked_credential_checks import (
LeakedCredentialCheckCreateResponse,
LeakedCredentialCheckGetResponse,
)
```
Methods:
- client.leaked_credential_checks.create(\*, zone_id, \*\*params) -> LeakedCredentialCheckCreateResponse
- client.leaked_credential_checks.get(\*, zone_id) -> LeakedCredentialCheckGetResponse
## Detections
Types:
```python
from cloudflare.types.leaked_credential_checks import (
DetectionCreateResponse,
DetectionUpdateResponse,
DetectionListResponse,
)
```
Methods:
- client.leaked_credential_checks.detections.create(\*, zone_id, \*\*params) -> DetectionCreateResponse
- client.leaked_credential_checks.detections.update(detection_id, \*, zone_id, \*\*params) -> DetectionUpdateResponse
- client.leaked_credential_checks.detections.list(\*, zone_id) -> SyncSinglePage[DetectionListResponse]
- client.leaked_credential_checks.detections.delete(detection_id, \*, zone_id) -> object
# ContentScanning
Methods:
- client.content_scanning.disable(\*, zone_id) -> object
- client.content_scanning.enable(\*, zone_id) -> object
## Payloads
Types:
```python
from cloudflare.types.content_scanning import (
PayloadCreateResponse,
PayloadListResponse,
PayloadDeleteResponse,
)
```
Methods:
- client.content_scanning.payloads.create(\*, zone_id, \*\*params) -> SyncSinglePage[PayloadCreateResponse]
- client.content_scanning.payloads.list(\*, zone_id) -> SyncSinglePage[PayloadListResponse]
- client.content_scanning.payloads.delete(expression_id, \*, zone_id) -> SyncSinglePage[PayloadDeleteResponse]
## Settings
Types:
```python
from cloudflare.types.content_scanning import SettingGetResponse
```
Methods:
- client.content_scanning.settings.get(\*, zone_id) -> SettingGetResponse
# AbuseReports
Types:
```python
from cloudflare.types.abuse_reports import AbuseReportCreateResponse
```
Methods:
- client.abuse_reports.create(report_type, \*, account_id, \*\*params) -> str
# AI
Types:
```python
from cloudflare.types.ai import AIRunResponse
```
Methods:
- client.ai.run(model_name, \*, account_id, \*\*params) -> Optional[AIRunResponse]
## Finetunes
Types:
```python
from cloudflare.types.ai import FinetuneCreateResponse, FinetuneListResponse
```
Methods:
- client.ai.finetunes.create(\*, account_id, \*\*params) -> FinetuneCreateResponse
- client.ai.finetunes.list(\*, account_id) -> FinetuneListResponse
### Assets
Types:
```python
from cloudflare.types.ai.finetunes import AssetCreateResponse
```
Methods:
- client.ai.finetunes.assets.create(finetune_id, \*, account_id, \*\*params) -> AssetCreateResponse
### Public
Types:
```python
from cloudflare.types.ai.finetunes import PublicListResponse
```
Methods:
- client.ai.finetunes.public.list(\*, account_id, \*\*params) -> SyncSinglePage[PublicListResponse]
## Authors
Methods:
- client.ai.authors.list(\*, account_id) -> SyncSinglePage[object]
## Tasks
Methods:
- client.ai.tasks.list(\*, account_id) -> SyncSinglePage[object]
## Models
Methods:
- client.ai.models.list(\*, account_id, \*\*params) -> SyncV4PagePaginationArray[object]
### Schema
Methods:
- client.ai.models.schema.get(\*, account_id, \*\*params) -> object
# SecurityCenter
## Insights
Types:
```python
from cloudflare.types.security_center import InsightListResponse, InsightDismissResponse
```
Methods:
- client.security_center.insights.list(\*, account_id, zone_id, \*\*params) -> SyncV4PagePagination[Optional[InsightListResponse]]
- client.security_center.insights.dismiss(issue_id, \*, account_id, zone_id, \*\*params) -> InsightDismissResponse
### Class
Types:
```python
from cloudflare.types.security_center.insights import ClassGetResponse
```
Methods:
- client.security*center.insights.class*.get(\*, account_id, zone_id, \*\*params) -> Optional[ClassGetResponse]
### Severity
Types:
```python
from cloudflare.types.security_center.insights import SeverityGetResponse
```
Methods:
- client.security_center.insights.severity.get(\*, account_id, zone_id, \*\*params) -> Optional[SeverityGetResponse]
### Type
Types:
```python
from cloudflare.types.security_center.insights import TypeGetResponse
```
Methods:
- client.security_center.insights.type.get(\*, account_id, zone_id, \*\*params) -> Optional[TypeGetResponse]
# BrowserRendering
## Content
Types:
```python
from cloudflare.types.browser_rendering import ContentCreateResponse
```
Methods:
- client.browser_rendering.content.create(\*, account_id, \*\*params) -> str
## PDF
Methods:
- client.browser_rendering.pdf.create(\*, account_id, \*\*params) -> BinaryAPIResponse
## Scrape
Types:
```python
from cloudflare.types.browser_rendering import ScrapeCreateResponse
```
Methods:
- client.browser_rendering.scrape.create(\*, account_id, \*\*params) -> ScrapeCreateResponse
## Screenshot
Types:
```python
from cloudflare.types.browser_rendering import ScreenshotCreateResponse
```
Methods:
- client.browser_rendering.screenshot.create(\*, account_id, \*\*params) -> ScreenshotCreateResponse
## Snapshot
Types:
```python
from cloudflare.types.browser_rendering import SnapshotCreateResponse
```
Methods:
- client.browser_rendering.snapshot.create(\*, account_id, \*\*params) -> Optional[SnapshotCreateResponse]
## Json
Types:
```python
from cloudflare.types.browser_rendering import JsonCreateResponse
```
Methods:
- client.browser_rendering.json.create(\*, account_id, \*\*params) -> JsonCreateResponse
## Links
Types:
```python
from cloudflare.types.browser_rendering import LinkCreateResponse
```
Methods:
- client.browser_rendering.links.create(\*, account_id, \*\*params) -> LinkCreateResponse
## Markdown
Types:
```python
from cloudflare.types.browser_rendering import MarkdownCreateResponse
```
Methods:
- client.browser_rendering.markdown.create(\*, account_id, \*\*params) -> str
# CustomPages
Types:
```python
from cloudflare.types.custom_pages import CustomPageUpdateResponse, CustomPageGetResponse
```
Methods:
- client.custom_pages.update(identifier, \*, account_id, zone_id, \*\*params) -> Optional[CustomPageUpdateResponse]
- client.custom_pages.list(\*, account_id, zone_id) -> SyncSinglePage[object]
- client.custom_pages.get(identifier, \*, account_id, zone_id) -> Optional[CustomPageGetResponse]
# SecretsStore
## Stores
Types:
```python
from cloudflare.types.secrets_store import (
StoreCreateResponse,
StoreListResponse,
StoreDeleteResponse,
)
```
Methods:
- client.secrets_store.stores.create(\*, account_id, \*\*params) -> SyncSinglePage[StoreCreateResponse]
- client.secrets_store.stores.list(\*, account_id, \*\*params) -> SyncV4PagePaginationArray[StoreListResponse]
- client.secrets_store.stores.delete(store_id, \*, account_id) -> Optional[StoreDeleteResponse]
### Secrets
Types:
```python
from cloudflare.types.secrets_store.stores import (
SecretCreateResponse,
SecretListResponse,
SecretDeleteResponse,
SecretBulkDeleteResponse,
SecretDuplicateResponse,
SecretEditResponse,
SecretGetResponse,
)
```
Methods:
- client.secrets_store.stores.secrets.create(store_id, \*, account_id, \*\*params) -> SyncSinglePage[SecretCreateResponse]
- client.secrets_store.stores.secrets.list(store_id, \*, account_id, \*\*params) -> SyncV4PagePaginationArray[SecretListResponse]
- client.secrets_store.stores.secrets.delete(secret_id, \*, account_id, store_id) -> Optional[SecretDeleteResponse]
- client.secrets_store.stores.secrets.bulk_delete(store_id, \*, account_id) -> SyncSinglePage[SecretBulkDeleteResponse]
- client.secrets_store.stores.secrets.duplicate(secret_id, \*, account_id, store_id, \*\*params) -> Optional[SecretDuplicateResponse]
- client.secrets_store.stores.secrets.edit(secret_id, \*, account_id, store_id, \*\*params) -> Optional[SecretEditResponse]
- client.secrets_store.stores.secrets.get(secret_id, \*, account_id, store_id) -> Optional[SecretGetResponse]
## Quota
Types:
```python
from cloudflare.types.secrets_store import QuotaGetResponse
```
Methods:
- client.secrets_store.quota.get(\*, account_id) -> Optional[QuotaGetResponse]
# Pipelines
Types:
```python
from cloudflare.types.pipelines import (
PipelineCreateResponse,
PipelineUpdateResponse,
PipelineListResponse,
PipelineGetResponse,
)
```
Methods:
- client.pipelines.create(\*, account_id, \*\*params) -> PipelineCreateResponse
- client.pipelines.update(pipeline_name, \*, account_id, \*\*params) -> PipelineUpdateResponse
- client.pipelines.list(\*, account_id, \*\*params) -> PipelineListResponse
- client.pipelines.delete(pipeline_name, \*, account_id) -> None
- client.pipelines.get(pipeline_name, \*, account_id) -> PipelineGetResponse
# SchemaValidation
## Schemas
Types:
```python
from cloudflare.types.schema_validation import (
SchemaCreateResponse,
SchemaListResponse,
SchemaDeleteResponse,
SchemaEditResponse,
SchemaGetResponse,
)
```
Methods:
- client.schema_validation.schemas.create(\*, zone_id, \*\*params) -> SchemaCreateResponse
- client.schema_validation.schemas.list(\*, zone_id, \*\*params) -> SyncV4PagePaginationArray[SchemaListResponse]
- client.schema_validation.schemas.delete(schema_id, \*, zone_id) -> SchemaDeleteResponse
- client.schema_validation.schemas.edit(schema_id, \*, zone_id, \*\*params) -> SchemaEditResponse
- client.schema_validation.schemas.get(schema_id, \*, zone_id, \*\*params) -> SchemaGetResponse
## Settings
Types:
```python
from cloudflare.types.schema_validation import (
SettingUpdateResponse,
SettingEditResponse,
SettingGetResponse,
)
```
Methods:
- client.schema_validation.settings.update(\*, zone_id, \*\*params) -> SettingUpdateResponse
- client.schema_validation.settings.edit(\*, zone_id, \*\*params) -> SettingEditResponse
- client.schema_validation.settings.get(\*, zone_id) -> SettingGetResponse
### Operations
Types:
```python
from cloudflare.types.schema_validation.settings import (
OperationUpdateResponse,
OperationListResponse,
OperationDeleteResponse,
OperationBulkEditResponse,
OperationGetResponse,
)
```
Methods:
- client.schema_validation.settings.operations.update(operation_id, \*, zone_id, \*\*params) -> OperationUpdateResponse
- client.schema_validation.settings.operations.list(\*, zone_id, \*\*params) -> SyncV4PagePaginationArray[OperationListResponse]
- client.schema_validation.settings.operations.delete(operation_id, \*, zone_id) -> OperationDeleteResponse
- client.schema_validation.settings.operations.bulk_edit(\*, zone_id, \*\*params) -> OperationBulkEditResponse
- client.schema_validation.settings.operations.get(operation_id, \*, zone_id) -> OperationGetResponse