@edifice.io/client 1.7.4-develop-pedago.20241211160712

package/dist/session/interfaces.d.ts

@@ -0,0 +1,268 @@
+import { App } from '../globals';
+import { WidgetName } from '../widget/interfaces';
+export declare abstract class SessionFrameworkFactory {
+    static instance(): ISessionFramework;
+}
+export interface ISessionFramework {
+    /** Initialize once before use. */
+    initialize(): Promise<void>;
+    /** The current user session. */
+    session: ISession;
+    /** Log the current user in. */
+    login(email: string, password: string, rememberMe?: boolean, secureLocation?: boolean): Promise<void>;
+    /** Close the current user session. */
+    logout(): Promise<void>;
+}
+export interface ILoginModel {
+    email: string;
+    password: string;
+    rememberMe?: boolean;
+    secureLocation?: boolean;
+}
+export interface GetUserProfileOptions {
+    options?: any;
+    params?: Record<string, any>;
+}
+export interface ISession {
+    /** Language code (2-letters) actually applied. */
+    readonly currentLanguage: string;
+    /** Truthy when no user is connected. */
+    readonly notLoggedIn: boolean;
+    /** Additional information about the connected user. */
+    readonly description: IUserDescription;
+    /** Additional profile user information. */
+    readonly profile: UserProfile;
+    /**
+     * Get the connected user's avatar URL, or a default one.
+     * Append a query parameter to this URL for it to get resized, for example "?thumbnail=48x48"
+     */
+    readonly avatarUrl: string;
+    /** Basic information about the connected user. */
+    readonly user: IUserInfo;
+    /** Retrieve the current main app, @see ConfigureFramework.Platform.apps */
+    readonly currentApp: App | null;
+    /** Retrieve the lastest storage + quota information. */
+    readonly latestQuotaAndUsage: Promise<IQuotaAndUsage>;
+    hasWorkflow(workflowName: string): boolean;
+    hasRight(resource: any, right: any): boolean;
+    /** Get User Profile */
+    getUserProfile({ options, params, }: Partial<GetUserProfileOptions>): Promise<UserProfile>;
+    /** Verify if the logged-in user has a valid email address. */
+    getEmailValidationInfos(): Promise<IEmailValidationInfos>;
+    /**
+     * Send a 6-digits code to an email address to validate it.
+     * => when resolved successfully, the email validation infos will switch to the "pending" state.
+     */
+    checkEmail(email: String): Promise<void>;
+    /** Send a 6-digits code to the server to try validating the pending email address. */
+    tryEmailValidation(code: String): Promise<IEmailValidationState>;
+    /** Verify if the logged-in user has a valid phone number. */
+    getMobileValidationInfos(): Promise<IMobileValidationInfos>;
+    /**
+     * Send a 6-digits code to a phone number to validate it.
+     * => when resolved successfully, the phone number infos will switch to the "pending" state.
+     */
+    checkMobile(mobile: String): Promise<void>;
+    /** Send a 6-digits code to the server to try validating the pending phone number. */
+    tryMobileValidation(code: String): Promise<IMobileValidationState>;
+    /** Start an MFA for the logged-in user, unless already pending or done. */
+    getMfaInfos(): Promise<IMfaInfos>;
+    /** Send a 6-digits code to the server to validate a pending MFA. */
+    tryMfaCode(code: String): Promise<IMfaCodeState>;
+}
+export type Hobby = {
+    visibility: 'PRIVE' | 'PUBLIC';
+    category: 'sport' | 'cinema' | 'animals' | 'music' | 'places' | 'books';
+    values: string;
+};
+export type School = {
+    classes: Array<string>;
+    id: string;
+    name: string;
+    UAI: string;
+    exports: string[];
+};
+export type UserProfile = Array<'Student' | 'Teacher' | 'Relative' | 'Personnel' | 'Guest'>;
+export interface IUserDescription {
+    alertSize: boolean;
+    health: string;
+    hobbies: Array<Hobby>;
+    mood: 'default' | 'happy' | 'proud' | 'dreamy' | 'love' | 'tired' | 'angry' | 'worried' | 'sick' | 'joker' | 'sad';
+    motto: string;
+    oldPicture?: string;
+    picture: string;
+    quota: number;
+    storage: number;
+    theme: string;
+    type: string;
+    userid: string;
+    address: string;
+    birthdate: string;
+    displayName: string;
+    email: string;
+    id: string;
+    login: string;
+    mobile: string;
+    photo: string;
+    relatedId?: any;
+    relatedName?: any;
+    relatedType?: any;
+    schools: Array<School>;
+    tel: string;
+    profiles: UserProfile;
+    userId: string;
+    visibleInfos: Array<string>;
+}
+export interface IQuotaAndUsage {
+    /** Maximum use of the storage space. */
+    quota: number;
+    /** Current use of the storage space. */
+    storage: number;
+}
+export interface IUserInfo {
+    apps: Array<IWebApp>;
+    authorizedActions: Array<IWorkflowAuth>;
+    birthDate: string;
+    children: any;
+    childrenIds: Array<string>;
+    classNames: Array<string>;
+    classes: Array<any>;
+    deletePending: boolean;
+    externalId: string;
+    federated?: any;
+    federatedIDP?: any;
+    firstName: string;
+    forceChangePassword?: any;
+    functions: {
+        ADMIN_LOCAL?: {
+            code: string;
+            scope: Array<string>;
+        };
+        SUPER_ADMIN: {
+            code: string;
+            scope: Array<string>;
+        };
+    };
+    groupsIds: Array<string>;
+    hasApp: boolean;
+    hasPw: boolean;
+    lastName: string;
+    level: string;
+    login: string;
+    needRevalidateTerms: any;
+    optionEnabled: Array<any>;
+    preferences?: {
+        save: (pref: any, data: any) => void;
+    };
+    sessionMetadata: {
+        _id: string;
+        userId: string;
+    };
+    structureNames: Array<string>;
+    structures: Array<string>;
+    type: 'ENSEIGNANT' | 'ELEVE' | 'PERSRELELEVE' | 'SUPERADMIN' | 'PERSEDUCNAT';
+    uai: Array<any>;
+    userId: string;
+    username: string;
+    widgets: Array<IWidgetModel>;
+}
+export declare const WIDGET_POSITION: {
+    readonly LEFT: "left";
+    readonly RIGHT: "right";
+};
+export type WidgetPosition = (typeof WIDGET_POSITION)[keyof typeof WIDGET_POSITION];
+export interface IWidgetModel {
+    application?: string;
+    position?: WidgetPosition;
+    i18n: string;
+    id: string;
+    js: string;
+    mandatory: boolean;
+    name: WidgetName;
+    path: string;
+}
+export interface IWebApp {
+    address: string;
+    casType?: string;
+    display: boolean;
+    displayName: string;
+    icon: string;
+    isExternal: boolean;
+    name: string;
+    prefix?: string;
+    scope: Array<string>;
+    target?: any;
+}
+export interface IWorkflowAuth {
+    displayName: string;
+    name: string;
+    type: string;
+}
+export interface IEmailValidationInfos {
+    /** The current email address of the user (maybe not verified) */
+    email: string;
+    /** State of the current email address. */
+    emailState: IEmailValidationState | null;
+    /** Suggested time to wait for the validation mail to be sent (platform configuration) */
+    waitInSeconds: number;
+}
+export interface IEmailValidationState {
+    /** Validation state */
+    state: 'unchecked' | 'outdated' | 'pending' | 'valid';
+    /** Last known valid email address, or empty string. */
+    valid: string;
+    /** (optional) Current pending (or outdated) email address being checked. */
+    pending?: string;
+    /** (optional) Seconds remaining for the user to type in the correct validation code. */
+    ttl?: number;
+    /** (optional) Remaining number of times a validation code can be typed in. */
+    tries?: number;
+}
+export interface IMobileValidationInfos {
+    /** The current phone number of the user (maybe not verified) */
+    mobile: string;
+    /** State of the current phone number. */
+    mobileState: IMobileValidationState | null;
+    /** Suggested time to wait for the validation phone number to be sent (platform configuration) */
+    waitInSeconds: number;
+}
+export interface IMobileValidationState {
+    /** Validation state */
+    state: 'unchecked' | 'outdated' | 'pending' | 'valid';
+    /** Last known valid phone number, or empty string. */
+    valid: string;
+    /** (optional) Current pending (or outdated) phone number being checked. */
+    pending?: string;
+    /** (optional) Seconds remaining for the user to type in the correct validation code. */
+    ttl?: number;
+    /** (optional) Remaining number of times a validation code can be typed in. */
+    tries?: number;
+}
+export interface IMfaInfos {
+    /** The type of MFA used. */
+    type: 'sms' | 'email';
+    /** State of the generated MFA code. */
+    state: IMfaCodeState | null;
+    /** Suggested time to wait for the MFA code to be sent (platform configuration) */
+    waitInSeconds: number;
+}
+export interface IMfaCodeState {
+    /** Validation state */
+    state: 'outdated' | 'pending' | 'valid';
+    /** (optional) Seconds remaining for the user to type in the correct code. */
+    ttl?: number;
+    /** (optional) Remaining number of times a code can be typed in. */
+    tries?: number;
+}
+export interface IGetSession {
+    user?: IUserInfo;
+    currentLanguage?: string;
+    quotaAndUsage: IQuotaAndUsage;
+    userDescription: Partial<IUserDescription>;
+    userProfile?: UserProfile;
+    bookmarkedApps: IWebApp[];
+}
+export type PersonApiResult = {
+    status: 'ok' | string;
+    result: Array<IUserDescription>;
+};

