@genispace/geniapp 0.2.0 → 0.4.0

package/dist/components/internal/workbench/contexts/WorkbenchGlobalSpaceContext.d.ts

@@ -0,0 +1,10 @@
+import { default as React, ReactNode } from 'react';
+import { useSpace } from '../../shared-ui/index.ts';
+
+type WorkbenchGlobalSpaceContextValue = ReturnType<typeof useSpace>;
+export declare function WorkbenchGlobalSpaceProvider({ children }: {
+    children: ReactNode;
+}): React.JSX.Element;
+export declare function useWorkbenchGlobalSpace(): WorkbenchGlobalSpaceContextValue;
+export declare function useWorkbenchGlobalSpaceOptional(): WorkbenchGlobalSpaceContextValue | null;
+export {};

package/dist/components/internal/workbench/contexts/WorkbenchThemeContext.d.ts

@@ -0,0 +1,23 @@
+import { default as React, ReactNode } from 'react';
+import { ThemeId, Theme } from '../themes';
+
+interface WorkbenchThemeContextValue {
+    themeId: ThemeId;
+    setThemeId: (id: ThemeId) => Promise<void>;
+    theme: Theme;
+    isDark: boolean;
+}
+export interface WorkbenchThemeProviderProps {
+    children: ReactNode;
+    workbenchId?: string;
+    serverThemeId?: string | undefined;
+    /**
+     * Persist theme into `Workbench.config` (merge `{ ...config, themeId }`).
+     * When omitted, viewers prefer locally saved preferences before server defaults.
+     */
+    onPersistTheme?: (themeId: ThemeId) => Promise<void>;
+}
+export declare function WorkbenchThemeProvider({ children, workbenchId, serverThemeId, onPersistTheme, }: WorkbenchThemeProviderProps): React.JSX.Element;
+/** Appearance package (`classic` / `inkOnyx`, …); unrelated to `@genispace/shared-ui` light/dark controls. */
+export declare function useWorkbenchTheme(): WorkbenchThemeContextValue;
+export {};

package/dist/components/internal/workbench/hooks/index.d.ts

@@ -0,0 +1,6 @@
+export { useComponentCommunication, useParameterEmitter, useParameterListener, } from './useComponentCommunication';
+export type { ComponentCommunicationConfig, ComponentCommunicationReturn, } from './useComponentCommunication';
+export { useParameterHandler, buildDataSourceFilters, buildFilterString, mergeFilterStrings, parseUrlParameters, } from './useParameterHandler';
+export { useEnhancedDataSource } from './useEnhancedDataSource';
+export type { UseEnhancedDataSourceOptions, UseEnhancedDataSourceReturn, } from './useEnhancedDataSource';
+export { usePageAutoRefresh } from './usePageAutoRefresh';

package/dist/components/internal/workbench/hooks/useComponentCommunication.d.ts

@@ -0,0 +1,27 @@
+import { ParameterValue, ParameterChangeEvent } from '../types/parameters';
+
+export interface ComponentCommunicationConfig {
+    componentId: string;
+    emitParameters?: string[];
+    listenParameters?: string[];
+    onParameterChange?: (key: string, value: ParameterValue, event: ParameterChangeEvent) => void;
+    autoCleanup?: boolean;
+    immediate?: boolean;
+}
+export interface ComponentCommunicationReturn {
+    emit: (key: string, value: ParameterValue) => void;
+    emitBatch: (params: Record<string, ParameterValue>) => void;
+    getCurrentParameter: (key: string) => ParameterValue;
+    getAllParameters: () => Record<string, ParameterValue>;
+    subscribe: (keys: string[], callback: (event: ParameterChangeEvent) => void) => () => void;
+    hasListeners: (key: string) => boolean;
+}
+export declare const useComponentCommunication: (config: ComponentCommunicationConfig) => ComponentCommunicationReturn;
+export declare const useParameterEmitter: (componentId: string, allowedParameters?: string[]) => {
+    emit: (key: string, value: ParameterValue) => void;
+    emitBatch: (params: Record<string, ParameterValue>) => void;
+};
+export declare const useParameterListener: (componentId: string, parameters: string[], callback: (key: string, value: ParameterValue, event: ParameterChangeEvent) => void) => {
+    getCurrentParameter: (key: string) => ParameterValue;
+    getAllParameters: () => Record<string, ParameterValue>;
+};

