@gooddata/sdk-ui-pluggable-host 11.40.0-alpha.3

package/esm/platformContext/bootstrap.js

@@ -0,0 +1,122 @@
+// (C) 2026 GoodData Corporation
+import { PantherTier, } from "@gooddata/sdk-pluggable-application-model";
+const DEFAULT_WHITE_LABELING = { enabled: false };
+const BOOTSTRAP_LOG_PREFIX = "[host-runtime/bootstrap]";
+function resolvePantherTier(entitlements) {
+    const tier = entitlements.find((e) => e.name === "Tier")?.value?.toUpperCase();
+    switch (tier) {
+        case PantherTier.INTERNAL:
+            return PantherTier.INTERNAL;
+        case PantherTier.POC:
+            return PantherTier.POC;
+        case PantherTier.LABS:
+            return PantherTier.LABS;
+        case PantherTier.DEMO:
+            return PantherTier.DEMO;
+        case PantherTier.TRIAL:
+        default:
+            return PantherTier.TRIAL;
+    }
+}
+export const PLATFORM_CONTEXT_VERSION = "1.0";
+function logBootstrapWarning(message, error) {
+    // Keep fallback behavior while making silent backend failures visible.
+    console.error(`${BOOTSTRAP_LOG_PREFIX} ${message}`, error);
+}
+function logAndRethrow(message) {
+    return (error) => {
+        logBootstrapWarning(message, error);
+        throw error;
+    };
+}
+async function fetchOrganizationDetails(backend, organizationId, includeAdditionalDetails = true) {
+    return backend
+        .organization(organizationId)
+        .getDescriptor(includeAdditionalDetails)
+        .catch((error) => {
+        logBootstrapWarning("Failed to load organization descriptor.", error);
+        return undefined;
+    });
+}
+export async function bootstrapApplication(backend) {
+    const entitlementsPromise = backend
+        .entitlements()
+        .resolveEntitlements()
+        .catch((error) => {
+        logBootstrapWarning("Failed to resolve entitlements.", error);
+        return [];
+    });
+    const [userProfile, userSettings] = await Promise.all([
+        backend
+            .currentUser()
+            .getUserWithDetails()
+            .catch(logAndRethrow("Failed to load current user profile.")),
+        backend
+            .currentUser()
+            .settings()
+            .getSettings()
+            .catch(logAndRethrow("Failed to load current user settings.")),
+    ]);
+    const includeAdditionalDetails = userProfile.permissions?.includes("MANAGE") ?? false;
+    const organizationId = userProfile.organizationId ??
+        (await backend
+            .organizations()
+            .getCurrentOrganization()
+            .catch(logAndRethrow("Failed to load current organization."))).organizationId;
+    const [userInfo, organizationDescriptor, entitlements, theme] = await Promise.all([
+        backend
+            .organization(organizationId)
+            .users()
+            .getUser(userProfile.login)
+            .catch((error) => {
+            logBootstrapWarning("Failed to load user details from organization.", error);
+            return undefined;
+        }),
+        fetchOrganizationDetails(backend, organizationId, includeAdditionalDetails),
+        entitlementsPromise,
+        backend
+            .organization(organizationId)
+            .styling()
+            .getTheme()
+            .catch((error) => {
+            logBootstrapWarning("Failed to load organization theme.", error);
+            return {};
+        }),
+    ]);
+    const user = {
+        ...userProfile,
+        email: userInfo?.email ?? userProfile.email,
+    };
+    const organizationPermissions = {
+        canManageOrganization: user.permissions?.includes("MANAGE") ?? false,
+        hasBaseUiAccess: user.permissions?.includes("BASE_UI_ACCESS") ?? false,
+        canCreateDevToken: user.permissions?.includes("SELF_CREATE_TOKEN") ?? false,
+    };
+    const organization = organizationDescriptor
+        ? {
+            id: organizationDescriptor.id,
+            title: organizationDescriptor.title,
+            bootstrapUser: organizationDescriptor.bootstrapUser,
+            bootstrapUserGroup: organizationDescriptor.bootstrapUserGroup,
+            identityProviderType: organizationDescriptor.identityProviderType,
+        }
+        : { id: organizationId, title: userProfile.organizationName };
+    const pantherTier = resolvePantherTier(entitlements);
+    const whiteLabelingSetting = userSettings.whiteLabeling;
+    const whiteLabeling = {
+        enabled: whiteLabelingSetting?.enabled ?? DEFAULT_WHITE_LABELING.enabled,
+        logoUrl: whiteLabelingSetting?.logoUrl,
+        faviconUrl: whiteLabelingSetting?.faviconUrl,
+        appleTouchIconUrl: whiteLabelingSetting?.appleTouchIconUrl,
+    };
+    return {
+        user,
+        userSettings,
+        organization,
+        organizationPermissions,
+        entitlements,
+        whiteLabeling,
+        pantherTier,
+        theme,
+    };
+}

