@rockcarver/frodo-lib/types/lib/FrodoLib.d.ts

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

import { Admin } from '../ops/AdminOps';
import { Agent } from '../ops/AgentOps';
import { AmConfig } from '../ops/AmConfigOps';
import { ApiFactory } from '../ops/ApiFactoryOps';
import { Application } from '../ops/ApplicationOps';
import { Authenticate } from '../ops/AuthenticateOps';
import { AuthenticationSettings } from '../ops/AuthenticationSettingsOps';
import { CirclesOfTrust } from '../ops/CirclesOfTrustOps';
import { SecretStore } from '../ops/classic/SecretStoreOps';
import { Server } from '../ops/classic/ServerOps';
import { Site } from '../ops/classic/SiteOps';
import { AdminFederation } from '../ops/cloud/AdminFederationOps';
import { EnvCertificate } from '../ops/cloud/EnvCertificatesOps';
import { EnvContentSecurityPolicy } from '../ops/cloud/EnvContentSecurityPolicyOps';
import { EnvCookieDomains } from '../ops/cloud/EnvCookieDomainsOps';
import { EnvCSR } from '../ops/cloud/EnvCSRsOps';
import { EnvCustomDomains } from '../ops/cloud/EnvCustomDomainsOps';
import { EnvFederationEnforcement } from '../ops/cloud/EnvFederationEnforcementOps';
import { EnvPromotion } from '../ops/cloud/EnvPromotionOps';
import { EnvRelease } from '../ops/cloud/EnvReleaseOps';
import { EnvServiceAccountScopes } from '../ops/cloud/EnvServiceAccountScopesOps';
import { EnvSSOCookieConfig } from '../ops/cloud/EnvSSOCookieConfigOps';
import { EsvCount } from '../ops/cloud/EsvCountOps';
import { Feature } from '../ops/cloud/FeatureOps';
import { Log } from '../ops/cloud/LogOps';
import { Secret } from '../ops/cloud/SecretsOps';
import { ServiceAccount } from '../ops/cloud/ServiceAccountOps';
import { Startup } from '../ops/cloud/StartupOps';
import { Variable } from '../ops/cloud/VariablesOps';
import { Config } from '../ops/ConfigOps';
import { ConnectionProfile } from '../ops/ConnectionProfileOps';
import { Connector } from '../ops/ConnectorOps';
import { EmailTemplate } from '../ops/EmailTemplateOps';
import { IdmConfig } from '../ops/IdmConfigOps';
import { IdmCrypto } from '../ops/IdmCryptoOps';
import { IdmScript } from '../ops/IdmScriptOps';
import { IdmSystem } from '../ops/IdmSystemOps';
import { Idp } from '../ops/IdpOps';
import { Info } from '../ops/InfoOps';
import { InternalRole } from '../ops/InternalRoleOps';
import { Jose } from '../ops/JoseOps';
import { Journey } from '../ops/JourneyOps';
import { ManagedObject } from '../ops/ManagedObjectOps';
import { Mapping } from '../ops/MappingOps';
import { Node } from '../ops/NodeOps';
import { OAuth2Client } from '../ops/OAuth2ClientOps';
import { OAuth2Oidc } from '../ops/OAuth2OidcOps';
import { OAuth2Provider } from '../ops/OAuth2ProviderOps';
import { OAuth2TrustedJwtIssuer } from '../ops/OAuth2TrustedJwtIssuerOps';
import { Organization } from '../ops/OrganizationOps';
import { Policy } from '../ops/PolicyOps';
import { PolicySet } from '../ops/PolicySetOps';
import { Realm } from '../ops/RealmOps';
import { Recon } from '../ops/ReconOps';
import { ResourceType } from '../ops/ResourceTypeOps';
import { Saml2 } from '../ops/Saml2Ops';
import { Script } from '../ops/ScriptOps';
import { ScriptType } from '../ops/ScriptTypeOps';
import { Service } from '../ops/ServiceOps';
import { Session } from '../ops/SessionOps';
import { Theme } from '../ops/ThemeOps';
import { TokenCache } from '../ops/TokenCacheOps';
import { User } from '../ops/UserOps';
import { Version } from '../ops/VersionUtils';
import { Constants } from '../shared/Constants';
import { State, StateInterface } from '../shared/State';
import { Base64 } from '../utils/Base64Utils';
import { ExportImport } from '../utils/ExportImportUtils';
import { FRUtils } from '../utils/ForgeRockUtils';
import { Json } from '../utils/JsonUtils';
import { ScriptValidation } from '../utils/ScriptValidationUtils';
/**
 * Frodo Library
 */