package/dist/components/internal/workbench/hooks/useConditionMapper.d.ts

@@ -0,0 +1,17 @@
+import { UpdateDatabaseConfig } from '../types';
+
+export declare const useConditionMapper: (updateConditions: UpdateDatabaseConfig["updateConditions"], onChange: (conditions: UpdateDatabaseConfig["updateConditions"]) => void) => {
+    isCollapsed: boolean;
+    setIsCollapsed: import('react').Dispatch<import('react').SetStateAction<boolean>>;
+    handleAddCondition: (fieldName: string, initialConfig?: Partial<UpdateDatabaseConfig["updateConditions"][string]>) => boolean;
+    handleRemoveCondition: (fieldName: string) => void;
+    handleConditionChange: (fieldName: string, key: string, value: string) => void;
+    handleFieldRename: (oldName: string, newName: string) => boolean;
+    getConditionStats: () => {
+        total: number;
+        hasStatic: boolean;
+        hasParameter: boolean;
+        hasColumn: boolean;
+        hasInputField: boolean;
+    };
+};

package/dist/components/internal/workbench/hooks/useCurrentUser.d.ts

@@ -0,0 +1,10 @@
+export interface CurrentUserInfo {
+    id: string;
+    name: string;
+    email: string;
+}
+export declare function useCurrentUser(): {
+    currentUser: CurrentUserInfo;
+    loading: boolean;
+    error: any;
+};

package/dist/components/internal/workbench/hooks/useDatabaseDataSource.d.ts

@@ -0,0 +1,8 @@
+import { DatabaseDataSourceConfig, UseDatabaseDataSourceReturn, SupportedComponentType, ErrorHandlingConfig, PerformanceConfig } from '../types/databaseDataSource';
+
+export declare const useDatabaseDataSource: (config: DatabaseDataSourceConfig | null, componentType: SupportedComponentType, additionalParams?: Record<string, any>, options?: {
+    errorConfig?: Partial<ErrorHandlingConfig>;
+    performanceConfig?: Partial<PerformanceConfig>;
+    autoFetch?: boolean;
+}) => UseDatabaseDataSourceReturn;
+export default useDatabaseDataSource;

package/dist/components/internal/workbench/hooks/useDatasourceVersionBindings.d.ts

@@ -0,0 +1,24 @@
+import { WorkbenchConfigData } from '../types';
+
+/**
+ * Non-default datasource version bindings of a workbench config — shared by the
+ * EditModeToolbar badge (count) and the PublishDialog binding list.
+ *
+ * A pin counts as non-default when the pinned version differs from the
+ * datasource's current default, or when the pinned version no longer exists.
+ * Single POST /datasources/versions/batch call — it returns name/identifier
+ * per datasource, so no per-datasource detail fetches are needed.
+ */
+export interface DatasourceVersionBindingInfo {
+    datasourceId: string;
+    name?: string;
+    identifier?: string;
+    pinnedVersion: number;
+    defaultVersion: number | null;
+    /** False when the pinned version was deleted upstream. */
+    pinnedExists: boolean;
+}
+export declare function useNonDefaultDatasourceBindings(config: Pick<WorkbenchConfigData, 'datasourceVersions'> | null | undefined): {
+    bindings: DatasourceVersionBindingInfo[];
+    loading: boolean;
+};

package/dist/components/internal/workbench/hooks/useEnhancedDataSource.d.ts

