@rockcarver/frodo-lib 2.0.0-13 → 2.0.0-15

package/types/lib/FrodoLib.d.ts

@@ -1,385 +1,239 @@
-import State, { StateInterface } from '../shared/State';
-import * as jose from '../ops/JoseOps';
-import * as utils from '../ops/utils/OpsUtils';
-import * as base64 from '../api/utils/Base64';
-import * as script from '../ops/utils/ScriptValidationUtils';
-import * as constants from '../storage/StaticStorage';
-declare const _default: (config?: StateInterface) => {
+import { State, StateInterface } from '../shared/State';
+import { AdminFederation } from '../ops/cloud/AdminFederationOps';
+import { Admin } from '../ops/AdminOps';
+import { Agent } from '../ops/AgentOps';
+import { Authenticate } from '../ops/AuthenticateOps';
+import { CirclesOfTrust } from '../ops/CirclesOfTrustOps';
+import { ConnectionProfile } from '../ops/ConnectionProfileOps';
+import { EmailTemplate } from '../ops/EmailTemplateOps';
+import { ExportImport } from '../ops/utils/ExportImportUtils';
+import { Feature } from '../ops/cloud/FeatureOps';
+import { Idm } from '../ops/IdmOps';
+import { Idp } from '../ops/IdpOps';
+import { Info } from '../ops/InfoOps';
+import { Jose } from '../ops/JoseOps';
+import { Journey } from '../ops/JourneyOps';
+import { Log } from '../ops/cloud/LogOps';
+import { ManagedObject } from '../ops/ManagedObjectOps';
+import { Node } from '../ops/NodeOps';
+import { OAuth2Client } from '../ops/OAuth2ClientOps';
+import { OAuth2Oidc } from '../ops/OAuth2OidcOps';
+import { OAuth2Provider } from '../ops/OAuth2ProviderOps';
+import { Utils } from '../ops/utils/OpsUtils';
+import { Organization } from '../ops/OrganizationOps';
+import { Policy } from '../ops/PolicyOps';
+import { PolicySet } from '../ops/PolicySetOps';
+import { Realm } from '../ops/RealmOps';
+import { ResourceType } from '../ops/ResourceTypeOps';
+import { Saml2 } from '../ops/Saml2Ops';
+import { Script } from '../ops/ScriptOps';
+import { ScriptValidation } from '../ops/utils/ScriptValidationUtils';
+import { Service } from '../ops/ServiceOps';
+import { Secret } from '../ops/cloud/SecretsOps';
+import { ServiceAccount } from '../ops/cloud/ServiceAccountOps';
+import { Startup } from '../ops/cloud/StartupOps';
+import { Theme } from '../ops/ThemeOps';
+import { Variable } from '../ops/cloud/VariablesOps';
+import { Version } from '../ops/utils/VersionUtils';
+import { Constants } from '../shared/Constants';
+/**
+ * Frodo Library
+ */
+export type Frodo = {
     state: State;
-    admin: {
-        listOAuth2CustomClients(): Promise<any>;
-        listOAuth2AdminClients(): Promise<any>;
-        listNonOAuth2AdminStaticUserMappings(showProtected: boolean): Promise<any>;
-        addAutoIdStaticUserMapping(): Promise<void>;
-        grantOAuth2ClientAdminPrivileges(clientId: string): Promise<void>;
-        revokeOAuth2ClientAdminPrivileges(clientId: string): Promise<void>;
-        createOAuth2ClientWithAdminPrivileges(clientId: string, clientSecret: string): Promise<void>;
-        createLongLivedToken(clientId: string, clientSecret: string, scope: string, secret: string | boolean, lifetime: number): Promise<any>;
-        removeStaticUserMapping(subject: string): Promise<void>;
-        hideGenericExtensionAttributes(includeCustomized: boolean, dryRun: boolean): Promise<void>;
-        showGenericExtensionAttributes(includeCustomized: boolean, dryRun: boolean): Promise<void>;
-        repairOrgModel(excludeCustomized: boolean, extendPermissions: boolean, dryRun: boolean): Promise<void>;
-    };
-    agent: {
-        createAgentExportTemplate(): import("../ops/OpsTypes").AgentExportInterface;
-        getAgents(): Promise<import("../api/ApiTypes").AgentSkeleton[]>;
-        getAgent(agentId: string): Promise<any>;
-        getAgentByTypeAndId(agentType: import("../api/ApiTypes").AgentType, agentId: string): Promise<any>;
-        getIdentityGatewayAgents(): Promise<any>;
-        getIdentityGatewayAgent(gatewayId: string): Promise<any>;
-        putIdentityGatewayAgent(gatewayId: string, gatewayData: import("../api/ApiTypes").AgentSkeleton): Promise<any>;
-        getJavaAgents(): Promise<any>;
-        getJavaAgent(agentId: string): Promise<any>;
-        putJavaAgent(agentId: string, agentData: import("../api/ApiTypes").AgentSkeleton): Promise<any>;
-        getWebAgents(): Promise<any>;
-        getWebAgent(agentId: string): Promise<any>;
-        putWebAgent(agentId: string, agentData: import("../api/ApiTypes").AgentSkeleton): Promise<any>;
-        exportAgents(): Promise<import("../ops/OpsTypes").AgentExportInterface>;
-        exportIdentityGatewayAgents(): Promise<import("../ops/OpsTypes").AgentExportInterface>;
-        exportJavaAgents(): Promise<import("../ops/OpsTypes").AgentExportInterface>;
-        exportWebAgents(): Promise<import("../ops/OpsTypes").AgentExportInterface>;
-        exportAgent(agentId: string): Promise<import("../ops/OpsTypes").AgentExportInterface>;
-        exportIdentityGatewayAgent(agentId: string): Promise<import("../ops/OpsTypes").AgentExportInterface>;
-        exportJavaAgent(agentId: string): Promise<import("../ops/OpsTypes").AgentExportInterface>;
-        exportWebAgent(agentId: string): Promise<import("../ops/OpsTypes").AgentExportInterface>;
-        importAgents(importData: import("../ops/OpsTypes").AgentExportInterface): Promise<void>;
-        importIdentityGatewayAgents(importData: import("../ops/OpsTypes").AgentExportInterface): Promise<void>;
-        importJavaAgents(importData: import("../ops/OpsTypes").AgentExportInterface): Promise<void>;
-        importWebAgents(importData: import("../ops/OpsTypes").AgentExportInterface): Promise<void>;
-        importAgent(agentId: string, importData: import("../ops/OpsTypes").AgentExportInterface): Promise<any>;
-        importIdentityGatewayAgent(agentId: string, importData: import("../ops/OpsTypes").AgentExportInterface): Promise<any>;
-        importJavaAgent(agentId: string, importData: import("../ops/OpsTypes").AgentExportInterface): Promise<any>;
-        importWebAgent(agentId: string, importData: import("../ops/OpsTypes").AgentExportInterface): Promise<any>;
-        deleteAgents(): Promise<void>;
-        deleteAgent(agentId: string): Promise<void>;
-        deleteIdentityGatewayAgents(): Promise<void>;
-        deleteIdentityGatewayAgent(agentId: string): Promise<void>;
-        deleteJavaAgents(): Promise<void>;
-        deleteJavaAgent(agentId: string): Promise<void>;
-        deleteWebAgents(): Promise<void>;
-        deleteWebAgent(agentId: string): Promise<void>;
-    };
+    admin: Admin;
+    agent: Agent;
     authn: {
-        journey: {
-            createSingleTreeExportTemplate(): import("../ops/OpsTypes").SingleTreeExportInterface;
-            createMultiTreeExportTemplate(): import("../ops/OpsTypes").MultiTreeExportInterface;
-            exportJourney(treeId: string, options?: import("../ops/OpsTypes").TreeExportOptions): Promise<import("../ops/OpsTypes").SingleTreeExportInterface>;
-            getJourneys(): Promise<import("../api/ApiTypes").TreeSkeleton[]>;
-            getJourney(journeyId: string): Promise<import("../api/ApiTypes").TreeSkeleton>;
-            importJourney(treeObject: import("../ops/OpsTypes").SingleTreeExportInterface, options: import("../ops/OpsTypes").TreeImportOptions): Promise<boolean>;
-            resolveDependencies(installedJorneys: any, journeyMap: any, unresolvedJourneys: any, resolvedJourneys: any, index?: number): Promise<void>;
-            importAllJourneys(treesMap: import("../ops/OpsTypes").MultiTreeExportInterface, options: import("../ops/OpsTypes").TreeImportOptions): Promise<void>;
-            getNodeRef(nodeObj: import("../api/ApiTypes").NodeSkeleton, singleTreeExport: import("../ops/OpsTypes").SingleTreeExportInterface): import("../api/ApiTypes").NodeRefSkeletonInterface | import("../api/ApiTypes").InnerNodeRefSkeletonInterface;
-            onlineTreeExportResolver: import("../ops/OpsTypes").TreeExportResolverInterface;
-            fileByIdTreeExportResolver: import("../ops/OpsTypes").TreeExportResolverInterface;
-            createFileParamTreeExportResolver(file: string): import("../ops/OpsTypes").TreeExportResolverInterface;
-            getTreeDescendents(treeExport: import("../ops/OpsTypes").SingleTreeExportInterface, resolveTreeExport: import("../ops/OpsTypes").TreeExportResolverInterface, resolvedTreeIds?: string[]): Promise<import("../ops/OpsTypes").TreeDependencyMapInterface>;
-            findOrphanedNodes(): Promise<import("../api/ApiTypes").NodeSkeleton[]>;
-            removeOrphanedNodes(orphanedNodes: import("../api/ApiTypes").NodeSkeleton[]): Promise<unknown[]>;
-            isCustomJourney(journey: import("../ops/OpsTypes").SingleTreeExportInterface): boolean;
-            isPremiumJourney(journey: import("../ops/OpsTypes").SingleTreeExportInterface): boolean;
-            isCloudOnlyJourney(journey: import("../ops/OpsTypes").SingleTreeExportInterface): boolean;
-            getJourneyClassification(journey: import("../ops/OpsTypes").SingleTreeExportInterface): import("../ops/OpsTypes").JourneyClassificationType[];
-            deleteJourney(journeyId: string, options: {
-                deep: boolean;
-                verbose: boolean;
-                progress?: boolean;
-            }): Promise<{
-                nodes: {};
-            }>;
-            deleteJourneys(options: {
-                deep: boolean;
-                verbose: boolean;
-            }): Promise<{}>;
-            enableJourney(journeyId: string): Promise<boolean>;
-            disableJourney(journeyId: string): Promise<boolean>;
-        };
-        node: {
-            findOrphanedNodes(): Promise<unknown[]>;
-            removeOrphanedNodes(orphanedNodes: import("../api/ApiTypes").NodeSkeleton[]): Promise<import("../api/ApiTypes").NodeSkeleton[]>;
-            isPremiumNode(nodeType: string): boolean;
-            isCloudOnlyNode(nodeType: string): boolean;
-            isCustomNode(nodeType: string): boolean;
-            getNodeClassification(nodeType: string): import("../ops/OpsTypes").NodeClassificationType[];
-        };
+        journey: Journey;
+        node: Node;
     };
     authz: {
-        policy: {
-            getPolicies(): Promise<import("../api/ApiTypes").PolicySkeleton[]>;
-            getPoliciesByPolicySet(policySetId: string): Promise<import("../api/ApiTypes").PolicySkeleton[]>;
-            getPolicy(policyId: string): Promise<import("../api/ApiTypes").PolicySkeleton>;
-            putPolicy(policyId: string, policyData: import("../api/ApiTypes").PolicySkeleton): Promise<any>;
-            deletePolicy(policyId: string): Promise<any>;
-            exportPolicy(policyId: string, options?: import("../ops/PolicyOps").PolicyExportOptions): Promise<import("../ops/PolicyOps").PolicyExportInterface>;
-            exportPolicies(options?: import("../ops/PolicyOps").PolicyExportOptions): Promise<import("../ops/PolicyOps").PolicyExportInterface>;
-            exportPoliciesByPolicySet(policySetName: string, options?: import("../ops/PolicyOps").PolicyExportOptions): Promise<import("../ops/PolicyOps").PolicyExportInterface>;
-            importPolicy(policyId: string, importData: import("../ops/PolicyOps").PolicyExportInterface, options?: import("../ops/PolicyOps").PolicyImportOptions): Promise<import("../api/ApiTypes").PolicySkeleton>;
-            importFirstPolicy(importData: import("../ops/PolicyOps").PolicyExportInterface, options?: import("../ops/PolicyOps").PolicyImportOptions): Promise<import("../api/ApiTypes").PolicySkeleton>;
-            importPolicies(importData: import("../ops/PolicyOps").PolicyExportInterface, options?: import("../ops/PolicyOps").PolicyImportOptions): Promise<import("../api/ApiTypes").PolicySkeleton[]>;
-        };
-        policySet: {
-            getPolicySets(): Promise<import("../api/ApiTypes").PolicySetSkeleton[]>;
-            getPolicySet(policySetName: string): Promise<import("../api/ApiTypes").PolicySetSkeleton>;
-            createPolicySet(policySetData: import("../api/ApiTypes").PolicySetSkeleton): Promise<any>;
-            updatePolicySet(policySetData: import("../api/ApiTypes").PolicySetSkeleton): Promise<any>;
-            deletePolicySet(policySetName: string): Promise<any>;
-            exportPolicySet(policySetName: string, options?: import("../ops/PolicySetOps").PolicySetExportOptions): Promise<import("../ops/PolicySetOps").PolicySetExportInterface>;
-            exportPolicySets(options?: import("../ops/PolicySetOps").PolicySetExportOptions): Promise<import("../ops/PolicySetOps").PolicySetExportInterface>;
-            importPolicySet(policySetName: string, importData: import("../ops/PolicySetOps").PolicySetExportInterface, options?: import("../ops/PolicySetOps").PolicySetImportOptions): Promise<any>;
-            importFirstPolicySet(importData: import("../ops/PolicySetOps").PolicySetExportInterface, options?: import("../ops/PolicySetOps").PolicySetImportOptions): Promise<any>;
-            importPolicySets(importData: import("../ops/PolicySetOps").PolicySetExportInterface, options?: import("../ops/PolicySetOps").PolicySetImportOptions): Promise<any>;
-        };
-        resourceType: {
-            getResourceType(resourceTypeUuid: string): Promise<any>;
-            getResourceTypes(): Promise<import("../api/ApiTypes").ResourceTypeSkeleton[]>;
-            getResourceTypeByName(resourceTypeName: string): Promise<import("../api/ApiTypes").ResourceTypeSkeleton>;
-            updateResourceType(resourceTypeUuid: string, resourceTypeData: import("../api/ApiTypes").ResourceTypeSkeleton): Promise<import("../api/ApiTypes").ResourceTypeSkeleton>;
-            deleteResourceType(resourceTypeUuid: string): Promise<any>;
-            deleteResourceTypeByName(resourceTypeName: string): Promise<import("../api/ApiTypes").ResourceTypeSkeleton>;
-            exportResourceType(resourceTypeUuid: string): Promise<import("../ops/ResourceTypeOps").ResourceTypeExportInterface>;
-            exportResourceTypeByName(resourceTypeName: string): Promise<import("../ops/ResourceTypeOps").ResourceTypeExportInterface>;
-            exportResourceTypes(): Promise<import("../ops/ResourceTypeOps").ResourceTypeExportInterface>;
-            importResourceType(resourceTypeUuid: string, importData: import("../ops/ResourceTypeOps").ResourceTypeExportInterface): Promise<any>;
-            importResourceTypeByName(resourceTypeName: string, importData: import("../ops/ResourceTypeOps").ResourceTypeExportInterface): Promise<any>;
-            importFirstResourceType(importData: import("../ops/ResourceTypeOps").ResourceTypeExportInterface): Promise<any>;
-            importResourceTypes(importData: import("../ops/ResourceTypeOps").ResourceTypeExportInterface): Promise<any[]>;
-        };
+        policy: Policy;
+        policySet: PolicySet;
+        resourceType: ResourceType;
     };
     cloud: {
-        adminFed: {
-            createAdminFederationExportTemplate(): import("../ops/cloud/AdminFederationOps").AdminFederationExportInterface;
-            getAdminFederationProviders(): Promise<import("../api/ApiTypes").SocialIdpSkeleton[]>;
-            getAdminFederationProvider(providerId: string): Promise<import("../api/ApiTypes").SocialIdpSkeleton>;
-            putProviderByTypeAndId(providerType: string, providerId: string, providerData: import("../api/ApiTypes").SocialIdpSkeleton): Promise<import("../api/ApiTypes").SocialIdpSkeleton>;
-            deleteAdminFederationProvider(providerId: string): Promise<import("../api/ApiTypes").SocialIdpSkeleton>;
-            exportAdminFederationProvider(providerId: string): Promise<import("../ops/cloud/AdminFederationOps").AdminFederationExportInterface>;
-            exportAdminFederationProviders(): Promise<import("../ops/cloud/AdminFederationOps").AdminFederationExportInterface>;
-            importAdminFederationProvider(providerId: string, importData: import("../ops/cloud/AdminFederationOps").AdminFederationExportInterface): Promise<import("../api/ApiTypes").SocialIdpSkeleton>;
-            importFirstAdminFederationProvider(importData: import("../ops/cloud/AdminFederationOps").AdminFederationExportInterface): Promise<import("../api/ApiTypes").SocialIdpSkeleton>;
-            importAdminFederationProviders(importData: import("../ops/cloud/AdminFederationOps").AdminFederationExportInterface): Promise<import("../api/ApiTypes").SocialIdpSkeleton[]>;
-        };
-        feature: {
-            getFeatures(): Promise<import("../api/cloud/FeatureApi").FeatureInterface[]>;
-            hasFeature(featureId: string): Promise<boolean>;
-        };
-        log: {
-            getDefaultNoiseFilter(): string[];
-            resolveLevel(level: string | number): string[];
-            resolvePayloadLevel(log: import("../api/ApiTypes").LogEventSkeleton): string;
-            getLogSources(): Promise<string[]>;
-            getLogApiKey(keyId: string): Promise<import("../api/ApiTypes").LogApiKey>;
-            getLogApiKeys(): Promise<import("../api/ApiTypes").LogApiKey[]>;
-            createLogApiKey(keyName: string): Promise<import("../api/ApiTypes").LogApiKey>;
-            deleteLogApiKey(keyId: string): Promise<import("../api/ApiTypes").LogApiKey>;
-            deleteLogApiKeys(): Promise<import("../api/ApiTypes").LogApiKey[]>;
-            tail(source: string, cookie: string): Promise<import("../api/ApiTypes").PagedResult<import("../api/ApiTypes").LogEventSkeleton>>;
-            fetch(source: string, startTs: string, endTs: string, cookie: string): Promise<import("../api/ApiTypes").PagedResult<import("../api/ApiTypes").LogEventSkeleton>>;
-        };
-        secret: {
-            getSecrets(): Promise<any>;
-            getSecret(secretId: string): Promise<any>;
-            putSecret(secretId: string, value: string, description: string, encoding?: string, useInPlaceholders?: boolean): Promise<any>;
-            setSecretDescription(secretId: string, description: string): Promise<any>;
-            deleteSecret(secretId: string): Promise<any>;
-            getSecretVersions(secretId: string): Promise<any>;
-            createNewVersionOfSecret(secretId: string, value: string): Promise<any>;
-            getVersionOfSecret(secretId: string, version: string): Promise<any>;
-            setStatusOfVersionOfSecret(secretId: string, version: string, status: import("../api/ApiTypes").VersionOfSecretStatus): Promise<any>;
-            deleteVersionOfSecret(secretId: string, version: string): Promise<any>;
-        };
-        serviceAccount: {
-            isServiceAccountsFeatureAvailable(): Promise<boolean>;
-            createServiceAccount(name: string, description: string, accountStatus: "Active" | "Inactive", scopes: string[], jwks: jose.JwksInterface): Promise<import("../api/ApiTypes").IdObjectSkeletonInterface>;
-            getServiceAccount(serviceAccountId: string): Promise<import("../ops/cloud/ServiceAccountOps").ServiceAccount>;
-        };
-        startup: {
-            checkForUpdates(): Promise<import("../ops/cloud/StartupOps").Updates>;
-            applyUpdates(wait: boolean, timeout?: number): Promise<boolean>;
-        };
-        variable: {
-            deleteVariable(variableId: string): Promise<any>;
-            getVariable(variableId: string): Promise<any>;
-            getVariables(): Promise<any>;
-            putVariable(variableId: string, value: string, description: string): Promise<any>;
-            setVariableDescription(variableId: string, description: string): Promise<any>;
-        };
-    };
-    conn: {
-        getConnectionProfilesPath(): string;
-        findConnectionProfiles(connectionProfiles: import("../ops/ConnectionProfileOps").ConnectionsFileInterface, host: string): import("../ops/ConnectionProfileOps").SecureConnectionProfileInterface[];
-        initConnectionProfiles(): Promise<void>;
-        getConnectionProfileByHost(host: string): Promise<import("../ops/ConnectionProfileOps").ConnectionProfileInterface>;
-        getConnectionProfile(): Promise<import("../ops/ConnectionProfileOps").ConnectionProfileInterface>;
-        saveConnectionProfile(host: string): Promise<boolean>;
-        deleteConnectionProfile(host: string): void;
-        addNewServiceAccount(): Promise<import("../api/ApiTypes").IdObjectSkeletonInterface>;
-    };
+        adminFed: AdminFederation;
+        feature: Feature;
+        log: Log;
+        secret: Secret;
+        serviceAccount: ServiceAccount;
+        startup: Startup;
+        variable: Variable;
+    };
+    conn: ConnectionProfile;
     email: {
-        template: {
-            EMAIL_TEMPLATE_TYPE: string;
-            getEmailTemplates(): Promise<any>;
-            getEmailTemplate(templateId: string): Promise<any>;
-            putEmailTemplate(templateId: string, templateData: import("../api/ApiTypes").EmailTemplateSkeleton): Promise<any>;
-        };
-    };
-    helper: {
-        base64: typeof base64;
-        constants: typeof constants;
-        jose: typeof jose;
-        script: typeof script;
-        utils: typeof utils;
+        template: EmailTemplate;
     };
     idm: {
-        config: {
-            getAllConfigEntities(): Promise<any>;
-            getConfigEntitiesByType(type: string): Promise<any>;
-            getConfigEntity(entityId: string): Promise<any>;
-            putConfigEntity(entityId: string, entityData: string | import("../api/ApiTypes").NoIdObjectSkeletonInterface): Promise<any>;
-            queryAllManagedObjectsByType(type: string, fields: string[], pageCookie: string): Promise<import("../api/ApiTypes").PagedResult<import("../api/ApiTypes").IdObjectSkeletonInterface>>;
-            testConnectorServers(): Promise<import("../api/IdmSystemApi").ConnectorServerStatusInterface[]>;
-        };
-        managed: {
-            resolveUserName(type: string, id: string): Promise<string | number | boolean | object>;
-            resolveFullName(type: string, id: string): Promise<string>;
-        };
-        organization: {
-            getRealmManagedOrganization(): string;
-            getOrganizations(): Promise<any[]>;
-        };
-    };
-    info: {
-        getInfo(): Promise<import("../ops/InfoOps").PlatformInfo>;
-    };
-    login: {
-        getAccessTokenForServiceAccount(saId?: string, saJwk?: jose.JwkRsa): Promise<string>;
-        getTokens(forceLoginAsUser?: boolean): Promise<boolean>;
+        config: Idm;
+        managed: ManagedObject;
+        organization: Organization;
     };
+    info: Info;
+    login: Authenticate;
     oauth2oidc: {
-        client: {
-            getOAuth2Clients(): Promise<import("../api/ApiTypes").OAuth2ClientSkeleton[]>;
-            getOAuth2Client(clientId: string): Promise<import("../api/ApiTypes").OAuth2ClientSkeleton>;
-            putOAuth2Client(clientId: string, clientData: import("../api/ApiTypes").OAuth2ClientSkeleton): Promise<import("../api/ApiTypes").OAuth2ClientSkeleton>;
-            deleteOAuth2Client(clientId: string): Promise<import("../api/ApiTypes").OAuth2ClientSkeleton>;
-            exportOAuth2Clients(options?: import("../ops/OAuth2ClientOps").OAuth2ClientExportOptions): Promise<import("../ops/OAuth2ClientOps").OAuth2ClientExportInterface>;
-            exportOAuth2Client(clientId: string, options?: import("../ops/OAuth2ClientOps").OAuth2ClientExportOptions): Promise<import("../ops/OAuth2ClientOps").OAuth2ClientExportInterface>;
-            importOAuth2Client(clientId: string, importData: import("../ops/OAuth2ClientOps").OAuth2ClientExportInterface, options?: import("../ops/OAuth2ClientOps").OAuth2ClientImportOptions): Promise<any>;
-            importFirstOAuth2Client(importData: import("../ops/OAuth2ClientOps").OAuth2ClientExportInterface, options?: import("../ops/OAuth2ClientOps").OAuth2ClientImportOptions): Promise<any>;
-            importOAuth2Clients(importData: import("../ops/OAuth2ClientOps").OAuth2ClientExportInterface, options?: import("../ops/OAuth2ClientOps").OAuth2ClientImportOptions): Promise<unknown[]>;
-        };
-        endpoint: {
-            authorize(amBaseUrl: string, data: string, config: import("axios").AxiosRequestConfig<any>): Promise<import("axios").AxiosResponse<any, any>>;
-            accessToken(amBaseUrl: string, data: any, config: import("axios").AxiosRequestConfig<any>): Promise<import("axios").AxiosResponse<any, any>>;
-            getTokenInfo(amBaseUrl: string, config: import("axios").AxiosRequestConfig<any>): Promise<any>;
-            clientCredentialsGrant(amBaseUrl: string, clientId: string, clientSecret: string, scope: string): Promise<any>;
-        };
-        external: {
-            getSocialIdentityProviders(): Promise<any>;
-            getSocialProvider(providerId: string): Promise<any>;
-            putProviderByTypeAndId(providerType: string, providerId: string, providerData: import("../api/ApiTypes").SocialIdpSkeleton): Promise<any>;
-            deleteSocialProvider(providerId: string): Promise<unknown>;
-            exportSocialProvider(providerId: string): Promise<import("../ops/IdpOps").SocialProviderExportInterface>;
-            exportSocialProviders(): Promise<import("../ops/IdpOps").SocialProviderExportInterface>;
-            importSocialProvider(providerId: string, importData: import("../ops/IdpOps").SocialProviderExportInterface): Promise<boolean>;
-            importFirstSocialProvider(importData: import("../ops/IdpOps").SocialProviderExportInterface): Promise<boolean>;
-            importSocialProviders(importData: import("../ops/IdpOps").SocialProviderExportInterface): Promise<boolean>;
-        };
-        provider: {
-            getOAuth2Provider(): Promise<any>;
-        };
-    };
-    realm: {
-        getRealms(): Promise<any>;
-        getRealmByName(realmName: string): Promise<any>;
-        putRealm(realmId: string, realmData: object): Promise<any>;
-        addCustomDomain(realmName: string, domain: string): Promise<any>;
-        removeCustomDomain(realmName: string, domain: string): Promise<any>;
+        client: OAuth2Client;
+        endpoint: OAuth2Oidc;
+        external: Idp;
+        provider: OAuth2Provider;
     };
+    realm: Realm;
     saml2: {
-        circlesOfTrust: {
-            createCirclesOfTrustExportTemplate(): import("../ops/OpsTypes").CirclesOfTrustExportInterface;
-            getCircleOfTrust(cotId: string): Promise<any>;
-            getCirclesOfTrust(): Promise<any>;
-            createCircleOfTrust(cotData: import("../api/ApiTypes").CircleOfTrustSkeleton): Promise<any>;
-            exportCircleOfTrust(cotId: string): Promise<import("../ops/OpsTypes").CirclesOfTrustExportInterface>;
-            exportCirclesOfTrust(): Promise<import("../ops/OpsTypes").CirclesOfTrustExportInterface>;
-            importCircleOfTrust(cotId: string, importData: import("../ops/OpsTypes").CirclesOfTrustExportInterface): Promise<any>;
-            importFirstCircleOfTrust(importData: import("../ops/OpsTypes").CirclesOfTrustExportInterface): Promise<any>;
-            importCirclesOfTrust(importData: import("../ops/OpsTypes").CirclesOfTrustExportInterface): Promise<any[]>;
-        };
-        entityProvider: {
-            getSaml2ProviderStubs(): Promise<import("../api/ApiTypes").Saml2ProviderStub[]>;
-            getProviderByLocationAndId(location: string, entityId64: string): Promise<any>;
-            getProviderMetadataUrl(entityId: string): string;
-            getProviderMetadata(entityId: string): Promise<any>;
-            getSaml2ProviderStub(entityId: string): Promise<import("../api/ApiTypes").Saml2ProviderStub>;
-            getSaml2Provider(entityId: string): Promise<import("../api/ApiTypes").Saml2ProviderSkeleton>;
-            deleteSaml2Provider(entityId: string): Promise<import("../api/ApiTypes").Saml2ProviderSkeleton>;
-            deleteSaml2Providers(): Promise<import("../api/ApiTypes").Saml2ProviderSkeleton[]>;
-            exportSaml2Provider(entityId: string): Promise<import("../ops/OpsTypes").Saml2ExportInterface>;
-            exportSaml2Providers(): Promise<import("../ops/OpsTypes").Saml2ExportInterface>;
-            importSaml2Provider(entityId: string, importData: import("../ops/OpsTypes").Saml2ExportInterface): Promise<boolean>;
-            importSaml2Providers(importData: import("../ops/OpsTypes").Saml2ExportInterface): Promise<import("../ops/OpsTypes").MultiOpStatusInterface>;
-        };
-    };
-    script: {
-        getScripts(): Promise<import("../api/ApiTypes").ScriptSkeleton[]>;
-        getScriptByName(scriptName: string): Promise<import("../api/ApiTypes").ScriptSkeleton>;
-        putScript(scriptId: string, scriptData: import("../api/ApiTypes").ScriptSkeleton): Promise<boolean>;
-        exportScript(scriptId: string): Promise<import("../ops/ScriptOps").ScriptExportInterface>;
-        exportScriptByName(scriptName: string): Promise<import("../ops/ScriptOps").ScriptExportInterface>;
-        exportScripts(): Promise<import("../ops/ScriptOps").ScriptExportInterface>;
-        importScripts(scriptName: string, importData: import("../ops/ScriptOps").ScriptExportInterface, reUuid?: boolean, validate?: boolean): Promise<boolean>;
-        getScript(scriptId: string): Promise<any>;
-        deleteScript(scriptId: string): Promise<any>;
-    };
-    service: {
-        createServiceExportTemplate(): import("../ops/OpsTypes").ServiceExportInterface;
-        getListOfServices(globalConfig?: boolean): Promise<import("../api/ServiceApi").ServiceListItem[]>;
-        getFullServices(globalConfig?: boolean): Promise<import("../api/ApiTypes").FullService[]>;
-        deleteFullService(serviceId: string, globalConfig?: boolean): Promise<void>;
-        deleteFullServices(globalConfig?: boolean): Promise<void>;
-        exportService(serviceId: string, globalConfig?: boolean): Promise<import("../ops/OpsTypes").ServiceExportInterface>;
-        exportServices(globalConfig?: boolean): Promise<import("../ops/OpsTypes").ServiceExportInterface>;
-        importService(serviceId: string, importData: import("../ops/OpsTypes").ServiceExportInterface, clean: boolean, globalConfig?: boolean): Promise<import("../api/ApiTypes").AmServiceSkeleton>;
-        importServices(importData: import("../ops/OpsTypes").ServiceExportInterface, clean: boolean, globalConfig?: boolean): Promise<import("../api/ApiTypes").AmServiceSkeleton[]>;
-    };
-    theme: {
-        getThemes(): Promise<import("../api/ApiTypes").ThemeSkeleton[]>;
-        getTheme(themeId: string, realm?: string): Promise<import("../api/ApiTypes").ThemeSkeleton>;
-        getThemeByName(themeName: string, realm?: string): Promise<import("../api/ApiTypes").ThemeSkeleton>;
-        putTheme(themeId: string, themeData: import("../api/ApiTypes").ThemeSkeleton, realm?: string): Promise<import("../api/ApiTypes").ThemeSkeleton>;
-        putThemeByName(themeName: string, themeData: import("../api/ApiTypes").ThemeSkeleton, realm?: string): Promise<import("../api/ApiTypes").ThemeSkeleton>;
-        putThemes(themeMap: Map<string, import("../api/ApiTypes").ThemeSkeleton>): Promise<Map<string, import("../api/ApiTypes").ThemeSkeleton>>;
-        deleteTheme(themeId: string, realm?: string): Promise<import("../api/ApiTypes").ThemeSkeleton>;
-        deleteThemeByName(themeName: string, realm?: string): Promise<import("../api/ApiTypes").ThemeSkeleton>;
-        deleteThemes(realm?: string): Promise<import("../api/ApiTypes").ThemeSkeleton[]>;
-    };
-    utils: {
-        impex: {
-            getMetadata(): import("../ops/OpsTypes").ExportMetaData;
-            titleCase(input: string): string;
-            getRealmString(): string;
-            convertBase64TextToArray(b64text: string): any[];
-            convertBase64UrlTextToArray(b64UTF8Text: string): any[];
-            convertTextArrayToBase64(textArray: string[]): string;
-            convertTextArrayToBase64Url(textArray: string[]): any;
-            validateImport(metadata: any): boolean;
-            getTypedFilename(name: string, type: string, suffix?: string): string;
-            getWorkingDirectory(): string;
-            saveToFile(type: string, data: object, identifier: string, filename: string): void;
-            saveJsonToFile(data: object, filename: string, includeMeta?: boolean): boolean;
-            appendTextToFile(data: string, filename: string): void;
-            findFilesByName(fileName: string, fast?: boolean, path?: string): string[];
-            readFilesRecursive(directory: string): Promise<string[]>;
-        };
-        version: {
-            getVersion(): string;
-            getAllVersions(endpoints: {
-                base: string;
-                path: string;
-            }[]): Promise<PromiseSettledResult<any>[]>;
-        };
-    };
+        circlesOfTrust: CirclesOfTrust;
+        entityProvider: Saml2;
+    };
+    script: Script;
+    service: Service;
+    theme: Theme;
+    utils: Utils & {
+        constants: Constants;
+        impex: ExportImport;
+        jose: Jose;
+        script: ScriptValidation;
+        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, serviceAccountId: string, serviceAccountJwkStr: 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;
 };
-export default _default;
+/**
+ * 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',
+ * });
+ *
+ * // 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, state, FrodoLib };
+export default FrodoLib;
 //# sourceMappingURL=FrodoLib.d.ts.map

package/types/lib/FrodoLib.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FrodoLib.d.ts","sourceRoot":"","sources":["../../src/lib/FrodoLib.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAoCxD,OAAO,KAAK,IAAI,MAAM,gBAAgB,CAAC;AACvC,OAAO,KAAK,KAAK,MAAM,uBAAuB,CAAC;AAC/C,OAAO,KAAK,MAAM,MAAM,qBAAqB,CAAC;AAC9C,OAAO,KAAK,MAAM,MAAM,oCAAoC,CAAC;AAC7D,OAAO,KAAK,SAAS,MAAM,0BAA0B,CAAC;kCAE9B,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAtC,wBA2EE"}
+{"version":3,"file":"FrodoLib.d.ts","sourceRoot":"","sources":["../../src/lib/FrodoLib.ts"],"names":[],"mappings":"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"}