package/dist/share/Service.d.ts

@@ -0,0 +1,18 @@
+import { IOdeServices } from '../services/OdeServices';
+import { GetResourceRightPayload, PutShareResponse, ShareMapping, ShareRight, ShareRightAction, ShareRightActionDisplayName, ShareRightWithVisibles, ShareSubject } from './interface';
+export declare class ShareService {
+    protected context: IOdeServices;
+    constructor(context: IOdeServices);
+    get directory(): import('../directory/Service').DirectoryService;
+    get http(): import('../transport/Service').HttpService;
+    get cache(): import('../cache/Service').CacheService;
+    searchShareSubjects(app: string, resourceId: string, searchText: string): Promise<ShareSubject[]>;
+    getShareMapping(app: string): Promise<ShareMapping>;
+    getActionsAvailableFor({ id, type }: {
+        id: string;
+        type: 'user' | 'group';
+    }, payload: GetResourceRightPayload, mapping: ShareMapping): ShareRightActionDisplayName[];
+    getRightsForResource(app: string, resourceId: string): Promise<ShareRightWithVisibles>;
+    saveRights(app: string, resourceId: string, rights: ShareRight[]): Promise<PutShareResponse>;
+    getActionsForApp(app: string): Promise<ShareRightAction[]>;
+}

