ode-ts-client 1.1.4 → 1.2.0-dev-integration.202401121221

package/dist/resources/BlogResourceService.d.ts

@@ -0,0 +1,11 @@
+import { ResourceType } from "..";
+import { BlogUpdate, UpdateResult } from "./interface";
+import { ResourceService } from "./ResourceService";
+export declare class BlogResourceService extends ResourceService {
+    update(parameters: BlogUpdate): Promise<UpdateResult>;
+    getResourceType(): ResourceType;
+    getApplication(): string;
+    getFormUrl(folderId?: string): string;
+    getViewUrl(resourceId: string): string;
+    getPrintUrl(resourceId: string, withComment?: boolean): string;
+}

package/dist/resources/ResourceService.d.ts

@@ -0,0 +1,55 @@
+import { PublishParameters, PublishResult, GetContextParameters, GetContextResult, ISearchResults, CreateFolderParameters, MoveParameters, IActionResult, TrashParameters, CreateFolderResult, UpdateFolderParameters, ID, GetSubFoldersResult, DeleteParameters, ResourceType } from "..";
+import { OdeServices } from "../services/OdeServices";
+import { UpdateParameters, UpdateResult } from "./interface";
+export declare abstract class ResourceService {
+    protected context: OdeServices;
+    private static registry;
+    static register({ application, resourceType, }: {
+        application: string;
+        resourceType: string;
+    }, service: (context: OdeServices) => ResourceService): void;
+    static findService({ application, resourceType, }: {
+        application: string;
+        resourceType: string;
+    }, context: OdeServices): ResourceService;
+    static findMainService({ application }: {
+        application: string;
+    }, context: OdeServices): ResourceService;
+    constructor(context: OdeServices);
+    protected get http(): import("../transport/Service").HttpService;
+    abstract getApplication(): string;
+    abstract getPrintUrl(resourceId: string, withComment?: boolean): string;
+    abstract getViewUrl(resourceId: string): string;
+    abstract getFormUrl(folderId?: string): string;
+    abstract update<T extends UpdateParameters>(parameters: T): Promise<UpdateResult>;
+    abstract getResourceType(): ResourceType;
+    getShareReadUrl(id: string): string;
+    getSaveShareUrl(id: string): string;
+    gotoPrint(resourceId: string, withComment?: boolean): void;
+    gotoView(resourceId: string): void;
+    gotoForm(folderId?: string): void;
+    publish(parameters: PublishParameters): Promise<PublishResult>;
+    /** Create a search context. */
+    createContext(parameters: GetContextParameters): Promise<GetContextResult>;
+    /** Search / paginate within a search context. */
+    searchContext(parameters: GetContextParameters): Promise<ISearchResults>;
+    /** Create a new folder. */
+    createFolder(parameters: CreateFolderParameters): Promise<CreateFolderResult>;
+    /** Update folder. */
+    updateFolder(parameters: UpdateFolderParameters): Promise<CreateFolderResult>;
+    /** Move resources/folders to a folder. */
+    moveToFolder(parameters: MoveParameters): Promise<IActionResult>;
+    /** List subfolders of a parent folder. */
+    listSubfolders(folderId: ID): Promise<GetSubFoldersResult>;
+    /** Delete folders and/or resources. */
+    deleteAll(parameters: DeleteParameters): Promise<IActionResult>;
+    /** Trash folders and/or resources. */
+    trashAll({ resourceType, ...parameters }: Omit<TrashParameters, "trash">): Promise<IActionResult>;
+    /** Trash folders and/or resources. */
+    restoreAll({ resourceType, ...parameters }: Omit<TrashParameters, "trash">): Promise<IActionResult>;
+    protected checkHttpResponse: <R>(result: R) => R;
+    protected getThumbnailPath(thumb: string | Blob | File | undefined): Promise<string | undefined>;
+    private toQueryParams;
+    private createFolderToBodyParams;
+    private moveToBodyParams;
+}

package/dist/resources/interface.d.ts

@@ -0,0 +1,26 @@
+import { IResource } from "..";
+/**
+ * Parameters expected to update resource
+ */
+export interface UpdateParameters {
+    entId: string;
+    trashed: boolean;
+    name: string;
+    thumbnail: string | Blob | File;
+    description: string;
+    public: boolean;
+    slug: string;
+}
+/**
+ * Response when updating resource
+ */
+export interface UpdateResult {
+    entId: string;
+    thumbnail?: string;
+}
+export interface BlogUpdate extends UpdateParameters {
+    "publish-type"?: "RESTRAINT" | "IMMEDIATE";
+}
+export interface BlogResource extends IResource {
+    "publish-type": "RESTRAINT" | "IMMEDIATE";
+}

