@distilled.cloud/cloudflare 0.0.0-john

package/lib/services/addressing.d.ts

@@ -0,0 +1,1321 @@
+/**
+ * Cloudflare ADDRESSING API
+ *
+ * Generated from Cloudflare TypeScript SDK.
+ * DO NOT EDIT - regenerate with: bun scripts/generate.ts --service addressing
+ */
+import * as stream from "effect/Stream";
+import * as Schema from "effect/Schema";
+import type * as HttpClient from "effect/unstable/http/HttpClient";
+import * as API from "../client/api.ts";
+import type { Credentials } from "../credentials.ts";
+import { type DefaultErrors } from "../errors.ts";
+declare const AddressMapNotFound_base: Schema.ErrorClass<AddressMapNotFound, Schema.TaggedStruct<"AddressMapNotFound", {
+    readonly code: Schema.Number;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class AddressMapNotFound extends AddressMapNotFound_base {
+}
+declare const BgpPrefixNotFound_base: Schema.ErrorClass<BgpPrefixNotFound, Schema.TaggedStruct<"BgpPrefixNotFound", {
+    readonly code: Schema.Number;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class BgpPrefixNotFound extends BgpPrefixNotFound_base {
+}
+declare const BindingNotFound_base: Schema.ErrorClass<BindingNotFound, Schema.TaggedStruct<"BindingNotFound", {
+    readonly code: Schema.Number;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class BindingNotFound extends BindingNotFound_base {
+}
+declare const DelegationNotFound_base: Schema.ErrorClass<DelegationNotFound, Schema.TaggedStruct<"DelegationNotFound", {
+    readonly code: Schema.Number;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class DelegationNotFound extends DelegationNotFound_base {
+}
+declare const FeatureNotEnabled_base: Schema.ErrorClass<FeatureNotEnabled, Schema.TaggedStruct<"FeatureNotEnabled", {
+    readonly code: Schema.Number;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class FeatureNotEnabled extends FeatureNotEnabled_base {
+}
+declare const InvalidAccountId_base: Schema.ErrorClass<InvalidAccountId, Schema.TaggedStruct<"InvalidAccountId", {
+    readonly code: Schema.Number;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class InvalidAccountId extends InvalidAccountId_base {
+}
+declare const InvalidHostname_base: Schema.ErrorClass<InvalidHostname, Schema.TaggedStruct<"InvalidHostname", {
+    readonly code: Schema.Number;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class InvalidHostname extends InvalidHostname_base {
+}
+declare const InvalidLoaForm_base: Schema.ErrorClass<InvalidLoaForm, Schema.TaggedStruct<"InvalidLoaForm", {
+    readonly code: Schema.Number;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class InvalidLoaForm extends InvalidLoaForm_base {
+}
+declare const InvalidNetworkCidr_base: Schema.ErrorClass<InvalidNetworkCidr, Schema.TaggedStruct<"InvalidNetworkCidr", {
+    readonly code: Schema.Number;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class InvalidNetworkCidr extends InvalidNetworkCidr_base {
+}
+declare const InvalidZoneId_base: Schema.ErrorClass<InvalidZoneId, Schema.TaggedStruct<"InvalidZoneId", {
+    readonly code: Schema.Number;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class InvalidZoneId extends InvalidZoneId_base {
+}
+declare const IrrEntryNotFound_base: Schema.ErrorClass<IrrEntryNotFound, Schema.TaggedStruct<"IrrEntryNotFound", {
+    readonly code: Schema.Number;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class IrrEntryNotFound extends IrrEntryNotFound_base {
+}
+declare const LoaDocumentNotFound_base: Schema.ErrorClass<LoaDocumentNotFound, Schema.TaggedStruct<"LoaDocumentNotFound", {
+    readonly code: Schema.Number;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class LoaDocumentNotFound extends LoaDocumentNotFound_base {
+}
+declare const MethodNotAllowed_base: Schema.ErrorClass<MethodNotAllowed, Schema.TaggedStruct<"MethodNotAllowed", {
+    readonly code: Schema.Number;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class MethodNotAllowed extends MethodNotAllowed_base {
+}
+declare const MissingAccountId_base: Schema.ErrorClass<MissingAccountId, Schema.TaggedStruct<"MissingAccountId", {
+    readonly code: Schema.Number;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class MissingAccountId extends MissingAccountId_base {
+}
+declare const NonexistentAccountPrefix_base: Schema.ErrorClass<NonexistentAccountPrefix, Schema.TaggedStruct<"NonexistentAccountPrefix", {
+    readonly code: Schema.Number;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class NonexistentAccountPrefix extends NonexistentAccountPrefix_base {
+}
+declare const PrefixNotFound_base: Schema.ErrorClass<PrefixNotFound, Schema.TaggedStruct<"PrefixNotFound", {
+    readonly code: Schema.Number;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class PrefixNotFound extends PrefixNotFound_base {
+}
+declare const RegionalHostnameEmpty_base: Schema.ErrorClass<RegionalHostnameEmpty, Schema.TaggedStruct<"RegionalHostnameEmpty", {
+    readonly code: Schema.Number;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class RegionalHostnameEmpty extends RegionalHostnameEmpty_base {
+}
+declare const RegionalHostnameNotFound_base: Schema.ErrorClass<RegionalHostnameNotFound, Schema.TaggedStruct<"RegionalHostnameNotFound", {
+    readonly code: Schema.Number;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class RegionalHostnameNotFound extends RegionalHostnameNotFound_base {
+}
+declare const UnsupportedBindingConfiguration_base: Schema.ErrorClass<UnsupportedBindingConfiguration, Schema.TaggedStruct<"UnsupportedBindingConfiguration", {
+    readonly code: Schema.Number;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class UnsupportedBindingConfiguration extends UnsupportedBindingConfiguration_base {
+}
+export interface GetAddressMapRequest {
+    addressMapId: string;
+    /** Identifier of a Cloudflare account. */
+    accountId: string;
+}
+export declare const GetAddressMapRequest: Schema.Schema<GetAddressMapRequest>;
+export interface GetAddressMapResponse {
+    /** Identifier of an Address Map. */
+    id?: string | null;
+    /** If set to false, then the Address Map cannot be deleted via API. This is true for Cloudflare-managed maps. */
+    canDelete?: boolean | null;
+    /** If set to false, then the IPs on the Address Map cannot be modified via the API. This is true for Cloudflare-managed maps. */
+    canModifyIps?: boolean | null;
+    createdAt?: string | null;
+    /** If you have legacy TLS clients which do not send the TLS server name indicator, then you can specify one default SNI on the map. If Cloudflare receives a TLS handshake from a client without an SNI, it */
+    defaultSni?: string | null;
+    /** An optional description field which may be used to describe the types of IPs or zones on the map. */
+    description?: string | null;
+    /** Whether the Address Map is enabled or not. Cloudflare's DNS will not respond with IP addresses on an Address Map until the map is enabled. */
+    enabled?: boolean | null;
+    /** The set of IPs on the Address Map. */
+    ips?: unknown | null;
+    /** Zones and Accounts which will be assigned IPs on this Address Map. A zone membership will take priority over an account membership. */
+    memberships?: {
+        canDelete?: boolean | null;
+        createdAt?: string | null;
+        identifier?: string | null;
+        kind?: "zone" | "account" | null;
+    }[] | null;
+    modifiedAt?: string | null;
+}
+export declare const GetAddressMapResponse: Schema.Schema<GetAddressMapResponse>;
+export type GetAddressMapError = DefaultErrors | AddressMapNotFound | InvalidAccountId;
+export declare const getAddressMap: API.OperationMethod<GetAddressMapRequest, GetAddressMapResponse, GetAddressMapError, Credentials | HttpClient.HttpClient>;
+export interface ListAddressMapsRequest {
+    /** Identifier of a Cloudflare account. */
+    accountId: string;
+}
+export declare const ListAddressMapsRequest: Schema.Schema<ListAddressMapsRequest>;
+export interface ListAddressMapsResponse {
+    result: {
+        id?: string | null;
+        canDelete?: boolean | null;
+        canModifyIps?: boolean | null;
+        createdAt?: string | null;
+        defaultSni?: string | null;
+        description?: string | null;
+        enabled?: boolean | null;
+        modifiedAt?: string | null;
+    }[];
+}
+export declare const ListAddressMapsResponse: Schema.Schema<ListAddressMapsResponse>;
+export type ListAddressMapsError = DefaultErrors;
+export declare const listAddressMaps: API.PaginatedOperationMethod<ListAddressMapsRequest, ListAddressMapsResponse, ListAddressMapsError, Credentials | HttpClient.HttpClient> & {
+    pages: (input: ListAddressMapsRequest) => stream.Stream<ListAddressMapsResponse, ListAddressMapsError, Credentials | HttpClient.HttpClient>;
+    items: (input: ListAddressMapsRequest) => stream.Stream<{
+        id?: string | null;
+        canDelete?: boolean | null;
+        canModifyIps?: boolean | null;
+        createdAt?: string | null;
+        defaultSni?: string | null;
+        description?: string | null;
+        enabled?: boolean | null;
+        modifiedAt?: string | null;
+    }, ListAddressMapsError, Credentials | HttpClient.HttpClient>;
+};
+export interface CreateAddressMapRequest {
+    /** Path param: Identifier of a Cloudflare account. */
+    accountId: string;
+    /** Body param: An optional description field which may be used to describe the types of IPs or zones on the map. */
+    description?: string | null;
+    /** Body param: Whether the Address Map is enabled or not. Cloudflare's DNS will not respond with IP addresses on an Address Map until the map is enabled. */
+    enabled?: boolean | null;
+    /** Body param: */
+    ips?: string[];
+    /** Body param: Zones and Accounts which will be assigned IPs on this Address Map. A zone membership will take priority over an account membership. */
+    memberships?: {
+        identifier?: string;
+        kind?: "zone" | "account";
+    }[];
+}
+export declare const CreateAddressMapRequest: Schema.Schema<CreateAddressMapRequest>;
+export interface CreateAddressMapResponse {
+    /** Identifier of an Address Map. */
+    id?: string | null;
+    /** If set to false, then the Address Map cannot be deleted via API. This is true for Cloudflare-managed maps. */
+    canDelete?: boolean | null;
+    /** If set to false, then the IPs on the Address Map cannot be modified via the API. This is true for Cloudflare-managed maps. */
+    canModifyIps?: boolean | null;
+    createdAt?: string | null;
+    /** If you have legacy TLS clients which do not send the TLS server name indicator, then you can specify one default SNI on the map. If Cloudflare receives a TLS handshake from a client without an SNI, it */
+    defaultSni?: string | null;
+    /** An optional description field which may be used to describe the types of IPs or zones on the map. */
+    description?: string | null;
+    /** Whether the Address Map is enabled or not. Cloudflare's DNS will not respond with IP addresses on an Address Map until the map is enabled. */
+    enabled?: boolean | null;
+    /** The set of IPs on the Address Map. */
+    ips?: unknown | null;
+    /** Zones and Accounts which will be assigned IPs on this Address Map. A zone membership will take priority over an account membership. */
+    memberships?: {
+        canDelete?: boolean | null;
+        createdAt?: string | null;
+        identifier?: string | null;
+        kind?: "zone" | "account" | null;
+    }[] | null;
+    modifiedAt?: string | null;
+}
+export declare const CreateAddressMapResponse: Schema.Schema<CreateAddressMapResponse>;
+export type CreateAddressMapError = DefaultErrors | FeatureNotEnabled | InvalidAccountId;
+export declare const createAddressMap: API.OperationMethod<CreateAddressMapRequest, CreateAddressMapResponse, CreateAddressMapError, Credentials | HttpClient.HttpClient>;
+export interface PatchAddressMapRequest {
+    addressMapId: string;
+    /** Path param: Identifier of a Cloudflare account. */
+    accountId: string;
+    /** Body param: If you have legacy TLS clients which do not send the TLS server name indicator, then you can specify one default SNI on the map. If Cloudflare receives a TLS handshake from a client withou */
+    defaultSni?: string | null;
+    /** Body param: An optional description field which may be used to describe the types of IPs or zones on the map. */
+    description?: string | null;
+    /** Body param: Whether the Address Map is enabled or not. Cloudflare's DNS will not respond with IP addresses on an Address Map until the map is enabled. */
+    enabled?: boolean | null;
+}
+export declare const PatchAddressMapRequest: Schema.Schema<PatchAddressMapRequest>;
+export interface PatchAddressMapResponse {
+    /** Identifier of an Address Map. */
+    id?: string | null;
+    /** If set to false, then the Address Map cannot be deleted via API. This is true for Cloudflare-managed maps. */
+    canDelete?: boolean | null;
+    /** If set to false, then the IPs on the Address Map cannot be modified via the API. This is true for Cloudflare-managed maps. */
+    canModifyIps?: boolean | null;
+    createdAt?: string | null;
+    /** If you have legacy TLS clients which do not send the TLS server name indicator, then you can specify one default SNI on the map. If Cloudflare receives a TLS handshake from a client without an SNI, it */
+    defaultSni?: string | null;
+    /** An optional description field which may be used to describe the types of IPs or zones on the map. */
+    description?: string | null;
+    /** Whether the Address Map is enabled or not. Cloudflare's DNS will not respond with IP addresses on an Address Map until the map is enabled. */
+    enabled?: boolean | null;
+    modifiedAt?: string | null;
+}
+export declare const PatchAddressMapResponse: Schema.Schema<PatchAddressMapResponse>;
+export type PatchAddressMapError = DefaultErrors | MethodNotAllowed | FeatureNotEnabled | InvalidAccountId;
+export declare const patchAddressMap: API.OperationMethod<PatchAddressMapRequest, PatchAddressMapResponse, PatchAddressMapError, Credentials | HttpClient.HttpClient>;
+export interface DeleteAddressMapRequest {
+    addressMapId: string;
+    /** Identifier of a Cloudflare account. */
+    accountId: string;
+}
+export declare const DeleteAddressMapRequest: Schema.Schema<DeleteAddressMapRequest>;
+export interface DeleteAddressMapResponse {
+    errors: {
+        code: number;
+        message: string;
+        documentationUrl?: string | null;
+        source?: {
+            pointer?: string | null;
+        } | null;
+    }[];
+    messages: {
+        code: number;
+        message: string;
+        documentationUrl?: string | null;
+        source?: {
+            pointer?: string | null;
+        } | null;
+    }[];
+    /** Whether the API call was successful. */
+    success: true;
+    resultInfo?: {
+        count?: number | null;
+        page?: number | null;
+        perPage?: number | null;
+        totalCount?: number | null;
+    } | null;
+}
+export declare const DeleteAddressMapResponse: Schema.Schema<DeleteAddressMapResponse>;
+export type DeleteAddressMapError = DefaultErrors | MethodNotAllowed | FeatureNotEnabled | InvalidAccountId | AddressMapNotFound;
+export declare const deleteAddressMap: API.OperationMethod<DeleteAddressMapRequest, DeleteAddressMapResponse, DeleteAddressMapError, Credentials | HttpClient.HttpClient>;
+export interface PutAddressMapAccountRequest {
+    addressMapId: string;
+    /** Path param: Identifier of a Cloudflare account. */
+    accountId: string;
+    /** Body param: */
+    body: unknown;
+}
+export declare const PutAddressMapAccountRequest: Schema.Schema<PutAddressMapAccountRequest>;
+export interface PutAddressMapAccountResponse {
+    errors: {
+        code: number;
+        message: string;
+        documentationUrl?: string | null;
+        source?: {
+            pointer?: string | null;
+        } | null;
+    }[];
+    messages: {
+        code: number;
+        message: string;
+        documentationUrl?: string | null;
+        source?: {
+            pointer?: string | null;
+        } | null;
+    }[];
+    /** Whether the API call was successful. */
+    success: true;
+    resultInfo?: {
+        count?: number | null;
+        page?: number | null;
+        perPage?: number | null;
+        totalCount?: number | null;
+    } | null;
+}
+export declare const PutAddressMapAccountResponse: Schema.Schema<PutAddressMapAccountResponse>;
+export type PutAddressMapAccountError = DefaultErrors | MethodNotAllowed | FeatureNotEnabled | InvalidAccountId;
+export declare const putAddressMapAccount: API.OperationMethod<PutAddressMapAccountRequest, PutAddressMapAccountResponse, PutAddressMapAccountError, Credentials | HttpClient.HttpClient>;
+export interface DeleteAddressMapAccountRequest {
+    addressMapId: string;
+    /** Identifier of a Cloudflare account. */
+    accountId: string;
+}
+export declare const DeleteAddressMapAccountRequest: Schema.Schema<DeleteAddressMapAccountRequest>;
+export interface DeleteAddressMapAccountResponse {
+    errors: {
+        code: number;
+        message: string;
+        documentationUrl?: string | null;
+        source?: {
+            pointer?: string | null;
+        } | null;
+    }[];
+    messages: {
+        code: number;
+        message: string;
+        documentationUrl?: string | null;
+        source?: {
+            pointer?: string | null;
+        } | null;
+    }[];
+    /** Whether the API call was successful. */
+    success: true;
+    resultInfo?: {
+        count?: number | null;
+        page?: number | null;
+        perPage?: number | null;
+        totalCount?: number | null;
+    } | null;
+}
+export declare const DeleteAddressMapAccountResponse: Schema.Schema<DeleteAddressMapAccountResponse>;
+export type DeleteAddressMapAccountError = DefaultErrors | MethodNotAllowed | FeatureNotEnabled | InvalidAccountId;
+export declare const deleteAddressMapAccount: API.OperationMethod<DeleteAddressMapAccountRequest, DeleteAddressMapAccountResponse, DeleteAddressMapAccountError, Credentials | HttpClient.HttpClient>;
+export interface PutAddressMapIpRequest {
+    addressMapId: string;
+    ipAddress: string;
+    /** Path param: Identifier of a Cloudflare account. */
+    accountId: string;
+    /** Body param: */
+    body: unknown;
+}
+export declare const PutAddressMapIpRequest: Schema.Schema<PutAddressMapIpRequest>;
+export interface PutAddressMapIpResponse {
+    errors: {
+        code: number;
+        message: string;
+        documentationUrl?: string | null;
+        source?: {
+            pointer?: string | null;
+        } | null;
+    }[];
+    messages: {
+        code: number;
+        message: string;
+        documentationUrl?: string | null;
+        source?: {
+            pointer?: string | null;
+        } | null;
+    }[];
+    /** Whether the API call was successful. */
+    success: true;
+    resultInfo?: {
+        count?: number | null;
+        page?: number | null;
+        perPage?: number | null;
+        totalCount?: number | null;
+    } | null;
+}
+export declare const PutAddressMapIpResponse: Schema.Schema<PutAddressMapIpResponse>;
+export type PutAddressMapIpError = DefaultErrors | MethodNotAllowed | FeatureNotEnabled | InvalidAccountId | AddressMapNotFound;
+export declare const putAddressMapIp: API.OperationMethod<PutAddressMapIpRequest, PutAddressMapIpResponse, PutAddressMapIpError, Credentials | HttpClient.HttpClient>;
+export interface DeleteAddressMapIpRequest {
+    addressMapId: string;
+    ipAddress: string;
+    /** Identifier of a Cloudflare account. */
+    accountId: string;
+}
+export declare const DeleteAddressMapIpRequest: Schema.Schema<DeleteAddressMapIpRequest>;
+export interface DeleteAddressMapIpResponse {
+    errors: {
+        code: number;
+        message: string;
+        documentationUrl?: string | null;
+        source?: {
+            pointer?: string | null;
+        } | null;
+    }[];
+    messages: {
+        code: number;
+        message: string;
+        documentationUrl?: string | null;
+        source?: {
+            pointer?: string | null;
+        } | null;
+    }[];
+    /** Whether the API call was successful. */
+    success: true;
+    resultInfo?: {
+        count?: number | null;
+        page?: number | null;
+        perPage?: number | null;
+        totalCount?: number | null;
+    } | null;
+}
+export declare const DeleteAddressMapIpResponse: Schema.Schema<DeleteAddressMapIpResponse>;
+export type DeleteAddressMapIpError = DefaultErrors | MethodNotAllowed | FeatureNotEnabled | InvalidAccountId | AddressMapNotFound;
+export declare const deleteAddressMapIp: API.OperationMethod<DeleteAddressMapIpRequest, DeleteAddressMapIpResponse, DeleteAddressMapIpError, Credentials | HttpClient.HttpClient>;
+export interface PutAddressMapZoneRequest {
+    addressMapId: string;
+    /** Path param: Identifier of a zone. */
+    zoneId: string;
+    /** Path param: Identifier of a Cloudflare account. */
+    accountId: string;
+    /** Body param: */
+    body: unknown;
+}
+export declare const PutAddressMapZoneRequest: Schema.Schema<PutAddressMapZoneRequest>;
+export interface PutAddressMapZoneResponse {
+    errors: {
+        code: number;
+        message: string;
+        documentationUrl?: string | null;
+        source?: {
+            pointer?: string | null;
+        } | null;
+    }[];
+    messages: {
+        code: number;
+        message: string;
+        documentationUrl?: string | null;
+        source?: {
+            pointer?: string | null;
+        } | null;
+    }[];
+    /** Whether the API call was successful. */
+    success: true;
+    resultInfo?: {
+        count?: number | null;
+        page?: number | null;
+        perPage?: number | null;
+        totalCount?: number | null;
+    } | null;
+}
+export declare const PutAddressMapZoneResponse: Schema.Schema<PutAddressMapZoneResponse>;
+export type PutAddressMapZoneError = DefaultErrors | MethodNotAllowed | FeatureNotEnabled | InvalidAccountId;
+export declare const putAddressMapZone: API.OperationMethod<PutAddressMapZoneRequest, PutAddressMapZoneResponse, PutAddressMapZoneError, Credentials | HttpClient.HttpClient>;
+export interface DeleteAddressMapZoneRequest {
+    addressMapId: string;
+    /** Identifier of a zone. */
+    zoneId: string;
+    /** Identifier of a Cloudflare account. */
+    accountId: string;
+}
+export declare const DeleteAddressMapZoneRequest: Schema.Schema<DeleteAddressMapZoneRequest>;
+export interface DeleteAddressMapZoneResponse {
+    errors: {
+        code: number;
+        message: string;
+        documentationUrl?: string | null;
+        source?: {
+            pointer?: string | null;
+        } | null;
+    }[];
+    messages: {
+        code: number;
+        message: string;
+        documentationUrl?: string | null;
+        source?: {
+            pointer?: string | null;
+        } | null;
+    }[];
+    /** Whether the API call was successful. */
+    success: true;
+    resultInfo?: {
+        count?: number | null;
+        page?: number | null;
+        perPage?: number | null;
+        totalCount?: number | null;
+    } | null;
+}
+export declare const DeleteAddressMapZoneResponse: Schema.Schema<DeleteAddressMapZoneResponse>;
+export type DeleteAddressMapZoneError = DefaultErrors | MethodNotAllowed | FeatureNotEnabled | InvalidAccountId;
+export declare const deleteAddressMapZone: API.OperationMethod<DeleteAddressMapZoneRequest, DeleteAddressMapZoneResponse, DeleteAddressMapZoneError, Credentials | HttpClient.HttpClient>;
+export interface GetLoaDocumentRequest {
+    loaDocumentId: string | null;
+    /** Identifier of a Cloudflare account. */
+    accountId: string;
+}
+export declare const GetLoaDocumentRequest: Schema.Schema<GetLoaDocumentRequest>;
+export type GetLoaDocumentResponse = unknown;
+export declare const GetLoaDocumentResponse: Schema.Schema<unknown>;
+export type GetLoaDocumentError = DefaultErrors | LoaDocumentNotFound | InvalidAccountId;
+export declare const getLoaDocument: API.OperationMethod<GetLoaDocumentRequest, GetLoaDocumentResponse, GetLoaDocumentError, Credentials | HttpClient.HttpClient>;
+export interface CreateLoaDocumentRequest {
+    /** Path param: Identifier of a Cloudflare account. */
+    accountId: string;
+    /** Body param: LOA document to upload. */
+    loaDocument: string;
+}
+export declare const CreateLoaDocumentRequest: Schema.Schema<CreateLoaDocumentRequest>;
+export interface CreateLoaDocumentResponse {
+    /** Identifier for the uploaded LOA document. */
+    id?: string | null;
+    /** Identifier of a Cloudflare account. */
+    accountId?: string | null;
+    /** Whether the LOA has been auto-generated for the prefix owner by Cloudflare. */
+    autoGenerated?: boolean | null;
+    created?: string | null;
+    /** Name of LOA document. Max file size 10MB, and supported filetype is pdf. */
+    filename?: string | null;
+    /** File size of the uploaded LOA document. */
+    sizeBytes?: number | null;
+    /** Whether the LOA has been verified by Cloudflare staff. */
+    verified?: boolean | null;
+    /** Timestamp of the moment the LOA was marked as validated. */
+    verifiedAt?: string | null;
+}
+export declare const CreateLoaDocumentResponse: Schema.Schema<CreateLoaDocumentResponse>;
+export type CreateLoaDocumentError = DefaultErrors | InvalidAccountId | InvalidLoaForm;
+export declare const createLoaDocument: API.OperationMethod<CreateLoaDocumentRequest, CreateLoaDocumentResponse, CreateLoaDocumentError, Credentials | HttpClient.HttpClient>;
+export interface GetPrefixRequest {
+    prefixId: string;
+    /** Identifier of a Cloudflare account. */
+    accountId: string;
+}
+export declare const GetPrefixRequest: Schema.Schema<GetPrefixRequest>;
+export interface GetPrefixResponse {
+    /** Identifier of an IP Prefix. */
+    id?: string | null;
+    /** Identifier of a Cloudflare account. */
+    accountId?: string | null;
+    /** @deprecated Prefer the [BGP Prefixes API](https://developers.cloudflare.com/api/resources/addressing/subresources/prefixes/subresources/bgp_prefixes/) instead, which allows for advertising multiple BG */
+    advertised?: boolean | null;
+    /** @deprecated Prefer the [BGP Prefixes API](https://developers.cloudflare.com/api/resources/addressing/subresources/prefixes/subresources/bgp_prefixes/) instead, which allows for advertising multiple BG */
+    advertisedModifiedAt?: string | null;
+    /** Approval state of the prefix (P = pending, V = active). */
+    approved?: string | null;
+    /** Autonomous System Number (ASN) the prefix will be advertised under. */
+    asn?: number | null;
+    /** IP Prefix in Classless Inter-Domain Routing format. */
+    cidr?: string | null;
+    createdAt?: string | null;
+    /** Whether Cloudflare is allowed to generate the LOA document on behalf of the prefix owner. */
+    delegateLoaCreation?: boolean | null;
+    /** Description of the prefix. */
+    description?: string | null;
+    /** State of one kind of validation for an IP prefix. */
+    irrValidationState?: string | null;
+    /** Identifier for the uploaded LOA document. */
+    loaDocumentId?: string | null;
+    modifiedAt?: string | null;
+    /** @deprecated Prefer the [BGP Prefixes API](https://developers.cloudflare.com/api/resources/addressing/subresources/prefixes/subresources/bgp_prefixes/) instead, which allows for advertising multiple BG */
+    onDemandEnabled?: boolean | null;
+    /** @deprecated Prefer the [BGP Prefixes API](https://developers.cloudflare.com/api/resources/addressing/subresources/prefixes/subresources/bgp_prefixes/) instead, which allows for advertising multiple BG */
+    onDemandLocked?: boolean | null;
+    /** State of one kind of validation for an IP prefix. */
+    ownershipValidationState?: string | null;
+    /** Token provided to demonstrate ownership of the prefix. */
+    ownershipValidationToken?: string | null;
+    /** State of one kind of validation for an IP prefix. */
+    rpkiValidationState?: string | null;
+}
+export declare const GetPrefixResponse: Schema.Schema<GetPrefixResponse>;
+export type GetPrefixError = DefaultErrors | PrefixNotFound | InvalidAccountId;
+export declare const getPrefix: API.OperationMethod<GetPrefixRequest, GetPrefixResponse, GetPrefixError, Credentials | HttpClient.HttpClient>;
+export interface ListPrefixesRequest {
+    /** Identifier of a Cloudflare account. */
+    accountId: string;
+}
+export declare const ListPrefixesRequest: Schema.Schema<ListPrefixesRequest>;
+export interface ListPrefixesResponse {
+    result: {
+        id?: string | null;
+        accountId?: string | null;
+        advertised?: boolean | null;
+        advertisedModifiedAt?: string | null;
+        approved?: string | null;
+        asn?: number | null;
+        cidr?: string | null;
+        createdAt?: string | null;
+        delegateLoaCreation?: boolean | null;
+        description?: string | null;
+        irrValidationState?: string | null;
+        loaDocumentId?: string | null;
+        modifiedAt?: string | null;
+        onDemandEnabled?: boolean | null;
+        onDemandLocked?: boolean | null;
+        ownershipValidationState?: string | null;
+        ownershipValidationToken?: string | null;
+        rpkiValidationState?: string | null;
+    }[];
+}
+export declare const ListPrefixesResponse: Schema.Schema<ListPrefixesResponse>;
+export type ListPrefixesError = DefaultErrors;
+export declare const listPrefixes: API.PaginatedOperationMethod<ListPrefixesRequest, ListPrefixesResponse, ListPrefixesError, Credentials | HttpClient.HttpClient> & {
+    pages: (input: ListPrefixesRequest) => stream.Stream<ListPrefixesResponse, ListPrefixesError, Credentials | HttpClient.HttpClient>;
+    items: (input: ListPrefixesRequest) => stream.Stream<{
+        id?: string | null;
+        accountId?: string | null;
+        advertised?: boolean | null;
+        advertisedModifiedAt?: string | null;
+        approved?: string | null;
+        asn?: number | null;
+        cidr?: string | null;
+        createdAt?: string | null;
+        delegateLoaCreation?: boolean | null;
+        description?: string | null;
+        irrValidationState?: string | null;
+        loaDocumentId?: string | null;
+        modifiedAt?: string | null;
+        onDemandEnabled?: boolean | null;
+        onDemandLocked?: boolean | null;
+        ownershipValidationState?: string | null;
+        ownershipValidationToken?: string | null;
+        rpkiValidationState?: string | null;
+    }, ListPrefixesError, Credentials | HttpClient.HttpClient>;
+};
+export interface CreatePrefixRequest {
+    /** Path param: Identifier of a Cloudflare account. */
+    accountId: string;
+    /** Body param: Autonomous System Number (ASN) the prefix will be advertised under. */
+    asn: number;
+    /** Body param: IP Prefix in Classless Inter-Domain Routing format. */
+    cidr: string;
+    /** Body param: Whether Cloudflare is allowed to generate the LOA document on behalf of the prefix owner. */
+    delegateLoaCreation?: boolean;
+    /** Body param: Description of the prefix. */
+    description?: string;
+    /** Body param: Identifier for the uploaded LOA document. */
+    loaDocumentId?: string | null;
+}
+export declare const CreatePrefixRequest: Schema.Schema<CreatePrefixRequest>;
+export interface CreatePrefixResponse {
+    /** Identifier of an IP Prefix. */
+    id?: string | null;
+    /** Identifier of a Cloudflare account. */
+    accountId?: string | null;
+    /** @deprecated Prefer the [BGP Prefixes API](https://developers.cloudflare.com/api/resources/addressing/subresources/prefixes/subresources/bgp_prefixes/) instead, which allows for advertising multiple BG */
+    advertised?: boolean | null;
+    /** @deprecated Prefer the [BGP Prefixes API](https://developers.cloudflare.com/api/resources/addressing/subresources/prefixes/subresources/bgp_prefixes/) instead, which allows for advertising multiple BG */
+    advertisedModifiedAt?: string | null;
+    /** Approval state of the prefix (P = pending, V = active). */
+    approved?: string | null;
+    /** Autonomous System Number (ASN) the prefix will be advertised under. */
+    asn?: number | null;
+    /** IP Prefix in Classless Inter-Domain Routing format. */
+    cidr?: string | null;
+    createdAt?: string | null;
+    /** Whether Cloudflare is allowed to generate the LOA document on behalf of the prefix owner. */
+    delegateLoaCreation?: boolean | null;
+    /** Description of the prefix. */
+    description?: string | null;
+    /** State of one kind of validation for an IP prefix. */
+    irrValidationState?: string | null;
+    /** Identifier for the uploaded LOA document. */
+    loaDocumentId?: string | null;
+    modifiedAt?: string | null;
+    /** @deprecated Prefer the [BGP Prefixes API](https://developers.cloudflare.com/api/resources/addressing/subresources/prefixes/subresources/bgp_prefixes/) instead, which allows for advertising multiple BG */
+    onDemandEnabled?: boolean | null;
+    /** @deprecated Prefer the [BGP Prefixes API](https://developers.cloudflare.com/api/resources/addressing/subresources/prefixes/subresources/bgp_prefixes/) instead, which allows for advertising multiple BG */
+    onDemandLocked?: boolean | null;
+    /** State of one kind of validation for an IP prefix. */
+    ownershipValidationState?: string | null;
+    /** Token provided to demonstrate ownership of the prefix. */
+    ownershipValidationToken?: string | null;
+    /** State of one kind of validation for an IP prefix. */
+    rpkiValidationState?: string | null;
+}
+export declare const CreatePrefixResponse: Schema.Schema<CreatePrefixResponse>;
+export type CreatePrefixError = DefaultErrors | InvalidAccountId | InvalidNetworkCidr | IrrEntryNotFound;
+export declare const createPrefix: API.OperationMethod<CreatePrefixRequest, CreatePrefixResponse, CreatePrefixError, Credentials | HttpClient.HttpClient>;
+export interface PatchPrefixRequest {
+    prefixId: string;
+    /** Path param: Identifier of a Cloudflare account. */
+    accountId: string;
+    /** Body param: Description of the prefix. */
+    description: string;
+}
+export declare const PatchPrefixRequest: Schema.Schema<PatchPrefixRequest>;
+export interface PatchPrefixResponse {
+    /** Identifier of an IP Prefix. */
+    id?: string | null;
+    /** Identifier of a Cloudflare account. */
+    accountId?: string | null;
+    /** @deprecated Prefer the [BGP Prefixes API](https://developers.cloudflare.com/api/resources/addressing/subresources/prefixes/subresources/bgp_prefixes/) instead, which allows for advertising multiple BG */
+    advertised?: boolean | null;
+    /** @deprecated Prefer the [BGP Prefixes API](https://developers.cloudflare.com/api/resources/addressing/subresources/prefixes/subresources/bgp_prefixes/) instead, which allows for advertising multiple BG */
+    advertisedModifiedAt?: string | null;
+    /** Approval state of the prefix (P = pending, V = active). */
+    approved?: string | null;
+    /** Autonomous System Number (ASN) the prefix will be advertised under. */
+    asn?: number | null;
+    /** IP Prefix in Classless Inter-Domain Routing format. */
+    cidr?: string | null;
+    createdAt?: string | null;
+    /** Whether Cloudflare is allowed to generate the LOA document on behalf of the prefix owner. */
+    delegateLoaCreation?: boolean | null;
+    /** Description of the prefix. */
+    description?: string | null;
+    /** State of one kind of validation for an IP prefix. */
+    irrValidationState?: string | null;
+    /** Identifier for the uploaded LOA document. */
+    loaDocumentId?: string | null;
+    modifiedAt?: string | null;
+    /** @deprecated Prefer the [BGP Prefixes API](https://developers.cloudflare.com/api/resources/addressing/subresources/prefixes/subresources/bgp_prefixes/) instead, which allows for advertising multiple BG */
+    onDemandEnabled?: boolean | null;
+    /** @deprecated Prefer the [BGP Prefixes API](https://developers.cloudflare.com/api/resources/addressing/subresources/prefixes/subresources/bgp_prefixes/) instead, which allows for advertising multiple BG */
+    onDemandLocked?: boolean | null;
+    /** State of one kind of validation for an IP prefix. */
+    ownershipValidationState?: string | null;
+    /** Token provided to demonstrate ownership of the prefix. */
+    ownershipValidationToken?: string | null;
+    /** State of one kind of validation for an IP prefix. */
+    rpkiValidationState?: string | null;
+}
+export declare const PatchPrefixResponse: Schema.Schema<PatchPrefixResponse>;
+export type PatchPrefixError = DefaultErrors | MethodNotAllowed | PrefixNotFound | InvalidAccountId;
+export declare const patchPrefix: API.OperationMethod<PatchPrefixRequest, PatchPrefixResponse, PatchPrefixError, Credentials | HttpClient.HttpClient>;
+export interface DeletePrefixRequest {
+    prefixId: string;
+    /** Identifier of a Cloudflare account. */
+    accountId: string;
+}
+export declare const DeletePrefixRequest: Schema.Schema<DeletePrefixRequest>;
+export interface DeletePrefixResponse {
+    errors: {
+        code: number;
+        message: string;
+        documentationUrl?: string | null;
+        source?: {
+            pointer?: string | null;
+        } | null;
+    }[];
+    messages: {
+        code: number;
+        message: string;
+        documentationUrl?: string | null;
+        source?: {
+            pointer?: string | null;
+        } | null;
+    }[];
+    /** Whether the API call was successful. */
+    success: true;
+}
+export declare const DeletePrefixResponse: Schema.Schema<DeletePrefixResponse>;
+export type DeletePrefixError = DefaultErrors | MethodNotAllowed | PrefixNotFound | InvalidAccountId;
+export declare const deletePrefix: API.OperationMethod<DeletePrefixRequest, DeletePrefixResponse, DeletePrefixError, Credentials | HttpClient.HttpClient>;
+export interface GetPrefixAdvertisementStatusRequest {
+    prefixId: string;
+    /** Identifier of a Cloudflare account. */
+    accountId: string;
+}
+export declare const GetPrefixAdvertisementStatusRequest: Schema.Schema<GetPrefixAdvertisementStatusRequest>;
+export interface GetPrefixAdvertisementStatusResponse {
+    /** Advertisement status of the prefix. If `true`, the BGP route for the prefix is advertised to the Internet. If `false`, the BGP route is withdrawn. */
+    advertised?: boolean | null;
+    /** Last time the advertisement status was changed. This field is only not 'null' if on demand is enabled. */
+    advertisedModifiedAt?: string | null;
+}
+export declare const GetPrefixAdvertisementStatusResponse: Schema.Schema<GetPrefixAdvertisementStatusResponse>;
+export type GetPrefixAdvertisementStatusError = DefaultErrors | PrefixNotFound | InvalidAccountId;
+export declare const getPrefixAdvertisementStatus: API.OperationMethod<GetPrefixAdvertisementStatusRequest, GetPrefixAdvertisementStatusResponse, GetPrefixAdvertisementStatusError, Credentials | HttpClient.HttpClient>;
+export interface PatchPrefixAdvertisementStatusRequest {
+    prefixId: string;
+    /** Path param: Identifier of a Cloudflare account. */
+    accountId: string;
+    /** Body param: Advertisement status of the prefix. If `true`, the BGP route for the prefix is advertised to the Internet. If `false`, the BGP route is withdrawn. */
+    advertised: boolean;
+}
+export declare const PatchPrefixAdvertisementStatusRequest: Schema.Schema<PatchPrefixAdvertisementStatusRequest>;
+export interface PatchPrefixAdvertisementStatusResponse {
+    /** Advertisement status of the prefix. If `true`, the BGP route for the prefix is advertised to the Internet. If `false`, the BGP route is withdrawn. */
+    advertised?: boolean | null;
+    /** Last time the advertisement status was changed. This field is only not 'null' if on demand is enabled. */
+    advertisedModifiedAt?: string | null;
+}
+export declare const PatchPrefixAdvertisementStatusResponse: Schema.Schema<PatchPrefixAdvertisementStatusResponse>;
+export type PatchPrefixAdvertisementStatusError = DefaultErrors | PrefixNotFound | InvalidAccountId;
+export declare const patchPrefixAdvertisementStatus: API.OperationMethod<PatchPrefixAdvertisementStatusRequest, PatchPrefixAdvertisementStatusResponse, PatchPrefixAdvertisementStatusError, Credentials | HttpClient.HttpClient>;
+export interface GetPrefixBgpPrefixRequest {
+    prefixId: string;
+    bgpPrefixId: string;
+    /** Identifier of a Cloudflare account. */
+    accountId: string;
+}
+export declare const GetPrefixBgpPrefixRequest: Schema.Schema<GetPrefixBgpPrefixRequest>;
+export interface GetPrefixBgpPrefixResponse {
+    /** Identifier of BGP Prefix. */
+    id?: string | null;
+    /** Autonomous System Number (ASN) the prefix will be advertised under. */
+    asn?: number | null;
+    /** Number of times to prepend the Cloudflare ASN to the BGP AS-Path attribute */
+    asnPrependCount?: number | null;
+    /** Determines if Cloudflare advertises a BYOIP BGP prefix even when there is no matching BGP prefix in the Magic routing table. When true, Cloudflare will automatically withdraw the BGP prefix when there */
+    autoAdvertiseWithdraw?: boolean | null;
+    bgpSignalOpts?: {
+        enabled?: boolean | null;
+        modifiedAt?: string | null;
+    } | null;
+    /** IP Prefix in Classless Inter-Domain Routing format. */
+    cidr?: string | null;
+    createdAt?: string | null;
+    modifiedAt?: string | null;
+    onDemand?: {
+        advertised?: boolean | null;
+        advertisedModifiedAt?: string | null;
+        onDemandEnabled?: boolean | null;
+        onDemandLocked?: boolean | null;
+    } | null;
+}
+export declare const GetPrefixBgpPrefixResponse: Schema.Schema<GetPrefixBgpPrefixResponse>;
+export type GetPrefixBgpPrefixError = DefaultErrors | BgpPrefixNotFound | InvalidAccountId | PrefixNotFound;
+export declare const getPrefixBgpPrefix: API.OperationMethod<GetPrefixBgpPrefixRequest, GetPrefixBgpPrefixResponse, GetPrefixBgpPrefixError, Credentials | HttpClient.HttpClient>;
+export interface ListPrefixBgpPrefixesRequest {
+    prefixId: string;
+    /** Identifier of a Cloudflare account. */
+    accountId: string;
+}
+export declare const ListPrefixBgpPrefixesRequest: Schema.Schema<ListPrefixBgpPrefixesRequest>;
+export interface ListPrefixBgpPrefixesResponse {
+    result: {
+        id?: string | null;
+        asn?: number | null;
+        asnPrependCount?: number | null;
+        autoAdvertiseWithdraw?: boolean | null;
+        bgpSignalOpts?: {
+            enabled?: boolean | null;
+            modifiedAt?: string | null;
+        } | null;
+        cidr?: string | null;
+        createdAt?: string | null;
+        modifiedAt?: string | null;
+        onDemand?: {
+            advertised?: boolean | null;
+            advertisedModifiedAt?: string | null;
+            onDemandEnabled?: boolean | null;
+            onDemandLocked?: boolean | null;
+        } | null;
+    }[];
+}
+export declare const ListPrefixBgpPrefixesResponse: Schema.Schema<ListPrefixBgpPrefixesResponse>;
+export type ListPrefixBgpPrefixesError = DefaultErrors;
+export declare const listPrefixBgpPrefixes: API.PaginatedOperationMethod<ListPrefixBgpPrefixesRequest, ListPrefixBgpPrefixesResponse, ListPrefixBgpPrefixesError, Credentials | HttpClient.HttpClient> & {
+    pages: (input: ListPrefixBgpPrefixesRequest) => stream.Stream<ListPrefixBgpPrefixesResponse, ListPrefixBgpPrefixesError, Credentials | HttpClient.HttpClient>;
+    items: (input: ListPrefixBgpPrefixesRequest) => stream.Stream<{
+        id?: string | null;
+        asn?: number | null;
+        asnPrependCount?: number | null;
+        autoAdvertiseWithdraw?: boolean | null;
+        bgpSignalOpts?: {
+            enabled?: boolean | null;
+            modifiedAt?: string | null;
+        } | null;
+        cidr?: string | null;
+        createdAt?: string | null;
+        modifiedAt?: string | null;
+        onDemand?: {
+            advertised?: boolean | null;
+            advertisedModifiedAt?: string | null;
+            onDemandEnabled?: boolean | null;
+            onDemandLocked?: boolean | null;
+        } | null;
+    }, ListPrefixBgpPrefixesError, Credentials | HttpClient.HttpClient>;
+};
+export interface CreatePrefixBgpPrefixRequest {
+    prefixId: string;
+    /** Path param: Identifier of a Cloudflare account. */
+    accountId: string;
+    /** Body param: IP Prefix in Classless Inter-Domain Routing format. */
+    cidr: string;
+}
+export declare const CreatePrefixBgpPrefixRequest: Schema.Schema<CreatePrefixBgpPrefixRequest>;
+export interface CreatePrefixBgpPrefixResponse {
+    /** Identifier of BGP Prefix. */
+    id?: string | null;
+    /** Autonomous System Number (ASN) the prefix will be advertised under. */
+    asn?: number | null;
+    /** Number of times to prepend the Cloudflare ASN to the BGP AS-Path attribute */
+    asnPrependCount?: number | null;
+    /** Determines if Cloudflare advertises a BYOIP BGP prefix even when there is no matching BGP prefix in the Magic routing table. When true, Cloudflare will automatically withdraw the BGP prefix when there */
+    autoAdvertiseWithdraw?: boolean | null;
+    bgpSignalOpts?: {
+        enabled?: boolean | null;
+        modifiedAt?: string | null;
+    } | null;
+    /** IP Prefix in Classless Inter-Domain Routing format. */
+    cidr?: string | null;
+    createdAt?: string | null;
+    modifiedAt?: string | null;
+    onDemand?: {
+        advertised?: boolean | null;
+        advertisedModifiedAt?: string | null;
+        onDemandEnabled?: boolean | null;
+        onDemandLocked?: boolean | null;
+    } | null;
+}
+export declare const CreatePrefixBgpPrefixResponse: Schema.Schema<CreatePrefixBgpPrefixResponse>;
+export type CreatePrefixBgpPrefixError = DefaultErrors | NonexistentAccountPrefix | InvalidAccountId | InvalidNetworkCidr;
+export declare const createPrefixBgpPrefix: API.OperationMethod<CreatePrefixBgpPrefixRequest, CreatePrefixBgpPrefixResponse, CreatePrefixBgpPrefixError, Credentials | HttpClient.HttpClient>;
+export interface PatchPrefixBgpPrefixRequest {
+    prefixId: string;
+    bgpPrefixId: string;
+    /** Path param: Identifier of a Cloudflare account. */
+    accountId: string;
+    /** Body param: Number of times to prepend the Cloudflare ASN to the BGP AS-Path attribute */
+    asnPrependCount?: number;
+    /** Body param: Determines if Cloudflare advertises a BYOIP BGP prefix even when there is no matching BGP prefix in the Magic routing table. When true, Cloudflare will automatically withdraw the BGP prefi */
+    autoAdvertiseWithdraw?: boolean;
+    /** Body param: */
+    onDemand?: {
+        advertised?: boolean;
+    };
+}
+export declare const PatchPrefixBgpPrefixRequest: Schema.Schema<PatchPrefixBgpPrefixRequest>;
+export interface PatchPrefixBgpPrefixResponse {
+    /** Identifier of BGP Prefix. */
+    id?: string | null;
+    /** Autonomous System Number (ASN) the prefix will be advertised under. */
+    asn?: number | null;
+    /** Number of times to prepend the Cloudflare ASN to the BGP AS-Path attribute */
+    asnPrependCount?: number | null;
+    /** Determines if Cloudflare advertises a BYOIP BGP prefix even when there is no matching BGP prefix in the Magic routing table. When true, Cloudflare will automatically withdraw the BGP prefix when there */
+    autoAdvertiseWithdraw?: boolean | null;
+    bgpSignalOpts?: {
+        enabled?: boolean | null;
+        modifiedAt?: string | null;
+    } | null;
+    /** IP Prefix in Classless Inter-Domain Routing format. */
+    cidr?: string | null;
+    createdAt?: string | null;
+    modifiedAt?: string | null;
+    onDemand?: {
+        advertised?: boolean | null;
+        advertisedModifiedAt?: string | null;
+        onDemandEnabled?: boolean | null;
+        onDemandLocked?: boolean | null;
+    } | null;
+}
+export declare const PatchPrefixBgpPrefixResponse: Schema.Schema<PatchPrefixBgpPrefixResponse>;
+export type PatchPrefixBgpPrefixError = DefaultErrors | BgpPrefixNotFound | InvalidAccountId;
+export declare const patchPrefixBgpPrefix: API.OperationMethod<PatchPrefixBgpPrefixRequest, PatchPrefixBgpPrefixResponse, PatchPrefixBgpPrefixError, Credentials | HttpClient.HttpClient>;
+export interface ListPrefixDelegationsRequest {
+    prefixId: string;
+    /** Identifier of a Cloudflare account. */
+    accountId: string;
+}
+export declare const ListPrefixDelegationsRequest: Schema.Schema<ListPrefixDelegationsRequest>;
+export interface ListPrefixDelegationsResponse {
+    result: {
+        id?: string | null;
+        cidr?: string | null;
+        createdAt?: string | null;
+        delegatedAccountId?: string | null;
+        modifiedAt?: string | null;
+        parentPrefixId?: string | null;
+    }[];
+}
+export declare const ListPrefixDelegationsResponse: Schema.Schema<ListPrefixDelegationsResponse>;
+export type ListPrefixDelegationsError = DefaultErrors;
+export declare const listPrefixDelegations: API.PaginatedOperationMethod<ListPrefixDelegationsRequest, ListPrefixDelegationsResponse, ListPrefixDelegationsError, Credentials | HttpClient.HttpClient> & {
+    pages: (input: ListPrefixDelegationsRequest) => stream.Stream<ListPrefixDelegationsResponse, ListPrefixDelegationsError, Credentials | HttpClient.HttpClient>;
+    items: (input: ListPrefixDelegationsRequest) => stream.Stream<{
+        id?: string | null;
+        cidr?: string | null;
+        createdAt?: string | null;
+        delegatedAccountId?: string | null;
+        modifiedAt?: string | null;
+        parentPrefixId?: string | null;
+    }, ListPrefixDelegationsError, Credentials | HttpClient.HttpClient>;
+};
+export interface CreatePrefixDelegationRequest {
+    prefixId: string;
+    /** Path param: Identifier of a Cloudflare account. */
+    accountId: string;
+    /** Body param: IP Prefix in Classless Inter-Domain Routing format. */
+    cidr: string;
+    /** Body param: Account identifier for the account to which prefix is being delegated. */
+    delegatedAccountId: string;
+}
+export declare const CreatePrefixDelegationRequest: Schema.Schema<CreatePrefixDelegationRequest>;
+export interface CreatePrefixDelegationResponse {
+    /** Identifier of a Delegation. */
+    id?: string | null;
+    /** IP Prefix in Classless Inter-Domain Routing format. */
+    cidr?: string | null;
+    createdAt?: string | null;
+    /** Account identifier for the account to which prefix is being delegated. */
+    delegatedAccountId?: string | null;
+    modifiedAt?: string | null;
+    /** Identifier of an IP Prefix. */
+    parentPrefixId?: string | null;
+}
+export declare const CreatePrefixDelegationResponse: Schema.Schema<CreatePrefixDelegationResponse>;
+export type CreatePrefixDelegationError = DefaultErrors | PrefixNotFound | MissingAccountId | InvalidAccountId;
+export declare const createPrefixDelegation: API.OperationMethod<CreatePrefixDelegationRequest, CreatePrefixDelegationResponse, CreatePrefixDelegationError, Credentials | HttpClient.HttpClient>;
+export interface DeletePrefixDelegationRequest {
+    prefixId: string;
+    delegationId: string;
+    /** Identifier of a Cloudflare account. */
+    accountId: string;
+}
+export declare const DeletePrefixDelegationRequest: Schema.Schema<DeletePrefixDelegationRequest>;
+export interface DeletePrefixDelegationResponse {
+    /** Identifier of a Delegation. */
+    id?: string | null;
+}
+export declare const DeletePrefixDelegationResponse: Schema.Schema<DeletePrefixDelegationResponse>;
+export type DeletePrefixDelegationError = DefaultErrors | DelegationNotFound | InvalidAccountId;
+export declare const deletePrefixDelegation: API.OperationMethod<DeletePrefixDelegationRequest, DeletePrefixDelegationResponse, DeletePrefixDelegationError, Credentials | HttpClient.HttpClient>;
+export interface GetPrefixServiceBindingRequest {
+    prefixId: string;
+    bindingId: string;
+    /** Identifier of a Cloudflare account. */
+    accountId: string;
+}
+export declare const GetPrefixServiceBindingRequest: Schema.Schema<GetPrefixServiceBindingRequest>;
+export interface GetPrefixServiceBindingResponse {
+    /** Identifier of a Service Binding. */
+    id?: string | null;
+    /** IP Prefix in Classless Inter-Domain Routing format. */
+    cidr?: string | null;
+    /** Status of a Service Binding's deployment to the Cloudflare network */
+    provisioning?: {
+        state?: "provisioning" | "active" | null;
+    } | null;
+    /** Identifier of a Service on the Cloudflare network. Available services and their IDs may be found in the  List Services  endpoint. */
+    serviceId?: string | null;
+    /** Name of a service running on the Cloudflare network */
+    serviceName?: string | null;
+}
+export declare const GetPrefixServiceBindingResponse: Schema.Schema<GetPrefixServiceBindingResponse>;
+export type GetPrefixServiceBindingError = DefaultErrors | BindingNotFound | InvalidAccountId | PrefixNotFound;
+export declare const getPrefixServiceBinding: API.OperationMethod<GetPrefixServiceBindingRequest, GetPrefixServiceBindingResponse, GetPrefixServiceBindingError, Credentials | HttpClient.HttpClient>;
+export interface ListPrefixServiceBindingsRequest {
+    prefixId: string;
+    /** Identifier of a Cloudflare account. */
+    accountId: string;
+}
+export declare const ListPrefixServiceBindingsRequest: Schema.Schema<ListPrefixServiceBindingsRequest>;
+export interface ListPrefixServiceBindingsResponse {
+    result: {
+        id?: string | null;
+        cidr?: string | null;
+        provisioning?: {
+            state?: "provisioning" | "active" | null;
+        } | null;
+        serviceId?: string | null;
+        serviceName?: string | null;
+    }[];
+}
+export declare const ListPrefixServiceBindingsResponse: Schema.Schema<ListPrefixServiceBindingsResponse>;
+export type ListPrefixServiceBindingsError = DefaultErrors;
+export declare const listPrefixServiceBindings: API.PaginatedOperationMethod<ListPrefixServiceBindingsRequest, ListPrefixServiceBindingsResponse, ListPrefixServiceBindingsError, Credentials | HttpClient.HttpClient> & {
+    pages: (input: ListPrefixServiceBindingsRequest) => stream.Stream<ListPrefixServiceBindingsResponse, ListPrefixServiceBindingsError, Credentials | HttpClient.HttpClient>;
+    items: (input: ListPrefixServiceBindingsRequest) => stream.Stream<{
+        id?: string | null;
+        cidr?: string | null;
+        provisioning?: {
+            state?: "provisioning" | "active" | null;
+        } | null;
+        serviceId?: string | null;
+        serviceName?: string | null;
+    }, ListPrefixServiceBindingsError, Credentials | HttpClient.HttpClient>;
+};
+export interface CreatePrefixServiceBindingRequest {
+    prefixId: string;
+    /** Path param: Identifier of a Cloudflare account. */
+    accountId: string;
+    /** Body param: IP Prefix in Classless Inter-Domain Routing format. */
+    cidr: string;
+    /** Body param: Identifier of a Service on the Cloudflare network. Available services and their IDs may be found in the  List Services  endpoint. */
+    serviceId: string;
+}
+export declare const CreatePrefixServiceBindingRequest: Schema.Schema<CreatePrefixServiceBindingRequest>;
+export interface CreatePrefixServiceBindingResponse {
+    /** Identifier of a Service Binding. */
+    id?: string | null;
+    /** IP Prefix in Classless Inter-Domain Routing format. */
+    cidr?: string | null;
+    /** Status of a Service Binding's deployment to the Cloudflare network */
+    provisioning?: {
+        state?: "provisioning" | "active" | null;
+    } | null;
+    /** Identifier of a Service on the Cloudflare network. Available services and their IDs may be found in the  List Services  endpoint. */
+    serviceId?: string | null;
+    /** Name of a service running on the Cloudflare network */
+    serviceName?: string | null;
+}
+export declare const CreatePrefixServiceBindingResponse: Schema.Schema<CreatePrefixServiceBindingResponse>;
+export type CreatePrefixServiceBindingError = DefaultErrors | UnsupportedBindingConfiguration | InvalidAccountId;
+export declare const createPrefixServiceBinding: API.OperationMethod<CreatePrefixServiceBindingRequest, CreatePrefixServiceBindingResponse, CreatePrefixServiceBindingError, Credentials | HttpClient.HttpClient>;
+export interface DeletePrefixServiceBindingRequest {
+    prefixId: string;
+    bindingId: string;
+    /** Identifier of a Cloudflare account. */
+    accountId: string;
+}
+export declare const DeletePrefixServiceBindingRequest: Schema.Schema<DeletePrefixServiceBindingRequest>;
+export interface DeletePrefixServiceBindingResponse {
+    errors: {
+        code: number;
+        message: string;
+        documentationUrl?: string | null;
+        source?: {
+            pointer?: string | null;
+        } | null;
+    }[];
+    messages: {
+        code: number;
+        message: string;
+        documentationUrl?: string | null;
+        source?: {
+            pointer?: string | null;
+        } | null;
+    }[];
+    /** Whether the API call was successful. */
+    success: true;
+}
+export declare const DeletePrefixServiceBindingResponse: Schema.Schema<DeletePrefixServiceBindingResponse>;
+export type DeletePrefixServiceBindingError = DefaultErrors | BindingNotFound | InvalidAccountId | PrefixNotFound;
+export declare const deletePrefixServiceBinding: API.OperationMethod<DeletePrefixServiceBindingRequest, DeletePrefixServiceBindingResponse, DeletePrefixServiceBindingError, Credentials | HttpClient.HttpClient>;
+export interface GetRegionalHostnameRequest {
+    hostname: string;
+    /** Identifier. */
+    zoneId: string;
+}
+export declare const GetRegionalHostnameRequest: Schema.Schema<GetRegionalHostnameRequest>;
+export interface GetRegionalHostnameResponse {
+    /** When the regional hostname was created */
+    createdOn: string;
+    /** DNS hostname to be regionalized, must be a subdomain of the zone. Wildcards are supported for one level, e.g ` .example.com` */
+    hostname: string;
+    /** Identifying key for the region */
+    regionKey: string;
+    /** Configure which routing method to use for the regional hostname */
+    routing?: string | null;
+}
+export declare const GetRegionalHostnameResponse: Schema.Schema<GetRegionalHostnameResponse>;
+export type GetRegionalHostnameError = DefaultErrors | InvalidZoneId | RegionalHostnameNotFound | RegionalHostnameEmpty;
+export declare const getRegionalHostname: API.OperationMethod<GetRegionalHostnameRequest, GetRegionalHostnameResponse, GetRegionalHostnameError, Credentials | HttpClient.HttpClient>;
+export interface ListRegionalHostnamesRequest {
+    /** Identifier. */
+    zoneId: string;
+}
+export declare const ListRegionalHostnamesRequest: Schema.Schema<ListRegionalHostnamesRequest>;
+export interface ListRegionalHostnamesResponse {
+    result: {
+        createdOn: string;
+        hostname: string;
+        regionKey: string;
+        routing?: string | null;
+    }[];
+}
+export declare const ListRegionalHostnamesResponse: Schema.Schema<ListRegionalHostnamesResponse>;
+export type ListRegionalHostnamesError = DefaultErrors;
+export declare const listRegionalHostnames: API.PaginatedOperationMethod<ListRegionalHostnamesRequest, ListRegionalHostnamesResponse, ListRegionalHostnamesError, Credentials | HttpClient.HttpClient> & {
+    pages: (input: ListRegionalHostnamesRequest) => stream.Stream<ListRegionalHostnamesResponse, ListRegionalHostnamesError, Credentials | HttpClient.HttpClient>;
+    items: (input: ListRegionalHostnamesRequest) => stream.Stream<{
+        createdOn: string;
+        hostname: string;
+        regionKey: string;
+        routing?: string | null;
+    }, ListRegionalHostnamesError, Credentials | HttpClient.HttpClient>;
+};
+export interface CreateRegionalHostnameRequest {
+    /** Path param: Identifier. */
+    zoneId: string;
+    /** Body param: DNS hostname to be regionalized, must be a subdomain of the zone. Wildcards are supported for one level, e.g ` .example.com` */
+    hostname: string;
+    /** Body param: Identifying key for the region */
+    regionKey: string;
+    /** Body param: Configure which routing method to use for the regional hostname */
+    routing?: string;
+}
+export declare const CreateRegionalHostnameRequest: Schema.Schema<CreateRegionalHostnameRequest>;
+export interface CreateRegionalHostnameResponse {
+    /** When the regional hostname was created */
+    createdOn: string;
+    /** DNS hostname to be regionalized, must be a subdomain of the zone. Wildcards are supported for one level, e.g ` .example.com` */
+    hostname: string;
+    /** Identifying key for the region */
+    regionKey: string;
+    /** Configure which routing method to use for the regional hostname */
+    routing?: string | null;
+}
+export declare const CreateRegionalHostnameResponse: Schema.Schema<CreateRegionalHostnameResponse>;
+export type CreateRegionalHostnameError = DefaultErrors | InvalidZoneId | InvalidHostname | RegionalHostnameEmpty;
+export declare const createRegionalHostname: API.OperationMethod<CreateRegionalHostnameRequest, CreateRegionalHostnameResponse, CreateRegionalHostnameError, Credentials | HttpClient.HttpClient>;
+export interface PatchRegionalHostnameRequest {
+    hostname: string;
+    /** Path param: Identifier. */
+    zoneId: string;
+    /** Body param: Identifying key for the region */
+    regionKey: string;
+}
+export declare const PatchRegionalHostnameRequest: Schema.Schema<PatchRegionalHostnameRequest>;
+export interface PatchRegionalHostnameResponse {
+    /** When the regional hostname was created */
+    createdOn: string;
+    /** DNS hostname to be regionalized, must be a subdomain of the zone. Wildcards are supported for one level, e.g ` .example.com` */
+    hostname: string;
+    /** Identifying key for the region */
+    regionKey: string;
+    /** Configure which routing method to use for the regional hostname */
+    routing?: string | null;
+}
+export declare const PatchRegionalHostnameResponse: Schema.Schema<PatchRegionalHostnameResponse>;
+export type PatchRegionalHostnameError = DefaultErrors | InvalidZoneId | RegionalHostnameNotFound | RegionalHostnameEmpty;
+export declare const patchRegionalHostname: API.OperationMethod<PatchRegionalHostnameRequest, PatchRegionalHostnameResponse, PatchRegionalHostnameError, Credentials | HttpClient.HttpClient>;
+export interface DeleteRegionalHostnameRequest {
+    hostname: string;
+    /** Identifier. */
+    zoneId: string;
+}
+export declare const DeleteRegionalHostnameRequest: Schema.Schema<DeleteRegionalHostnameRequest>;
+export interface DeleteRegionalHostnameResponse {
+    errors: {
+        code: number;
+        message: string;
+        documentationUrl?: string | null;
+        source?: {
+            pointer?: string | null;
+        } | null;
+    }[];
+    messages: {
+        code: number;
+        message: string;
+        documentationUrl?: string | null;
+        source?: {
+            pointer?: string | null;
+        } | null;
+    }[];
+    /** Whether the API call was successful. */
+    success: true;
+}
+export declare const DeleteRegionalHostnameResponse: Schema.Schema<DeleteRegionalHostnameResponse>;
+export type DeleteRegionalHostnameError = DefaultErrors | MethodNotAllowed | InvalidZoneId | RegionalHostnameNotFound | RegionalHostnameEmpty;
+export declare const deleteRegionalHostname: API.OperationMethod<DeleteRegionalHostnameRequest, DeleteRegionalHostnameResponse, DeleteRegionalHostnameError, Credentials | HttpClient.HttpClient>;
+export interface ListRegionalHostnameRegionsRequest {
+    /** Identifier. */
+    accountId: string;
+}
+export declare const ListRegionalHostnameRegionsRequest: Schema.Schema<ListRegionalHostnameRegionsRequest>;
+export interface ListRegionalHostnameRegionsResponse {
+    result: {
+        key?: string | null;
+        label?: string | null;
+    }[];
+}
+export declare const ListRegionalHostnameRegionsResponse: Schema.Schema<ListRegionalHostnameRegionsResponse>;
+export type ListRegionalHostnameRegionsError = DefaultErrors;
+export declare const listRegionalHostnameRegions: API.PaginatedOperationMethod<ListRegionalHostnameRegionsRequest, ListRegionalHostnameRegionsResponse, ListRegionalHostnameRegionsError, Credentials | HttpClient.HttpClient> & {
+    pages: (input: ListRegionalHostnameRegionsRequest) => stream.Stream<ListRegionalHostnameRegionsResponse, ListRegionalHostnameRegionsError, Credentials | HttpClient.HttpClient>;
+    items: (input: ListRegionalHostnameRegionsRequest) => stream.Stream<{
+        key?: string | null;
+        label?: string | null;
+    }, ListRegionalHostnameRegionsError, Credentials | HttpClient.HttpClient>;
+};
+export interface ListServicesRequest {
+    /** Identifier of a Cloudflare account. */
+    accountId: string;
+}
+export declare const ListServicesRequest: Schema.Schema<ListServicesRequest>;
+export interface ListServicesResponse {
+    result: {
+        id?: string | null;
+        name?: string | null;
+    }[];
+}
+export declare const ListServicesResponse: Schema.Schema<ListServicesResponse>;
+export type ListServicesError = DefaultErrors;
+export declare const listServices: API.PaginatedOperationMethod<ListServicesRequest, ListServicesResponse, ListServicesError, Credentials | HttpClient.HttpClient> & {
+    pages: (input: ListServicesRequest) => stream.Stream<ListServicesResponse, ListServicesError, Credentials | HttpClient.HttpClient>;
+    items: (input: ListServicesRequest) => stream.Stream<{
+        id?: string | null;
+        name?: string | null;
+    }, ListServicesError, Credentials | HttpClient.HttpClient>;
+};
+export {};
+//# sourceMappingURL=addressing.d.ts.map