package/dist/share/interface.d.ts

@@ -0,0 +1,104 @@
+import { Group, Bookmark, User } from '../directory/interface';
+export interface ShareRight {
+    id: string;
+    type: ShareRightType;
+    displayName: string;
+    profile?: string;
+    avatarUrl: string;
+    directoryUrl: string;
+    actions: ShareRightAction[];
+    isBookmarkMember?: boolean;
+    users?: User[];
+    groups?: Group[];
+}
+export interface ShareParameters {
+    id: string;
+    rights: ShareRight[];
+}
+/**
+ * Type of share right
+ * */
+export type ShareRightType = 'user' | 'group' | 'sharebookmark';
+/**
+ * Type of action when sharing
+ * */
+export interface ShareRightAction {
+    id: ShareRightActionDisplayName;
+    displayName: ShareRightActionDisplayName;
+    priority?: number;
+    requires?: ShareRightActionDisplayName[];
+}
+/**
+ * Name of current action when sharing
+ * */
+export type ShareRightActionDisplayName = 'read' | 'contrib' | 'manage' | 'publish' | 'manager' | 'comment';
+export type ShareRightActionDisplayNameExt = ShareRightActionDisplayName | 'creator';
+export type SharingRight = Record<ShareRightActionDisplayName, {
+    priority: number;
+    default: boolean;
+    requires: ShareRightActionDisplayName[];
+}>;
+export type ShareMapping = Record<ShareRightActionDisplayName, string[]>;
+/**
+ * Payload of shared resource
+ * */
+export interface GetResourceRightPayload {
+    actions: Array<{
+        name: string[];
+        displayName: string;
+        type: 'RESOURCE';
+    }>;
+    groups: {
+        visibles: Array<{
+            id: string;
+            name: string;
+            groupDisplayName: string;
+            structureName: string;
+        }>;
+        checked: Record<string, string[]>;
+    };
+    users: {
+        visibles: Array<{
+            id: string;
+            login: string;
+            username: string;
+            lastName: string;
+            firstName: string;
+            profile: string;
+        }>;
+        checked: Record<string, string[]>;
+    };
+}
+/**
+ * Update payload of shared resource
+ * */
+export interface PutSharePayload {
+    users: Record<string, string[]>;
+    groups: Record<string, string[]>;
+    bookmarks: Record<string, string[]>;
+}
+/**
+ * Response of shared resource
+ * */
+export interface PutShareResponse {
+    'notify-timeline-array': Array<{
+        groupId: string;
+    } | {
+        userId: string;
+    }>;
+}
+export interface ShareSubject {
+    id: string;
+    displayName: string;
+    profile?: string;
+    avatarUrl: string;
+    directoryUrl: string;
+    type: 'user' | 'group' | 'sharebookmark';
+    structureName?: string;
+}
+export interface ShareRightWithVisibles {
+    rights: ShareRight[];
+    visibleUsers: User[];
+    visibleGroups: Group[];
+    visibleBookmarks: Bookmark[];
+}