@@ -0,0 +1,40 @@
+import { EnhancedDataSource } from '../types/datasource';
+
+export interface UseEnhancedDataSourceOptions {
+    dataSource: EnhancedDataSource | null;
+    onDataChange?: (data: any[]) => void;
+    onError?: (error: string) => void;
+    onFilterChange?: (filter: string) => void;
+    componentId?: string;
+    pageSize?: number;
+}
+export interface DatasetPagination {
+    total: number;
+    limit: number;
+    offset: number;
+    current_page: number;
+    total_pages: number;
+    has_more: boolean;
+}
+export interface EnhancedDataSourceRefreshOptions {
+    page?: number;
+    pageSize?: number;
+}
+export interface UseEnhancedDataSourceReturn {
+    data: any[];
+    loading: boolean;
+    error: string | null;
+    pagination: DatasetPagination | undefined;
+    refresh: (options?: EnhancedDataSourceRefreshOptions) => Promise<void>;
+    currentFilter: string;
+    parameterValues: Record<string, any>;
+    filterConditions: string[];
+    exportAllData: (onProgress: (current: number, total: number) => void) => Promise<any[]>;
+}
+export declare function extractDatasetPagination(payload: unknown, fallback: {
+    page: number;
+    pageSize: number;
+    rowCount: number;
+}): DatasetPagination;
+export declare const useEnhancedDataSource: ({ dataSource, onDataChange, onError, onFilterChange, componentId, pageSize: requestedPageSize, }: UseEnhancedDataSourceOptions) => UseEnhancedDataSourceReturn;
+export default useEnhancedDataSource;

package/dist/components/internal/workbench/hooks/useMobileViewport.d.ts

@@ -0,0 +1,18 @@
+import { ViewportSource } from '../mobile/utils/getMobileViewportState';
+
+interface UseMobileViewportOptions {
+    wecom?: boolean;
+    debug?: boolean;
+}
+interface UseMobileViewportReturn {
+    mode: 'mobile' | 'desktop';
+    isMobile: boolean;
+    canReturnToDesktop: boolean;
+    viewportSource: ViewportSource;
+    isWeCom: boolean;
+    forceMobile: () => void;
+    forceDesktop: () => void;
+    reset: () => void;
+}
+export declare function useMobileViewport(options?: UseMobileViewportOptions): UseMobileViewportReturn;
+export {};

package/dist/components/internal/workbench/hooks/usePageAutoRefresh.d.ts

@@ -0,0 +1,9 @@
+import { PageConfig } from '../types/components';
+
+interface PageAutoRefreshOptions {
+    pageConfig: PageConfig;
+    pageId: string;
+    isActive: boolean;
+}
+export declare const usePageAutoRefresh: ({ pageConfig, pageId, isActive }: PageAutoRefreshOptions) => void;
+export default usePageAutoRefresh;

package/dist/components/internal/workbench/hooks/useParameterHandler.d.ts

@@ -0,0 +1,27 @@
+import { ParameterConfig } from '../types';
+import { ParameterRecord, ParameterValue, ComponentParameterConfig, ParameterChangeEvent } from '../types/parameters';
+
+interface UseParameterHandlerProps {
+    parameterConfig?: ParameterConfig;
+    pageParams?: ParameterRecord;
+    componentId?: string;
+    preferProvidedParams?: boolean;
+    componentParameterConfig?: ComponentParameterConfig;
+}
+interface UseParameterHandlerReturn {
+    rawParams: ParameterRecord;
+    getParameterForDataSource: () => ParameterRecord;
+    getParameterForProps: () => ParameterRecord;
+    updateParameter: (key: string, value: ParameterValue) => void;
+    isParameterEnabled: boolean;
+    parameterSource: 'context' | 'provided' | 'none';
+    broadcastParameter: (key: string, value: ParameterValue) => void;
+    subscribeToParameters: (keys: string[], callback: (event: ParameterChangeEvent) => void) => () => void;
+    isListeningToParameters: boolean;
+}
+export declare const useParameterHandler: ({ parameterConfig, pageParams, componentId, preferProvidedParams, componentParameterConfig }: UseParameterHandlerProps) => UseParameterHandlerReturn;
+export declare const buildDataSourceFilters: (filters?: ParameterConfig["dataSourceFilters"], parameters?: ParameterRecord) => ParameterRecord;
+export declare const buildFilterString: (filters?: ParameterRecord, fieldTypes?: Record<string, string>) => string;
+export declare const mergeFilterStrings: (...filters: (string | undefined)[]) => string;
+export declare const parseUrlParameters: () => ParameterRecord;
+export {};