package/esm/platformContext/loadPlatformContext.d.ts

@@ -0,0 +1,18 @@
+import { type IAuthCredentials } from "@gooddata/sdk-pluggable-application-model";
+import { type IBackendPlatformContext } from "./types.js";
+export declare class HostApplicationDisabledError extends Error {
+    constructor();
+}
+/**
+ * @alpha
+ */
+export interface ILoadPlatformContextCallbacks {
+    onBootstrapError?: (error: string, context: string) => void;
+    onLoaded?: (durationMs: number) => void;
+}
+export interface ILoadPlatformContextOptions {
+    signal?: AbortSignal;
+    auth?: IAuthCredentials;
+    callbacks?: ILoadPlatformContextCallbacks;
+}
+export declare function loadPlatformContext(options?: ILoadPlatformContextOptions): Promise<IBackendPlatformContext>;

package/esm/platformContext/loadPlatformContext.js

@@ -0,0 +1,50 @@
+// (C) 2026 GoodData Corporation
+import { now } from "../debug.js";
+import { getAuthCredentials, getBackend, reinitializeBackend } from "./backend.js";
+import { PLATFORM_CONTEXT_VERSION, bootstrapApplication } from "./bootstrap.js";
+export class HostApplicationDisabledError extends Error {
+    constructor() {
+        super("Host application is disabled by feature flag.");
+        this.name = "HostApplicationDisabledError";
+    }
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted) {
+        throw new DOMException("Aborted", "AbortError");
+    }
+}
+export async function loadPlatformContext(options = {}) {
+    const start = now();
+    if (options.auth) {
+        reinitializeBackend(options.auth);
+    }
+    const backend = getBackend();
+    throwIfAborted(options.signal);
+    let bootstrap;
+    try {
+        bootstrap = await bootstrapApplication(backend);
+    }
+    catch (e) {
+        options.callbacks?.onBootstrapError?.(e instanceof Error ? e.message : "Unknown bootstrap error", "loadPlatformContext");
+        throw e;
+    }
+    throwIfAborted(options.signal);
+    if (bootstrap.userSettings["enableShellApplication"] !== true) {
+        throw new HostApplicationDisabledError();
+    }
+    const elapsed = now() - start;
+    options.callbacks?.onLoaded?.(elapsed);
+    return {
+        version: PLATFORM_CONTEXT_VERSION,
+        auth: getAuthCredentials(),
+        user: bootstrap.user,
+        organization: bootstrap.organization,
+        organizationPermissions: bootstrap.organizationPermissions,
+        entitlements: bootstrap.entitlements,
+        userSettings: bootstrap.userSettings,
+        whiteLabeling: bootstrap.whiteLabeling,
+        pantherTier: bootstrap.pantherTier,
+        theme: bootstrap.theme,
+        embeddingMode: "none",
+    };
+}

package/esm/platformContext/tigerNotAuthenticatedHandler.d.ts

@@ -0,0 +1,3 @@
+import { type IAuthenticationContext, type NotAuthenticated } from "@gooddata/sdk-backend-spi";
+/** Not authenticated handler will be called every time 401 is returned from Tiger backend. */
+export declare function createNotAuthenticatedHandler(externalProviderId?: string): (ctx: IAuthenticationContext, err: NotAuthenticated) => void;

package/esm/platformContext/tigerNotAuthenticatedHandler.js

