import type { RequestInit, RequestInfo } from "./internal/builtin-types.mjs";
import type { PromiseOrValue, MergedRequestInit, FinalizedRequestInit } from "./internal/types.mjs";
export type { Logger, LogLevel } from "./internal/utils/log.mjs";
import * as Opts from "./internal/request-options.mjs";
import * as Errors from "./core/error.mjs";
import * as Pagination from "./core/pagination.mjs";
import { type CursorLimitPaginationParams, CursorLimitPaginationResponse, type CursorPaginationAfterParams, CursorPaginationAfterResponse, type CursorPaginationParams, CursorPaginationResponse, SinglePageResponse, type V4PagePaginationArrayParams, V4PagePaginationArrayResponse, type V4PagePaginationParams, V4PagePaginationResponse } from "./core/pagination.mjs";
import * as Uploads from "./core/uploads.mjs";
import * as API from "./resources/index.mjs";
import { APIPromise } from "./core/api-promise.mjs";
import { AbuseReports } from "./resources/abuse-reports/abuse-reports.mjs";
import { Accounts } from "./resources/accounts/accounts.mjs";
import { ACM } from "./resources/acm/acm.mjs";
import { Addressing } from "./resources/addressing/addressing.mjs";
import { AIAudit } from "./resources/ai-audit/ai-audit.mjs";
import { AIGateway } from "./resources/ai-gateway/ai-gateway.mjs";
import { AISecurity } from "./resources/ai-security/ai-security.mjs";
import { AI } from "./resources/ai/ai.mjs";
import { AISearch } from "./resources/aisearch/aisearch.mjs";
import { Alerting } from "./resources/alerting/alerting.mjs";
import { APIGateway } from "./resources/api-gateway/api-gateway.mjs";
import { Argo } from "./resources/argo/argo.mjs";
import { AuditLogs } from "./resources/audit-logs/audit-logs.mjs";
import { Billing } from "./resources/billing/billing.mjs";
import { BotManagement } from "./resources/bot-management/bot-management.mjs";
import { BotnetFeed } from "./resources/botnet-feed/botnet-feed.mjs";
import { BrandProtection } from "./resources/brand-protection/brand-protection.mjs";
import { BrowserRendering } from "./resources/browser-rendering/browser-rendering.mjs";
import { Cache } from "./resources/cache/cache.mjs";
import { Calls } from "./resources/calls/calls.mjs";
import { CertificateAuthorities } from "./resources/certificate-authorities/certificate-authorities.mjs";
import { ClientCertificates } from "./resources/client-certificates/client-certificates.mjs";
import { CloudConnector } from "./resources/cloud-connector/cloud-connector.mjs";
import { CloudforceOne } from "./resources/cloudforce-one/cloudforce-one.mjs";
import { Connectivity } from "./resources/connectivity/connectivity.mjs";
import { ContentScanning } from "./resources/content-scanning/content-scanning.mjs";
import { CsamScanner } from "./resources/csam-scanner/csam-scanner.mjs";
import { CustomCertificates } from "./resources/custom-certificates/custom-certificates.mjs";
import { CustomCsrs } from "./resources/custom-csrs/custom-csrs.mjs";
import { CustomHostnames } from "./resources/custom-hostnames/custom-hostnames.mjs";
import { CustomNameservers } from "./resources/custom-nameservers/custom-nameservers.mjs";
import { CustomPages } from "./resources/custom-pages/custom-pages.mjs";
import { D1Resource } from "./resources/d1/d1.mjs";
import { DCVDelegation } from "./resources/dcv-delegation/dcv-delegation.mjs";
import { DDoSProtection } from "./resources/ddos-protection/ddos-protection.mjs";
import { Diagnostics } from "./resources/diagnostics/diagnostics.mjs";
import { DLS } from "./resources/dls/dls.mjs";
import { DNSFirewall } from "./resources/dns-firewall/dns-firewall.mjs";
import { DNS } from "./resources/dns/dns.mjs";
import { DurableObjects } from "./resources/durable-objects/durable-objects.mjs";
import { EmailAuth } from "./resources/email-auth/email-auth.mjs";
import { EmailRouting } from "./resources/email-routing/email-routing.mjs";
import { EmailSecurity } from "./resources/email-security/email-security.mjs";
import { EmailSending } from "./resources/email-sending/email-sending.mjs";
import { Filters } from "./resources/filters/filters.mjs";
import { Firewall } from "./resources/firewall/firewall.mjs";
import { Flagship } from "./resources/flagship/flagship.mjs";
import { Fraud } from "./resources/fraud/fraud.mjs";
import { GoogleTagGateway } from "./resources/google-tag-gateway/google-tag-gateway.mjs";
import { Healthchecks } from "./resources/healthchecks/healthchecks.mjs";
import { Hostnames } from "./resources/hostnames/hostnames.mjs";
import { HyperdriveResource } from "./resources/hyperdrive/hyperdrive.mjs";
import { IAM } from "./resources/iam/iam.mjs";
import { Images } from "./resources/images/images.mjs";
import { Intel } from "./resources/intel/intel.mjs";
import { IPs } from "./resources/ips/ips.mjs";
import { KeylessCertificates } from "./resources/keyless-certificates/keyless-certificates.mjs";
import { KV } from "./resources/kv/kv.mjs";
import { LeakedCredentialChecks } from "./resources/leaked-credential-checks/leaked-credential-checks.mjs";
import { LoadBalancers } from "./resources/load-balancers/load-balancers.mjs";
import { Logpush } from "./resources/logpush/logpush.mjs";
import { Logs } from "./resources/logs/logs.mjs";
import { MagicCloudNetworking } from "./resources/magic-cloud-networking/magic-cloud-networking.mjs";
import { MagicNetworkMonitoring } from "./resources/magic-network-monitoring/magic-network-monitoring.mjs";
import { MagicTransit } from "./resources/magic-transit/magic-transit.mjs";
import { ManagedTransforms } from "./resources/managed-transforms/managed-transforms.mjs";
import { Memberships } from "./resources/memberships/memberships.mjs";
import { MoQ } from "./resources/moq/moq.mjs";
import { MTLSCertificates } from "./resources/mtls-certificates/mtls-certificates.mjs";
import { NetworkInterconnects } from "./resources/network-interconnects/network-interconnects.mjs";
import { Organizations } from "./resources/organizations/organizations.mjs";
import { OriginCACertificates } from "./resources/origin-ca-certificates/origin-ca-certificates.mjs";
import { OriginPostQuantumEncryption } from "./resources/origin-post-quantum-encryption/origin-post-quantum-encryption.mjs";
import { OriginTLSClientAuth } from "./resources/origin-tls-client-auth/origin-tls-client-auth.mjs";
import { OriginTLSComplianceModes } from "./resources/origin-tls-compliance-modes/origin-tls-compliance-modes.mjs";
import { PageRules } from "./resources/page-rules/page-rules.mjs";
import { PageShield } from "./resources/page-shield/page-shield.mjs";
import { Pages } from "./resources/pages/pages.mjs";
import { Pipelines } from "./resources/pipelines/pipelines.mjs";
import { Queues } from "./resources/queues/queues.mjs";
import { R2DataCatalog } from "./resources/r2-data-catalog/r2-data-catalog.mjs";
import { R2 } from "./resources/r2/r2.mjs";
import { Radar } from "./resources/radar/radar.mjs";
import { RateLimits } from "./resources/rate-limits/rate-limits.mjs";
import { RealtimeKit } from "./resources/realtime-kit/realtime-kit.mjs";
import { Registrar } from "./resources/registrar/registrar.mjs";
import { RequestTracers } from "./resources/request-tracers/request-tracers.mjs";
import { ResourceSharing } from "./resources/resource-sharing/resource-sharing.mjs";
import { ResourceTagging } from "./resources/resource-tagging/resource-tagging.mjs";
import { Rules } from "./resources/rules/rules.mjs";
import { Rulesets } from "./resources/rulesets/rulesets.mjs";
import { RUM } from "./resources/rum/rum.mjs";
import { SchemaValidation } from "./resources/schema-validation/schema-validation.mjs";
import { SecretsStore } from "./resources/secrets-store/secrets-store.mjs";
import { SecurityCenter } from "./resources/security-center/security-center.mjs";
import { SecurityTXT } from "./resources/security-txt/security-txt.mjs";
import { Snippets } from "./resources/snippets/snippets.mjs";
import { Spectrum } from "./resources/spectrum/spectrum.mjs";
import { Speed } from "./resources/speed/speed.mjs";
import { SSL } from "./resources/ssl/ssl.mjs";
import { Stream } from "./resources/stream/stream.mjs";
import { TenantCustomNameservers } from "./resources/tenant-custom-nameservers/tenant-custom-nameservers.mjs";
import { Tenants } from "./resources/tenants/tenants.mjs";
import { TokenValidation } from "./resources/token-validation/token-validation.mjs";
import { Turnstile } from "./resources/turnstile/turnstile.mjs";
import { URLNormalization } from "./resources/url-normalization/url-normalization.mjs";
import { URLScanner } from "./resources/url-scanner/url-scanner.mjs";
import { User } from "./resources/user/user.mjs";
import { Vectorize } from "./resources/vectorize/vectorize.mjs";
import { VulnerabilityScanner } from "./resources/vulnerability-scanner/vulnerability-scanner.mjs";
import { WaitingRooms } from "./resources/waiting-rooms/waiting-rooms.mjs";
import { Web3 } from "./resources/web3/web3.mjs";
import { WorkersForPlatforms } from "./resources/workers-for-platforms/workers-for-platforms.mjs";
import { Workers } from "./resources/workers/workers.mjs";
import { Workflows } from "./resources/workflows/workflows.mjs";
import { Zaraz } from "./resources/zaraz/zaraz.mjs";
import { ZeroTrust } from "./resources/zero-trust/zero-trust.mjs";
import { Zones } from "./resources/zones/zones.mjs";
import { type Fetch } from "./internal/builtin-types.mjs";
import { HeadersLike, NullableHeaders } from "./internal/headers.mjs";
import { FinalRequestOptions, RequestOptions } from "./internal/request-options.mjs";
import { type LogLevel, type Logger } from "./internal/utils/log.mjs";
export interface ClientOptions {
    /**
     * The preferred authorization scheme for interacting with the Cloudflare API. [Create a token](https://developers.cloudflare.com/fundamentals/api/get-started/create-token/).
     */
    apiToken?: string | null | undefined;
    /**
     * The previous authorization scheme for interacting with the Cloudflare API. When possible, use API tokens instead of Global API keys.
     */
    apiKey?: string | null | undefined;
    /**
     * The previous authorization scheme for interacting with the Cloudflare API, used in conjunction with a Global API key.
     */
    apiEmail?: string | null | undefined;
    /**
     * Used when interacting with the Origin CA certificates API. [View/change your key](https://developers.cloudflare.com/fundamentals/api/get-started/ca-keys/#viewchange-your-origin-ca-keys).
     */
    userServiceKey?: string | null | undefined;
    /**
     * Override the default base URL for the API, e.g., "https://api.example.com/v2/"
     *
     * Defaults to process.env['CLOUDFLARE_BASE_URL'].
     */
    baseURL?: string | null | undefined;
    /**
     * The maximum amount of time (in milliseconds) that the client should wait for a response
     * from the server before timing out a single request.
     *
     * Note that request timeouts are retried by default, so in a worst-case scenario you may wait
     * much longer than this timeout before the promise succeeds or fails.
     *
     * @unit milliseconds
     */
    timeout?: number | undefined;
    /**
     * Additional `RequestInit` options to be passed to `fetch` calls.
     * Properties will be overridden by per-request `fetchOptions`.
     */
    fetchOptions?: MergedRequestInit | undefined;
    /**
     * Specify a custom `fetch` function implementation.
     *
     * If not provided, we expect that `fetch` is defined globally.
     */
    fetch?: Fetch | undefined;
    /**
     * The maximum number of times that the client will retry a request in case of a
     * temporary failure, like a network error or a 5XX error from the server.
     *
     * @default 2
     */
    maxRetries?: number | undefined;
    /**
     * Default headers to include with every request to the API.
     *
     * These can be removed in individual requests by explicitly setting the
     * header to `null` in request options.
     */
    defaultHeaders?: HeadersLike | undefined;
    /**
     * Default query parameters to include with every request to the API.
     *
     * These can be removed in individual requests by explicitly setting the
     * param to `undefined` in request options.
     */
    defaultQuery?: Record<string, string | undefined> | undefined;
    /**
     * Set the log level.
     *
     * Defaults to process.env['CLOUDFLARE_LOG'] or 'warn' if it isn't set.
     */
    logLevel?: LogLevel | undefined;
    /**
     * Set the logger.
     *
     * Defaults to globalThis.console.
     */
    logger?: Logger | undefined;
    /**
     * Define the API version to target for the requests, e.g., "2025-01-01".
     *
     * Defaults to today's date.
     */
    apiVersion?: string | null | undefined;
}
/**
 * Base class for Cloudflare API clients.
 */