package/dist/components/internal/workbench/hooks/useReleaseNotesPrompt.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Release-notes prompt state ("new version published" dialog), shared by the
+ * desktop (WorkbenchLayout) and mobile (WorkbenchMobileLayout) shells.
+ *
+ * Shows once per user per published version: the dismissal marker lives
+ * server-side in `User.launcherState.releaseNoteDismissals` (a
+ * `{ [workbenchId]: publishedVersion }` map) via `GET/PUT /users/me/settings`
+ * — localStorage is deliberately NOT the source of truth because the WeCom
+ * webview wipes it on re-entry. A bare localStorage key is only an
+ * anti-flicker cache consulted before the settings GET resolves.
+ *
+ * Writes are deliberately narrow: `dismiss()` re-fetches settings, then PUTs
+ * ONLY the merged `releaseNoteDismissals` map — echoing back mount-time
+ * snapshots of sibling fields would clobber concurrent writes (e.g. hub's
+ * persistLauncherState); the server preserves fields we don't send and
+ * deep-merges this map per key.
+ *
+ * An unread version is still NOT enough to pop: the prompt only shows when
+ * `GET /workbenches/:id/publish-history?limit=1` returns a real note.
+ * Versions with empty history (publishes predating the history feature,
+ * template/copy-created workbenches) are marked read silently; a failed
+ * history fetch stays quiet without persisting, so the next visit retries.
+ */
+export interface UseReleaseNotesPromptOptions {
+    workbenchId?: string;
+    /** `currentWorkbench.publishedVersion` — absent until the workbench loads. */
+    publishedVersion?: string | null;
+    isEditMode: boolean;
+    isPreviewActive: boolean;
+    /** `UserContext.user.id` — absent until the user profile resolves. */
+    userId?: string | null;
+}
+export interface UseReleaseNotesPromptResult {
+    shouldShow: boolean;
+    /** Close the dialog and persist the dismissal (best-effort, never blocks). */
+    dismiss: () => void;
+}
+export declare function useReleaseNotesPrompt({ workbenchId, publishedVersion, isEditMode, isPreviewActive, userId, }: UseReleaseNotesPromptOptions): UseReleaseNotesPromptResult;

package/dist/components/internal/workbench/hooks/useSpaceSwitchHandler.d.ts

@@ -0,0 +1,7 @@
+interface UseSpaceSwitchHandlerOptions {
+    onSpaceSwitch?: () => void;
+    enabled?: boolean;
+}
+export declare const useSpaceSwitchHandler: (options?: UseSpaceSwitchHandlerOptions) => void;
+export declare const useSpaceSwitchRefresh: (refetchFn?: () => void) => void;
+export default useSpaceSwitchHandler;

package/dist/components/internal/workbench/hooks/useTaskInputDataSourceCache.d.ts

@@ -0,0 +1,24 @@
+export interface DataSourceConfig {
+    datasourceId: string;
+    version?: number;
+    valueField: string;
+    labelField: string;
+}
+export interface DataSourceOption {
+    value: string;
+    label: string;
+}
+export declare function parseDataSourceConfigFromMapping(mapping: {
+    source?: string;
+    value?: string;
+} | undefined): DataSourceConfig | null;
+export declare function useTaskInputDataSourceCache(parameterMapping: Record<string, {
+    source?: string;
+    value?: string;
+}> | undefined, schemaLoaded: boolean): {
+    getOptionsForConfig: (config: DataSourceConfig | null) => DataSourceOption[];
+    parseDataSourceConfig: (mapping: {
+        source?: string;
+        value?: string;
+    } | undefined) => DataSourceConfig | null;
+};

package/dist/components/internal/workbench/hooks/useVisibleWhenContext.d.ts

@@ -0,0 +1,3 @@
+import { VisibleWhenContext } from '../utils/visibleWhen';
+
+export declare function useVisibleWhenContext(pageParams: Record<string, unknown> | undefined): VisibleWhenContext;

package/dist/components/internal/workbench/hooks/useWaitForParameters.d.ts

@@ -0,0 +1,9 @@
+interface UseWaitForParametersOptions {
+    onReady?: () => void;
+}
+interface UseWaitForParametersReturn {
+    ready: boolean;
+    isReady: (parameterKeys: string[]) => boolean;
+}
+export declare const useWaitForParameters: (listenParameters: string[] | undefined, options?: UseWaitForParametersOptions) => UseWaitForParametersReturn;
+export default useWaitForParameters;