@@ -0,0 +1,16 @@
+// (C) 2026 GoodData Corporation
+import { throttle } from "lodash-es";
+import { createRedirectToTigerAuthenticationWithParams, redirectToTigerAuthentication, } from "@gooddata/sdk-backend-tiger";
+/** Not authenticated handler will be called every time 401 is returned from Tiger backend. */
+export function createNotAuthenticatedHandler(externalProviderId) {
+    const redirectHandler = externalProviderId
+        ? createRedirectToTigerAuthenticationWithParams({ externalProviderId })
+        : redirectToTigerAuthentication;
+    const debouncedRedirectHandler = throttle(redirectHandler, 500, {
+        leading: false,
+        trailing: true,
+    });
+    return (ctx, err) => {
+        debouncedRedirectHandler(ctx, err);
+    };
+}

package/esm/platformContext/types.d.ts

@@ -0,0 +1,17 @@
+import { type IPlatformContext } from "@gooddata/sdk-pluggable-application-model";
+export interface IPlatformContextLoadingResult {
+    state: "loading";
+}
+export interface IPlatformContextReadyResult<TContext> {
+    state: "ready";
+    ctx: TContext;
+}
+export interface IPlatformContextErrorResult {
+    state: "error";
+    error: string;
+}
+type RoutePlatformContextFields = "currentWorkspaceId" | "currentApplicationScope" | "workspacePermissions" | "workspaceSettings" | "settings" | "preferredLocale";
+export type IRoutePlatformContext = Pick<IPlatformContext, RoutePlatformContextFields>;
+export type IBackendPlatformContext = Omit<IPlatformContext, RoutePlatformContextFields>;
+export type IPlatformContextLoadResult<TContext> = IPlatformContextLoadingResult | IPlatformContextReadyResult<TContext> | IPlatformContextErrorResult;
+export {};

package/esm/platformContext/types.js

@@ -0,0 +1,2 @@
+// (C) 2026 GoodData Corporation
+export {};

package/esm/platformContext/useLoadPlatformContext.d.ts

@@ -0,0 +1,35 @@
+import { type IPlatformContext } from "@gooddata/sdk-pluggable-application-model";
+import { type ILoadPlatformContextCallbacks } from "./loadPlatformContext.js";
+import { type IBackendPlatformContext, type IPlatformContextLoadResult } from "./types.js";
+/**
+ * Builds the platform context inside the host application.
+ *
+ * @remarks
+ * This is intentionally host-owned and can evolve as host bootstrapping grows.
+ *
+ * @internal
+ */
+export declare function useLoadPlatformContext(): IPlatformContextLoadResult<IPlatformContext>;
+/**
+ * Subscribable provider of the host's backend platform context (org / user / settings).
+ *
+ * @internal
+ */
+export interface IBackendPlatformContextProvider {
+    setCallbacks(callbacks: ILoadPlatformContextCallbacks): void;
+    getResult: () => Readonly<IPlatformContextLoadResult<IBackendPlatformContext>>;
+    subscribe: (listener: () => void) => () => void;
+    load: () => Promise<void>;
+}
+/**
+ * @internal
+ */
+export declare const BackendPlatformContextProvider: IBackendPlatformContextProvider;
+/**
+ * Registers the host's platform-context lifecycle callbacks. Must be called once at
+ * host boot before `<Root>` is rendered so the very first load can report telemetry
+ * / errors back to the host application.
+ *
+ * @alpha
+ */
+export declare function registerPlatformContextCallbacks(callbacks: ILoadPlatformContextCallbacks): void;

package/esm/platformContext/useLoadPlatformContext.js

