@rockcarver/frodo-lib/types/ops/cloud/EnvCertificatesOps.d.ts

A library to manage ForgeRock Identity Cloud tenants, ForgeOps deployments, and classic deployments.

import { type CertificateResponse } from '../../api/cloud/EnvCertificatesApi';
import { State } from '../../shared/State';
export type EnvCertificate = {
    /**
     * Read certificate by id
     * @param {string} certificateId certificate id
     * @returns {Promise<CertificateResponse>} a promise that resolves to a certificate object
     */
    readCertificate(certificateId: string): Promise<CertificateResponse>;
    /**
     * Read all certificates
     * @param {boolean} noDecode Do not decode values (default: false)
     * @returns {Promise<CertificateResponse[]>} a promise that resolves to an array of certificate objects
     */
    readCertificates(noDecode?: boolean): Promise<CertificateResponse[]>;
    /**
     * Create certificate
     * @param {boolean} active The active status of the certificate. Set this to true for the certificate to actively be served.
     * @param {string} certificate The PEM formatted certificate.
     * @param {string} privateKey The private key for the certificate. For security reasons, only insert requests include this field.
     * @param {boolean} wait Wait until certificate is live (use interval and retries to modify default behavior)
     * @param {number} interval Only applies when wait=true: Time (in milliseconds) to wait between retries (default: 5000)
     * @param {number} retries Only applies when wait=true: How many times to retry (default: 24)
     * @returns {Promise<CertificateResponse>} a promise that resolves to a certificate object
     */
    createCertificate(active: boolean, certificate: string, privateKey: string, wait?: boolean, interval?: number, retries?: number): Promise<CertificateResponse>;
    /**
     * Update certificate
     * @param {string} certificateId ID of the certificate
     * @param {boolean} active The active status of the certificate. Set this to true for the certificate to actively be served.
     * @returns {Promise<CertificateResponse>} a promise that resolves to a certificate object
     */
    updateCertificate(certificateId: string, active: boolean): Promise<CertificateResponse>;
    /**
     * Activate certificate
     * @param {string} certificateId ID of the certificate
     * @param {boolean} wait Wait until certificate is live (use interval and retries to modify default behavior)
     * @param {number} interval Only applies when wait=true: Time (in milliseconds) to wait between retries (default: 5000)
     * @param {number} retries Only applies when wait=true: How many times to retry (default: 24)
     * @returns {Promise<CertificateResponse>} a promise that resolves to a certificate object
     */
    activateCertificate(certificateId: string, wait?: boolean, interval?: number, retries?: number): Promise<CertificateResponse>;
    /**
     * Deactivate certificate
     * @param {string} certificateId ID of the certificate
     * @param {boolean} wait Wait until certificate is live (use interval and retries to modify default behavior)
     * @param {number} interval Only applies when wait=true: Time (in milliseconds) to wait between retries (default: 5000)
     * @param {number} retries Only applies when wait=true: How many times to retry (default: 24)
     * @returns {Promise<CertificateResponse>} a promise that resolves to a certificate object
     */
    deactivateCertificate(certificateId: string, wait?: boolean, interval?: number, retries?: number): Promise<CertificateResponse>;
    /**
     * Check if certificate is active
     * @param {string} certificateId ID of the certificate
     * @returns {Promise<boolean>} a promise that resolves to true or false
     */
    isCertificateActive(certificateId: string): Promise<boolean>;
    /**
     * Check if certificate is live
     * @param {string} certificateId ID of the certificate
     * @returns {Promise<boolean>} a promise that resolves to true or false
     */
    isCertificateLive(certificateId: string): Promise<boolean>;
    /**
     * Delete certificate
     * @param {string} certificateId certificate id/name
     * @param {boolean} force force deletion of active certificate by attempting to deactivate it (use interval and retries to modify default behavior)
     * @param {number} interval Only applies when force=true: Time (in milliseconds) to wait between retries (default: 5000)
     * @param {number} retries Only applies when force=true: How many times to retry (default: 24)
     * @returns {Promise<CertificateResponse>} a promise that resolves to a certificate object
     */
    deleteCertificate(certificateId: string, force?: boolean, interval?: number, retries?: number): Promise<CertificateResponse>;
    /**
     * Delete all certificates
     * @param {boolean} force force deletion of active certificate by attempting to deactivate it (use interval and retries to modify default behavior)
     * @param {number} interval Only applies when force=true: Time (in milliseconds) to wait between retries (default: 5000)
     * @param {number} retries Only applies when force=true: How many times to retry (default: 24)
     * @returns {Promise<CertificateResponse>} a promise that resolves to a certificate object
     */
    deleteCertificates(force?: boolean, interval?: number, retries?: number): Promise<CertificateResponse[]>;
};
declare const _default: (state: State) => EnvCertificate;
export default _default;
export declare function readCertificate({ certificateId, state, }: {
    certificateId: string;
    state: State;
}): Promise<CertificateResponse>;
export declare function readCertificates({ state, }: {
    state: State;
}): Promise<CertificateResponse[]>;
export declare function createCertificate({ active, certificate, privateKey, wait, interval, retries, state, }: {
    active: boolean;
    certificate: string;
    privateKey: string;
    wait?: boolean;
    interval?: number;
    retries?: number;
    state: State;
}): Promise<CertificateResponse>;
export declare function updateCertificate({ certificateId, active, state, }: {
    certificateId: string;
    active: boolean;
    state: State;
}): Promise<CertificateResponse>;
export declare function activateCertificate({ certificateId, wait, interval, retries, state, }: {
    certificateId: string;
    wait?: boolean;
    interval?: number;
    retries?: number;
    state: State;
}): Promise<CertificateResponse>;
export declare function deactivateCertificate({ certificateId, wait, interval, retries, state, }: {
    certificateId: string;
    wait?: boolean;
    interval?: number;
    retries?: number;
    state: State;
}): Promise<CertificateResponse>;
export declare function isCertificateActive({ certificateId, state, }: {
    certificateId: string;
    state: State;
}): Promise<boolean>;
export declare function isCertificateLive({ certificateId, state, }: {
    certificateId: string;
    state: State;
}): Promise<boolean>;
export declare function deleteCertificate({ certificateId, force, interval, retries, state, }: {
    certificateId: string;
    force?: boolean;
    interval?: number;
    retries?: number;
    state: State;
}): Promise<CertificateResponse>;
export declare function deleteCertificates({ force, interval, retries, state, }: {
    force?: boolean;
    interval?: number;
    retries?: number;
    state: State;
}): Promise<CertificateResponse[]>;
//# sourceMappingURL=EnvCertificatesOps.d.ts.map