package/dist/transport/Framework.d.ts

@@ -0,0 +1,9 @@
+import { IHttp, ITransportFramework } from './interfaces';
+declare class TransportFramework implements ITransportFramework {
+    private _http;
+    get http(): IHttp;
+    newHttpInstance(params?: any): IHttp;
+}
+/** The whole framework is a singleton. */
+export declare const transport: TransportFramework;
+export {};

package/dist/transport/Http.d.ts

@@ -0,0 +1,26 @@
+import { IHttp, IHttpParams, IHttpResponse } from './interfaces';
+export declare class Http implements IHttp {
+    private axios;
+    private _latestResponse;
+    constructor(params?: any);
+    setCdn(cdnUrl: string): void;
+    private toAxiosConfig;
+    private toCdnUrl;
+    private mapAxiosError;
+    private mapAxiosResponse;
+    get latestResponse(): IHttpResponse;
+    isResponseError(): boolean;
+    get<R = any>(url: string, params?: IHttpParams): Promise<R>;
+    post<R = any>(url: string, data?: any, params?: IHttpParams): Promise<R>;
+    postFile<R = any>(url: string, data: any, params?: IHttpParams): Promise<R>;
+    postJson<R = any>(url: string, json: any, params?: IHttpParams): Promise<R>;
+    put<R = any>(url: string, data?: any, params?: IHttpParams): Promise<R>;
+    putJson<R = any>(url: string, json: any, params?: IHttpParams): Promise<R>;
+    delete<R = any>(url: string, params?: IHttpParams): Promise<R>;
+    deleteJson<R = any>(url: string, json: any): Promise<R>;
+    getScript<R = any>(url: string, params?: IHttpParams, variableName?: string): Promise<R>;
+    loadScript(url: string, params?: IHttpParams): Promise<void>;
+}
+/**
+ * Promisified HTTP
+ */

package/dist/transport/Service.d.ts

@@ -0,0 +1,31 @@
+import { IOdeServices } from '../services/OdeServices';
+import { IHttp, IHttpParams, IHttpResponse } from './interfaces';
+export declare class HttpService implements IHttp {
+    private context;
+    private axios;
+    private baseUrl?;
+    private headers;
+    private _latestResponse;
+    constructor(context: IOdeServices, params?: any);
+    private fixBaseUrl;
+    useBaseUrl(baseUrl?: string): this;
+    useHeaders(headers: Record<string, string>): this;
+    setCdn(cdnUrl: string): void;
+    private toAxiosConfig;
+    private toCdnUrl;
+    private mapAxiosError;
+    private mapAxiosResponse;
+    get latestResponse(): IHttpResponse;
+    isResponseError(): boolean;
+    get<R = any>(url: string, params?: IHttpParams): Promise<R>;
+    post<R = any>(url: string, data?: any, params?: IHttpParams): Promise<R>;
+    postFile<R = any>(url: string, data: any, params?: IHttpParams): Promise<R>;
+    postJson<R = any>(url: string, json: any, params?: IHttpParams): Promise<R>;
+    put<R = any>(url: string, data?: any, params?: IHttpParams): Promise<R>;
+    putFile<R = any>(url: string, data: FormData, params?: IHttpParams): Promise<any>;
+    putJson<R = any>(url: string, json: any, params?: IHttpParams): Promise<R>;
+    delete<R = any>(url: string, params?: IHttpParams): Promise<R>;
+    deleteJson<R = any>(url: string, json: any): Promise<R>;
+    getScript<R = any>(url: string, params?: IHttpParams, variableName?: string): Promise<R>;
+    loadScript(url: string, params?: IHttpParams): Promise<void>;
+}

package/dist/transport/interfaces.d.ts