package/dist/rights/Service.d.ts

@@ -0,0 +1,78 @@
+import { RightStringified } from "../explore/interfaces";
+import { OdeServices } from "../services/OdeServices";
+import { ResourceRight, RightRole } from "./interface";
+export declare class RightService {
+    private context;
+    constructor(context: OdeServices);
+    get session(): import("../session/Service").SessionService;
+    /**
+     * Parse right concat as "$TYPE:$ID:$RIGHT"
+     * $TYPE = user | group | creator
+     * $ID: id of the resource
+     * $RIGHT: read | contrib | manage
+     *
+     * @param right  a concat right
+     * @returns Right parsed
+     */
+    parseResourceRight(right: RightStringified): ResourceRight | undefined;
+    /**
+     * Parse an array of rights concat as "$TYPE:$ID:$RIGHT"
+     * $TYPE = user | group | creator
+     * $ID: id of the resource
+     * $RIGHT: read | contrib | manage
+     *
+     * @param rights  a list of concat rights
+     * @returns Array of Right parsed
+     */
+    parseResourceRights(rights: RightStringified[]): ResourceRight[];
+    /**
+     * Check wether a user has the expected right for a ressource
+     * @param user the userId and groupId concerned by the check
+     * @param expect the expected right to check
+     * @param rights array of Right for the resource
+     * @returns true if has rights
+     */
+    hasResourceRight({ id, groupIds }: {
+        id: string;
+        groupIds: string[];
+    }, expect: RightRole, rights: ResourceRight[] | RightStringified[]): boolean;
+    /**
+     * Check wether the current user have resource right
+     * @param expect the expected right to check
+     * @param rights array of Right for the resource
+     * @returns true if has rights
+     */
+    sessionHasResourceRight(expect: RightRole, rights: ResourceRight[] | RightStringified[]): Promise<boolean>;
+    /**
+     * Check wether the current user have at least one of resource right expected
+     * @param expects array of expected right to check
+     * @param rights array of Right for the resource
+     * @returns true if has rights
+     */
+    sessionHasAtLeastOneResourceRight(expects: RightRole[], rights: ResourceRight[] | RightStringified[]): Promise<boolean>;
+    /**
+     * Check wether the current user has resource right for each right list
+     * @param expect expected right to check
+     * @param rightsArray array of array of Right for multiple resources
+     * @returns true if has rights
+     */
+    sessionHasResourceRightForEachList(expect: RightRole, rightsArray: ResourceRight[][] | RightStringified[][]): Promise<boolean>;
+    /**
+     * Check wether the current user have at least one of resource right for each right list
+     * @param expects array of expected right to check
+     * @param rightsArray array of array of Right for multiple resources
+     * @returns true if has rights
+     */
+    sessionHasAtLeastOneResourceRightForEachList(expects: RightRole[], rightsArray: ResourceRight[][] | RightStringified[][]): Promise<boolean>;
+    hasWorkflowRight(expect: string, right: string[]): boolean;
+    /**
+     * @param expect a workflow right
+     * @returns true if current session has right on it
+     */
+    sessionHasWorkflowRight(expect: string): Promise<boolean>;
+    /**
+     * @param expect a workflow right
+     * @returns a record with right as key and boolean as value if current session has right on it
+     */
+    sessionHasWorkflowRights(expects: string[]): Promise<Record<string, boolean>>;
+}

package/dist/rights/interface.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Identify the type of "user"
+ */
+export declare type RightSubject = "user" | "group" | "creator";
+/**
+ * Identify the role of the right
+ */
+export declare type RightRole = "read" | "contrib" | "manager" | "creator";
+/**
+ * Right of a resource
+ */
+export interface ResourceRight {
+    type: RightSubject;
+    id: string;
+    right: RightRole;
+}

package/dist/services/OdeServices.d.ts

