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

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

import { SecretSkeleton, VersionOfSecretSkeleton, VersionOfSecretStatus } from '../../api/cloud/SecretsApi';
import { State } from '../../shared/State';
import { ExportMetaData } from '../OpsTypes';
export type Secret = {
    /**
     * Read all secrets
     * @returns {Promise<SecretSkeleton[]>} a promise that resolves to an array of secrets
     */
    readSecrets(): Promise<SecretSkeleton[]>;
    /**
     * Read secret
     * @param {string} secretId secret id/name
     * @returns {Promise<SecretSkeleton>} a promise that resolves to a secret
     */
    readSecret(secretId: string): Promise<SecretSkeleton>;
    /**
     * Read the value of a secret
     * @param {string} secretId secret id/name
     * @param {string} target Host URL of target environment to encrypt secret value for
     * @param {boolean} decrypt retrieve secret value in the clear (default: false)
     * @returns {Promise<string>} a promise that resolves to the value of the secret
     */
    readSecretValue(secretId: string, target?: string, decrypt?: boolean): Promise<any>;
    /**
     * Read the values of an array of secrets
     * @param {string} secretIds secret id/name
     * @param {string} target Host URL of target environment to encrypt secret values for
     * @param {boolean} decrypt retrieve secret values in the clear (default: false)
     * @returns {Promise<{ [key: string]: string }>} a promise that resolves to a map of secret ids and values
     */
    readSecretValues(secretIds: string[], target?: string, decrypt?: boolean): Promise<{
        [key: string]: string;
    }>;
    /**
     * Export secret. The response can be saved to file as is.
     * @param {string} secretId secret id/name
     * @param {boolean} includeActiveValue include active value of secret (default: false)
     * @param {string} target Host URL of target environment to encrypt secret value for
     * @returns {Promise<SecretsExportInterface>} Promise resolving to a SecretsExportInterface object.
     */
    exportSecret(secretId: string, includeActiveValue?: boolean, target?: string): Promise<SecretsExportInterface>;
    /**
     * Export all secrets
     * @param {boolean} includeActiveValues include active values of secrets (default: false)
     * @param {string} target Host URL of target environment to encrypt secret values for
     * @returns {Promise<SecretsExportInterface>} Promise resolving to an SecretsExportInterface object.
     */
    exportSecrets(includeActiveValues?: boolean, target?: string): Promise<SecretsExportInterface>;
    /**
     * Import secret by id
     * @param {string} secretId secret id/name
     * @param {SecretsExportInterface} importData import data
     * @param {boolean} includeActiveValue include active value of secret (default: false)
     * @param {string} source Host URL of source environment where the secret was exported from
     * @returns {Promise<SecretSkeleton>} imported secret object
     */
    importSecret(secretId: string, importData: SecretsExportInterface, includeActiveValue?: boolean, source?: string): Promise<SecretSkeleton>;
    /**
     * Import secrets
     * @param {SecretsExportInterface} importData import data
     * @param {boolean} includeActiveValues include active values of secrets (default: false)
     * @param {string} source Host URL of source environment where the secrets were exported from
     * @returns {Promise<SecretSkeleton[]>} array of imported secret objects
     */
    importSecrets(importData: SecretsExportInterface, includeActiveValues?: boolean, source?: string): Promise<SecretSkeleton[]>;
    /**
     * Create secret
     * @param {string} secretId secret id/name
     * @param {string} value secret value
     * @param {string} description secret description
     * @param {string} encoding secret encoding (only `generic` is supported)
     * @param {boolean} useInPlaceholders flag indicating if the secret can be used in placeholders
     * @returns {Promise<SecretSkeleton>} a promise that resolves to a secret
     */
    createSecret(secretId: string, value: string, description: string, encoding?: string, useInPlaceholders?: boolean): Promise<SecretSkeleton>;
    /**
     * Update secret description
     * @param {string} secretId secret id/name
     * @param {string} description secret description
     * @returns {Promise<any>} a promise that resolves to an empty string
     */
    updateSecretDescription(secretId: string, description: string): Promise<any>;
    /**
     * Delete secret
     * @param {string} secretId secret id/name
     * @returns {Promise<SecretSkeleton>} a promise that resolves to a secret object
     */
    deleteSecret(secretId: string): Promise<SecretSkeleton>;
    /**
     * Read versions of secret
     * @param {string} secretId secret id/name
     * @returns {Promise<VersionOfSecretSkeleton[]>} a promise that resolves to an array of secret versions
     */
    readVersionsOfSecret(secretId: string): Promise<VersionOfSecretSkeleton[]>;
    /**
     * Create version of secret
     * @param {string} secretId secret id/name
     * @param {string} value secret value
     * @returns {Promise<VersionOfSecretSkeleton>} a promise that resolves to a version object
     */
    createVersionOfSecret(secretId: string, value: string): Promise<VersionOfSecretSkeleton>;
    /**
     * Read version of secret
     * @param {string} secretId secret id/name
     * @param {string} version secret version
     * @returns {Promise<VersionOfSecretSkeleton>} a promise that resolves to a version object
     */
    readVersionOfSecret(secretId: string, version: string): Promise<VersionOfSecretSkeleton>;
    /**
     * Enable a version of a secret
     * @param {string} secretId secret id/name
     * @param {string} version secret version
     * @returns {Promise<VersionOfSecretSkeleton>} a promise that resolves to a status object
     */
    enableVersionOfSecret(secretId: string, version: string): Promise<VersionOfSecretSkeleton>;
    /**
     * Disable a version of a secret
     * @param {string} secretId secret id/name
     * @param {string} version secret version
     * @returns {Promise<VersionOfSecretSkeleton>} a promise that resolves to a status object
     */
    disableVersionOfSecret(secretId: string, version: string): Promise<VersionOfSecretSkeleton>;
    /**
     * Delete version of secret
     * @param {string} secretId secret id/name
     * @param {string} version secret version
     * @returns {Promise<VersionOfSecretSkeleton>} a promise that resolves to a version object
     */
    deleteVersionOfSecret(secretId: string, version: string): Promise<VersionOfSecretSkeleton>;
    /**
     * Get all secrets
     * @returns {Promise<any[]>} a promise that resolves to an array of secrets
     * @deprecated since v2.0.0 use {@link Secret.readSecrets | readSecrets} instead
     * ```javascript
     * readSecrets(): Promise<SecretSkeleton[]>
     * ```
     * @group Deprecated
     */
    getSecrets(): Promise<SecretSkeleton[]>;
    /**
     * Get secret
     * @param secretId secret id/name
     * @returns {Promise<SecretSkeleton>} a promise that resolves to a secret
     * @deprecated since v2.0.0 use {@link Secret.readSecret | readSecret} instead
     * ```javascript
     * readSecret(secretId: string): Promise<any>
     * ```
     * @group Deprecated
     */
    getSecret(secretId: string): Promise<SecretSkeleton>;
    /**
     * Create secret
     * @param {string} secretId secret id/name
     * @param {string} value secret value
     * @param {string} description secret description
     * @param {string} encoding secret encoding (only `generic` is supported)
     * @param {boolean} useInPlaceholders flag indicating if the secret can be used in placeholders
     * @returns {Promise<SecretSkeleton>} a promise that resolves to a secret
     * @deprecated since v2.0.0 use {@link Secret.createSecret | createSecret} instead
     * ```javascript
     * createSecret(secretId: string, value: string, description: string, encoding?: string, useInPlaceholders?: boolean): Promise<any>
     * ```
     * @group Deprecated
     */
    putSecret(secretId: string, value: string, description: string, encoding?: string, useInPlaceholders?: boolean): Promise<SecretSkeleton>;
    /**
     * Set secret description
     * @param {string} secretId secret id/name
     * @param {string} description secret description
     * @returns {Promise<any>} a promise that resolves to an empty string
     * @deprecated since v2.0.0 use {@link Secret.updateSecretDescription | updateSecretDescription} instead
     * ```javascript
     * updateSecretDescription(secretId: string, description: string): Promise<any>
     * ```
     * @group Deprecated
     */
    setSecretDescription(secretId: string, description: string): Promise<any>;
    /**
     * Get secret versions
     * @param {string} secretId secret id/name
     * @returns {Promise<VersionOfSecretSkeleton[]>} a promise that resolves to an array of secret versions
     * @deprecated since v2.0.0 use {@link Secret.readVersionsOfSecret | readVersionsOfSecret} instead
     * ```javascript
     * readVersionsOfSecret(secretId: string): Promise<any>
     * ```
     * @group Deprecated
     */
    getSecretVersions(secretId: string): Promise<VersionOfSecretSkeleton[]>;
    /**
     * Create new secret version
     * @param {string} secretId secret id/name
     * @param {string} value secret value
     * @returns {Promise<VersionOfSecretSkeleton>} a promise that resolves to a version object
     * @deprecated since v2.0.0 use {@link Secret.createVersionOfSecret | createVersionOfSecret} instead
     * ```javascript
     * createVersionOfSecret(secretId: string, value: string): Promise<any>
     * ```
     * @group Deprecated
     */
    createNewVersionOfSecret(secretId: string, value: string): Promise<VersionOfSecretSkeleton>;
    /**
     * Get version of secret
     * @param {string} secretId secret id/name
     * @param {string} version secret version
     * @returns {Promise<VersionOfSecretSkeleton>} a promise that resolves to a version object
     * @deprecated since v2.0.0 use {@link Secret.readVersionOfSecret | readVersionOfSecret} instead
     * ```javascript
     * readVersionOfSecret(secretId: string, version: string): Promise<any>
     * ```
     * @group Deprecated
     */
    getVersionOfSecret(secretId: string, version: string): Promise<VersionOfSecretSkeleton>;
    /**
     * Update the status of a version of a secret
     * @param {string} secretId secret id/name
     * @param {string} version secret version
     * @param {VersionOfSecretStatus} status status
     * @returns {Promise<VersionOfSecretSkeleton>} a promise that resolves to a status object
     * @deprecated since v2.0.0 use {@link Secret.enableVersionOfSecret | enableVersionOfSecret} or {@link Secret.disableVersionOfSecret | disableVersionOfSecret} instead
     * ```javascript
     * enableVersionOfSecret(secretId: string, version: string): Promise<any>
     * disableVersionOfSecret(secretId: string, version: string): Promise<any>
     * ```
     * @group Deprecated
     */
    setStatusOfVersionOfSecret(secretId: string, version: string, status: VersionOfSecretStatus): Promise<VersionOfSecretSkeleton>;
};
declare const _default: (state: State) => Secret;
export default _default;
export interface SecretsExportInterface {
    meta?: ExportMetaData;
    secret: Record<string, SecretSkeleton>;
}
/**
 * Secrets import options
 */
