/**
 * Cloudflare CUSTOM-CERTIFICATES API
 *
 * Generated from Cloudflare TypeScript SDK.
 * DO NOT EDIT - regenerate with: bun scripts/generate.ts --service custom-certificates
 */
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 GetCustomCertificateRequest {
    customCertificateId: string;
    /** Identifier. */
    zoneId: string;
}
export declare const GetCustomCertificateRequest: Schema.Schema<GetCustomCertificateRequest>;
export interface GetCustomCertificateResponse {
    /** Identifier. */
    id: string;
    /** A ubiquitous bundle has the highest probability of being verified everywhere, even by clients using outdated or unusual trust stores. An optimal bundle uses the shortest chain and newest intermediates */
    bundleMethod: "ubiquitous" | "optimal" | "force";
    /** When the certificate from the authority expires. */
    expiresOn: string;
    hosts: string[];
    /** The certificate authority that issued the certificate. */
    issuer: string;
    /** When the certificate was last modified. */
    modifiedOn: string;
    /** The order/priority in which the certificate will be used in a request. The higher priority will break ties across overlapping 'legacy_custom' certificates, but 'legacy_custom' certificates will always */
    priority: number;
    /** The type of hash used for the certificate. */
    signature: string;
    /** Status of the zone's custom SSL. */
    status: "active" | "expired" | "deleted" | "pending" | "initializing";
    /** When the certificate was uploaded to Cloudflare. */
    uploadedOn: string;
    /** Identifier. */
    zoneId: string;
    /** Specify the region where your private key can be held locally for optimal TLS performance. HTTPS connections to any excluded data center will still be fully encrypted, but will incur some latency whil */
    geoRestrictions?: {
        label?: "us" | "eu" | "highest_security" | null;
    } | null;
    keylessServer?: {
        id: string;
        createdOn: string;
        enabled: boolean;
        host: string;
        modifiedOn: string;
        name: string;
        permissions: string[];
        port: number;
        status: "active" | "deleted";
        tunnel?: {
            privateIp: string;
            vnetId: string;
        } | null;
    } | null;
    /** Specify the policy that determines the region where your private key will be held locally. HTTPS connections to any excluded data center will still be fully encrypted, but will incur some latency whil */
    policy?: string | null;
}
export declare const GetCustomCertificateResponse: Schema.Schema<GetCustomCertificateResponse>;
export type GetCustomCertificateError = DefaultErrors;
export declare const getCustomCertificate: API.OperationMethod<GetCustomCertificateRequest, GetCustomCertificateResponse, GetCustomCertificateError, Credentials | HttpClient.HttpClient>;
export interface ListCustomCertificatesRequest {
    /** Path param: Identifier. */
    zoneId: string;
    page?: number;
    perPage?: number;
    /** Query param: Whether to match all search requirements or at least one (any). */
    match?: "any" | "all";
    /** Query param: Status of the zone's custom SSL. */
    status?: "active" | "expired" | "deleted" | "pending" | "initializing";
}
export declare const ListCustomCertificatesRequest: Schema.Schema<ListCustomCertificatesRequest>;
export interface ListCustomCertificatesResponse {
    result: {
        id: string;
        bundleMethod: "ubiquitous" | "optimal" | "force";
        expiresOn: string;
        hosts: string[];
        issuer: string;
        modifiedOn: string;
        priority: number;
        signature: string;
        status: "active" | "expired" | "deleted" | "pending" | "initializing";
        uploadedOn: string;
        zoneId: string;
        geoRestrictions?: {
            label?: "us" | "eu" | "highest_security" | null;
        } | null;
        keylessServer?: {
            id: string;
            createdOn: string;
            enabled: boolean;
            host: string;
            modifiedOn: string;
            name: string;
            permissions: string[];
            port: number;
            status: "active" | "deleted";
            tunnel?: {
                privateIp: string;
                vnetId: string;
            } | null;
        } | null;
        policy?: string | null;
    }[];
    resultInfo?: {
        count?: number | null;
        page?: number | null;
        perPage?: number | null;
        totalCount?: number | null;
    } | null;
}
export declare const ListCustomCertificatesResponse: Schema.Schema<ListCustomCertificatesResponse>;
export type ListCustomCertificatesError = DefaultErrors;
export declare const listCustomCertificates: API.PaginatedOperationMethod<ListCustomCertificatesRequest, ListCustomCertificatesResponse, ListCustomCertificatesError, Credentials | HttpClient.HttpClient>;
export interface CreateCustomCertificateRequest {
    /** Path param: Identifier. */
    zoneId: string;
    /** Body param: The zone's SSL certificate or certificate and the intermediate(s). */
    certificate: string;
    /** Body param: The zone's private key. */
    privateKey: string;
    /** Body param: A ubiquitous bundle has the highest probability of being verified everywhere, even by clients using outdated or unusual trust stores. An optimal bundle uses the shortest chain and newest i */
    bundleMethod?: "ubiquitous" | "optimal" | "force";
    /** Body param: Specify the region where your private key can be held locally for optimal TLS performance. HTTPS connections to any excluded data center will still be fully encrypted, but will incur some  */
    geoRestrictions?: {
        label?: "us" | "eu" | "highest_security";
    };
    /** Body param: Specify the policy that determines the region where your private key will be held locally. HTTPS connections to any excluded data center will still be fully encrypted, but will incur some  */
    policy?: string;
    /** Body param: The type 'legacy_custom' enables support for legacy clients which do not include SNI in the TLS handshake. */
    type?: "legacy_custom" | "sni_custom";
}
export declare const CreateCustomCertificateRequest: Schema.Schema<CreateCustomCertificateRequest>;
export interface CreateCustomCertificateResponse {
    /** Identifier. */
    id: string;
    /** A ubiquitous bundle has the highest probability of being verified everywhere, even by clients using outdated or unusual trust stores. An optimal bundle uses the shortest chain and newest intermediates */
    bundleMethod: "ubiquitous" | "optimal" | "force";
    /** When the certificate from the authority expires. */
    expiresOn: string;
    hosts: string[];
    /** The certificate authority that issued the certificate. */
    issuer: string;
    /** When the certificate was last modified. */
    modifiedOn: string;
    /** The order/priority in which the certificate will be used in a request. The higher priority will break ties across overlapping 'legacy_custom' certificates, but 'legacy_custom' certificates will always */
    priority: number;
    /** The type of hash used for the certificate. */
    signature: string;
    /** Status of the zone's custom SSL. */
    status: "active" | "expired" | "deleted" | "pending" | "initializing";
    /** When the certificate was uploaded to Cloudflare. */
    uploadedOn: string;
    /** Identifier. */
    zoneId: string;
    /** Specify the region where your private key can be held locally for optimal TLS performance. HTTPS connections to any excluded data center will still be fully encrypted, but will incur some latency whil */
    geoRestrictions?: {
        label?: "us" | "eu" | "highest_security" | null;
    } | null;
    keylessServer?: {
        id: string;
        createdOn: string;
        enabled: boolean;
        host: string;
        modifiedOn: string;
        name: string;
        permissions: string[];
        port: number;
        status: "active" | "deleted";
        tunnel?: {
            privateIp: string;
            vnetId: string;
        } | null;
    } | null;
    /** Specify the policy that determines the region where your private key will be held locally. HTTPS connections to any excluded data center will still be fully encrypted, but will incur some latency whil */
    policy?: string | null;
}
export declare const CreateCustomCertificateResponse: Schema.Schema<CreateCustomCertificateResponse>;
export type CreateCustomCertificateError = DefaultErrors;
export declare const createCustomCertificate: API.OperationMethod<CreateCustomCertificateRequest, CreateCustomCertificateResponse, CreateCustomCertificateError, Credentials | HttpClient.HttpClient>;
export interface PatchCustomCertificateRequest {
    customCertificateId: string;
    /** Path param: Identifier. */
    zoneId: string;
    /** Body param: A ubiquitous bundle has the highest probability of being verified everywhere, even by clients using outdated or unusual trust stores. An optimal bundle uses the shortest chain and newest i */
    bundleMethod?: "ubiquitous" | "optimal" | "force";
    /** Body param: The zone's SSL certificate or certificate and the intermediate(s). */
    certificate?: string;
    /** Body param: Specify the region where your private key can be held locally for optimal TLS performance. HTTPS connections to any excluded data center will still be fully encrypted, but will incur some  */
    geoRestrictions?: {
        label?: "us" | "eu" | "highest_security";
    };
    /** Body param: Specify the policy that determines the region where your private key will be held locally. HTTPS connections to any excluded data center will still be fully encrypted, but will incur some  */
    policy?: string;
    /** Body param: The zone's private key. */
    privateKey?: string;
}
export declare const PatchCustomCertificateRequest: Schema.Schema<PatchCustomCertificateRequest>;
export interface PatchCustomCertificateResponse {
    /** Identifier. */
    id: string;
    /** A ubiquitous bundle has the highest probability of being verified everywhere, even by clients using outdated or unusual trust stores. An optimal bundle uses the shortest chain and newest intermediates */
    bundleMethod: "ubiquitous" | "optimal" | "force";
    /** When the certificate from the authority expires. */
    expiresOn: string;
    hosts: string[];
    /** The certificate authority that issued the certificate. */
    issuer: string;
    /** When the certificate was last modified. */
    modifiedOn: string;
    /** The order/priority in which the certificate will be used in a request. The higher priority will break ties across overlapping 'legacy_custom' certificates, but 'legacy_custom' certificates will always */
    priority: number;
    /** The type of hash used for the certificate. */
    signature: string;
    /** Status of the zone's custom SSL. */
    status: "active" | "expired" | "deleted" | "pending" | "initializing";
    /** When the certificate was uploaded to Cloudflare. */
    uploadedOn: string;
    /** Identifier. */
    zoneId: string;
    /** Specify the region where your private key can be held locally for optimal TLS performance. HTTPS connections to any excluded data center will still be fully encrypted, but will incur some latency whil */
    geoRestrictions?: {
        label?: "us" | "eu" | "highest_security" | null;
    } | null;
    keylessServer?: {
        id: string;
        createdOn: string;
        enabled: boolean;
        host: string;
        modifiedOn: string;
        name: string;
        permissions: string[];
        port: number;
        status: "active" | "deleted";
        tunnel?: {
            privateIp: string;
            vnetId: string;
        } | null;
    } | null;
    /** Specify the policy that determines the region where your private key will be held locally. HTTPS connections to any excluded data center will still be fully encrypted, but will incur some latency whil */
    policy?: string | null;
}
export declare const PatchCustomCertificateResponse: Schema.Schema<PatchCustomCertificateResponse>;
export type PatchCustomCertificateError = DefaultErrors;
export declare const patchCustomCertificate: API.OperationMethod<PatchCustomCertificateRequest, PatchCustomCertificateResponse, PatchCustomCertificateError, Credentials | HttpClient.HttpClient>;
export interface DeleteCustomCertificateRequest {
    customCertificateId: string;
    /** Identifier. */
    zoneId: string;
}
export declare const DeleteCustomCertificateRequest: Schema.Schema<DeleteCustomCertificateRequest>;
export interface DeleteCustomCertificateResponse {
    /** Identifier. */
    id?: string | null;
}
export declare const DeleteCustomCertificateResponse: Schema.Schema<DeleteCustomCertificateResponse>;
export type DeleteCustomCertificateError = DefaultErrors;
export declare const deleteCustomCertificate: API.OperationMethod<DeleteCustomCertificateRequest, DeleteCustomCertificateResponse, DeleteCustomCertificateError, Credentials | HttpClient.HttpClient>;
export interface PutPrioritizeRequest {
    /** Path param: Identifier. */
    zoneId: string;
    /** Body param: Array of ordered certificates. */
    certificates: {
        id?: string;
        priority?: number;
    }[];
}
export declare const PutPrioritizeRequest: Schema.Schema<PutPrioritizeRequest>;
export interface PutPrioritizeResponse {
    result: {
        id: string;
        bundleMethod: "ubiquitous" | "optimal" | "force";
        expiresOn: string;
        hosts: string[];
        issuer: string;
        modifiedOn: string;
        priority: number;
        signature: string;
        status: "active" | "expired" | "deleted" | "pending" | "initializing";
        uploadedOn: string;
        zoneId: string;
        geoRestrictions?: {
            label?: "us" | "eu" | "highest_security" | null;
        } | null;
        keylessServer?: {
            id: string;
            createdOn: string;
            enabled: boolean;
            host: string;
            modifiedOn: string;
            name: string;
            permissions: string[];
            port: number;
            status: "active" | "deleted";
            tunnel?: {
                privateIp: string;
                vnetId: string;
            } | null;
        } | null;
        policy?: string | null;
    }[];
}
export declare const PutPrioritizeResponse: Schema.Schema<PutPrioritizeResponse>;
export type PutPrioritizeError = DefaultErrors;
export declare const putPrioritize: API.PaginatedOperationMethod<PutPrioritizeRequest, PutPrioritizeResponse, PutPrioritizeError, Credentials | HttpClient.HttpClient>;
//# sourceMappingURL=custom-certificates.d.ts.map