export type Frodo = {
    state: State;
    admin: Admin;
    agent: Agent;
    am: {
        config: AmConfig;
    };
    app: Application;
    authn: {
        journey: Journey;
        node: Node;
        settings: AuthenticationSettings;
    };
    authz: {
        policy: Policy;
        policySet: PolicySet;
        resourceType: ResourceType;
    };
    cloud: EsvCount & {
        adminFed: AdminFederation;
        env: EnvContentSecurityPolicy & EnvCookieDomains & EnvCustomDomains & EnvFederationEnforcement & EnvRelease & EnvServiceAccountScopes & EnvSSOCookieConfig & {
            cert: EnvCertificate;
            csr: EnvCSR;
            promotion: EnvPromotion;
        };
        /**
         * @deprecated since v2.0.4 use {@link frodo.cloud.getEsvCount | frodo.cloud.getEsvCount} instead
         */
        esvCount: EsvCount;
        feature: Feature;
        log: Log;
        secret: Secret;
        serviceAccount: ServiceAccount;
        startup: Startup;
        variable: Variable;
    };
    config: Config;
    conn: ConnectionProfile;
    cache: TokenCache;
    email: {
        template: EmailTemplate;
    };
    factory: ApiFactory;
    idm: {
        config: IdmConfig;
        connector: Connector;
        crypto: IdmCrypto;
        managed: ManagedObject;
        mapping: Mapping;
        organization: Organization;
        recon: Recon;
        script: IdmScript;
        system: IdmSystem;
    };
    info: Info;
    login: Authenticate;
    oauth2oidc: {
        client: OAuth2Client;
        endpoint: OAuth2Oidc;
        external: Idp;
        provider: OAuth2Provider;
        issuer: OAuth2TrustedJwtIssuer;
    };
    realm: Realm;
    role: InternalRole;
    saml2: {
        circlesOfTrust: CirclesOfTrust;
        entityProvider: Saml2;
    };
    script: Script;
    scriptType: ScriptType;
    server: Server;
    secretStore: SecretStore;
    service: Service;
    session: Session;
    site: Site;
    theme: Theme;
    user: User;
    utils: FRUtils & ScriptValidation & ExportImport & Base64 & {
        constants: Constants;
        jose: Jose;
        json: Json;
        version: Version;
    };
    /**
     * Create a new frodo instance
     * @param {StateInterface} config Initial state configuration to use with the new instance
     * @returns {Frodo} frodo instance
     */
    createInstance(config: StateInterface): Frodo;
    /**
     * Factory helper to create a frodo instance ready for logging in with an admin user account
     * @param {string} host host base URL, e.g. 'https://openam-my-tenant.forgeblocks.com/am'
     * @param {string} username admin account username
     * @param {string} password admin account password
     * @param {string} realm (optional) override default realm
     * @param {string} deploymentType (optional) override deployment type ('cloud', 'forgeops', or 'classic')
     * @param {boolean} allowInsecureConnection (optional) allow insecure connection
     * @param {boolean} debug (optional) enable debug output
     * @param {boolean} curlirize (optional) enable output of all library REST calls as curl commands
     * @returns {Frodo} frodo instance
     */
    createInstanceWithAdminAccount(host: string, username: string, password: string, realm?: string, deploymentType?: string, allowInsecureConnection?: boolean, debug?: boolean, curlirize?: boolean): Frodo;
    /**
     * Factory helper to create a frodo instance ready for logging in with a service account
     * @param {string} host host base URL, e.g. 'https://openam-my-tenant.forgeblocks.com/am'
     * @param {string} serviceAccountId service account uuid
     * @param {string} serviceAccountJwkStr service account JWK as stringified JSON
     * @param {string} realm (optional) override default realm
     * @param {string} deploymentType (optional) override deployment type ('cloud', 'forgeops', or 'classic')
     * @param {boolean} allowInsecureConnection (optional) allow insecure connection
     * @param {boolean} debug (optional) enable debug output
     * @param {boolean} curlirize (optional) enable output of all library REST calls as curl commands
     * @returns {Frodo} frodo instance
     */
    createInstanceWithServiceAccount(host: string, serviceAccountId: string, serviceAccountJwkStr: string, realm?: string, deploymentType?: string, allowInsecureConnection?: boolean, debug?: boolean, curlirize?: boolean): Frodo;
};
/**
 * Create a new frodo instance
 * @param {StateInterface} config Initial state configuration to use with the new instance
 * @returns {Frodo} frodo instance
 */