@@ -0,0 +1,70 @@
+export declare abstract class TransportFrameworkFactory {
+    static instance(): ITransportFramework;
+}
+export interface ITransportFramework {
+    /** Default instance. */
+    readonly http: IHttp;
+    /**
+     * Creates a new IHttp object with a custom configuration;
+     * @param params see available options at https://axios-http.com/docs/req_config
+     */
+    newHttpInstance(params?: any): IHttp;
+}
+export interface IHttp {
+    /** Latest available HTTP response, valid during your get|post|put...then() and catch() handlers. */
+    readonly latestResponse: IHttpResponse;
+    /** Check if HTTP status of latestResponse is <200 or >=300 */
+    isResponseError(): boolean;
+    /** HTTP GET Accept: application/json */
+    get<R = any>(url: string, params?: IHttpParams): Promise<R>;
+    /** HTTP POST, Accept: application/json */
+    post<R = any>(url: string, data?: any, params?: IHttpParams): Promise<R>;
+    /**
+     * HTTP POST
+     * @param data must be of one of the following types:
+     * string, plain object, ArrayBuffer, ArrayBufferView, URLSearchParams
+     * Browser only: FormData, File, Blob
+     * Node only: Stream, Buffer
+     */
+    postFile<R = any>(url: string, data: any, params?: IHttpParams): Promise<R>;
+    /** HTTP POST, Accept: application/json, Content-type: application/json */
+    postJson<T = any, R = any>(url: string, json: any, params?: IHttpParams): Promise<R>;
+    /** HTTP PUT, Accept: application/json */
+    put<T = any, R = any>(url: string, data?: any, params?: IHttpParams): Promise<R>;
+    /** HTTP PUT, Accept: application/json, Content-type: application/json */
+    putJson<T = any, R = any>(url: string, json: any, params?: IHttpParams): Promise<R>;
+    /** HTTP DELETE */
+    delete<T = any, R = any>(url: string, params?: IHttpParams): Promise<R>;
+    /** HTTP DELETE, Accept: application/json */
+    deleteJson<T = any, R = any>(url: string, json: any): Promise<R>;
+    /**
+     * HTTP GET, Accept: application/javascript
+     * @param exportedVariableName: unused at the moment.
+     */
+    getScript<R = any>(url: string, params?: IHttpParams, exportedVariableName?: string): Promise<R>;
+    /** HTTP GET, Accept: application/javascript */
+    loadScript(url: string, params?: IHttpParams): Promise<void>;
+    setCdn(url: string): void;
+}
+export type IHttpParamsResponseType = 'arraybuffer' | 'blob' | 'document' | 'json' | 'text' | 'stream';
+export type IHttpParams = {
+    /** Request the API to send a notification when done. */
+    readonly requestName?: string;
+    /** Set to true to prevent sending notifications. */
+    readonly disableNotifications?: boolean;
+    /** HTTP headers to apply to the request. */
+    readonly headers?: {
+        [key: string]: string;
+    };
+    /** Object to serialize as query parameters and append to the request URL. */
+    readonly queryParams?: {
+        [key: string]: any;
+    };
+    /** Response Type */
+    readonly responseType?: IHttpParamsResponseType;
+};
+export type IHttpResponse = {
+    status: number;
+    statusText: string;
+    headers?: any;
+};

package/dist/utilities/DocumentHelper.d.ts

@@ -0,0 +1,27 @@
+import { WorkspaceElement } from '../services';
+export type RoleMapperParams = {
+    type: string;
+    previewRole: boolean;
+    extension?: string;
+};
+declare const defaultMappers: {
+    readonly csv: ({ type, extension }: RoleMapperParams) => boolean;
+    readonly doc: ({ type, extension }: RoleMapperParams) => boolean;
+    readonly xls: ({ type, extension }: RoleMapperParams) => boolean;
+    readonly img: ({ type }: RoleMapperParams) => boolean;
+    readonly pdf: ({ type }: RoleMapperParams) => boolean;
+    readonly ppt: ({ type, extension }: RoleMapperParams) => boolean;
+    readonly txt: ({ type, extension }: RoleMapperParams) => boolean;
+    readonly md: ({ type, extension }: RoleMapperParams) => boolean;
+    readonly video: ({ type }: RoleMapperParams) => boolean;
+    readonly audio: ({ type }: RoleMapperParams) => boolean;
+    readonly zip: ({ type }: RoleMapperParams) => boolean;
+};
+export type Role = keyof typeof defaultMappers;
+export type RoleMapper = (params: RoleMapperParams) => Role | undefined;
+export declare abstract class DocumentHelper {
+    private static roleMappers;
+    static getRole(doc: WorkspaceElement): Role | 'unknown';
+    static role(contentType: string | undefined, previewRole?: boolean, extension?: string): Role | 'unknown';
+}
+export {};