export declare class BaseCloudflare {
    #private;
    apiToken: string | null;
    apiKey: string | null;
    apiEmail: string | null;
    userServiceKey: string | null;
    baseURL: string;
    maxRetries: number;
    timeout: number;
    logger: Logger;
    logLevel: LogLevel | undefined;
    fetchOptions: MergedRequestInit | undefined;
    apiVersion: string;
    private fetch;
    protected idempotencyHeader?: string;
    private _options;
    /**
     * API Client for interfacing with the Cloudflare API.
     *
     * @param {string | null | undefined} [opts.apiToken=process.env['CLOUDFLARE_API_TOKEN'] ?? null]
     * @param {string | null | undefined} [opts.apiKey=process.env['CLOUDFLARE_API_KEY'] ?? null]
     * @param {string | null | undefined} [opts.apiEmail=process.env['CLOUDFLARE_EMAIL'] ?? null]
     * @param {string | null | undefined} [opts.userServiceKey=process.env['CLOUDFLARE_API_USER_SERVICE_KEY'] ?? null]
     * @param {string} [opts.baseURL=process.env['CLOUDFLARE_BASE_URL'] ?? https://api.cloudflare.com/client/v4] - Override the default base URL for the API.
     * @param {number} [opts.timeout=1 minute] - The maximum amount of time (in milliseconds) the client will wait for a response before timing out.
     * @param {MergedRequestInit} [opts.fetchOptions] - Additional `RequestInit` options to be passed to `fetch` calls.
     * @param {Fetch} [opts.fetch] - Specify a custom `fetch` function implementation.
     * @param {number} [opts.maxRetries=2] - The maximum number of times the client will retry a request.
     * @param {HeadersLike} opts.defaultHeaders - Default headers to include with every request to the API.
     * @param {Record<string, string | undefined>} opts.defaultQuery - Default query parameters to include with every request to the API.
     * @param {string | null} [opts.apiVersion] - Define the version to target for the API.
     */
    constructor({ baseURL, apiVersion, apiToken, apiKey, apiEmail, userServiceKey, ...opts }?: ClientOptions);
    /**
     * Create a new client instance re-using the same options given to the current client with optional overriding.
     */
    withOptions(options: Partial<ClientOptions>): this;
    protected defaultQuery(): Record<string, string | undefined> | undefined;
    protected validateHeaders({ values, nulls }: NullableHeaders): void;
    protected authHeaders(opts: FinalRequestOptions): Promise<NullableHeaders | undefined>;
    protected apiEmailAuth(opts: FinalRequestOptions): Promise<NullableHeaders | undefined>;
    protected apiKeyAuth(opts: FinalRequestOptions): Promise<NullableHeaders | undefined>;
    protected apiTokenAuth(opts: FinalRequestOptions): Promise<NullableHeaders | undefined>;
    protected userServiceKeyAuth(opts: FinalRequestOptions): Promise<NullableHeaders | undefined>;
    protected stringifyQuery(query: object | Record<string, unknown>): string;
    private getUserAgent;
    protected defaultIdempotencyKey(): string;
    protected makeStatusError(status: number, error: Object, message: string | undefined, headers: Headers): Errors.APIError;
    buildURL(path: string, query: Record<string, unknown> | null | undefined, defaultBaseURL?: string | undefined): string;
    /**
     * Used as a callback for mutating the given `FinalRequestOptions` object.
     */
    protected prepareOptions(options: FinalRequestOptions): Promise<void>;
    /**
     * Used as a callback for mutating the given `RequestInit` object.
     *
     * This is useful for cases where you want to add certain headers based off of
     * the request properties, e.g. `method` or `url`.
     */
    protected prepareRequest(request: RequestInit, { url, options }: {
        url: string;
        options: FinalRequestOptions;
    }): Promise<void>;
    get<Rsp>(path: string, opts?: PromiseOrValue<RequestOptions>): APIPromise<Rsp>;
    post<Rsp>(path: string, opts?: PromiseOrValue<RequestOptions>): APIPromise<Rsp>;
    patch<Rsp>(path: string, opts?: PromiseOrValue<RequestOptions>): APIPromise<Rsp>;
    put<Rsp>(path: string, opts?: PromiseOrValue<RequestOptions>): APIPromise<Rsp>;
    delete<Rsp>(path: string, opts?: PromiseOrValue<RequestOptions>): APIPromise<Rsp>;
    private methodRequest;
    request<Rsp>(options: PromiseOrValue<FinalRequestOptions>, remainingRetries?: number | null): APIPromise<Rsp>;
    private makeRequest;
    getAPIList<Item, PageClass extends Pagination.AbstractPage<Item> = Pagination.AbstractPage<Item>>(path: string, Page: new (...args: any[]) => PageClass, opts?: PromiseOrValue<RequestOptions>): Pagination.PagePromise<PageClass, Item>;
    requestAPIList<Item = unknown, PageClass extends Pagination.AbstractPage<Item> = Pagination.AbstractPage<Item>>(Page: new (...args: ConstructorParameters<typeof Pagination.AbstractPage>) => PageClass, options: PromiseOrValue<FinalRequestOptions>): Pagination.PagePromise<PageClass, Item>;
    fetchWithTimeout(url: RequestInfo, init: RequestInit | undefined, ms: number, controller: AbortController): Promise<Response>;
    private shouldRetry;
    private retryRequest;
    private calculateDefaultRetryTimeoutMillis;
    buildRequest(inputOptions: FinalRequestOptions, { retryCount }?: {
        retryCount?: number;
    }): Promise<{
        req: FinalizedRequestInit;
        url: string;
        timeout: number;
    }>;
    private buildHeaders;
    private _makeAbort;
    private buildBody;
    static DEFAULT_TIMEOUT: number;
}
/**
 * API Client for interfacing with the Cloudflare API.
 */