declare const FrodoLib: (config?: StateInterface) => Frodo;
/**
 * Default frodo instance
 *
 * @remarks
 *
 * If your application requires a single connection to a ForgeRock Identity Platform
 * instance at a time, then this default instance is all you need:
 *
 * In order to use the default {@link Frodo | frodo} instance, you must populate its {@link State | state} with the
 * minimum required information to login to your ForgeRock Identity Platform instance:
 *
 * ```javascript
 * // configure the state before invoking any library functions that require credentials
 * state.setHost('https://instance0/am');
 * state.setUsername('admin');
 * state.setPassword('p@ssw0rd!');
 *
 * // now the library can login
 * frodo.login.getTokens();
 *
 * // and perform operations
 * frodo.authn.journey.exportJourney('Login');
 * ```
 *
 * If your application needs to connect to multiple ForgeRock Identity Platform instances
 * simultaneously, then you will want to create additional frodo instances using any of
 * the available factory methods accessible from the default instance:
 *
 * {@link frodo.createInstance}
 * ```javascript
 * // use factory method to create a new Frodo instance
 * const instance1 = frodo.createInstance({
 *    host: 'https://instance1/am',
 *    username: 'admin',
 *    password: 'p@ssw0rd!',
 * });
 *
 * // now the instance can login
 * instance1.login.getTokens();
 *
 * // and perform operations
 * instance1.authn.journey.exportJourney('Login');
 * ```
 *
 * {@link frodo.createInstanceWithAdminAccount}
 * ```javascript
 * // use factory method to create a new Frodo instance ready to login with an admin user account
 * const instance2 = frodo.createInstanceWithAdminAccount(
 *   'https://instance2/am',
 *   'admin',
 *   'p@ssw0rd!'
 * );
 *
 * // now the instance can login
 * instance2.login.getTokens();
 *
 * // and perform operations
 * instance2.authn.journey.exportJourney('Login');
 * ```
 *
 * {@link frodo.createInstanceWithServiceAccount}
 * ```javascript
 * // use factory method to create a new Frodo instance ready to login with a service account
 * const instance3 = frodo.createInstanceWithServiceAccount(
 *   'https://instance3/am',
 *   'serviceAccount',
 *   '{"k":"jwk"}'
 * );
 *
 * // now the instance can login
 * instance3.login.getTokens();
 *
 * // and perform operations
 * instance3.authn.journey.exportJourney('Login');
 * ```
 */
declare const frodo: Frodo;
/**
 * Default state instance
 *
 * @remarks
 *
 * {@link Frodo} maintains a {@link State | state} for each instance. The state is where Frodo gets configuration
 * information from like host to connecto to, username and password to use, whether to
 * allow insecure connections or not, etc. As the library operates, it updates its state.
 *
 * The default frodo instance contains an empty state instance by default. In order to
 * use the default frodo instance, you must populate its state with the minimum required
 * information to login to your ForgeRock Identity Platform instance:
 *
 * ```javascript
 * // configure the state before invoking any library functions that require credentials
 * state.setHost('https://instance0/am');
 * state.setUsername('admin');
 * state.setPassword('p@ssw0rd!');
 *
 * // now the library can login
 * frodo.login.getTokens();
 *
 * // and perform operations
 * frodo.authn.journey.exportJourney('Login');
 * ```
 */
declare const state: State;
export { frodo, FrodoLib, state };
export default FrodoLib;
//# sourceMappingURL=FrodoLib.d.ts.map