package/dist/utilities/StringUtils.d.ts

@@ -0,0 +1,3 @@
+export declare class StringUtils {
+    static removeAccents(str: string): string;
+}

package/dist/utilities/index.d.ts

@@ -0,0 +1,3 @@
+export * from './DocumentHelper';
+export * from './isActionAvailable';
+export * from './StringUtils';

package/dist/utilities/isActionAvailable.d.ts

@@ -0,0 +1,2 @@
+import { IAction } from '../services';
+export declare const isActionAvailable: (workflow: string, actions: IAction[] | undefined) => boolean | undefined;

package/dist/video/Service.d.ts

@@ -0,0 +1,21 @@
+import { IOdeServices } from '../services/OdeServices';
+import { VideoConf, VideoUploadParams, VideoUploadResponse } from './interface';
+export declare class VideoService {
+    private context;
+    private static MAX_WEIGHT;
+    private static MAX_DURATION;
+    constructor(context: IOdeServices);
+    private get http();
+    private get conf();
+    /**
+     * Returns the video app public conf (maxWeight, maxDuration and accepted extensions)
+     * @returns the Video app public conf
+     */
+    getVideoConf(): Promise<VideoConf>;
+    /**
+     * Starts the encoding process and check when video is fully processed.
+     * @param params cf VideoUploadParams
+     * @returns a VideoCheckResponse
+     */
+    upload({ data, appCode, captation, duration, }: VideoUploadParams): Promise<VideoUploadResponse>;
+}

package/dist/video/interface.d.ts

@@ -0,0 +1,42 @@
+export type VideoEncodeResponse = {
+    /** encoding process id, useful for check API */
+    processid: string;
+    /** encoding API state */
+    state: 'running' | 'succeed' | 'error';
+};
+export type VideoUploadParams = {
+    data: {
+        device: string | undefined;
+        browser: {
+            name: string | undefined;
+            version: string | undefined;
+        };
+        url: string;
+        file: Blob;
+        filename: string;
+        weight: number;
+    };
+    appCode: string;
+    captation: boolean;
+    duration: number;
+};
+export type VideoUploadResponse = VideoEncodeResponse & {
+    /** ID of the video file. */
+    videoid?: string;
+    /** size of the encoded video, in bytes. */
+    videosize?: number;
+    /** ID of the video document in Workspace. */
+    videoworkspaceid?: string;
+    /** Error code (i18n key), when state==="error" */
+    code?: string;
+};
+export type VideoPublicConfResponse = {
+    'accept-videoupload-extensions': Array<string>;
+    'max-videoduration-minutes': number;
+    'max-videosize-mbytes': number;
+};
+export type VideoConf = {
+    acceptVideoUploadExtensions: Array<string>;
+    maxDuration: number;
+    maxWeight: number;
+};

package/dist/widget/Framework.d.ts

@@ -0,0 +1,31 @@
+import { IWidgetFramework, IWidget, WidgetUserPref, WidgetName } from './interfaces';
+import { IWidgetModel, WidgetPosition } from '../session/interfaces';
+export declare class WidgetFramework implements IWidgetFramework {
+    private _initialized?;
+    private _widgets;
+    initialize(version: string | null, cdnDomain: string | null): Promise<void>;
+    get list(): Widget[];
+    lookup(widgetName: string): IWidget | undefined;
+    lookupDefaultPosition(widgetName: WidgetName): WidgetPosition | undefined;
+    private _userPrefs;
+    get userPrefs(): IWidgetUserPrefs;
+    private loadUserPrefs;
+    saveUserPrefs(): Promise<void>;
+    private applyUserPrefs;
+}
+declare class Widget implements IWidget {
+    private _platformConf;
+    constructor(_platformConf: IWidgetModel);
+    get platformConf(): IWidgetModel;
+    private _schoolConf;
+    get schoolConf(): {};
+    private _userPref;
+    get userPref(): WidgetUserPref;
+    applyUserPref(pref: WidgetUserPref): void;
+}
+interface IWidgetUserPrefs {
+    [widgetName: string]: WidgetUserPref;
+}
+/** The whole framework is a singleton. */
+export declare const widgets: WidgetFramework;
+export {};