package/dist/components/internal/workbench/hooks/useWorkbenchAppAccess.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Current user's access within the workbench's owning application.
+ * `roles` are the application role CODES assigned to the current user (from
+ * `GET /applications/:id/users/me/access`). Empty when the user has no app roles or the
+ * workbench app has no custom roles yet.
+ */
+export interface WorkbenchAppAccess {
+    isUser: boolean;
+    roles: string[];
+    permissionCodes: string[];
+    loading: boolean;
+    /** The workbench's owning application id (undefined until the workbench config loads). */
+    applicationId?: string;
+}
+export declare function useResolvedApplicationId(): string | undefined;
+export declare function useWorkbenchAppAccess(): WorkbenchAppAccess;

package/dist/components/internal/workbench/hooks/useWorkbenchHeaderNavApps.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Enabled built-in nav apps + active id for AppHeader (pinned shortcuts, team apps menu).
+ */
+export declare function useWorkbenchHeaderNavApps(displayLanguage?: string): {
+    enabledBuiltInApps: import('../../shared-ui/index.ts').EnabledBuiltInAppItem[];
+    activeBuiltInAppId: string;
+};

package/dist/components/internal/workbench/hooks/useWorkbenchPreview.d.ts

@@ -0,0 +1,24 @@
+import { WorkbenchConfigView, WorkbenchResponse } from '../app/services/workbenchApi';
+
+export interface ResolvedConfigView {
+    view: WorkbenchConfigView;
+    previewToken?: string;
+}
+export declare function resolveDraftLoadFallback(viewOptions: ResolvedConfigView, error: unknown): {
+    fallbackToPublished: boolean;
+    exitPreview: boolean;
+};
+/**
+ * Shared draft-preview state for the publish flow, consumed by both the desktop
+ * (WorkbenchLayout) and mobile (WorkbenchMobileLayout) shells: resolves which
+ * config view to load (preview link / edit mode / published), tracks whether a
+ * preview is on screen, and handles exiting preview — manually or when the
+ * backend rejects an expired preview token (403 PREVIEW_TOKEN_INVALID).
+ */
+export declare function useWorkbenchPreview(): {
+    resolveConfigView: (id: string) => ResolvedConfigView;
+    exitPreview: (id: string) => void;
+    isPreviewActive: boolean;
+    lastLoadedWorkbenchIdRef: import('react').MutableRefObject<string>;
+    loadWorkbenchWithPreview: (id: string) => Promise<WorkbenchResponse>;
+};

package/dist/components/internal/workbench/lib/api/apiClient.d.ts

@@ -0,0 +1,22 @@
+import { NavigateFunction } from 'react-router-dom';
+import { BaseApiClient } from './baseApiClient';
+import { ApiResponse } from '../types/api';
+import { getAuthToken } from '../../../shared-api/index.ts';
+
+declare class AuthApiClient extends BaseApiClient {
+    constructor();
+    setNavigate(_nav: NavigateFunction): void;
+    private setupAuthInterceptors;
+    withoutAuth(): BaseApiClient;
+    batchRequest<T>(requests: Array<{
+        url: string;
+        method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+        body?: any;
+        config?: any;
+    }>): Promise<ApiResponse<T>[]>;
+}
+export declare const apiClient: AuthApiClient;
+export declare const setNavigate: (nav: NavigateFunction) => void;
+export { AuthApiClient };
+export { getAuthToken };
+export default apiClient;

package/dist/components/internal/workbench/lib/api/baseApiClient.d.ts