export interface SecretImportOptions {
    /**
     * Import active values of secret
     */
    includeActiveValues: boolean;
    /**
     * Host URL of source environment to decrypt secret values from
     */
    source?: string;
}
/**
 * Secrets export options
 */
export interface SecretExportOptions {
    /**
     * Export active values of secret
     */
    includeActiveValues: boolean;
    /**
     * Host URL of target environment to encrypt secret values for
     */
    target?: string;
}
export declare function createSecretsExportTemplate({ state, }: {
    state: State;
}): SecretsExportInterface;
export declare function exportSecret({ secretId, options, state, }: {
    secretId: string;
    options?: SecretExportOptions;
    state: State;
}): Promise<SecretsExportInterface>;
export declare function exportSecrets({ options, state, }: {
    options?: SecretExportOptions;
    state: State;
}): Promise<SecretsExportInterface>;
export declare function readSecretValue({ secretId, decrypt, target, state, }: {
    secretId: string;
    decrypt?: boolean;
    target?: string;
    state: State;
}): Promise<any>;
export declare function readSecretValues({ secretIds, decrypt, target, state, }: {
    secretIds: string[];
    decrypt?: boolean;
    target?: string;
    state: State;
}): Promise<{
    [key: string]: string;
}>;
/**
 * Import secret
 * @param {string} secretId secret id/name
 * @param {SecretsExportInterface} importData import data
 * @returns {Promise<SecretSkeleton[]>} array of imported secret objects
 */