@@ -0,0 +1,131 @@
+// (C) 2026 GoodData Corporation
+import { useMemo, useSyncExternalStore } from "react";
+import { useLocation } from "react-router";
+import { isLocale } from "@gooddata/sdk-model";
+import { isProduction } from "../lib/isProduction.js";
+import { getApplicationScopeFromPath, getWorkspaceIdFromPath } from "../loader/routing.js";
+import { getBackend } from "./backend.js";
+import { HostApplicationDisabledError, loadPlatformContext, } from "./loadPlatformContext.js";
+import { useWorkspacePermissions } from "./useWorkspacePermissions.js";
+import { useWorkspaceSettings } from "./useWorkspaceSettings.js";
+function redirectToAppRoot() {
+    const rootUrl = new URL("/", window.location.origin).toString();
+    window.location.assign(rootUrl);
+}
+/**
+ * Builds the platform context inside the host application.
+ *
+ * @remarks
+ * This is intentionally host-owned and can evolve as host bootstrapping grows.
+ *
+ * @internal
+ */
+export function useLoadPlatformContext() {
+    const backendContext = useSyncExternalStore(BackendPlatformContextProvider.subscribe, BackendPlatformContextProvider.getResult);
+    const { pathname } = useLocation();
+    const applicationScope = getApplicationScopeFromPath(pathname);
+    const workspaceId = getWorkspaceIdFromPath(pathname);
+    const backend = backendContext.state === "ready" ? getBackend() : undefined;
+    const workspacePermissionsState = useWorkspacePermissions(backend, workspaceId);
+    const workspaceSettingsState = useWorkspaceSettings(backend, workspaceId);
+    return useMemo(() => {
+        if (backendContext.state !== "ready") {
+            return backendContext;
+        }
+        // Block rendering until workspace permissions AND settings are available when inside a workspace route.
+        const permissionsLoading = workspacePermissionsState.state === "loading" || workspacePermissionsState.state === "idle";
+        const settingsLoading = workspaceSettingsState.state === "loading" || workspaceSettingsState.state === "idle";
+        if (workspaceId !== undefined && (permissionsLoading || settingsLoading)) {
+            return { state: "loading" };
+        }
+        // Surface fetch failures so the user sees an error rather than a silent 404
+        if (workspaceId !== undefined && workspacePermissionsState.state === "error") {
+            return { state: "error", error: workspacePermissionsState.error };
+        }
+        if (workspaceId !== undefined && workspaceSettingsState.state === "error") {
+            return { state: "error", error: workspaceSettingsState.error };
+        }
+        const workspacePermissions = workspacePermissionsState.state === "ready" ? workspacePermissionsState.permissions : undefined;
+        const workspaceSettings = workspaceSettingsState.state === "ready" ? workspaceSettingsState.settings : undefined;
+        const settings = workspaceSettings ?? backendContext.ctx.userSettings;
+        const preferredLocale = isLocale(settings.locale) ? settings.locale : undefined;
+        const routeCtx = {
+            currentApplicationScope: applicationScope,
+            currentWorkspaceId: workspaceId,
+            workspacePermissions,
+            workspaceSettings,
+            settings,
+            preferredLocale,
+        };
+        return { state: "ready", ctx: { ...backendContext.ctx, ...routeCtx } };
+    }, [backendContext, applicationScope, workspaceId, workspacePermissionsState, workspaceSettingsState]);
+}
+class BackendPlatformContextProviderClass {
+    _loadingStateMemo = { state: "loading" };
+    _result = this._loadingStateMemo;
+    _abortController = new AbortController();
+    _listeners = new Set();
+    _loadStarted = false;
+    _callbacks;
+    setCallbacks(callbacks) {
+        this._callbacks = callbacks;
+    }
+    getResult = () => this._result;
+    subscribe = (listener) => {
+        if (!this._loadStarted) {
+            void this.load();
+        }
+        this._listeners.add(listener);
+        return () => this._listeners.delete(listener);
+    };
+    load = async () => {
+        this._loadStarted = true;
+        this._abortController.abort();
+        const keepCurrentContextMounted = this._result.state === "ready";
+        if (!keepCurrentContextMounted) {
+            this._setResult(this._loadingStateMemo);
+        }
+        this._abortController = new AbortController();
+        try {
+            const ctx = await loadPlatformContext({
+                signal: this._abortController.signal,
+                callbacks: this._callbacks,
+            });
+            if (!this._abortController.signal.aborted) {
+                this._setResult({ state: "ready", ctx });
+            }
+        }
+        catch (e) {
+            if (e instanceof HostApplicationDisabledError && isProduction) {
+                redirectToAppRoot(); // In dev env, this would just loop due to app routing
+                return;
+            }
+            if (e instanceof DOMException && e.name === "AbortError") {
+                return;
+            }
+            console.error("[host-runtime/platform-context] Failed to load platform context.", e);
+            const message = e instanceof Error ? e.message : "Unknown platform context error.";
+            if (!this._abortController.signal.aborted) {
+                this._setResult({ state: "error", error: message });
+            }
+        }
+    };
+    _setResult(value) {
+        this._result = value;
+        this._listeners.forEach((listener) => listener());
+    }
+}
+/**
+ * @internal
+ */
+export const BackendPlatformContextProvider = new BackendPlatformContextProviderClass();
+/**
+ * Registers the host's platform-context lifecycle callbacks. Must be called once at
+ * host boot before `<Root>` is rendered so the very first load can report telemetry
+ * / errors back to the host application.
+ *
+ * @alpha
+ */
+export function registerPlatformContextCallbacks(callbacks) {
+    BackendPlatformContextProvider.setCallbacks(callbacks);
+}

