/**
 * Cloudflare DNS API
 *
 * Generated from Cloudflare TypeScript SDK.
 * DO NOT EDIT - regenerate with: bun scripts/generate.ts --service dns
 */
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";
export interface GetAnalyticReportRequest {
    /** Path param: Identifier. */
    zoneId: string;
    /** Query param: A comma-separated list of dimensions to group results by. */
    dimensions?: string;
    /** Query param: Segmentation filter in 'attribute operator value' format. */
    filters?: string;
    /** Query param: Limit number of returned metrics. */
    limit?: number;
    /** Query param: A comma-separated list of metrics to query. */
    metrics?: string;
    /** Query param: Start date and time of requesting data period in ISO 8601 format. */
    since?: string;
    /** Query param: A comma-separated list of dimensions to sort by, where each dimension may be prefixed by - (descending) or + (ascending). */
    sort?: string;
    /** Query param: End date and time of requesting data period in ISO 8601 format. */
    until?: string;
}
export declare const GetAnalyticReportRequest: Schema.Schema<GetAnalyticReportRequest>;
export interface GetAnalyticReportResponse {
    /** Array with one row per combination of dimension values. */
    data: {
        dimensions: string[];
        metrics: number[];
    }[];
    /** Number of seconds between current time and last processed event, in another words how many seconds of data could be missing. */
    dataLag: number;
    /** Maximum results for each metric (object mapping metric names to values). Currently always an empty object. */
    max: unknown;
    /** Minimum results for each metric (object mapping metric names to values). Currently always an empty object. */
    min: unknown;
    query: {
        dimensions: string[];
        limit: number;
        metrics: string[];
        since: string;
        until: string;
        filters?: string | null;
        sort?: string[] | null;
    };
    /** Total number of rows in the result. */
    rows: number;
    /** Total results for metrics across all data (object mapping metric names to values). */
    totals: unknown;
}
export declare const GetAnalyticReportResponse: Schema.Schema<GetAnalyticReportResponse>;
export type GetAnalyticReportError = DefaultErrors;
export declare const getAnalyticReport: API.OperationMethod<GetAnalyticReportRequest, GetAnalyticReportResponse, GetAnalyticReportError, Credentials | HttpClient.HttpClient>;
export interface GetAnalyticReportBytimeRequest {
    /** Path param: Identifier. */
    zoneId: string;
    /** Query param: A comma-separated list of dimensions to group results by. */
    dimensions?: string;
    /** Query param: Segmentation filter in 'attribute operator value' format. */
    filters?: string;
    /** Query param: Limit number of returned metrics. */
    limit?: number;
    /** Query param: A comma-separated list of metrics to query. */
    metrics?: string;
    /** Query param: Start date and time of requesting data period in ISO 8601 format. */
    since?: string;
    /** Query param: A comma-separated list of dimensions to sort by, where each dimension may be prefixed by - (descending) or + (ascending). */
    sort?: string;
    /** Query param: Unit of time to group data by. */
    timeDelta?: "all" | "auto" | "year" | "quarter" | "month" | "week" | "day" | "hour" | "dekaminute" | "minute";
    /** Query param: End date and time of requesting data period in ISO 8601 format. */
    until?: string;
}
export declare const GetAnalyticReportBytimeRequest: Schema.Schema<GetAnalyticReportBytimeRequest>;
export interface GetAnalyticReportBytimeResponse {
    /** Array with one row per combination of dimension values. */
    data: {
        dimensions: string[];
        metrics: number[][];
    }[];
    /** Number of seconds between current time and last processed event, in another words how many seconds of data could be missing. */
    dataLag: number;
    /** Maximum results for each metric (object mapping metric names to values). Currently always an empty object. */
    max: unknown;
    /** Minimum results for each metric (object mapping metric names to values). Currently always an empty object. */
    min: unknown;
    query: {
        dimensions: string[];
        limit: number;
        metrics: string[];
        since: string;
        timeDelta: "all" | "auto" | "year" | "quarter" | "month" | "week" | "day" | "hour" | "dekaminute" | "minute";
        until: string;
        filters?: string | null;
        sort?: string[] | null;
    };
    /** Total number of rows in the result. */
    rows: number;
    /** Array of time intervals in the response data. Each interval is represented as an array containing two values: the start time, and the end time. */
    timeIntervals: string[][];
    /** Total results for metrics across all data (object mapping metric names to values). */
    totals: unknown;
}
export declare const GetAnalyticReportBytimeResponse: Schema.Schema<GetAnalyticReportBytimeResponse>;
export type GetAnalyticReportBytimeError = DefaultErrors;
export declare const getAnalyticReportBytime: API.OperationMethod<GetAnalyticReportBytimeRequest, GetAnalyticReportBytimeResponse, GetAnalyticReportBytimeError, Credentials | HttpClient.HttpClient>;
export interface GetDnssecRequest {
    /** Identifier. */
    zoneId: string;
}
export declare const GetDnssecRequest: Schema.Schema<GetDnssecRequest>;
export interface GetDnssecResponse {
    /** Algorithm key code. */
    algorithm?: string | null;
    /** Digest hash. */
    digest?: string | null;
    /** Type of digest algorithm. */
    digestAlgorithm?: string | null;
    /** Coded type for digest algorithm. */
    digestType?: string | null;
    /** If true, multi-signer DNSSEC is enabled on the zone, allowing multiple providers to serve a DNSSEC-signed zone at the same time. This is required for DNSKEY records (except those automatically generat */
    dnssecMultiSigner?: boolean | null;
    /** If true, allows Cloudflare to transfer in a DNSSEC-signed zone including signatures from an external provider, without requiring Cloudflare to sign any records on the fly.  Note that this feature has  */
    dnssecPresigned?: boolean | null;
    /** If true, enables the use of NSEC3 together with DNSSEC on the zone. Combined with setting dnssec_presigned to true, this enables the use of NSEC3 records when transferring in from an external provider */
    dnssecUseNsec3?: boolean | null;
    /** Full DS record. */
    ds?: string | null;
    /** Flag for DNSSEC record. */
    flags?: number | null;
    /** Code for key tag. */
    keyTag?: number | null;
    /** Algorithm key type. */
    keyType?: string | null;
    /** When DNSSEC was last modified. */
    modifiedOn?: string | null;
    /** Public key for DS record. */
    publicKey?: string | null;
    /** Status of DNSSEC, based on user-desired state and presence of necessary records. */
    status?: "active" | "pending" | "disabled" | "pending-disabled" | "error" | null;
}
export declare const GetDnssecResponse: Schema.Schema<GetDnssecResponse>;
export type GetDnssecError = DefaultErrors;
export declare const getDnssec: API.OperationMethod<GetDnssecRequest, GetDnssecResponse, GetDnssecError, Credentials | HttpClient.HttpClient>;
export interface PatchDnssecRequest {
    /** Path param: Identifier. */
    zoneId: string;
    /** Body param: If true, multi-signer DNSSEC is enabled on the zone, allowing multiple providers to serve a DNSSEC-signed zone at the same time. This is required for DNSKEY records (except those automatic */
    dnssecMultiSigner?: boolean;
    /** Body param: If true, allows Cloudflare to transfer in a DNSSEC-signed zone including signatures from an external provider, without requiring Cloudflare to sign any records on the fly.  Note that this  */
    dnssecPresigned?: boolean;
    /** Body param: If true, enables the use of NSEC3 together with DNSSEC on the zone. Combined with setting dnssec_presigned to true, this enables the use of NSEC3 records when transferring in from an exter */
    dnssecUseNsec3?: boolean;
    /** Body param: Status of DNSSEC, based on user-desired state and presence of necessary records. */
    status?: "active" | "disabled";
}
export declare const PatchDnssecRequest: Schema.Schema<PatchDnssecRequest>;
export interface PatchDnssecResponse {
    /** Algorithm key code. */
    algorithm?: string | null;
    /** Digest hash. */
    digest?: string | null;
    /** Type of digest algorithm. */
    digestAlgorithm?: string | null;
    /** Coded type for digest algorithm. */
    digestType?: string | null;
    /** If true, multi-signer DNSSEC is enabled on the zone, allowing multiple providers to serve a DNSSEC-signed zone at the same time. This is required for DNSKEY records (except those automatically generat */
    dnssecMultiSigner?: boolean | null;
    /** If true, allows Cloudflare to transfer in a DNSSEC-signed zone including signatures from an external provider, without requiring Cloudflare to sign any records on the fly.  Note that this feature has  */
    dnssecPresigned?: boolean | null;
    /** If true, enables the use of NSEC3 together with DNSSEC on the zone. Combined with setting dnssec_presigned to true, this enables the use of NSEC3 records when transferring in from an external provider */
    dnssecUseNsec3?: boolean | null;
    /** Full DS record. */
    ds?: string | null;
    /** Flag for DNSSEC record. */
    flags?: number | null;
    /** Code for key tag. */
    keyTag?: number | null;
    /** Algorithm key type. */
    keyType?: string | null;
    /** When DNSSEC was last modified. */
    modifiedOn?: string | null;
    /** Public key for DS record. */
    publicKey?: string | null;
    /** Status of DNSSEC, based on user-desired state and presence of necessary records. */
    status?: "active" | "pending" | "disabled" | "pending-disabled" | "error" | null;
}
export declare const PatchDnssecResponse: Schema.Schema<PatchDnssecResponse>;
export type PatchDnssecError = DefaultErrors;
export declare const patchDnssec: API.OperationMethod<PatchDnssecRequest, PatchDnssecResponse, PatchDnssecError, Credentials | HttpClient.HttpClient>;
export interface DeleteDnssecRequest {
    /** Identifier. */
    zoneId: string;
}
export declare const DeleteDnssecRequest: Schema.Schema<DeleteDnssecRequest>;
export type DeleteDnssecResponse = string;
export declare const DeleteDnssecResponse: Schema.Schema<DeleteDnssecResponse>;
export type DeleteDnssecError = DefaultErrors;
export declare const deleteDnssec: API.OperationMethod<DeleteDnssecRequest, DeleteDnssecResponse, DeleteDnssecError, Credentials | HttpClient.HttpClient>;
export interface ScanListRecordRequest {
    /** Identifier. */
    zoneId: string;
}
export declare const ScanListRecordRequest: Schema.Schema<ScanListRecordRequest>;
export interface ScanListRecordResponse {
    result: ({
        id: string;
        createdOn: string;
        meta: unknown;
        modifiedOn: string;
        proxiable: boolean;
        commentModifiedOn?: string | null;
        tagsModifiedOn?: string | null;
    } | {
        id: string;
        comment: string;
        content: string;
        createdOn: string;
        meta: unknown;
        modifiedOn: string;
        name: string;
        proxiable: boolean;
        proxied: boolean;
        settings: {
            ipv4Only?: boolean | null;
            ipv6Only?: boolean | null;
        };
        tags: string[];
        ttl: number | "1";
        type: "OPENPGPKEY";
        commentModifiedOn?: string | null;
        tagsModifiedOn?: string | null;
    })[];
}
export declare const ScanListRecordResponse: Schema.Schema<ScanListRecordResponse>;
export type ScanListRecordError = DefaultErrors;
export declare const scanListRecord: API.PaginatedOperationMethod<ScanListRecordRequest, ScanListRecordResponse, ScanListRecordError, Credentials | HttpClient.HttpClient>;
export interface ForceNotifyZoneTransferOutgoingRequest {
    /** Path param: */
    zoneId: string;
    /** Body param: */
    body: unknown;
}
export declare const ForceNotifyZoneTransferOutgoingRequest: Schema.Schema<ForceNotifyZoneTransferOutgoingRequest>;
export type ForceNotifyZoneTransferOutgoingResponse = string;
export declare const ForceNotifyZoneTransferOutgoingResponse: Schema.Schema<ForceNotifyZoneTransferOutgoingResponse>;
export type ForceNotifyZoneTransferOutgoingError = DefaultErrors;
export declare const forceNotifyZoneTransferOutgoing: API.OperationMethod<ForceNotifyZoneTransferOutgoingRequest, ForceNotifyZoneTransferOutgoingResponse, ForceNotifyZoneTransferOutgoingError, Credentials | HttpClient.HttpClient>;
export interface GetRecordRequest {
    dnsRecordId: string;
    /** Identifier. */
    zoneId: string;
}
export declare const GetRecordRequest: Schema.Schema<GetRecordRequest>;
export type GetRecordResponse = {
    id: string;
    createdOn: string;
    meta: unknown;
    modifiedOn: string;
    proxiable: boolean;
    commentModifiedOn?: string | null;
    tagsModifiedOn?: string | null;
} | {
    id: string;
    comment: string;
    content: string;
    createdOn: string;
    meta: unknown;
    modifiedOn: string;
    name: string;
    proxiable: boolean;
    proxied: boolean;
    settings: {
        ipv4Only?: boolean | null;
        ipv6Only?: boolean | null;
    };
    tags: string[];
    ttl: number | "1";
    type: "OPENPGPKEY";
    commentModifiedOn?: string | null;
    tagsModifiedOn?: string | null;
};
export declare const GetRecordResponse: Schema.Schema<GetRecordResponse>;
export type GetRecordError = DefaultErrors;
export declare const getRecord: API.OperationMethod<GetRecordRequest, GetRecordResponse, GetRecordError, Credentials | HttpClient.HttpClient>;
export interface ListRecordsRequest {
    /** Path param: Identifier. */
    zoneId: string;
    /** Query param: */
    comment?: {
        absent?: string;
        contains?: string;
        endswith?: string;
        exact?: string;
        present?: string;
        startswith?: string;
    };
    /** Query param: */
    content?: {
        contains?: string;
        endswith?: string;
        exact?: string;
        startswith?: string;
    };
    /** Query param: Direction to order DNS records in. */
    direction?: "asc" | "desc";
    /** Query param: Whether to match all search requirements or at least one (any). If set to `all`, acts like a logical AND between filters. If set to `any`, acts like a logical OR instead. Note that the in */
    match?: "any" | "all";
    /** Query param: */
    name?: {
        contains?: string;
        endswith?: string;
        exact?: string;
        startswith?: string;
    };
    /** Query param: Field to order DNS records by. */
    order?: "type" | "name" | "content" | "ttl" | "proxied";
    /** Query param: Whether the record is receiving the performance and security benefits of Cloudflare. */
    proxied?: boolean;
    /** Query param: Allows searching in multiple properties of a DNS record simultaneously. This parameter is intended for human users, not automation. Its exact behavior is intentionally left unspecified an */
    search?: string;
    /** Query param: */
    tag?: {
        absent?: string;
        contains?: string;
        endswith?: string;
        exact?: string;
        present?: string;
        startswith?: string;
    };
    /** Query param: Whether to match all tag search requirements or at least one (any). If set to `all`, acts like a logical AND between tag filters. If set to `any`, acts like a logical OR instead. Note tha */
    tagMatch?: "any" | "all";
    /** Query param: Record type. */
    type?: "A" | "AAAA" | "CAA" | "CERT" | "CNAME" | "DNSKEY" | "DS" | "HTTPS" | "LOC" | "MX" | "NAPTR" | "NS" | "OPENPGPKEY" | "PTR" | "SMIMEA" | "SRV" | "SSHFP" | "SVCB" | "TLSA" | "TXT" | "URI";
}
export declare const ListRecordsRequest: Schema.Schema<ListRecordsRequest>;
export interface ListRecordsResponse {
    result: ({
        id: string;
        createdOn: string;
        meta: unknown;
        modifiedOn: string;
        proxiable: boolean;
        commentModifiedOn?: string | null;
        tagsModifiedOn?: string | null;
    } | {
        id: string;
        comment: string;
        content: string;
        createdOn: string;
        meta: unknown;
        modifiedOn: string;
        name: string;
        proxiable: boolean;
        proxied: boolean;
        settings: {
            ipv4Only?: boolean | null;
            ipv6Only?: boolean | null;
        };
        tags: string[];
        ttl: number | "1";
        type: "OPENPGPKEY";
        commentModifiedOn?: string | null;
        tagsModifiedOn?: string | null;
    })[];
    resultInfo: {
        count?: number | null;
        page?: number | null;
        perPage?: number | null;
        totalCount?: number | null;
    };
}
export declare const ListRecordsResponse: Schema.Schema<ListRecordsResponse>;
export type ListRecordsError = DefaultErrors;
export declare const listRecords: API.PaginatedOperationMethod<ListRecordsRequest, ListRecordsResponse, ListRecordsError, Credentials | HttpClient.HttpClient>;
export interface CreateRecordRequest {
    /** Path param: Identifier. */
    zoneId: string;
    /** Body param: Complete DNS record name, including the zone name, in Punycode. */
    name: string;
    /** Body param: Time To Live (TTL) of the DNS record in seconds. Setting to 1 means 'automatic'. Value must be between 60 and 86400, with the minimum reduced to 30 for Enterprise zones. */
    ttl: number | "1";
    /** Body param: Record type. */
    type: "A";
    /** Body param: Comments or notes about the DNS record. This field has no effect on DNS responses. */
    comment?: string;
    /** Body param: A valid IPv4 address. */
    content?: string;
    /** Body param: Whether the record is receiving the performance and security benefits of Cloudflare. */
    proxied?: boolean;
    /** Body param: Settings for the DNS record. */
    settings?: {
        ipv4Only?: boolean;
        ipv6Only?: boolean;
    };
    /** Body param: Custom tags for the DNS record. This field has no effect on DNS responses. */
    tags?: string[];
}
export declare const CreateRecordRequest: Schema.Schema<CreateRecordRequest>;
export type CreateRecordResponse = {
    id: string;
    createdOn: string;
    meta: unknown;
    modifiedOn: string;
    proxiable: boolean;
    commentModifiedOn?: string | null;
    tagsModifiedOn?: string | null;
} | {
    id: string;
    comment: string;
    content: string;
    createdOn: string;
    meta: unknown;
    modifiedOn: string;
    name: string;
    proxiable: boolean;
    proxied: boolean;
    settings: {
        ipv4Only?: boolean | null;
        ipv6Only?: boolean | null;
    };
    tags: string[];
    ttl: number | "1";
    type: "OPENPGPKEY";
    commentModifiedOn?: string | null;
    tagsModifiedOn?: string | null;
};
export declare const CreateRecordResponse: Schema.Schema<CreateRecordResponse>;
export type CreateRecordError = DefaultErrors;
export declare const createRecord: API.OperationMethod<CreateRecordRequest, CreateRecordResponse, CreateRecordError, Credentials | HttpClient.HttpClient>;
export interface UpdateRecordRequest {
    dnsRecordId: string;
    /** Path param: Identifier. */
    zoneId: string;
    /** Body param: Complete DNS record name, including the zone name, in Punycode. */
    name: string;
    /** Body param: Time To Live (TTL) of the DNS record in seconds. Setting to 1 means 'automatic'. Value must be between 60 and 86400, with the minimum reduced to 30 for Enterprise zones. */
    ttl: number | "1";
    /** Body param: Record type. */
    type: "A";
    /** Body param: Comments or notes about the DNS record. This field has no effect on DNS responses. */
    comment?: string;
    /** Body param: A valid IPv4 address. */
    content?: string;
    /** Body param: Whether the record is receiving the performance and security benefits of Cloudflare. */
    proxied?: boolean;
    /** Body param: Settings for the DNS record. */
    settings?: {
        ipv4Only?: boolean;
        ipv6Only?: boolean;
    };
    /** Body param: Custom tags for the DNS record. This field has no effect on DNS responses. */
    tags?: string[];
}
export declare const UpdateRecordRequest: Schema.Schema<UpdateRecordRequest>;
export type UpdateRecordResponse = {
    id: string;
    createdOn: string;
    meta: unknown;
    modifiedOn: string;
    proxiable: boolean;
    commentModifiedOn?: string | null;
    tagsModifiedOn?: string | null;
} | {
    id: string;
    comment: string;
    content: string;
    createdOn: string;
    meta: unknown;
    modifiedOn: string;
    name: string;
    proxiable: boolean;
    proxied: boolean;
    settings: {
        ipv4Only?: boolean | null;
        ipv6Only?: boolean | null;
    };
    tags: string[];
    ttl: number | "1";
    type: "OPENPGPKEY";
    commentModifiedOn?: string | null;
    tagsModifiedOn?: string | null;
};
export declare const UpdateRecordResponse: Schema.Schema<UpdateRecordResponse>;
export type UpdateRecordError = DefaultErrors;
export declare const updateRecord: API.OperationMethod<UpdateRecordRequest, UpdateRecordResponse, UpdateRecordError, Credentials | HttpClient.HttpClient>;
export interface PatchRecordRequest {
    dnsRecordId: string;
    /** Path param: Identifier. */
    zoneId: string;
    /** Body param: Complete DNS record name, including the zone name, in Punycode. */
    name: string;
    /** Body param: Time To Live (TTL) of the DNS record in seconds. Setting to 1 means 'automatic'. Value must be between 60 and 86400, with the minimum reduced to 30 for Enterprise zones. */
    ttl: number | "1";
    /** Body param: Record type. */
    type: "A";
    /** Body param: Comments or notes about the DNS record. This field has no effect on DNS responses. */
    comment?: string;
    /** Body param: A valid IPv4 address. */
    content?: string;
    /** Body param: Whether the record is receiving the performance and security benefits of Cloudflare. */
    proxied?: boolean;
    /** Body param: Settings for the DNS record. */
    settings?: {
        ipv4Only?: boolean;
        ipv6Only?: boolean;
    };
    /** Body param: Custom tags for the DNS record. This field has no effect on DNS responses. */
    tags?: string[];
}
export declare const PatchRecordRequest: Schema.Schema<PatchRecordRequest>;
export type PatchRecordResponse = {
    id: string;
    createdOn: string;
    meta: unknown;
    modifiedOn: string;
    proxiable: boolean;
    commentModifiedOn?: string | null;
    tagsModifiedOn?: string | null;
} | {
    id: string;
    comment: string;
    content: string;
    createdOn: string;
    meta: unknown;
    modifiedOn: string;
    name: string;
    proxiable: boolean;
    proxied: boolean;
    settings: {
        ipv4Only?: boolean | null;
        ipv6Only?: boolean | null;
    };
    tags: string[];
    ttl: number | "1";
    type: "OPENPGPKEY";
    commentModifiedOn?: string | null;
    tagsModifiedOn?: string | null;
};
export declare const PatchRecordResponse: Schema.Schema<PatchRecordResponse>;
export type PatchRecordError = DefaultErrors;
export declare const patchRecord: API.OperationMethod<PatchRecordRequest, PatchRecordResponse, PatchRecordError, Credentials | HttpClient.HttpClient>;
export interface DeleteRecordRequest {
    dnsRecordId: string;
    /** Identifier. */
    zoneId: string;
}
export declare const DeleteRecordRequest: Schema.Schema<DeleteRecordRequest>;
export interface DeleteRecordResponse {
    /** Identifier. */
    id?: string | null;
}
export declare const DeleteRecordResponse: Schema.Schema<DeleteRecordResponse>;
export type DeleteRecordError = DefaultErrors;
export declare const deleteRecord: API.OperationMethod<DeleteRecordRequest, DeleteRecordResponse, DeleteRecordError, Credentials | HttpClient.HttpClient>;
export interface BatchRecordRequest {
    /** Path param: Identifier. */
    zoneId: string;
    /** Body param: */
    deletes?: {
        id: string;
    }[];
    /** Body param: */
    patches?: ({
        id: string;
    } | {
        id: string;
        name: string;
        ttl: number | "1";
        type: "OPENPGPKEY";
        comment?: string;
        content?: string;
        proxied?: boolean;
        settings?: {
            ipv4Only?: boolean;
            ipv6Only?: boolean;
        };
        tags?: string[];
    })[];
    /** Body param: */
    posts?: ({
        name: string;
        ttl: number | "1";
        type: "A";
        comment?: string;
        content?: string;
        proxied?: boolean;
        settings?: {
            ipv4Only?: boolean;
            ipv6Only?: boolean;
        };
        tags?: string[];
    } | {
        name: string;
        ttl: number | "1";
        type: "AAAA";
        comment?: string;
        content?: string;
        proxied?: boolean;
        settings?: {
            ipv4Only?: boolean;
            ipv6Only?: boolean;
        };
        tags?: string[];
    } | {
        name: string;
        ttl: number | "1";
        type: "CNAME";
        comment?: string;
        content?: string;
        proxied?: boolean;
        settings?: {
            flattenCname?: boolean;
            ipv4Only?: boolean;
            ipv6Only?: boolean;
        };
        tags?: string[];
    } | {
        name: string;
        ttl: number | "1";
        type: "MX";
        comment?: string;
        content?: string;
        priority?: number;
        proxied?: boolean;
        settings?: {
            ipv4Only?: boolean;
            ipv6Only?: boolean;
        };
        tags?: string[];
    } | {
        name: string;
        ttl: number | "1";
        type: "NS";
        comment?: string;
        content?: string;
        proxied?: boolean;
        settings?: {
            ipv4Only?: boolean;
            ipv6Only?: boolean;
        };
        tags?: string[];
    } | {
        name: string;
        ttl: number | "1";
        type: "OPENPGPKEY";
        comment?: string;
        content?: string;
        proxied?: boolean;
        settings?: {
            ipv4Only?: boolean;
            ipv6Only?: boolean;
        };
        tags?: string[];
    } | {
        name: string;
        ttl: number | "1";
        type: "PTR";
        comment?: string;
        content?: string;
        proxied?: boolean;
        settings?: {
            ipv4Only?: boolean;
            ipv6Only?: boolean;
        };
        tags?: string[];
    } | {
        name: string;
        ttl: number | "1";
        type: "TXT";
        comment?: string;
        content?: string;
        proxied?: boolean;
        settings?: {
            ipv4Only?: boolean;
            ipv6Only?: boolean;
        };
        tags?: string[];
    } | {
        name: string;
        ttl: number | "1";
        type: "CAA";
        comment?: string;
        data?: {
            flags?: number;
            tag?: string;
            value?: string;
        };
        proxied?: boolean;
        settings?: {
            ipv4Only?: boolean;
            ipv6Only?: boolean;
        };
        tags?: string[];
    } | {
        name: string;
        ttl: number | "1";
        type: "CERT";
        comment?: string;
        data?: {
            algorithm?: number;
            certificate?: string;
            keyTag?: number;
            type?: number;
        };
        proxied?: boolean;
        settings?: {
            ipv4Only?: boolean;
            ipv6Only?: boolean;
        };
        tags?: string[];
    } | {
        name: string;
        ttl: number | "1";
        type: "DNSKEY";
        comment?: string;
        data?: {
            algorithm?: number;
            flags?: number;
            protocol?: number;
            publicKey?: string;
        };
        proxied?: boolean;
        settings?: {
            ipv4Only?: boolean;
            ipv6Only?: boolean;
        };
        tags?: string[];
    } | {
        name: string;
        ttl: number | "1";
        type: "DS";
        comment?: string;
        data?: {
            algorithm?: number;
            digest?: string;
            digestType?: number;
            keyTag?: number;
        };
        proxied?: boolean;
        settings?: {
            ipv4Only?: boolean;
            ipv6Only?: boolean;
        };
        tags?: string[];
    } | {
        name: string;
        ttl: number | "1";
        type: "HTTPS";
        comment?: string;
        data?: {
            priority?: number;
            target?: string;
            value?: string;
        };
        proxied?: boolean;
        settings?: {
            ipv4Only?: boolean;
            ipv6Only?: boolean;
        };
        tags?: string[];
    } | {
        name: string;
        ttl: number | "1";
        type: "LOC";
        comment?: string;
        data?: {
            altitude?: number;
            latDegrees?: number;
            latDirection?: "N" | "S";
            latMinutes?: number;
            latSeconds?: number;
            longDegrees?: number;
            longDirection?: "E" | "W";
            longMinutes?: number;
            longSeconds?: number;
            precisionHorz?: number;
            precisionVert?: number;
            size?: number;
        };
        proxied?: boolean;
        settings?: {
            ipv4Only?: boolean;
            ipv6Only?: boolean;
        };
        tags?: string[];
    } | {
        name: string;
        ttl: number | "1";
        type: "NAPTR";
        comment?: string;
        data?: {
            flags?: string;
            order?: number;
            preference?: number;
            regex?: string;
            replacement?: string;
            service?: string;
        };
        proxied?: boolean;
        settings?: {
            ipv4Only?: boolean;
            ipv6Only?: boolean;
        };
        tags?: string[];
    } | {
        name: string;
        ttl: number | "1";
        type: "SMIMEA";
        comment?: string;
        data?: {
            certificate?: string;
            matchingType?: number;
            selector?: number;
            usage?: number;
        };
        proxied?: boolean;
        settings?: {
            ipv4Only?: boolean;
            ipv6Only?: boolean;
        };
        tags?: string[];
    } | {
        name: string;
        ttl: number | "1";
        type: "SRV";
        comment?: string;
        data?: {
            port?: number;
            priority?: number;
            target?: string;
            weight?: number;
        };
        proxied?: boolean;
        settings?: {
            ipv4Only?: boolean;
            ipv6Only?: boolean;
        };
        tags?: string[];
    } | {
        name: string;
        ttl: number | "1";
        type: "SSHFP";
        comment?: string;
        data?: {
            algorithm?: number;
            fingerprint?: string;
            type?: number;
        };
        proxied?: boolean;
        settings?: {
            ipv4Only?: boolean;
            ipv6Only?: boolean;
        };
        tags?: string[];
    } | {
        name: string;
        ttl: number | "1";
        type: "SVCB";
        comment?: string;
        data?: {
            priority?: number;
            target?: string;
            value?: string;
        };
        proxied?: boolean;
        settings?: {
            ipv4Only?: boolean;
            ipv6Only?: boolean;
        };
        tags?: string[];
    } | {
        name: string;
        ttl: number | "1";
        type: "TLSA";
        comment?: string;
        data?: {
            certificate?: string;
            matchingType?: number;
            selector?: number;
            usage?: number;
        };
        proxied?: boolean;
        settings?: {
            ipv4Only?: boolean;
            ipv6Only?: boolean;
        };
        tags?: string[];
    } | {
        name: string;
        ttl: number | "1";
        type: "URI";
        comment?: string;
        data?: {
            target?: string;
            weight?: number;
        };
        priority?: number;
        proxied?: boolean;
        settings?: {
            ipv4Only?: boolean;
            ipv6Only?: boolean;
        };
        tags?: string[];
    })[];
    /** Body param: */
    puts?: ({
        id: string;
    } | {
        id: string;
        name: string;
        ttl: number | "1";
        type: "OPENPGPKEY";
        comment?: string;
        content?: string;
        proxied?: boolean;
        settings?: {
            ipv4Only?: boolean;
            ipv6Only?: boolean;
        };
        tags?: string[];
    })[];
}
export declare const BatchRecordRequest: Schema.Schema<BatchRecordRequest>;
export interface BatchRecordResponse {
    deletes?: ({
        id: string;
        createdOn: string;
        meta: unknown;
        modifiedOn: string;
        proxiable: boolean;
        commentModifiedOn?: string | null;
        tagsModifiedOn?: string | null;
    } | {
        id: string;
        comment: string;
        content: string;
        createdOn: string;
        meta: unknown;
        modifiedOn: string;
        name: string;
        proxiable: boolean;
        proxied: boolean;
        settings: {
            ipv4Only?: boolean | null;
            ipv6Only?: boolean | null;
        };
        tags: string[];
        ttl: number | "1";
        type: "OPENPGPKEY";
        commentModifiedOn?: string | null;
        tagsModifiedOn?: string | null;
    })[] | null;
    patches?: ({
        id: string;
        createdOn: string;
        meta: unknown;
        modifiedOn: string;
        proxiable: boolean;
        commentModifiedOn?: string | null;
        tagsModifiedOn?: string | null;
    } | {
        id: string;
        comment: string;
        content: string;
        createdOn: string;
        meta: unknown;
        modifiedOn: string;
        name: string;
        proxiable: boolean;
        proxied: boolean;
        settings: {
            ipv4Only?: boolean | null;
            ipv6Only?: boolean | null;
        };
        tags: string[];
        ttl: number | "1";
        type: "OPENPGPKEY";
        commentModifiedOn?: string | null;
        tagsModifiedOn?: string | null;
    })[] | null;
    posts?: ({
        id: string;
        createdOn: string;
        meta: unknown;
        modifiedOn: string;
        proxiable: boolean;
        commentModifiedOn?: string | null;
        tagsModifiedOn?: string | null;
    } | {
        id: string;
        comment: string;
        content: string;
        createdOn: string;
        meta: unknown;
        modifiedOn: string;
        name: string;
        proxiable: boolean;
        proxied: boolean;
        settings: {
            ipv4Only?: boolean | null;
            ipv6Only?: boolean | null;
        };
        tags: string[];
        ttl: number | "1";
        type: "OPENPGPKEY";
        commentModifiedOn?: string | null;
        tagsModifiedOn?: string | null;
    })[] | null;
    puts?: ({
        id: string;
        createdOn: string;
        meta: unknown;
        modifiedOn: string;
        proxiable: boolean;
        commentModifiedOn?: string | null;
        tagsModifiedOn?: string | null;
    } | {
        id: string;
        comment: string;
        content: string;
        createdOn: string;
        meta: unknown;
        modifiedOn: string;
        name: string;
        proxiable: boolean;
        proxied: boolean;
        settings: {
            ipv4Only?: boolean | null;
            ipv6Only?: boolean | null;
        };
        tags: string[];
        ttl: number | "1";
        type: "OPENPGPKEY";
        commentModifiedOn?: string | null;
        tagsModifiedOn?: string | null;
    })[] | null;
}
export declare const BatchRecordResponse: Schema.Schema<BatchRecordResponse>;
export type BatchRecordError = DefaultErrors;
export declare const batchRecord: API.OperationMethod<BatchRecordRequest, BatchRecordResponse, BatchRecordError, Credentials | HttpClient.HttpClient>;
export interface ExportRecordRequest {
    /** Identifier. */
    zoneId: string;
}
export declare const ExportRecordRequest: Schema.Schema<ExportRecordRequest>;
export type ExportRecordResponse = string;
export declare const ExportRecordResponse: Schema.Schema<ExportRecordResponse>;
export type ExportRecordError = DefaultErrors;
export declare const exportRecord: API.OperationMethod<ExportRecordRequest, ExportRecordResponse, ExportRecordError, Credentials | HttpClient.HttpClient>;
export interface ImportRecordRequest {
    /** Path param: Identifier. */
    zoneId: string;
    /** Body param: BIND config to import.    Tip:  When using cURL, a file can be uploaded using `--form 'file=@bind_config.txt'`. */
    file: string;
    /** Body param: Whether or not proxiable records should receive the performance and security benefits of Cloudflare.  The value should be either `true` or `false`. */
    proxied?: string;
}
export declare const ImportRecordRequest: Schema.Schema<ImportRecordRequest>;
export interface ImportRecordResponse {
    /** Number of DNS records added. */
    recsAdded?: number | null;
    /** Total number of DNS records parsed. */
    totalRecordsParsed?: number | null;
}
export declare const ImportRecordResponse: Schema.Schema<ImportRecordResponse>;
export type ImportRecordError = DefaultErrors;
export declare const importRecord: API.OperationMethod<ImportRecordRequest, ImportRecordResponse, ImportRecordError, Credentials | HttpClient.HttpClient>;
export interface ScanRecordRequest {
    /** Path param: Identifier. */
    zoneId: string;
    /** Body param: */
    body: unknown;
}
export declare const ScanRecordRequest: Schema.Schema<ScanRecordRequest>;
export interface ScanRecordResponse {
    /** Number of DNS records added. */
    recsAdded?: number | null;
    /** Total number of DNS records parsed. */
    totalRecordsParsed?: number | null;
}
export declare const ScanRecordResponse: Schema.Schema<ScanRecordResponse>;
export type ScanRecordError = DefaultErrors;
export declare const scanRecord: API.OperationMethod<ScanRecordRequest, ScanRecordResponse, ScanRecordError, Credentials | HttpClient.HttpClient>;
export interface ScanReviewRecordRequest {
    /** Path param: Identifier. */
    zoneId: string;
    /** Body param: */
    accepts?: ({
        name: string;
        ttl: number | "1";
        type: "A";
        comment?: string;
        content?: string;
        proxied?: boolean;
        settings?: {
            ipv4Only?: boolean;
            ipv6Only?: boolean;
        };
        tags?: string[];
    } | {
        name: string;
        ttl: number | "1";
        type: "AAAA";
        comment?: string;
        content?: string;
        proxied?: boolean;
        settings?: {
            ipv4Only?: boolean;
            ipv6Only?: boolean;
        };
        tags?: string[];
    } | {
        name: string;
        ttl: number | "1";
        type: "CNAME";
        comment?: string;
        content?: string;
        proxied?: boolean;
        settings?: {
            flattenCname?: boolean;
            ipv4Only?: boolean;
            ipv6Only?: boolean;
        };
        tags?: string[];
    } | {
        name: string;
        ttl: number | "1";
        type: "MX";
        comment?: string;
        content?: string;
        priority?: number;
        proxied?: boolean;
        settings?: {
            ipv4Only?: boolean;
            ipv6Only?: boolean;
        };
        tags?: string[];
    } | {
        name: string;
        ttl: number | "1";
        type: "NS";
        comment?: string;
        content?: string;
        proxied?: boolean;
        settings?: {
            ipv4Only?: boolean;
            ipv6Only?: boolean;
        };
        tags?: string[];
    } | {
        name: string;
        ttl: number | "1";
        type: "OPENPGPKEY";
        comment?: string;
        content?: string;
        proxied?: boolean;
        settings?: {
            ipv4Only?: boolean;
            ipv6Only?: boolean;
        };
        tags?: string[];
    } | {
        name: string;
        ttl: number | "1";
        type: "PTR";
        comment?: string;
        content?: string;
        proxied?: boolean;
        settings?: {
            ipv4Only?: boolean;
            ipv6Only?: boolean;
        };
        tags?: string[];
    } | {
        name: string;
        ttl: number | "1";
        type: "TXT";
        comment?: string;
        content?: string;
        proxied?: boolean;
        settings?: {
            ipv4Only?: boolean;
            ipv6Only?: boolean;
        };
        tags?: string[];
    } | {
        name: string;
        ttl: number | "1";
        type: "CAA";
        comment?: string;
        data?: {
            flags?: number;
            tag?: string;
            value?: string;
        };
        proxied?: boolean;
        settings?: {
            ipv4Only?: boolean;
            ipv6Only?: boolean;
        };
        tags?: string[];
    } | {
        name: string;
        ttl: number | "1";
        type: "CERT";
        comment?: string;
        data?: {
            algorithm?: number;
            certificate?: string;
            keyTag?: number;
            type?: number;
        };
        proxied?: boolean;
        settings?: {
            ipv4Only?: boolean;
            ipv6Only?: boolean;
        };
        tags?: string[];
    } | {
        name: string;
        ttl: number | "1";
        type: "DNSKEY";
        comment?: string;
        data?: {
            algorithm?: number;
            flags?: number;
            protocol?: number;
            publicKey?: string;
        };
        proxied?: boolean;
        settings?: {
            ipv4Only?: boolean;
            ipv6Only?: boolean;
        };
        tags?: string[];
    } | {
        name: string;
        ttl: number | "1";
        type: "DS";
        comment?: string;
        data?: {
            algorithm?: number;
            digest?: string;
            digestType?: number;
            keyTag?: number;
        };
        proxied?: boolean;
        settings?: {
            ipv4Only?: boolean;
            ipv6Only?: boolean;
        };
        tags?: string[];
    } | {
        name: string;
        ttl: number | "1";
        type: "HTTPS";
        comment?: string;
        data?: {
            priority?: number;
            target?: string;
            value?: string;
        };
        proxied?: boolean;
        settings?: {
            ipv4Only?: boolean;
            ipv6Only?: boolean;
        };
        tags?: string[];
    } | {
        name: string;
        ttl: number | "1";
        type: "LOC";
        comment?: string;
        data?: {
            altitude?: number;
            latDegrees?: number;
            latDirection?: "N" | "S";
            latMinutes?: number;
            latSeconds?: number;
            longDegrees?: number;
            longDirection?: "E" | "W";
            longMinutes?: number;
            longSeconds?: number;
            precisionHorz?: number;
            precisionVert?: number;
            size?: number;
        };
        proxied?: boolean;
        settings?: {
            ipv4Only?: boolean;
            ipv6Only?: boolean;
        };
        tags?: string[];
    } | {
        name: string;
        ttl: number | "1";
        type: "NAPTR";
        comment?: string;
        data?: {
            flags?: string;
            order?: number;
            preference?: number;
            regex?: string;
            replacement?: string;
            service?: string;
        };
        proxied?: boolean;
        settings?: {
            ipv4Only?: boolean;
            ipv6Only?: boolean;
        };
        tags?: string[];
    } | {
        name: string;
        ttl: number | "1";
        type: "SMIMEA";
        comment?: string;
        data?: {
            certificate?: string;
            matchingType?: number;
            selector?: number;
            usage?: number;
        };
        proxied?: boolean;
        settings?: {
            ipv4Only?: boolean;
            ipv6Only?: boolean;
        };
        tags?: string[];
    } | {
        name: string;
        ttl: number | "1";
        type: "SRV";
        comment?: string;
        data?: {
            port?: number;
            priority?: number;
            target?: string;
            weight?: number;
        };
        proxied?: boolean;
        settings?: {
            ipv4Only?: boolean;
            ipv6Only?: boolean;
        };
        tags?: string[];
    } | {
        name: string;
        ttl: number | "1";
        type: "SSHFP";
        comment?: string;
        data?: {
            algorithm?: number;
            fingerprint?: string;
            type?: number;
        };
        proxied?: boolean;
        settings?: {
            ipv4Only?: boolean;
            ipv6Only?: boolean;
        };
        tags?: string[];
    } | {
        name: string;
        ttl: number | "1";
        type: "SVCB";
        comment?: string;
        data?: {
            priority?: number;
            target?: string;
            value?: string;
        };
        proxied?: boolean;
        settings?: {
            ipv4Only?: boolean;
            ipv6Only?: boolean;
        };
        tags?: string[];
    } | {
        name: string;
        ttl: number | "1";
        type: "TLSA";
        comment?: string;
        data?: {
            certificate?: string;
            matchingType?: number;
            selector?: number;
            usage?: number;
        };
        proxied?: boolean;
        settings?: {
            ipv4Only?: boolean;
            ipv6Only?: boolean;
        };
        tags?: string[];
    } | {
        name: string;
        ttl: number | "1";
        type: "URI";
        comment?: string;
        data?: {
            target?: string;
            weight?: number;
        };
        priority?: number;
        proxied?: boolean;
        settings?: {
            ipv4Only?: boolean;
            ipv6Only?: boolean;
        };
        tags?: string[];
    })[];
    /** Body param: */
    rejects?: {
        id: string;
    }[];
}
export declare const ScanReviewRecordRequest: Schema.Schema<ScanReviewRecordRequest>;
export interface ScanReviewRecordResponse {
    accepts?: ({
        id: string;
        createdOn: string;
        meta: unknown;
        modifiedOn: string;
        proxiable: boolean;
        commentModifiedOn?: string | null;
        tagsModifiedOn?: string | null;
    } | {
        id: string;
        comment: string;
        content: string;
        createdOn: string;
        meta: unknown;
        modifiedOn: string;
        name: string;
        proxiable: boolean;
        proxied: boolean;
        settings: {
            ipv4Only?: boolean | null;
            ipv6Only?: boolean | null;
        };
        tags: string[];
        ttl: number | "1";
        type: "OPENPGPKEY";
        commentModifiedOn?: string | null;
        tagsModifiedOn?: string | null;
    })[] | null;
    rejects?: string[] | null;
}
export declare const ScanReviewRecordResponse: Schema.Schema<ScanReviewRecordResponse>;
export type ScanReviewRecordError = DefaultErrors;
export declare const scanReviewRecord: API.OperationMethod<ScanReviewRecordRequest, ScanReviewRecordResponse, ScanReviewRecordError, Credentials | HttpClient.HttpClient>;
export interface GetSettingAccountRequest {
    /** Identifier. */
    accountId: string;
}
export declare const GetSettingAccountRequest: Schema.Schema<GetSettingAccountRequest>;
export interface GetSettingAccountResponse {
    zoneDefaults: {
        flattenAllCnames: boolean;
        foundationDns: boolean;
        internalDns: {
            referenceZoneId?: string | null;
        };
        multiProvider: boolean;
        nameservers: {
            type: "cloudflare.standard" | "cloudflare.standard.random" | "custom.account" | "custom.tenant";
        };
        nsTtl: number;
        secondaryOverrides: boolean;
        soa: {
            expire?: number | null;
            minTtl?: number | null;
            mname?: string | null;
            refresh?: number | null;
            retry?: number | null;
            rname?: string | null;
            ttl?: number | null;
        };
        zoneMode: "standard" | "cdn_only" | "dns_only";
    };
}
export declare const GetSettingAccountResponse: Schema.Schema<GetSettingAccountResponse>;
export type GetSettingAccountError = DefaultErrors;
export declare const getSettingAccount: API.OperationMethod<GetSettingAccountRequest, GetSettingAccountResponse, GetSettingAccountError, Credentials | HttpClient.HttpClient>;
export interface PatchSettingAccountRequest {
    /** Path param: Identifier. */
    accountId: string;
    /** Body param: */
    zoneDefaults?: {
        flattenAllCnames?: boolean;
        foundationDns?: boolean;
        internalDns?: {
            referenceZoneId?: string;
        };
        multiProvider?: boolean;
        nameservers?: {
            type?: "cloudflare.standard" | "cloudflare.standard.random" | "custom.account" | "custom.tenant";
        };
        nsTtl?: number;
        secondaryOverrides?: boolean;
        soa?: {
            expire?: number;
            minTtl?: number;
            mname?: string | null;
            refresh?: number;
            retry?: number;
            rname?: string;
            ttl?: number;
        };
        zoneMode?: "standard" | "cdn_only" | "dns_only";
    };
}
export declare const PatchSettingAccountRequest: Schema.Schema<PatchSettingAccountRequest>;
export interface PatchSettingAccountResponse {
    zoneDefaults: {
        flattenAllCnames: boolean;
        foundationDns: boolean;
        internalDns: {
            referenceZoneId?: string | null;
        };
        multiProvider: boolean;
        nameservers: {
            type: "cloudflare.standard" | "cloudflare.standard.random" | "custom.account" | "custom.tenant";
        };
        nsTtl: number;
        secondaryOverrides: boolean;
        soa: {
            expire?: number | null;
            minTtl?: number | null;
            mname?: string | null;
            refresh?: number | null;
            retry?: number | null;
            rname?: string | null;
            ttl?: number | null;
        };
        zoneMode: "standard" | "cdn_only" | "dns_only";
    };
}
export declare const PatchSettingAccountResponse: Schema.Schema<PatchSettingAccountResponse>;
export type PatchSettingAccountError = DefaultErrors;
export declare const patchSettingAccount: API.OperationMethod<PatchSettingAccountRequest, PatchSettingAccountResponse, PatchSettingAccountError, Credentials | HttpClient.HttpClient>;
export interface GetSettingAccountViewRequest {
    viewId: string;
    /** Identifier. */
    accountId: string;
}
export declare const GetSettingAccountViewRequest: Schema.Schema<GetSettingAccountViewRequest>;
export interface GetSettingAccountViewResponse {
    /** Identifier. */
    id: string;
    /** When the view was created. */
    createdTime: string;
    /** When the view was last modified. */
    modifiedTime: string;
    /** The name of the view. */
    name: string;
    /** The list of zones linked to this view. */
    zones: string[];
}
export declare const GetSettingAccountViewResponse: Schema.Schema<GetSettingAccountViewResponse>;
export type GetSettingAccountViewError = DefaultErrors;
export declare const getSettingAccountView: API.OperationMethod<GetSettingAccountViewRequest, GetSettingAccountViewResponse, GetSettingAccountViewError, Credentials | HttpClient.HttpClient>;
export interface ListSettingAccountViewsRequest {
    /** Path param: Identifier. */
    accountId: string;
    /** Query param: Direction to order DNS views in. */
    direction?: "asc" | "desc";
    /** Query param: Whether to match all search requirements or at least one (any). If set to `all`, acts like a logical AND between filters. If set to `any`, acts like a logical OR instead. */
    match?: "any" | "all";
    /** Query param: */
    name?: {
        contains?: string;
        endswith?: string;
        exact?: string;
        startswith?: string;
    };
    /** Query param: Field to order DNS views by. */
    order?: "name" | "created_on" | "modified_on";
    /** Query param: A zone ID that exists in the zones list for the view. */
    zoneId?: string;
    /** Query param: A zone name that exists in the zones list for the view. */
    zoneName?: string;
}
export declare const ListSettingAccountViewsRequest: Schema.Schema<ListSettingAccountViewsRequest>;
export interface ListSettingAccountViewsResponse {
    result: {
        id: string;
        createdTime: string;
        modifiedTime: string;
        name: string;
        zones: string[];
    }[];
    resultInfo: {
        count?: number | null;
        page?: number | null;
        perPage?: number | null;
        totalCount?: number | null;
    };
}
export declare const ListSettingAccountViewsResponse: Schema.Schema<ListSettingAccountViewsResponse>;
export type ListSettingAccountViewsError = DefaultErrors;
export declare const listSettingAccountViews: API.PaginatedOperationMethod<ListSettingAccountViewsRequest, ListSettingAccountViewsResponse, ListSettingAccountViewsError, Credentials | HttpClient.HttpClient>;
export interface CreateSettingAccountViewRequest {
    /** Path param: Identifier. */
    accountId: string;
    /** Body param: The name of the view. */
    name: string;
    /** Body param: The list of zones linked to this view. */
    zones: string[];
}
export declare const CreateSettingAccountViewRequest: Schema.Schema<CreateSettingAccountViewRequest>;
export interface CreateSettingAccountViewResponse {
    /** Identifier. */
    id: string;
    /** When the view was created. */
    createdTime: string;
    /** When the view was last modified. */
    modifiedTime: string;
    /** The name of the view. */
    name: string;
    /** The list of zones linked to this view. */
    zones: string[];
}
export declare const CreateSettingAccountViewResponse: Schema.Schema<CreateSettingAccountViewResponse>;
export type CreateSettingAccountViewError = DefaultErrors;
export declare const createSettingAccountView: API.OperationMethod<CreateSettingAccountViewRequest, CreateSettingAccountViewResponse, CreateSettingAccountViewError, Credentials | HttpClient.HttpClient>;
export interface PatchSettingAccountViewRequest {
    viewId: string;
    /** Path param: Identifier. */
    accountId: string;
    /** Body param: The name of the view. */
    name?: string;
    /** Body param: The list of zones linked to this view. */
    zones?: string[];
}
export declare const PatchSettingAccountViewRequest: Schema.Schema<PatchSettingAccountViewRequest>;
export interface PatchSettingAccountViewResponse {
    /** Identifier. */
    id: string;
    /** When the view was created. */
    createdTime: string;
    /** When the view was last modified. */
    modifiedTime: string;
    /** The name of the view. */
    name: string;
    /** The list of zones linked to this view. */
    zones: string[];
}
export declare const PatchSettingAccountViewResponse: Schema.Schema<PatchSettingAccountViewResponse>;
export type PatchSettingAccountViewError = DefaultErrors;
export declare const patchSettingAccountView: API.OperationMethod<PatchSettingAccountViewRequest, PatchSettingAccountViewResponse, PatchSettingAccountViewError, Credentials | HttpClient.HttpClient>;
export interface DeleteSettingAccountViewRequest {
    viewId: string;
    /** Identifier. */
    accountId: string;
}
export declare const DeleteSettingAccountViewRequest: Schema.Schema<DeleteSettingAccountViewRequest>;
export interface DeleteSettingAccountViewResponse {
    /** Identifier. */
    id?: string | null;
}
export declare const DeleteSettingAccountViewResponse: Schema.Schema<DeleteSettingAccountViewResponse>;
export type DeleteSettingAccountViewError = DefaultErrors;
export declare const deleteSettingAccountView: API.OperationMethod<DeleteSettingAccountViewRequest, DeleteSettingAccountViewResponse, DeleteSettingAccountViewError, Credentials | HttpClient.HttpClient>;
export interface GetSettingZoneRequest {
    /** Identifier. */
    zoneId: string;
}
export declare const GetSettingZoneRequest: Schema.Schema<GetSettingZoneRequest>;
export interface GetSettingZoneResponse {
    /** Whether to flatten all CNAME records in the zone. Note that, due to DNS limitations, a CNAME record at the zone apex will always be flattened. */
    flattenAllCnames: boolean;
    /** Whether to enable Foundation DNS Advanced Nameservers on the zone. */
    foundationDns: boolean;
    /** Settings for this internal zone. */
    internalDns: {
        referenceZoneId?: string | null;
    };
    /** Whether to enable multi-provider DNS, which causes Cloudflare to activate the zone even when non-Cloudflare NS records exist, and to respect NS records at the zone apex during outbound zone transfers. */
    multiProvider: boolean;
    /** Settings determining the nameservers through which the zone should be available. */
    nameservers: {
        type: "cloudflare.standard" | "custom.account" | "custom.tenant" | "custom.zone";
        nsSet?: number | null;
    };
    /** The time to live (TTL) of the zone's nameserver (NS) records. */
    nsTtl: number;
    /** Allows a Secondary DNS zone to use (proxied) override records and CNAME flattening at the zone apex. */
    secondaryOverrides: boolean;
    /** Components of the zone's SOA record. */
    soa: {
        expire?: number | null;
        minTtl?: number | null;
        mname?: string | null;
        refresh?: number | null;
        retry?: number | null;
        rname?: string | null;
        ttl?: number | null;
    };
    /** Whether the zone mode is a regular or CDN/DNS only zone. */
    zoneMode: "standard" | "cdn_only" | "dns_only";
}
export declare const GetSettingZoneResponse: Schema.Schema<GetSettingZoneResponse>;
export type GetSettingZoneError = DefaultErrors;
export declare const getSettingZone: API.OperationMethod<GetSettingZoneRequest, GetSettingZoneResponse, GetSettingZoneError, Credentials | HttpClient.HttpClient>;
export interface PatchSettingZoneRequest {
    /** Path param: Identifier. */
    zoneId: string;
    /** Body param: Whether to flatten all CNAME records in the zone. Note that, due to DNS limitations, a CNAME record at the zone apex will always be flattened. */
    flattenAllCnames?: boolean;
    /** Body param: Whether to enable Foundation DNS Advanced Nameservers on the zone. */
    foundationDns?: boolean;
    /** Body param: Settings for this internal zone. */
    internalDns?: {
        referenceZoneId?: string;
    };
    /** Body param: Whether to enable multi-provider DNS, which causes Cloudflare to activate the zone even when non-Cloudflare NS records exist, and to respect NS records at the zone apex during outbound zon */
    multiProvider?: boolean;
    /** Body param: Settings determining the nameservers through which the zone should be available. */
    nameservers?: {
        nsSet?: number;
        type?: "cloudflare.standard" | "custom.account" | "custom.tenant" | "custom.zone";
    };
    /** Body param: The time to live (TTL) of the zone's nameserver (NS) records. */
    nsTtl?: number;
    /** Body param: Allows a Secondary DNS zone to use (proxied) override records and CNAME flattening at the zone apex. */
    secondaryOverrides?: boolean;
    /** Body param: Components of the zone's SOA record. */
    soa?: {
        expire?: number;
        minTtl?: number;
        mname?: string | null;
        refresh?: number;
        retry?: number;
        rname?: string;
        ttl?: number;
    };
    /** Body param: Whether the zone mode is a regular or CDN/DNS only zone. */
    zoneMode?: "standard" | "cdn_only" | "dns_only";
}
export declare const PatchSettingZoneRequest: Schema.Schema<PatchSettingZoneRequest>;
export interface PatchSettingZoneResponse {
    /** Whether to flatten all CNAME records in the zone. Note that, due to DNS limitations, a CNAME record at the zone apex will always be flattened. */
    flattenAllCnames: boolean;
    /** Whether to enable Foundation DNS Advanced Nameservers on the zone. */
    foundationDns: boolean;
    /** Settings for this internal zone. */
    internalDns: {
        referenceZoneId?: string | null;
    };
    /** Whether to enable multi-provider DNS, which causes Cloudflare to activate the zone even when non-Cloudflare NS records exist, and to respect NS records at the zone apex during outbound zone transfers. */
    multiProvider: boolean;
    /** Settings determining the nameservers through which the zone should be available. */
    nameservers: {
        type: "cloudflare.standard" | "custom.account" | "custom.tenant" | "custom.zone";
        nsSet?: number | null;
    };
    /** The time to live (TTL) of the zone's nameserver (NS) records. */
    nsTtl: number;
    /** Allows a Secondary DNS zone to use (proxied) override records and CNAME flattening at the zone apex. */
    secondaryOverrides: boolean;
    /** Components of the zone's SOA record. */
    soa: {
        expire?: number | null;
        minTtl?: number | null;
        mname?: string | null;
        refresh?: number | null;
        retry?: number | null;
        rname?: string | null;
        ttl?: number | null;
    };
    /** Whether the zone mode is a regular or CDN/DNS only zone. */
    zoneMode: "standard" | "cdn_only" | "dns_only";
}
export declare const PatchSettingZoneResponse: Schema.Schema<PatchSettingZoneResponse>;
export type PatchSettingZoneError = DefaultErrors;
export declare const patchSettingZone: API.OperationMethod<PatchSettingZoneRequest, PatchSettingZoneResponse, PatchSettingZoneError, Credentials | HttpClient.HttpClient>;
export interface ScanTriggerRecordRequest {
    /** Identifier. */
    zoneId: string;
}
export declare const ScanTriggerRecordRequest: Schema.Schema<ScanTriggerRecordRequest>;
export interface ScanTriggerRecordResponse {
    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 ScanTriggerRecordResponse: Schema.Schema<ScanTriggerRecordResponse>;
export type ScanTriggerRecordError = DefaultErrors;
export declare const scanTriggerRecord: API.OperationMethod<ScanTriggerRecordRequest, ScanTriggerRecordResponse, ScanTriggerRecordError, Credentials | HttpClient.HttpClient>;
export interface GetZoneTransferAclRequest {
    aclId: string;
    accountId: string;
}
export declare const GetZoneTransferAclRequest: Schema.Schema<GetZoneTransferAclRequest>;
export interface GetZoneTransferAclResponse {
    id: string;
    /** Allowed IPv4/IPv6 address range of primary or secondary nameservers. This will be applied for the entire account. The IP range is used to allow additional NOTIFY IPs for secondary zones and IPs Cloudf */
    ipRange: string;
    /** The name of the acl. */
    name: string;
}
export declare const GetZoneTransferAclResponse: Schema.Schema<GetZoneTransferAclResponse>;
export type GetZoneTransferAclError = DefaultErrors;
export declare const getZoneTransferAcl: API.OperationMethod<GetZoneTransferAclRequest, GetZoneTransferAclResponse, GetZoneTransferAclError, Credentials | HttpClient.HttpClient>;
export interface ListZoneTransferAclsRequest {
    accountId: string;
}
export declare const ListZoneTransferAclsRequest: Schema.Schema<ListZoneTransferAclsRequest>;
export interface ListZoneTransferAclsResponse {
    result: {
        id: string;
        ipRange: string;
        name: string;
    }[];
}
export declare const ListZoneTransferAclsResponse: Schema.Schema<ListZoneTransferAclsResponse>;
export type ListZoneTransferAclsError = DefaultErrors;
export declare const listZoneTransferAcls: API.PaginatedOperationMethod<ListZoneTransferAclsRequest, ListZoneTransferAclsResponse, ListZoneTransferAclsError, Credentials | HttpClient.HttpClient>;
export interface CreateZoneTransferAclRequest {
    /** Path param: */
    accountId: string;
    /** Body param: Allowed IPv4/IPv6 address range of primary or secondary nameservers. This will be applied for the entire account. The IP range is used to allow additional NOTIFY IPs for secondary zones an */
    ipRange: string;
    /** Body param: The name of the acl. */
    name: string;
}
export declare const CreateZoneTransferAclRequest: Schema.Schema<CreateZoneTransferAclRequest>;
export interface CreateZoneTransferAclResponse {
    id: string;
    /** Allowed IPv4/IPv6 address range of primary or secondary nameservers. This will be applied for the entire account. The IP range is used to allow additional NOTIFY IPs for secondary zones and IPs Cloudf */
    ipRange: string;
    /** The name of the acl. */
    name: string;
}
export declare const CreateZoneTransferAclResponse: Schema.Schema<CreateZoneTransferAclResponse>;
export type CreateZoneTransferAclError = DefaultErrors;
export declare const createZoneTransferAcl: API.OperationMethod<CreateZoneTransferAclRequest, CreateZoneTransferAclResponse, CreateZoneTransferAclError, Credentials | HttpClient.HttpClient>;
export interface UpdateZoneTransferAclRequest {
    aclId: string;
    /** Path param: */
    accountId: string;
    /** Body param: Allowed IPv4/IPv6 address range of primary or secondary nameservers. This will be applied for the entire account. The IP range is used to allow additional NOTIFY IPs for secondary zones an */
    ipRange: string;
    /** Body param: The name of the acl. */
    name: string;
}
export declare const UpdateZoneTransferAclRequest: Schema.Schema<UpdateZoneTransferAclRequest>;
export interface UpdateZoneTransferAclResponse {
    id: string;
    /** Allowed IPv4/IPv6 address range of primary or secondary nameservers. This will be applied for the entire account. The IP range is used to allow additional NOTIFY IPs for secondary zones and IPs Cloudf */
    ipRange: string;
    /** The name of the acl. */
    name: string;
}
export declare const UpdateZoneTransferAclResponse: Schema.Schema<UpdateZoneTransferAclResponse>;
export type UpdateZoneTransferAclError = DefaultErrors;
export declare const updateZoneTransferAcl: API.OperationMethod<UpdateZoneTransferAclRequest, UpdateZoneTransferAclResponse, UpdateZoneTransferAclError, Credentials | HttpClient.HttpClient>;
export interface DeleteZoneTransferAclRequest {
    aclId: string;
    accountId: string;
}
export declare const DeleteZoneTransferAclRequest: Schema.Schema<DeleteZoneTransferAclRequest>;
export interface DeleteZoneTransferAclResponse {
    id?: string | null;
}
export declare const DeleteZoneTransferAclResponse: Schema.Schema<DeleteZoneTransferAclResponse>;
export type DeleteZoneTransferAclError = DefaultErrors;
export declare const deleteZoneTransferAcl: API.OperationMethod<DeleteZoneTransferAclRequest, DeleteZoneTransferAclResponse, DeleteZoneTransferAclError, Credentials | HttpClient.HttpClient>;
export interface CreateZoneTransferForceAxfrRequest {
    /** Path param: */
    zoneId: string;
    /** Body param: */
    body: unknown;
}
export declare const CreateZoneTransferForceAxfrRequest: Schema.Schema<CreateZoneTransferForceAxfrRequest>;
export type CreateZoneTransferForceAxfrResponse = string;
export declare const CreateZoneTransferForceAxfrResponse: Schema.Schema<CreateZoneTransferForceAxfrResponse>;
export type CreateZoneTransferForceAxfrError = DefaultErrors;
export declare const createZoneTransferForceAxfr: API.OperationMethod<CreateZoneTransferForceAxfrRequest, CreateZoneTransferForceAxfrResponse, CreateZoneTransferForceAxfrError, Credentials | HttpClient.HttpClient>;
export interface GetZoneTransferIncomingRequest {
    zoneId: string;
}
export declare const GetZoneTransferIncomingRequest: Schema.Schema<GetZoneTransferIncomingRequest>;
export interface GetZoneTransferIncomingResponse {
    id?: string | null;
    /** How often should a secondary zone auto refresh regardless of DNS NOTIFY. Not applicable for primary zones. */
    autoRefreshSeconds?: number | null;
    /** The time for a specific event. */
    checkedTime?: string | null;
    /** The time for a specific event. */
    createdTime?: string | null;
    /** The time for a specific event. */
    modifiedTime?: string | null;
    /** Zone name. */
    name?: string | null;
    /** A list of peer tags. */
    peers?: string[] | null;
    /** The serial number of the SOA for the given zone. */
    soaSerial?: number | null;
}
export declare const GetZoneTransferIncomingResponse: Schema.Schema<GetZoneTransferIncomingResponse>;
export type GetZoneTransferIncomingError = DefaultErrors;
export declare const getZoneTransferIncoming: API.OperationMethod<GetZoneTransferIncomingRequest, GetZoneTransferIncomingResponse, GetZoneTransferIncomingError, Credentials | HttpClient.HttpClient>;
export interface CreateZoneTransferIncomingRequest {
    /** Path param: */
    zoneId: string;
    /** Body param: How often should a secondary zone auto refresh regardless of DNS NOTIFY. Not applicable for primary zones. */
    autoRefreshSeconds: number;
    /** Body param: Zone name. */
    name: string;
    /** Body param: A list of peer tags. */
    peers: string[];
}
export declare const CreateZoneTransferIncomingRequest: Schema.Schema<CreateZoneTransferIncomingRequest>;
export interface CreateZoneTransferIncomingResponse {
    id?: string | null;
    /** How often should a secondary zone auto refresh regardless of DNS NOTIFY. Not applicable for primary zones. */
    autoRefreshSeconds?: number | null;
    /** The time for a specific event. */
    checkedTime?: string | null;
    /** The time for a specific event. */
    createdTime?: string | null;
    /** The time for a specific event. */
    modifiedTime?: string | null;
    /** Zone name. */
    name?: string | null;
    /** A list of peer tags. */
    peers?: string[] | null;
    /** The serial number of the SOA for the given zone. */
    soaSerial?: number | null;
}
export declare const CreateZoneTransferIncomingResponse: Schema.Schema<CreateZoneTransferIncomingResponse>;
export type CreateZoneTransferIncomingError = DefaultErrors;
export declare const createZoneTransferIncoming: API.OperationMethod<CreateZoneTransferIncomingRequest, CreateZoneTransferIncomingResponse, CreateZoneTransferIncomingError, Credentials | HttpClient.HttpClient>;
export interface UpdateZoneTransferIncomingRequest {
    /** Path param: */
    zoneId: string;
    /** Body param: How often should a secondary zone auto refresh regardless of DNS NOTIFY. Not applicable for primary zones. */
    autoRefreshSeconds: number;
    /** Body param: Zone name. */
    name: string;
    /** Body param: A list of peer tags. */
    peers: string[];
}
export declare const UpdateZoneTransferIncomingRequest: Schema.Schema<UpdateZoneTransferIncomingRequest>;
export interface UpdateZoneTransferIncomingResponse {
    id?: string | null;
    /** How often should a secondary zone auto refresh regardless of DNS NOTIFY. Not applicable for primary zones. */
    autoRefreshSeconds?: number | null;
    /** The time for a specific event. */
    checkedTime?: string | null;
    /** The time for a specific event. */
    createdTime?: string | null;
    /** The time for a specific event. */
    modifiedTime?: string | null;
    /** Zone name. */
    name?: string | null;
    /** A list of peer tags. */
    peers?: string[] | null;
    /** The serial number of the SOA for the given zone. */
    soaSerial?: number | null;
}
export declare const UpdateZoneTransferIncomingResponse: Schema.Schema<UpdateZoneTransferIncomingResponse>;
export type UpdateZoneTransferIncomingError = DefaultErrors;
export declare const updateZoneTransferIncoming: API.OperationMethod<UpdateZoneTransferIncomingRequest, UpdateZoneTransferIncomingResponse, UpdateZoneTransferIncomingError, Credentials | HttpClient.HttpClient>;
export interface DeleteZoneTransferIncomingRequest {
    zoneId: string;
}
export declare const DeleteZoneTransferIncomingRequest: Schema.Schema<DeleteZoneTransferIncomingRequest>;
export interface DeleteZoneTransferIncomingResponse {
    id?: string | null;
}
export declare const DeleteZoneTransferIncomingResponse: Schema.Schema<DeleteZoneTransferIncomingResponse>;
export type DeleteZoneTransferIncomingError = DefaultErrors;
export declare const deleteZoneTransferIncoming: API.OperationMethod<DeleteZoneTransferIncomingRequest, DeleteZoneTransferIncomingResponse, DeleteZoneTransferIncomingError, Credentials | HttpClient.HttpClient>;
export interface GetZoneTransferOutgoingRequest {
    zoneId: string;
}
export declare const GetZoneTransferOutgoingRequest: Schema.Schema<GetZoneTransferOutgoingRequest>;
export interface GetZoneTransferOutgoingResponse {
    id?: string | null;
    /** The time for a specific event. */
    checkedTime?: string | null;
    /** The time for a specific event. */
    createdTime?: string | null;
    /** The time for a specific event. */
    lastTransferredTime?: string | null;
    /** Zone name. */
    name?: string | null;
    /** A list of peer tags. */
    peers?: string[] | null;
    /** The serial number of the SOA for the given zone. */
    soaSerial?: number | null;
}
export declare const GetZoneTransferOutgoingResponse: Schema.Schema<GetZoneTransferOutgoingResponse>;
export type GetZoneTransferOutgoingError = DefaultErrors;
export declare const getZoneTransferOutgoing: API.OperationMethod<GetZoneTransferOutgoingRequest, GetZoneTransferOutgoingResponse, GetZoneTransferOutgoingError, Credentials | HttpClient.HttpClient>;
export interface CreateZoneTransferOutgoingRequest {
    /** Path param: */
    zoneId: string;
    /** Body param: Zone name. */
    name: string;
    /** Body param: A list of peer tags. */
    peers: string[];
}
export declare const CreateZoneTransferOutgoingRequest: Schema.Schema<CreateZoneTransferOutgoingRequest>;
export interface CreateZoneTransferOutgoingResponse {
    id?: string | null;
    /** The time for a specific event. */
    checkedTime?: string | null;
    /** The time for a specific event. */
    createdTime?: string | null;
    /** The time for a specific event. */
    lastTransferredTime?: string | null;
    /** Zone name. */
    name?: string | null;
    /** A list of peer tags. */
    peers?: string[] | null;
    /** The serial number of the SOA for the given zone. */
    soaSerial?: number | null;
}
export declare const CreateZoneTransferOutgoingResponse: Schema.Schema<CreateZoneTransferOutgoingResponse>;
export type CreateZoneTransferOutgoingError = DefaultErrors;
export declare const createZoneTransferOutgoing: API.OperationMethod<CreateZoneTransferOutgoingRequest, CreateZoneTransferOutgoingResponse, CreateZoneTransferOutgoingError, Credentials | HttpClient.HttpClient>;
export interface UpdateZoneTransferOutgoingRequest {
    /** Path param: */
    zoneId: string;
    /** Body param: Zone name. */
    name: string;
    /** Body param: A list of peer tags. */
    peers: string[];
}
export declare const UpdateZoneTransferOutgoingRequest: Schema.Schema<UpdateZoneTransferOutgoingRequest>;
export interface UpdateZoneTransferOutgoingResponse {
    id?: string | null;
    /** The time for a specific event. */
    checkedTime?: string | null;
    /** The time for a specific event. */
    createdTime?: string | null;
    /** The time for a specific event. */
    lastTransferredTime?: string | null;
    /** Zone name. */
    name?: string | null;
    /** A list of peer tags. */
    peers?: string[] | null;
    /** The serial number of the SOA for the given zone. */
    soaSerial?: number | null;
}
export declare const UpdateZoneTransferOutgoingResponse: Schema.Schema<UpdateZoneTransferOutgoingResponse>;
export type UpdateZoneTransferOutgoingError = DefaultErrors;
export declare const updateZoneTransferOutgoing: API.OperationMethod<UpdateZoneTransferOutgoingRequest, UpdateZoneTransferOutgoingResponse, UpdateZoneTransferOutgoingError, Credentials | HttpClient.HttpClient>;
export interface DeleteZoneTransferOutgoingRequest {
    zoneId: string;
}
export declare const DeleteZoneTransferOutgoingRequest: Schema.Schema<DeleteZoneTransferOutgoingRequest>;
export interface DeleteZoneTransferOutgoingResponse {
    id?: string | null;
}
export declare const DeleteZoneTransferOutgoingResponse: Schema.Schema<DeleteZoneTransferOutgoingResponse>;
export type DeleteZoneTransferOutgoingError = DefaultErrors;
export declare const deleteZoneTransferOutgoing: API.OperationMethod<DeleteZoneTransferOutgoingRequest, DeleteZoneTransferOutgoingResponse, DeleteZoneTransferOutgoingError, Credentials | HttpClient.HttpClient>;
export interface EnableZoneTransferOutgoingRequest {
    /** Path param: */
    zoneId: string;
    /** Body param: */
    body: unknown;
}
export declare const EnableZoneTransferOutgoingRequest: Schema.Schema<EnableZoneTransferOutgoingRequest>;
export type EnableZoneTransferOutgoingResponse = string;
export declare const EnableZoneTransferOutgoingResponse: Schema.Schema<EnableZoneTransferOutgoingResponse>;
export type EnableZoneTransferOutgoingError = DefaultErrors;
export declare const enableZoneTransferOutgoing: API.OperationMethod<EnableZoneTransferOutgoingRequest, EnableZoneTransferOutgoingResponse, EnableZoneTransferOutgoingError, Credentials | HttpClient.HttpClient>;
export interface DisableZoneTransferOutgoingRequest {
    /** Path param: */
    zoneId: string;
    /** Body param: */
    body: unknown;
}
export declare const DisableZoneTransferOutgoingRequest: Schema.Schema<DisableZoneTransferOutgoingRequest>;
export type DisableZoneTransferOutgoingResponse = string;
export declare const DisableZoneTransferOutgoingResponse: Schema.Schema<DisableZoneTransferOutgoingResponse>;
export type DisableZoneTransferOutgoingError = DefaultErrors;
export declare const disableZoneTransferOutgoing: API.OperationMethod<DisableZoneTransferOutgoingRequest, DisableZoneTransferOutgoingResponse, DisableZoneTransferOutgoingError, Credentials | HttpClient.HttpClient>;
export interface GetZoneTransferOutgoingStatusRequest {
    zoneId: string;
}
export declare const GetZoneTransferOutgoingStatusRequest: Schema.Schema<GetZoneTransferOutgoingStatusRequest>;
export type GetZoneTransferOutgoingStatusResponse = string;
export declare const GetZoneTransferOutgoingStatusResponse: Schema.Schema<GetZoneTransferOutgoingStatusResponse>;
export type GetZoneTransferOutgoingStatusError = DefaultErrors;
export declare const getZoneTransferOutgoingStatus: API.OperationMethod<GetZoneTransferOutgoingStatusRequest, GetZoneTransferOutgoingStatusResponse, GetZoneTransferOutgoingStatusError, Credentials | HttpClient.HttpClient>;
export interface GetZoneTransferPeerRequest {
    peerId: string;
    accountId: string;
}
export declare const GetZoneTransferPeerRequest: Schema.Schema<GetZoneTransferPeerRequest>;
export interface GetZoneTransferPeerResponse {
    id: string;
    /** The name of the peer. */
    name: string;
    /** IPv4/IPv6 address of primary or secondary nameserver, depending on what zone this peer is linked to. For primary zones this IP defines the IP of the secondary nameserver Cloudflare will NOTIFY upon zo */
    ip?: string | null;
    /** Enable IXFR transfer protocol, default is AXFR. Only applicable to secondary zones. */
    ixfrEnable?: boolean | null;
    /** DNS port of primary or secondary nameserver, depending on what zone this peer is linked to. */
    port?: number | null;
    /** TSIG authentication will be used for zone transfer if configured. */
    tsigId?: string | null;
}
export declare const GetZoneTransferPeerResponse: Schema.Schema<GetZoneTransferPeerResponse>;
export type GetZoneTransferPeerError = DefaultErrors;
export declare const getZoneTransferPeer: API.OperationMethod<GetZoneTransferPeerRequest, GetZoneTransferPeerResponse, GetZoneTransferPeerError, Credentials | HttpClient.HttpClient>;
export interface ListZoneTransferPeersRequest {
    accountId: string;
}
export declare const ListZoneTransferPeersRequest: Schema.Schema<ListZoneTransferPeersRequest>;
export interface ListZoneTransferPeersResponse {
    result: {
        id: string;
        name: string;
        ip?: string | null;
        ixfrEnable?: boolean | null;
        port?: number | null;
        tsigId?: string | null;
    }[];
}
export declare const ListZoneTransferPeersResponse: Schema.Schema<ListZoneTransferPeersResponse>;
export type ListZoneTransferPeersError = DefaultErrors;
export declare const listZoneTransferPeers: API.PaginatedOperationMethod<ListZoneTransferPeersRequest, ListZoneTransferPeersResponse, ListZoneTransferPeersError, Credentials | HttpClient.HttpClient>;
export interface CreateZoneTransferPeerRequest {
    /** Path param: */
    accountId: string;
    /** Body param: The name of the peer. */
    name: string;
}
export declare const CreateZoneTransferPeerRequest: Schema.Schema<CreateZoneTransferPeerRequest>;
export interface CreateZoneTransferPeerResponse {
    id: string;
    /** The name of the peer. */
    name: string;
    /** IPv4/IPv6 address of primary or secondary nameserver, depending on what zone this peer is linked to. For primary zones this IP defines the IP of the secondary nameserver Cloudflare will NOTIFY upon zo */
    ip?: string | null;
    /** Enable IXFR transfer protocol, default is AXFR. Only applicable to secondary zones. */
    ixfrEnable?: boolean | null;
    /** DNS port of primary or secondary nameserver, depending on what zone this peer is linked to. */
    port?: number | null;
    /** TSIG authentication will be used for zone transfer if configured. */
    tsigId?: string | null;
}
export declare const CreateZoneTransferPeerResponse: Schema.Schema<CreateZoneTransferPeerResponse>;
export type CreateZoneTransferPeerError = DefaultErrors;
export declare const createZoneTransferPeer: API.OperationMethod<CreateZoneTransferPeerRequest, CreateZoneTransferPeerResponse, CreateZoneTransferPeerError, Credentials | HttpClient.HttpClient>;
export interface UpdateZoneTransferPeerRequest {
    peerId: string;
    /** Path param: */
    accountId: string;
    /** Body param: The name of the peer. */
    name: string;
    /** Body param: IPv4/IPv6 address of primary or secondary nameserver, depending on what zone this peer is linked to. For primary zones this IP defines the IP of the secondary nameserver Cloudflare will NO */
    ip?: string;
    /** Body param: Enable IXFR transfer protocol, default is AXFR. Only applicable to secondary zones. */
    ixfrEnable?: boolean;
    /** Body param: DNS port of primary or secondary nameserver, depending on what zone this peer is linked to. */
    port?: number;
    /** Body param: TSIG authentication will be used for zone transfer if configured. */
    tsigId?: string;
}
export declare const UpdateZoneTransferPeerRequest: Schema.Schema<UpdateZoneTransferPeerRequest>;
export interface UpdateZoneTransferPeerResponse {
    id: string;
    /** The name of the peer. */
    name: string;
    /** IPv4/IPv6 address of primary or secondary nameserver, depending on what zone this peer is linked to. For primary zones this IP defines the IP of the secondary nameserver Cloudflare will NOTIFY upon zo */
    ip?: string | null;
    /** Enable IXFR transfer protocol, default is AXFR. Only applicable to secondary zones. */
    ixfrEnable?: boolean | null;
    /** DNS port of primary or secondary nameserver, depending on what zone this peer is linked to. */
    port?: number | null;
    /** TSIG authentication will be used for zone transfer if configured. */
    tsigId?: string | null;
}
export declare const UpdateZoneTransferPeerResponse: Schema.Schema<UpdateZoneTransferPeerResponse>;
export type UpdateZoneTransferPeerError = DefaultErrors;
export declare const updateZoneTransferPeer: API.OperationMethod<UpdateZoneTransferPeerRequest, UpdateZoneTransferPeerResponse, UpdateZoneTransferPeerError, Credentials | HttpClient.HttpClient>;
export interface DeleteZoneTransferPeerRequest {
    peerId: string;
    accountId: string;
}
export declare const DeleteZoneTransferPeerRequest: Schema.Schema<DeleteZoneTransferPeerRequest>;
export interface DeleteZoneTransferPeerResponse {
    id?: string | null;
}
export declare const DeleteZoneTransferPeerResponse: Schema.Schema<DeleteZoneTransferPeerResponse>;
export type DeleteZoneTransferPeerError = DefaultErrors;
export declare const deleteZoneTransferPeer: API.OperationMethod<DeleteZoneTransferPeerRequest, DeleteZoneTransferPeerResponse, DeleteZoneTransferPeerError, Credentials | HttpClient.HttpClient>;
export interface GetZoneTransferTsigRequest {
    tsigId: string;
    accountId: string;
}
export declare const GetZoneTransferTsigRequest: Schema.Schema<GetZoneTransferTsigRequest>;
export interface GetZoneTransferTsigResponse {
    id: string;
    /** TSIG algorithm. */
    algo: string;
    /** TSIG key name. */
    name: string;
    /** TSIG secret. */
    secret: string;
}
export declare const GetZoneTransferTsigResponse: Schema.Schema<GetZoneTransferTsigResponse>;
export type GetZoneTransferTsigError = DefaultErrors;
export declare const getZoneTransferTsig: API.OperationMethod<GetZoneTransferTsigRequest, GetZoneTransferTsigResponse, GetZoneTransferTsigError, Credentials | HttpClient.HttpClient>;
export interface ListZoneTransferTsigsRequest {
    accountId: string;
}
export declare const ListZoneTransferTsigsRequest: Schema.Schema<ListZoneTransferTsigsRequest>;
export interface ListZoneTransferTsigsResponse {
    result: {
        id: string;
        algo: string;
        name: string;
        secret: string;
    }[];
}
export declare const ListZoneTransferTsigsResponse: Schema.Schema<ListZoneTransferTsigsResponse>;
export type ListZoneTransferTsigsError = DefaultErrors;
export declare const listZoneTransferTsigs: API.PaginatedOperationMethod<ListZoneTransferTsigsRequest, ListZoneTransferTsigsResponse, ListZoneTransferTsigsError, Credentials | HttpClient.HttpClient>;
export interface CreateZoneTransferTsigRequest {
    /** Path param: */
    accountId: string;
    /** Body param: TSIG algorithm. */
    algo: string;
    /** Body param: TSIG key name. */
    name: string;
    /** Body param: TSIG secret. */
    secret: string;
}
export declare const CreateZoneTransferTsigRequest: Schema.Schema<CreateZoneTransferTsigRequest>;
export interface CreateZoneTransferTsigResponse {
    id: string;
    /** TSIG algorithm. */
    algo: string;
    /** TSIG key name. */
    name: string;
    /** TSIG secret. */
    secret: string;
}
export declare const CreateZoneTransferTsigResponse: Schema.Schema<CreateZoneTransferTsigResponse>;
export type CreateZoneTransferTsigError = DefaultErrors;
export declare const createZoneTransferTsig: API.OperationMethod<CreateZoneTransferTsigRequest, CreateZoneTransferTsigResponse, CreateZoneTransferTsigError, Credentials | HttpClient.HttpClient>;
export interface UpdateZoneTransferTsigRequest {
    tsigId: string;
    /** Path param: */
    accountId: string;
    /** Body param: TSIG algorithm. */
    algo: string;
    /** Body param: TSIG key name. */
    name: string;
    /** Body param: TSIG secret. */
    secret: string;
}
export declare const UpdateZoneTransferTsigRequest: Schema.Schema<UpdateZoneTransferTsigRequest>;
export interface UpdateZoneTransferTsigResponse {
    id: string;
    /** TSIG algorithm. */
    algo: string;
    /** TSIG key name. */
    name: string;
    /** TSIG secret. */
    secret: string;
}
export declare const UpdateZoneTransferTsigResponse: Schema.Schema<UpdateZoneTransferTsigResponse>;
export type UpdateZoneTransferTsigError = DefaultErrors;
export declare const updateZoneTransferTsig: API.OperationMethod<UpdateZoneTransferTsigRequest, UpdateZoneTransferTsigResponse, UpdateZoneTransferTsigError, Credentials | HttpClient.HttpClient>;
export interface DeleteZoneTransferTsigRequest {
    tsigId: string;
    accountId: string;
}
export declare const DeleteZoneTransferTsigRequest: Schema.Schema<DeleteZoneTransferTsigRequest>;
export interface DeleteZoneTransferTsigResponse {
    id?: string | null;
}
export declare const DeleteZoneTransferTsigResponse: Schema.Schema<DeleteZoneTransferTsigResponse>;
export type DeleteZoneTransferTsigError = DefaultErrors;
export declare const deleteZoneTransferTsig: API.OperationMethod<DeleteZoneTransferTsigRequest, DeleteZoneTransferTsigResponse, DeleteZoneTransferTsigError, Credentials | HttpClient.HttpClient>;
//# sourceMappingURL=dns.d.ts.map