@@ -0,0 +1,48 @@
+import { CacheService } from "../cache/Service";
+import { ConfService } from "../configure/Service";
+import { DirectoryService } from "../directory/Service";
+import { HttpService } from "../transport/Service";
+import { ResourceService } from "../resources/ResourceService";
+import { RightService } from "../rights/Service";
+import { SessionService } from "../session/Service";
+import { ShareService } from "../share/Service";
+import { WorkspaceService } from "../workspace/Service";
+import { IdiomService } from "../idiom/Service";
+import { AnalyticsService } from "../analytics/Service";
+export interface IOdeServices {
+    analytics(): AnalyticsService;
+    cache(): CacheService;
+    conf(): ConfService;
+    directory(): DirectoryService;
+    http(): HttpService;
+    idiom(): IdiomService;
+    resource(application: string, resourceType?: string): ResourceService;
+    rights(): RightService;
+    session(): SessionService;
+    share(): ShareService;
+    workspace(): WorkspaceService;
+}
+export declare class OdeServices implements IOdeServices {
+    private _analytics;
+    private _cache;
+    private _conf;
+    private _directory;
+    private _http;
+    private _idiom;
+    private _rights;
+    private _session;
+    private _share;
+    private _workspace;
+    constructor();
+    analytics(): AnalyticsService;
+    cache(): CacheService;
+    conf(): ConfService;
+    directory(): DirectoryService;
+    http(): HttpService;
+    idiom(): IdiomService;
+    resource(application: string, resourceType?: string): ResourceService;
+    rights(): RightService;
+    session(): SessionService;
+    share(): ShareService;
+    workspace(): WorkspaceService;
+}

package/dist/services/index.d.ts

@@ -0,0 +1,7 @@
+import { IOdeServices } from "./OdeServices";
+export declare const odeServices: IOdeServices;
+export * from "../directory/interface";
+export * from "../resources/interface";
+export * from "../rights/interface";
+export * from "../share/interface";
+export * from "../workspace/interface";

package/dist/{ts/session → session}/Framework.d.ts

@@ -3,7 +3,8 @@ import { Session } from "./Session";
 export declare class SessionFramework implements ISessionFramework {
     session: Session;
     initialize(): Promise<void>;
+    login(email: string, password: string, rememberMe?: boolean, secureLocation?: boolean): Promise<void>;
+    logout(): Promise<void>;
 }
 /** The whole framework is a singleton. */
 export declare const session: SessionFramework;
-//# sourceMappingURL=Framework.d.ts.map

package/dist/session/Service.d.ts

@@ -0,0 +1,32 @@
+import { IGetSession, IQuotaAndUsage, IUserInfo, UserProfile } from "./interfaces";
+import { IOdeServices } from "../services/OdeServices";
+export declare class SessionService {
+    private context;
+    constructor(context: IOdeServices);
+    get http(): import("../transport/Service").HttpService;
+    get cache(): import("../cache/Service").CacheService;
+    /**
+     * Callback to call when user logout
+     */
+    onLogout(): void;
+    /**
+     * Callback to call when session change
+     */
+    onRefreshSession(): void;
+    getSession(): Promise<IGetSession>;
+    login(email: string, password: string, rememberMe?: boolean, secureLocation?: boolean): Promise<void>;
+    logout(): Promise<void>;
+    latestQuotaAndUsage(user: IUserInfo | undefined): Promise<IQuotaAndUsage>;
+    getCurrentLanguage(user: IUserInfo | undefined): Promise<string | undefined>;
+    private loadUserLanguage;
+    private loadDefaultLanguage;
+    getUser(): Promise<IUserInfo | undefined>;
+    hasWorkflow({ workflowName, user, }: {
+        workflowName: string;
+        user: IUserInfo;
+    }): boolean;
+    private loadDescription;
+    private getBookmarks;
+    getUserProfile(options?: any): Promise<UserProfile>;
+    isAdml(): Promise<boolean>;
+}

package/dist/{ts/session → session}/Session.d.ts