package/esm/platformContext/useWorkspacePermissions.d.ts

@@ -0,0 +1,26 @@
+import { type IAnalyticalBackend } from "@gooddata/sdk-backend-spi";
+import { type IWorkspacePermissions } from "@gooddata/sdk-model";
+type WorkspacePermissionsState = {
+    state: "idle";
+} | {
+    state: "loading";
+} | {
+    state: "ready";
+    permissions: IWorkspacePermissions;
+} | {
+    state: "forbidden";
+} | {
+    state: "error";
+    error: string;
+};
+/**
+ * Loads workspace permissions for the current user.
+ *
+ * @remarks
+ * Returns `"idle"` when `backend` or `workspaceId` is absent.
+ * Re-fetches whenever `workspaceId` changes.
+ *
+ * @internal
+ */
+export declare function useWorkspacePermissions(backend: IAnalyticalBackend | undefined, workspaceId: string | undefined): WorkspacePermissionsState;
+export {};

package/esm/platformContext/useWorkspacePermissions.js

@@ -0,0 +1,52 @@
+// (C) 2026 GoodData Corporation
+import { useEffect, useState } from "react";
+import { UnexpectedResponseError } from "@gooddata/sdk-backend-spi";
+/**
+ * Loads workspace permissions for the current user.
+ *
+ * @remarks
+ * Returns `"idle"` when `backend` or `workspaceId` is absent.
+ * Re-fetches whenever `workspaceId` changes.
+ *
+ * @internal
+ */
+export function useWorkspacePermissions(backend, workspaceId) {
+    const [permissionsState, setPermissionsState] = useState({
+        state: "idle",
+    });
+    useEffect(() => {
+        if (!backend || !workspaceId) {
+            setPermissionsState((prev) => (prev.state === "idle" ? prev : { state: "idle" }));
+            return;
+        }
+        let cancelled = false;
+        setPermissionsState({ state: "loading" });
+        backend
+            .workspace(workspaceId)
+            .permissions()
+            .getPermissionsForCurrentUser()
+            .then((permissions) => {
+            if (!cancelled) {
+                setPermissionsState({ state: "ready", permissions });
+            }
+        })
+            .catch((e) => {
+            if (cancelled)
+                return;
+            // 403/404 on the workspace permissions endpoint means no access — Tiger uses
+            // 404 to avoid leaking workspace existence (same message as 403). Signal
+            // "forbidden" so the platform context reaches "ready" with undefined permissions
+            // and the mounted app can render its own access-denied UI.
+            if (e instanceof UnexpectedResponseError && (e.httpStatus === 403 || e.httpStatus === 404)) {
+                setPermissionsState({ state: "forbidden" });
+                return;
+            }
+            const error = e instanceof Error ? e.message : "Unknown error loading workspace permissions.";
+            setPermissionsState({ state: "error", error });
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [backend, workspaceId]);
+    return permissionsState;
+}

package/esm/platformContext/useWorkspaceSettings.d.ts

@@ -0,0 +1,25 @@
+import { type IAnalyticalBackend, type IUserWorkspaceSettings } from "@gooddata/sdk-backend-spi";
+type WorkspaceSettingsState = {
+    state: "idle";
+} | {
+    state: "loading";
+} | {
+    state: "ready";
+    settings: IUserWorkspaceSettings;
+} | {
+    state: "forbidden";
+} | {
+    state: "error";
+    error: string;
+};
+/**
+ * Loads effective workspace-scoped settings for the current user.
+ *
+ * @remarks
+ * Returns `"idle"` when `backend` or `workspaceId` is absent.
+ * Re-fetches whenever `workspaceId` changes.
+ *
+ * @internal
+ */
+export declare function useWorkspaceSettings(backend: IAnalyticalBackend | undefined, workspaceId: string | undefined): WorkspaceSettingsState;
+export {};

package/esm/platformContext/useWorkspaceSettings.js

@@ -0,0 +1,46 @@
+// (C) 2026 GoodData Corporation
+import { useEffect, useState } from "react";
+import { UnexpectedResponseError, } from "@gooddata/sdk-backend-spi";
+/**
+ * Loads effective workspace-scoped settings for the current user.
+ *
+ * @remarks
+ * Returns `"idle"` when `backend` or `workspaceId` is absent.
+ * Re-fetches whenever `workspaceId` changes.
+ *
+ * @internal
+ */
+export function useWorkspaceSettings(backend, workspaceId) {
+    const [settingsState, setSettingsState] = useState({ state: "idle" });
+    useEffect(() => {
+        if (!backend || !workspaceId) {
+            setSettingsState((prev) => (prev.state === "idle" ? prev : { state: "idle" }));
+            return;
+        }
+        let cancelled = false;
+        setSettingsState({ state: "loading" });
+        backend
+            .workspace(workspaceId)
+            .settings()
+            .getSettingsForCurrentUser()
+            .then((settings) => {
+            if (!cancelled) {
+                setSettingsState({ state: "ready", settings });
+            }
+        })
+            .catch((e) => {
+            if (cancelled)
+                return;
+            if (e instanceof UnexpectedResponseError && (e.httpStatus === 403 || e.httpStatus === 404)) {
+                setSettingsState({ state: "forbidden" });
+                return;
+            }
+            const error = e instanceof Error ? e.message : "Unknown error loading workspace settings.";
+            setSettingsState({ state: "error", error });
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [backend, workspaceId]);
+    return settingsState;
+}

package/esm/registry/pluggableApplicationsRegistry.d.ts

@@ -0,0 +1,55 @@
+import { type ApplicationScope, type LocalPluggableApplicationsRegistry, type PluggableApplicationRegistryItem, type RemotePluggableApplicationsRegistry } from "@gooddata/sdk-model";
+import { type IPlatformContext } from "@gooddata/sdk-pluggable-application-model";
+/**
+ * Registers the local pluggable applications manifest. Called by the host or harness
+ * before rendering.
+ *
+ * @alpha
+ */
+export declare function registerLocalApplications(registry: LocalPluggableApplicationsRegistry): void;
+/**
+ * @internal - exported for testing
+ */
+export declare function getRemoteRegistry(ctx: IPlatformContext): RemotePluggableApplicationsRegistry | undefined;
+interface IResolveApplicationsOptions {
+    /**
+     * Local (standard) pluggable applications
+     */
+    localApps: PluggableApplicationRegistryItem[];
+    /**
+     * Remote registry configuration from user settings, may be undefined
+     */
+    remoteRegistry: RemotePluggableApplicationsRegistry | undefined;
+    /**
+     * Platform context containing user settings, permissions, entitlements, etc.
+     */
+    ctx: IPlatformContext;
+    /**
+     * Application scope to filter by; if undefined, no apps are returned
+     */
+    scope: ApplicationScope | undefined;
+}
+/**
+ * Resolves the final list of pluggable applications from the local and remote registries.
+ *
+ * Processing steps (in order):
+ * 1. Filter local apps by allowedStandardApplications list (if provided in remote registry)
+ * 2. Filter local apps by BASE_UI_ACCESS organization permission (if restrictBaseUi is set)
+ * 3. Merge local and remote applications - local apps are added first, duplicates (by ID) are skipped with console.error
+ * 4. Apply overrides from the remote registry to the merged list
+ * 5. Filter out disabled applications (isEnabled: false)
+ * 6. Filter by application scope - keep only apps whose applicationScope matches scope; if scope is undefined, no apps pass through
+ * 7. Filter by requirements - check requiredSettings, requiredWorkspacePermissions, requiredOrganizationPermissions, and requiredEntitlements
+ * 8. Sort by menuOrder (ascending)
+ *
+ * @param options - Resolution options; see {@link IResolveApplicationsOptions}
+ * @returns Filtered and sorted list of pluggable applications ready for display
+ *
+ * @internal - exported for testing
+ */
+export declare function resolveApplications({ localApps, remoteRegistry, ctx, scope }: IResolveApplicationsOptions): PluggableApplicationRegistryItem[];
+/**
+ * Builds the resolved list of pluggable applications from the local and remote registries.
+ */
+export declare function usePluggableApplications(ctx: IPlatformContext): PluggableApplicationRegistryItem[];
+export {};