@@ -0,0 +1,21 @@
+import { AxiosRequestConfig } from 'axios';
+import { ApiResponse, PaginatedResponse } from '../types/api';
+
+declare const baseAxiosInstance: import('axios').AxiosInstance;
+declare class BaseApiClient {
+    private axiosInstance;
+    constructor();
+    getInstance(): import('axios').AxiosInstance;
+    private request;
+    get<T>(url: string, params?: Record<string, any>, config?: AxiosRequestConfig): Promise<ApiResponse<T>>;
+    post<T>(url: string, body?: any, config?: AxiosRequestConfig): Promise<ApiResponse<T>>;
+    put<T>(url: string, body?: any, config?: AxiosRequestConfig): Promise<ApiResponse<T>>;
+    delete<T>(url: string, config?: AxiosRequestConfig): Promise<ApiResponse<T>>;
+    patch<T>(url: string, body?: any, config?: AxiosRequestConfig): Promise<ApiResponse<T>>;
+    getWithPagination<T>(url: string, params?: any, config?: AxiosRequestConfig): Promise<PaginatedResponse<T>>;
+    uploadFile<T>(url: string, file: File, additionalData?: Record<string, any>, config?: AxiosRequestConfig): Promise<ApiResponse<T>>;
+    downloadFile(url: string, filename?: string): Promise<void>;
+}
+export declare const baseApiClient: BaseApiClient;
+export { BaseApiClient };
+export { baseAxiosInstance };

package/dist/components/internal/workbench/lib/api/hostAdapterBridge.d.ts

@@ -0,0 +1,21 @@
+export interface WorkbenchHostRequest {
+    url: string;
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    body?: unknown;
+    headers?: Record<string, string>;
+    responseType?: 'json' | 'blob' | 'text';
+    signal?: AbortSignal;
+}
+export interface WorkbenchHostResponse<T = unknown> {
+    success: boolean;
+    data?: T;
+    code?: number;
+    message?: string;
+    error?: unknown;
+    timestamp?: string;
+}
+export interface WorkbenchHostAdapters {
+    request?: <T = unknown>(request: WorkbenchHostRequest) => Promise<WorkbenchHostResponse<T>>;
+}
+export declare function configureWorkbenchHostAdapters(adapters: WorkbenchHostAdapters): () => void;
+export declare function getWorkbenchHostAdapters(): WorkbenchHostAdapters;

package/dist/components/internal/workbench/lib/api.d.ts

@@ -0,0 +1 @@
+export declare const apiClient: import('axios').AxiosInstance;

package/dist/components/internal/workbench/lib/auth/permissionManager.d.ts

@@ -0,0 +1,67 @@
+export type SubscriptionPlan = 'FREE' | 'PERSONAL' | 'PRO' | 'TEAM' | 'ENTERPRISE';
+export declare const TeamRoles: {
+    readonly OWNER: "OWNER";
+    readonly ADMINISTRATOR: "ADMINISTRATOR";
+    readonly MEMBER: "MEMBER";
+    readonly VIEWER: "VIEWER";
+};
+export type TeamRole = typeof TeamRoles[keyof typeof TeamRoles];
+export interface TeamOwner {
+    id: string;
+    name: string;
+    email: string;
+    subscriptionPlan: SubscriptionPlan;
+    subscriptionExpiry: string;
+}
+export interface TeamInfo {
+    id: string;
+    name: string;
+    type: 'personal' | 'collaborative';
+    subscriptionPlan?: SubscriptionPlan;
+    owner?: TeamOwner;
+    role?: string;
+}
+export interface UserPermissions {
+    isAdmin: boolean;
+    isSuperAdmin: boolean;
+    isPartner: boolean;
+    partner: {
+        id: string;
+        name: string;
+        type: string;
+        tier: string;
+    } | null;
+}
+interface SpacePermissions {
+    spaceId: string;
+    role: string;
+    permissions: string[];
+    canManageRoles: boolean;
+}
+declare class PermissionManager {
+    private data;
+    private readonly STORAGE_KEY;
+    private initializePromise;
+    private isInitializing;
+    private loadFromStorage;
+    private saveToStorage;
+    clearPermissions(spaceId?: string): void;
+    initialize(): Promise<void>;
+    private _doInitialize;
+    private loadPlatformPermissions;
+    loadSpacePermissions(spaceId: string): Promise<void>;
+    hasSpacePermission(spaceId: string, permission: string): boolean;
+    hasPlatformPermission(permission: string): boolean;
+    clearUserPermissions(): void;
+    getSpacePermissions(spaceId: string): SpacePermissions | null;
+    getPlatformRoles(): string[];
+    getCurrentSpaceRole(spaceId: string | null | undefined): string | null;
+    isSpacePermissionsLoaded(spaceId: string): boolean;
+    getPermissionSummary(): any;
+}
+export declare const permissionManager: PermissionManager;
+export declare const hasSpacePermission: (spaceId: string, permission: string) => boolean;
+export declare const hasPlatformPermission: (permission: string) => boolean;
+export declare const initializePermissions: () => Promise<void>;
+export declare const loadSpacePermissions: (spaceId: string) => Promise<void>;
+export default permissionManager;

