/**
 * Cloudflare ADDRESSING API
 *
 * Generated from Cloudflare TypeScript SDK.
 * DO NOT EDIT - regenerate with: bun scripts/generate.ts --service addressing
 */
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.Class<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.Class<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.Class<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.Class<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.Class<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.Class<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.Class<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.Class<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.Class<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.Class<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.Class<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.Class<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.Class<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.Class<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.Class<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.Class<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.Class<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.Class<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.Class<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?: {
        createdAt?: string | null;
        ip?: string | null;
    }[] | 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>;
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?: {
        createdAt?: string | null;
        ip?: string | null;
    }[] | 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<GetLoaDocumentResponse>;
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>;
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>;
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>;
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>;
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>;
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>;
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>;
export {};
//# sourceMappingURL=addressing.d.ts.map