export declare function importSecret({ secretId, importData, options, state, }: {
    secretId: string;
    importData: SecretsExportInterface;
    options?: SecretImportOptions;
    state: State;
}): Promise<SecretSkeleton>;
/**
 * Import secrets
 * @param {SecretsExportInterface} importData import data
 * @returns {Promise<SecretSkeleton[]>} array of imported secret objects
 */
export declare function importSecrets({ importData, options, state, }: {
    importData: SecretsExportInterface;
    options?: SecretImportOptions;
    state: State;
}): Promise<SecretSkeleton[]>;
export declare function enableVersionOfSecret({ secretId, version, state, }: {
    secretId: string;
    version: string;
    state: State;
}): Promise<VersionOfSecretSkeleton>;
export declare function disableVersionOfSecret({ secretId, version, state, }: {
    secretId: string;
    version: string;
    state: State;
}): Promise<VersionOfSecretSkeleton>;
export declare function readSecret({ secretId, state, }: {
    secretId: string;
    state: State;
}): Promise<SecretSkeleton>;
export declare function readSecrets({ state, }: {
    state: State;
}): Promise<SecretSkeleton[]>;
export declare function createSecret({ secretId, value, description, encoding, useInPlaceholders, state, }: {
    secretId: string;
    value: string;
    description: string;
    encoding: string;
    useInPlaceholders: boolean;
    state: State;
}): Promise<SecretSkeleton>;
export declare function createVersionOfSecret({ secretId, value, state, }: {
    secretId: string;
    value: string;
    state: State;
}): Promise<VersionOfSecretSkeleton>;
export declare function deleteSecret({ secretId, state, }: {
    secretId: string;
    state: State;
}): Promise<any>;
export declare function readVersionOfSecret({ secretId, version, state, }: {
    secretId: string;
    version: string;
    state: State;
}): Promise<VersionOfSecretSkeleton>;
export declare function readVersionsOfSecret({ secretId, state, }: {
    secretId: string;
    state: State;
}): Promise<VersionOfSecretSkeleton[]>;
export declare function updateSecretDescription({ secretId, description, state, }: {
    secretId: string;
    description: string;
    state: State;
}): Promise<any>;
//# sourceMappingURL=SecretsOps.d.ts.map