export declare class Cloudflare extends BaseCloudflare {
    static Cloudflare: typeof Cloudflare;
    static CloudflareError: typeof Errors.CloudflareError;
    static APIError: typeof Errors.APIError;
    static APIConnectionError: typeof Errors.APIConnectionError;
    static APIConnectionTimeoutError: typeof Errors.APIConnectionTimeoutError;
    static APIUserAbortError: typeof Errors.APIUserAbortError;
    static NotFoundError: typeof Errors.NotFoundError;
    static ConflictError: typeof Errors.ConflictError;
    static RateLimitError: typeof Errors.RateLimitError;
    static BadRequestError: typeof Errors.BadRequestError;
    static AuthenticationError: typeof Errors.AuthenticationError;
    static InternalServerError: typeof Errors.InternalServerError;
    static PermissionDeniedError: typeof Errors.PermissionDeniedError;
    static UnprocessableEntityError: typeof Errors.UnprocessableEntityError;
    static toFile: typeof Uploads.toFile;
    accounts: API.Accounts;
    organizations: API.Organizations;
    tenants: API.Tenants;
    originCACertificates: API.OriginCACertificates;
    ips: API.IPs;
    memberships: API.Memberships;
    user: API.User;
    zones: API.Zones;
    loadBalancers: API.LoadBalancers;
    cache: API.Cache;
    ssl: API.SSL;
    acm: API.ACM;
    argo: API.Argo;
    certificateAuthorities: API.CertificateAuthorities;
    clientCertificates: API.ClientCertificates;
    customCertificates: API.CustomCertificates;
    customCsrs: API.CustomCsrs;
    customHostnames: API.CustomHostnames;
    customNameservers: API.CustomNameservers;
    tenantCustomNameservers: API.TenantCustomNameservers;
    dnsFirewall: API.DNSFirewall;
    dns: API.DNS;
    emailSecurity: API.EmailSecurity;
    emailAuth: API.EmailAuth;
    emailRouting: API.EmailRouting;
    emailSending: API.EmailSending;
    filters: API.Filters;
    firewall: API.Firewall;
    healthchecks: API.Healthchecks;
    keylessCertificates: API.KeylessCertificates;
    logpush: API.Logpush;
    logs: API.Logs;
    originTLSClientAuth: API.OriginTLSClientAuth;
    pageRules: API.PageRules;
    rateLimits: API.RateLimits;
    waitingRooms: API.WaitingRooms;
    web3: API.Web3;
    workers: API.Workers;
    kv: API.KV;
    durableObjects: API.DurableObjects;
    queues: API.Queues;
    apiGateway: API.APIGateway;
    managedTransforms: API.ManagedTransforms;
    pageShield: API.PageShield;
    rulesets: API.Rulesets;
    urlNormalization: API.URLNormalization;
    spectrum: API.Spectrum;
    addressing: API.Addressing;
    dls: API.DLS;
    auditLogs: API.AuditLogs;
    billing: API.Billing;
    brandProtection: API.BrandProtection;
    diagnostics: API.Diagnostics;
    images: API.Images;
    intel: API.Intel;
    magicTransit: API.MagicTransit;
    DDoSProtection: API.DDoSProtection;
    magicNetworkMonitoring: API.MagicNetworkMonitoring;
    magicCloudNetworking: API.MagicCloudNetworking;
    networkInterconnects: API.NetworkInterconnects;
    mtlsCertificates: API.MTLSCertificates;
    pages: API.Pages;
    registrar: API.Registrar;
    requestTracers: API.RequestTracers;
    rules: API.Rules;
    stream: API.Stream;
    alerting: API.Alerting;
    d1: API.D1Resource;
    r2: API.R2;
    r2DataCatalog: API.R2DataCatalog;
    workersForPlatforms: API.WorkersForPlatforms;
    zeroTrust: API.ZeroTrust;
    turnstile: API.Turnstile;
    connectivity: API.Connectivity;
    hyperdrive: API.HyperdriveResource;
    rum: API.RUM;
    vectorize: API.Vectorize;
    urlScanner: API.URLScanner;
    vulnerabilityScanner: API.VulnerabilityScanner;
    radar: API.Radar;
    botManagement: API.BotManagement;
    fraud: API.Fraud;
    originPostQuantumEncryption: API.OriginPostQuantumEncryption;
    originTLSComplianceModes: API.OriginTLSComplianceModes;
    googleTagGateway: API.GoogleTagGateway;
    zaraz: API.Zaraz;
    speed: API.Speed;
    dcvDelegation: API.DCVDelegation;
    hostnames: API.Hostnames;
    snippets: API.Snippets;
    realtimeKit: API.RealtimeKit;
    calls: API.Calls;
    moq: API.MoQ;
    cloudforceOne: API.CloudforceOne;
    aiGateway: API.AIGateway;
    flagship: API.Flagship;
    iam: API.IAM;
    cloudConnector: API.CloudConnector;
    botnetFeed: API.BotnetFeed;
    securityTXT: API.SecurityTXT;
    workflows: API.Workflows;
    resourceSharing: API.ResourceSharing;
    resourceTagging: API.ResourceTagging;
    leakedCredentialChecks: API.LeakedCredentialChecks;
    contentScanning: API.ContentScanning;
    aiSecurity: API.AISecurity;
    csamScanner: API.CsamScanner;
    abuseReports: API.AbuseReports;
    ai: API.AI;
    aiAudit: API.AIAudit;
    aiSearch: API.AISearch;
    securityCenter: API.SecurityCenter;
    browserRendering: API.BrowserRendering;
    customPages: API.CustomPages;
    secretsStore: API.SecretsStore;
    pipelines: API.Pipelines;
    schemaValidation: API.SchemaValidation;
    tokenValidation: API.TokenValidation;
}
export declare namespace Cloudflare {
    export type RequestOptions = Opts.RequestOptions;
    export import V4PagePagination = Pagination.V4PagePagination;
    export { type V4PagePaginationParams as V4PagePaginationParams, type V4PagePaginationResponse as V4PagePaginationResponse, };
    export import V4PagePaginationArray = Pagination.V4PagePaginationArray;
    export { type V4PagePaginationArrayParams as V4PagePaginationArrayParams, type V4PagePaginationArrayResponse as V4PagePaginationArrayResponse, };
    export import CursorPagination = Pagination.CursorPagination;
    export { type CursorPaginationParams as CursorPaginationParams, type CursorPaginationResponse as CursorPaginationResponse, };
    export import CursorPaginationAfter = Pagination.CursorPaginationAfter;
    export { type CursorPaginationAfterParams as CursorPaginationAfterParams, type CursorPaginationAfterResponse as CursorPaginationAfterResponse, };
    export import CursorLimitPagination = Pagination.CursorLimitPagination;
    export { type CursorLimitPaginationParams as CursorLimitPaginationParams, type CursorLimitPaginationResponse as CursorLimitPaginationResponse, };
    export import SinglePage = Pagination.SinglePage;
    export { type SinglePageResponse as SinglePageResponse };
    export { Accounts as Accounts };
    export { Organizations as Organizations };
    export { Tenants as Tenants };
    export { OriginCACertificates as OriginCACertificates };
    export { IPs as IPs };
    export { Memberships as Memberships };
    export { User as User };
    export { Zones as Zones };
    export { LoadBalancers as LoadBalancers };
    export { Cache as Cache };
    export { SSL as SSL };
    export { ACM as ACM };
    export { Argo as Argo };
    export { CertificateAuthorities as CertificateAuthorities };
    export { ClientCertificates as ClientCertificates };
    export { CustomCertificates as CustomCertificates };
    export { CustomCsrs as CustomCsrs };
    export { CustomHostnames as CustomHostnames };
    export { CustomNameservers as CustomNameservers };
    export { TenantCustomNameservers as TenantCustomNameservers };
    export { DNSFirewall as DNSFirewall };
    export { DNS as DNS };
    export { EmailSecurity as EmailSecurity };
    export { EmailAuth as EmailAuth };
    export { EmailRouting as EmailRouting };
    export { EmailSending as EmailSending };
    export { Filters as Filters };
    export { Firewall as Firewall };
    export { Healthchecks as Healthchecks };
    export { KeylessCertificates as KeylessCertificates };
    export { Logpush as Logpush };
    export { Logs as Logs };
    export { OriginTLSClientAuth as OriginTLSClientAuth };
    export { PageRules as PageRules };
    export { RateLimits as RateLimits };
    export { WaitingRooms as WaitingRooms };
    export { Web3 as Web3 };
    export { Workers as Workers };
    export { KV as KV };
    export { DurableObjects as DurableObjects };
    export { Queues as Queues };
    export { APIGateway as APIGateway };
    export { ManagedTransforms as ManagedTransforms };
    export { PageShield as PageShield };
    export { Rulesets as Rulesets };
    export { URLNormalization as URLNormalization };
    export { Spectrum as Spectrum };
    export { Addressing as Addressing };
    export { DLS as DLS };
    export { AuditLogs as AuditLogs };
    export { Billing as Billing };
    export { BrandProtection as BrandProtection };
    export { Diagnostics as Diagnostics };
    export { Images as Images };
    export { Intel as Intel };
    export { MagicTransit as MagicTransit };
    export { DDoSProtection as DDoSProtection };
    export { MagicNetworkMonitoring as MagicNetworkMonitoring };
    export { MagicCloudNetworking as MagicCloudNetworking };
    export { NetworkInterconnects as NetworkInterconnects };
    export { MTLSCertificates as MTLSCertificates };
    export { Pages as Pages };
    export { Registrar as Registrar };
    export { RequestTracers as RequestTracers };
    export { Rules as Rules };
    export { Stream as Stream };
    export { Alerting as Alerting };
    export { D1Resource as D1Resource };
    export { R2 as R2 };
    export { R2DataCatalog as R2DataCatalog };
    export { WorkersForPlatforms as WorkersForPlatforms };
    export { ZeroTrust as ZeroTrust };
    export { Turnstile as Turnstile };
    export { Connectivity as Connectivity };
    export { HyperdriveResource as HyperdriveResource };
    export { RUM as RUM };
    export { Vectorize as Vectorize };
    export { URLScanner as URLScanner };
    export { VulnerabilityScanner as VulnerabilityScanner };
    export { Radar as Radar };
    export { BotManagement as BotManagement };
    export { Fraud as Fraud };
    export { OriginPostQuantumEncryption as OriginPostQuantumEncryption };
    export { OriginTLSComplianceModes as OriginTLSComplianceModes };
    export { GoogleTagGateway as GoogleTagGateway };
    export { Zaraz as Zaraz };
    export { Speed as Speed };
    export { DCVDelegation as DCVDelegation };
    export { Hostnames as Hostnames };
    export { Snippets as Snippets };
    export { RealtimeKit as RealtimeKit };
    export { Calls as Calls };
    export { MoQ as MoQ };
    export { CloudforceOne as CloudforceOne };
    export { AIGateway as AIGateway };
    export { Flagship as Flagship };
    export { IAM as IAM };
    export { CloudConnector as CloudConnector };
    export { BotnetFeed as BotnetFeed };
    export { SecurityTXT as SecurityTXT };
    export { Workflows as Workflows };
    export { ResourceSharing as ResourceSharing };
    export { ResourceTagging as ResourceTagging };
    export { LeakedCredentialChecks as LeakedCredentialChecks };
    export { ContentScanning as ContentScanning };
    export { AISecurity as AISecurity };
    export { CsamScanner as CsamScanner };
    export { AbuseReports as AbuseReports };
    export { AI as AI };
    export { AIAudit as AIAudit };
    export { AISearch as AISearch };
    export { SecurityCenter as SecurityCenter };
    export { BrowserRendering as BrowserRendering };
    export { CustomPages as CustomPages };
    export { SecretsStore as SecretsStore };
    export { Pipelines as Pipelines };
    export { SchemaValidation as SchemaValidation };
    export { TokenValidation as TokenValidation };
    export type ASN = API.ASN;
    export type AuditLog = API.AuditLog;
    export type CertificateCA = API.CertificateCA;
    export type CertificateRequestType = API.CertificateRequestType;
    export type CloudflareTunnel = API.CloudflareTunnel;
    export type ErrorData = API.ErrorData;
    export type Identifier = API.Identifier;
    export type LoadBalancerPreview = API.LoadBalancerPreview;
    export type Member = API.Member;
    export type PaginationInfo = API.PaginationInfo;
    export type Permission = API.Permission;
    export type PermissionGrant = API.PermissionGrant;
    export type RatePlan = API.RatePlan;
    export type ResponseInfo = API.ResponseInfo;
    export type Result = API.Result;
    export type Role = API.Role;
    export type SortDirection = API.SortDirection;
    export type Subscription = API.Subscription;
    export type SubscriptionComponent = API.SubscriptionComponent;
    export type SubscriptionZone = API.SubscriptionZone;
    export type Token = API.Token;
    export type TokenConditionCIDRList = API.TokenConditionCIDRList;
    export type TokenPolicy = API.TokenPolicy;
    export type TokenValue = API.TokenValue;
}
//# sourceMappingURL=client.d.mts.map