package/dist/components/internal/workbench/lib/config/deployment.d.ts

@@ -0,0 +1,33 @@
+export type ReleaseEdition = 'cn' | 'global' | 'standalone';
+export declare function getReleaseEdition(): ReleaseEdition;
+export declare function isStandaloneDeployment(): boolean;
+export declare function isCnEdition(): boolean;
+export declare function isGlobalEdition(): boolean;
+export declare function isSaaSDeployment(): boolean;
+export declare function getDeploymentConfig(): {
+    edition: "cn";
+    showSignUp: boolean;
+    showPricing: boolean;
+    showMarketplace: boolean;
+    enableBilling: boolean;
+    homeRoute: string;
+    homeComponent: string;
+} | {
+    edition: "global";
+    showSignUp: boolean;
+    showPricing: boolean;
+    showMarketplace: boolean;
+    enableBilling: boolean;
+    homeRoute: string;
+    homeComponent: string;
+} | {
+    edition: "standalone";
+    showSignUp: boolean;
+    showPricing: boolean;
+    showMarketplace: boolean;
+    enableBilling: boolean;
+    homeRoute: string;
+    homeComponent: string;
+};
+export type DeploymentMode = 'saas' | 'standalone';
+export declare function getDeploymentMode(): DeploymentMode;

package/dist/components/internal/workbench/lib/config.d.ts

@@ -0,0 +1,45 @@
+import { ReleaseEdition } from './config/deployment';
+
+interface AppConfig {
+    RELEASE_EDITION?: ReleaseEdition;
+    API_BASE_URL: string;
+    WEBSITE_URL: string;
+    APP_TITLE: string;
+    APP_DESCRIPTION: string;
+    /** Hub / platform base (login / account / identity), e.g. https://www.genispace.ai */
+    APP_URL?: string;
+    /** Console (management) base, e.g. https://www.genispace.ai/console */
+    CONSOLE_URL?: string;
+    CHAT_URL?: string;
+    WORKBENCH_URL?: string;
+    PARTNER_URL?: string;
+    /** App Shell origin for built-in GeniApp shortcuts in the header */
+    SHELL_URL?: string;
+    BRAND_CHANNEL?: string;
+}
+declare global {
+    interface Window {
+        __APP_CONFIG__?: AppConfig;
+        __CONFIG_LOADED__?: boolean;
+        onConfigReady?: (callback: () => void) => void;
+    }
+}
+export declare const isConfigLoaded: () => boolean;
+export declare const waitForConfig: () => Promise<void>;
+export declare const API_BASE_URL: string;
+export declare const APP_TITLE: string;
+export declare const APP_DESCRIPTION: string;
+export declare const getConfig: () => {
+    API_BASE_URL: string;
+    WEBSITE_URL: string;
+    APP_TITLE: string;
+    APP_DESCRIPTION: string;
+    APP_URL: string;
+    CONSOLE_URL: string;
+    CHAT_URL: string;
+    WORKBENCH_URL: string;
+    PARTNER_URL: string;
+    SHELL_URL: string;
+    BRAND_CHANNEL: string;
+};
+export type { AppConfig };

package/dist/components/internal/workbench/lib/hooks/use-mobile.d.ts

@@ -0,0 +1 @@
+export declare function useIsMobile(): boolean;

package/dist/components/internal/workbench/lib/hooks/useOperator.d.ts

@@ -0,0 +1,11 @@
+export declare const useOperators: (initialFilters?: {}) => {
+    operators: any[];
+    loading: boolean;
+    error: string;
+    pagination: {
+        page: number;
+        limit: number;
+        total: number;
+    };
+    fetchOperators: (params?: {}) => Promise<void>;
+};