/**
 * Cloudflare KEYLESS-CERTIFICATES API
 *
 * Generated from Cloudflare TypeScript SDK.
 * DO NOT EDIT - regenerate with: bun scripts/generate.ts --service keyless-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 GetKeylessCertificateRequest {
    keylessCertificateId: string;
    /** Identifier. */
    zoneId: string;
}
export declare const GetKeylessCertificateRequest: Schema.Schema<GetKeylessCertificateRequest>;
export interface GetKeylessCertificateResponse {
    /** Keyless certificate identifier tag. */
    id: string;
    /** When the Keyless SSL was created. */
    createdOn: string;
    /** Whether or not the Keyless SSL is on or off. */
    enabled: boolean;
    /** The keyless SSL name. */
    host: string;
    /** When the Keyless SSL was last modified. */
    modifiedOn: string;
    /** The keyless SSL name. */
    name: string;
    /** Available permissions for the Keyless SSL for the current user requesting the item. */
    permissions: string[];
    /** The keyless SSL port used to communicate between Cloudflare and the client's Keyless SSL server. */
    port: number;
    /** Status of the Keyless SSL. */
    status: "active" | "deleted";
    /** Configuration for using Keyless SSL through a Cloudflare Tunnel */
    tunnel?: {
        privateIp: string;
        vnetId: string;
    } | null;
}
export declare const GetKeylessCertificateResponse: Schema.Schema<GetKeylessCertificateResponse>;
export type GetKeylessCertificateError = DefaultErrors;
export declare const getKeylessCertificate: API.OperationMethod<GetKeylessCertificateRequest, GetKeylessCertificateResponse, GetKeylessCertificateError, Credentials | HttpClient.HttpClient>;
export interface ListKeylessCertificatesRequest {
    /** Identifier. */
    zoneId: string;
}
export declare const ListKeylessCertificatesRequest: Schema.Schema<ListKeylessCertificatesRequest>;
export interface ListKeylessCertificatesResponse {
    result: {
        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;
    }[];
}
export declare const ListKeylessCertificatesResponse: Schema.Schema<ListKeylessCertificatesResponse>;
export type ListKeylessCertificatesError = DefaultErrors;
export declare const listKeylessCertificates: API.PaginatedOperationMethod<ListKeylessCertificatesRequest, ListKeylessCertificatesResponse, ListKeylessCertificatesError, Credentials | HttpClient.HttpClient>;
export interface CreateKeylessCertificateRequest {
    /** Path param: Identifier. */
    zoneId: string;
    /** Body param: The zone's SSL certificate or SSL certificate and intermediate(s). */
    certificate: string;
    /** Body param: The keyless SSL name. */
    host: string;
    /** Body param: The keyless SSL port used to communicate between Cloudflare and the client's Keyless SSL server. */
    port: number;
    /** 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 keyless SSL name. */
    name?: string;
    /** Body param: Configuration for using Keyless SSL through a Cloudflare Tunnel */
    tunnel?: {
        privateIp: string;
        vnetId: string;
    };
}
export declare const CreateKeylessCertificateRequest: Schema.Schema<CreateKeylessCertificateRequest>;
export interface CreateKeylessCertificateResponse {
    /** Keyless certificate identifier tag. */
    id: string;
    /** When the Keyless SSL was created. */
    createdOn: string;
    /** Whether or not the Keyless SSL is on or off. */
    enabled: boolean;
    /** The keyless SSL name. */
    host: string;
    /** When the Keyless SSL was last modified. */
    modifiedOn: string;
    /** The keyless SSL name. */
    name: string;
    /** Available permissions for the Keyless SSL for the current user requesting the item. */
    permissions: string[];
    /** The keyless SSL port used to communicate between Cloudflare and the client's Keyless SSL server. */
    port: number;
    /** Status of the Keyless SSL. */
    status: "active" | "deleted";
    /** Configuration for using Keyless SSL through a Cloudflare Tunnel */
    tunnel?: {
        privateIp: string;
        vnetId: string;
    } | null;
}
export declare const CreateKeylessCertificateResponse: Schema.Schema<CreateKeylessCertificateResponse>;
export type CreateKeylessCertificateError = DefaultErrors;
export declare const createKeylessCertificate: API.OperationMethod<CreateKeylessCertificateRequest, CreateKeylessCertificateResponse, CreateKeylessCertificateError, Credentials | HttpClient.HttpClient>;
export interface PatchKeylessCertificateRequest {
    keylessCertificateId: string;
    /** Path param: Identifier. */
    zoneId: string;
    /** @deprecated Body param: Whether or not the Keyless SSL is on or off. */
    enabled?: boolean;
    /** Body param: The keyless SSL name. */
    host?: string;
    /** Body param: The keyless SSL name. */
    name?: string;
    /** Body param: The keyless SSL port used to communicate between Cloudflare and the client's Keyless SSL server. */
    port?: number;
    /** Body param: Configuration for using Keyless SSL through a Cloudflare Tunnel */
    tunnel?: {
        privateIp: string;
        vnetId: string;
    };
}
export declare const PatchKeylessCertificateRequest: Schema.Schema<PatchKeylessCertificateRequest>;
export interface PatchKeylessCertificateResponse {
    /** Keyless certificate identifier tag. */
    id: string;
    /** When the Keyless SSL was created. */
    createdOn: string;
    /** Whether or not the Keyless SSL is on or off. */
    enabled: boolean;
    /** The keyless SSL name. */
    host: string;
    /** When the Keyless SSL was last modified. */
    modifiedOn: string;
    /** The keyless SSL name. */
    name: string;
    /** Available permissions for the Keyless SSL for the current user requesting the item. */
    permissions: string[];
    /** The keyless SSL port used to communicate between Cloudflare and the client's Keyless SSL server. */
    port: number;
    /** Status of the Keyless SSL. */
    status: "active" | "deleted";
    /** Configuration for using Keyless SSL through a Cloudflare Tunnel */
    tunnel?: {
        privateIp: string;
        vnetId: string;
    } | null;
}
export declare const PatchKeylessCertificateResponse: Schema.Schema<PatchKeylessCertificateResponse>;
export type PatchKeylessCertificateError = DefaultErrors;
export declare const patchKeylessCertificate: API.OperationMethod<PatchKeylessCertificateRequest, PatchKeylessCertificateResponse, PatchKeylessCertificateError, Credentials | HttpClient.HttpClient>;
export interface DeleteKeylessCertificateRequest {
    keylessCertificateId: string;
    /** Identifier. */
    zoneId: string;
}
export declare const DeleteKeylessCertificateRequest: Schema.Schema<DeleteKeylessCertificateRequest>;
export interface DeleteKeylessCertificateResponse {
    /** Identifier. */
    id?: string | null;
}
export declare const DeleteKeylessCertificateResponse: Schema.Schema<DeleteKeylessCertificateResponse>;
export type DeleteKeylessCertificateError = DefaultErrors;
export declare const deleteKeylessCertificate: API.OperationMethod<DeleteKeylessCertificateRequest, DeleteKeylessCertificateResponse, DeleteKeylessCertificateError, Credentials | HttpClient.HttpClient>;
//# sourceMappingURL=keyless-certificates.d.ts.map