@@ -1,10 +1,11 @@
-import { IEmailValidationInfos, IEmailValidationState, IMfaCodeState, IMfaInfos, IMobileValidationInfos, IMobileValidationState, IQuotaAndUsage, ISession, IUserDescription, IUserInfo } from "./interfaces";
+import { IEmailValidationInfos, IEmailValidationState, IMfaCodeState, IMfaInfos, IMobileValidationInfos, IMobileValidationState, IQuotaAndUsage, ISession, IUserDescription, IUserInfo, UserProfile } from "./interfaces";
 import { App } from "../globals";
 export declare class Session implements ISession {
     private _me;
     private _currentLanguage;
     private _notLoggedIn;
     private _description?;
+    private _profile?;
     get currentLanguage(): string;
     get notLoggedIn(): boolean;
     get description(): IUserDescription;
@@ -18,8 +19,10 @@ export declare class Session implements ISession {
     get latestQuotaAndUsage(): Promise<IQuotaAndUsage>;
     private setCurrentLanguage;
     private loadDefaultLanguage;
-    private loadUserLanguage;
     private loadDescription;
+    get profile(): UserProfile;
+    getUserProfile(): Promise<UserProfile>;
+    private loadUserLanguage;
     getEmailValidationInfos(): Promise<IEmailValidationInfos>;
     checkEmail(email: String): Promise<void>;
     tryEmailValidation(code: String): Promise<IEmailValidationState>;
@@ -29,4 +32,3 @@ export declare class Session implements ISession {
     getMfaInfos(): Promise<IMfaInfos>;
     tryMfaCode(code: String): Promise<IMfaCodeState>;
 }
-//# sourceMappingURL=Session.d.ts.map

package/dist/{ts/session → session}/interfaces.d.ts

@@ -4,8 +4,20 @@ 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 ISession {
     /** Language code (2-letters) actually applied. */
@@ -14,6 +26,8 @@ export interface ISession {
     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"
@@ -27,6 +41,8 @@ export interface ISession {
     readonly latestQuotaAndUsage: Promise<IQuotaAndUsage>;
     hasWorkflow(workflowName: string): boolean;
     hasRight(resource: any, right: any): boolean;
+    /** Get User Profile */
+    getUserProfile(): Promise<UserProfile>;
     /** Verify if the logged-in user has a valid email address. */
     getEmailValidationInfos(): Promise<IEmailValidationInfos>;
     /**
@@ -62,11 +78,12 @@ export declare type School = {
     UAI: string;
     exports: string[];
 };
+export declare 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';
+    mood: "default" | "happy" | "proud" | "dreamy" | "love" | "tired" | "angry" | "worried" | "sick" | "joker" | "sad";
     motto: string;
     oldPicture?: string;
     picture: string;
@@ -88,7 +105,7 @@ export interface IUserDescription {
     relatedType?: any;
     schools: Array<School>;
     tel: string;
-    profiles: Array<"Student" | "Teacher" | "Relative" | "Personnel" | "Guest">;
+    profiles: UserProfile;
     userId: string;
     visibleInfos: Array<string>;
 }
@@ -149,7 +166,7 @@ export declare const WIDGET_POSITION: {
     readonly LEFT: "left";
     readonly RIGHT: "right";
 };
-export declare type WidgetPosition = typeof WIDGET_POSITION[keyof typeof WIDGET_POSITION];
+export declare type WidgetPosition = (typeof WIDGET_POSITION)[keyof typeof WIDGET_POSITION];
 export interface IWidgetModel {
     application?: string;
     position?: WidgetPosition;
@@ -233,4 +250,15 @@ export interface IMfaCodeState {
     /** (optional) Remaining number of times a code can be typed in. */
     tries?: number;
 }
-//# sourceMappingURL=interfaces.d.ts.map
+export interface IGetSession {
+    user: IUserInfo | undefined;
+    currentLanguage: string | undefined;
+    quotaAndUsage: IQuotaAndUsage;
+    userDescription: IUserDescription;
+    userProfile?: UserProfile;
+    bookmarkedApps: IWebApp[];
+}
+export declare type PersonApiResult = {
+    status: "ok" | string;
+    result: Array<IUserDescription>;
+};

package/dist/share/Service.d.ts

@@ -0,0 +1,18 @@
+import { OdeServices } from "../services/OdeServices";
+import { GetResourceRightPayload, ShareMapping, ShareRightWithVisibles, PutShareResponse, ShareSubject, ShareRight, ShareRightAction, ShareRightActionDisplayName } from "./interface";
+export declare class ShareService {
+    protected context: OdeServices;
+    constructor(context: OdeServices);
+    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,99 @@
+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[];
+}
+/**
+ * Type of share right
+ * */
+export declare 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 declare type ShareRightActionDisplayName = "read" | "contrib" | "manage" | "publish" | "manager" | "comment";
+export declare type ShareRightActionDisplayNameExt = ShareRightActionDisplayName | "creator";
+export declare type SharingRight = Record<ShareRightActionDisplayName, {
+    priority: number;
+    default: boolean;
+    requires: ShareRightActionDisplayName[];
+}>;
+export declare 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";
+}
+export interface ShareRightWithVisibles {
+    rights: ShareRight[];
+    visibleUsers: User[];
+    visibleGroups: Group[];
+    visibleBookmarks: Bookmark[];
+}

package/dist/{ts/transport → transport}/Framework.d.ts

@@ -7,4 +7,3 @@ declare class TransportFramework implements ITransportFramework {
 /** The whole framework is a singleton. */
 export declare const transport: TransportFramework;
 export {};
-//# sourceMappingURL=Framework.d.ts.map

package/dist/{ts/transport → transport}/Http.d.ts

@@ -23,4 +23,3 @@ export declare class Http implements IHttp {
 /**
  * Promisified HTTP
  */
-//# sourceMappingURL=Http.d.ts.map

package/dist/transport/Service.d.ts

@@ -0,0 +1,25 @@
+import { IHttpResponse, IHttpParams } from "./interfaces";
+import { OdeServices } from "../services/OdeServices";
+export declare class HttpService {
+    private context;
+    private axios;
+    private _latestResponse;
+    constructor(context: OdeServices, params?: any);
+    setCdn(cdnUrl: string): void;
+    private toAxiosConfig;
+    private toCdnUrl;
+    private mapAxiosError;
+    private mapAxiosResponse;
+    get latestResponse(): IHttpResponse;
+    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/{ts/transport → transport}/interfaces.d.ts

@@ -44,6 +44,7 @@ export interface IHttp {
     loadScript(url: string, params?: IHttpParams): Promise<void>;
     setCdn(url: string): void;
 }
+export declare type IHttpParamsResponseType = "arraybuffer" | "blob" | "document" | "json" | "text" | "stream";
 export declare type IHttpParams = {
     /** Request the API to send a notification when done. */
     readonly requestName?: string;
@@ -57,10 +58,11 @@ export declare type IHttpParams = {
     readonly queryParams?: {
         [key: string]: any;
     };
+    /** Response Type */
+    readonly responseType?: IHttpParamsResponseType;
 };
 export declare type IHttpResponse = {
     status: number;
     statusText: string;
     headers?: any;
 };
-//# sourceMappingURL=interfaces.d.ts.map

package/dist/utils/FileTypeUtils.d.ts

@@ -0,0 +1,6 @@
+export declare class FileTypeUtils {
+    private static fileTypes;
+    static registerContentTypeToFileType(mapper: ContentTypeToFileType): void;
+    static getFileType(fileType: string, previewRole?: boolean, extension?: string): string;
+}
+export declare type ContentTypeToFileType = (contentType: string, previewRole: boolean) => string | undefined;

package/dist/utils/MimeTypeUtils.d.ts

@@ -0,0 +1,20 @@
+export declare class MimeTypeUtils {
+    static INSTANCE: MimeTypeUtils;
+    private wordExtensions;
+    private excelExtensions;
+    private pptExtensions;
+    private fileExtensionMap;
+    private csvContentType;
+    private csvExtensions;
+    private txtExtensions;
+    PDF: string;
+    OCTET_STREAM: string;
+    constructor();
+    getContentTypeForExtension(extension: string): string | undefined;
+    getExtensionForContentType(contentType: string): string | null;
+    isWordLike(contentType: string, originalExt?: string): boolean;
+    isExcelLike(contentType: string, originalExt?: string): boolean;
+    isCsvLike(contentType: string, originalExt?: string): boolean;
+    isPowerpointLike(contentType: string, originalExt?: string): boolean;
+    isTxtLike(contentType: string, originalExt?: string): boolean;
+}

package/dist/utils/StringUtils.d.ts

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

package/dist/version.txt

@@ -1 +1 @@
-ode-ts-client=1.1.4 05/04/2023 16:27:50
+ode-ts-client=1.2.0 12/01/2024 12:21:41

package/dist/{ts/widget → widget}/Framework.d.ts

@@ -29,4 +29,3 @@ interface IWidgetUserPrefs {
 /** The whole framework is a singleton. */
 export declare const widgets: WidgetFramework;
 export {};
-//# sourceMappingURL=Framework.d.ts.map

package/dist/{ts/widget → widget}/LastInfos.widget.d.ts

@@ -13,4 +13,3 @@ export declare class LastInfosWidget {
     getMaxResults(): Promise<number>;
     setMaxResults(maxResults: number): Promise<void>;
 }
-//# sourceMappingURL=LastInfos.widget.d.ts.map

package/dist/{ts/widget → widget}/interfaces.d.ts

@@ -18,8 +18,9 @@ export declare const WIDGET_NAME: {
     readonly UNIVERSALIS: "universalis-widget";
     readonly BRIEFME: "briefme-widget";
     readonly SCHOOL: "school-widget";
+    readonly EDUMALIN: "edumalin-widget";
 };
-export declare type WidgetName = typeof WIDGET_NAME[keyof typeof WIDGET_NAME];
+export declare type WidgetName = (typeof WIDGET_NAME)[keyof typeof WIDGET_NAME];
 export declare abstract class WidgetFrameworkFactory {
     static instance(): IWidgetFramework;
 }
@@ -51,4 +52,3 @@ export declare type WidgetUserPref = {
     [pref in WidgetSpecificUserPrefs]?: any;
 };
 export * from "./LastInfos.widget";
-//# sourceMappingURL=interfaces.d.ts.map