@metarisc/metarisc-js 0.0.1-alpha.24 → 0.0.1-alpha.25

package/README.md

@@ -1,4 +1,3 @@
-
 # Metarisc JS
 
 La librairie Metarisc JS offre un accès simple et pratique à l'API Metarisc à partir d'applications écrites en langage JS. Elle comprend un ensemble de classes et de fonctions pour l'ensemble des ressources de l'API.
@@ -13,20 +12,61 @@ npm i @metarisc/metarisc-js
 
 Pour utiliser la librairie, il suffit de l'importer comme ceci :
 
-```php
-import { Metarisc } from '@metarisc/metarisc-js';';
+```ts
+import { Metarisc } from '@metarisc/metarisc-js';
 ```
 
 ## Utilisation
 
 ### Requêtes
 
-Pour effectuer une requête sur Metarisc, qu'elle soit simple ou paginés (voir la [documentation](http://metarisc.fr/docs/api/#/#pagination)), faites de cette manière :
+Pour effectuer une requête sur Metarisc, il faut tout d'adord initialisé le client metarisc de cette manière :
+
+```ts
+const m = new Metarisc({
+  metarisc_url: "https://api.metarisc.fr",
+  client_id: "CLIENT_ID",
+  client_secret: "CLIENT_SECRET"
+});
+
+m.dossiers.getDossier("123456");
+```
+
+Ensuite vous pouvez faire vos requêtes.
+
+#### Requêtes simple
+
+Pour faire un appel API après initialisation du client, vous pouvez utiliser l'accès rapide à l'API souhaitée.
+
+Exemple :
+
+```ts
+m.dossiers.getDossier("123456");
+```
+
+Le type de retour d'une requête simple est :
+
+```ts
+Promise<AxiosResponse<T>>;
+```
+
+(voir les documentations suivantes [Promise](https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Global_Objects/Promise) et [AxiosResponse](https://axios-http.com/docs/res_schema))
+
+#### Requêtes paginées
+
+Pour récupérer des résultats paginés Metarisc (voir la [documentation](http://metarisc.fr/docs/api/#/#pagination)), il suffit de faire appel à l'api souhaitée de la même manière que pour une requête simple.
 
 Exemple :
 
 ```ts
 const m = new Metarisc(config);
-m.NotificationsAPI.getNotification('123456');
 m.NotificationsAPI.paginateNotifications();
-```
+```
+
+Le type de retour d'une requête paginée est :
+
+```ts
+AsyncGenerator<T>;
+```
+
+(voir la documentation suivante [AsyncGenerator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/AsyncGenerator))

package/lib/api/FeedAPI.d.ts

@@ -7,5 +7,5 @@ export declare class FeedAPI extends Core {
     /**
      * Récupération d'une liste de message composant un flux d'activité pour l'utilisateur connecté.
      */
-    getFeedMessages(): Collection<FeedMessage>;
+    paginateFeedMessages(): Collection<FeedMessage>;
 }

package/lib/api/FeedAPI.js

@@ -13,7 +13,7 @@ class FeedAPI extends core_1.Core {
     /**
      * Récupération d'une liste de message composant un flux d'activité pour l'utilisateur connecté.
      */
-    getFeedMessages() {
+    paginateFeedMessages() {
         const pathVariable = {};
         return this.collect({
             method: 'GET',

package/lib/api/MoiAPI.d.ts

@@ -0,0 +1,11 @@
+import { Core, MetariscConfig } from "../core";
+import type { AxiosResponse } from "axios";
+import { Client } from "../client";
+import { Moi200Response } from '../model/Moi200Response';
+export declare class MoiAPI extends Core {
+    constructor(config: MetariscConfig, client?: Client);
+    /**
+     * Récupérer les détails de l'utilisateur connecté.
+     */
+    moi(): Promise<AxiosResponse<Moi200Response>>;
+}

package/lib/api/MoiAPI.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MoiAPI = void 0;
+const core_1 = require("../core");
+const utils_1 = __importDefault(require("../utils"));
+class MoiAPI extends core_1.Core {
+    constructor(config, client) {
+        super(config, client);
+    }
+    /**
+     * Récupérer les détails de l'utilisateur connecté.
+     */
+    async moi() {
+        const pathVariable = {};
+        return this.request({
+            method: 'GET',
+            endpoint: utils_1.default.constructPath(pathVariable, '/@moi'),
+            headers: {},
+            params: {},
+            body: {}
+        });
+    }
+}
+exports.MoiAPI = MoiAPI;

package/lib/api/SupportAPI.js

@@ -35,7 +35,7 @@ class SupportAPI extends core_1.Core {
             method: 'GET',
             endpoint: utils_1.default.constructPath(pathVariable, '/support/'),
             headers: {},
-            params: { 'page': page.toString(), 'per_page': perPage.toString() },
+            params: { 'page': page?.toString(), 'per_page': perPage?.toString() },
             body: {}
         });
     }

package/lib/api/UtilisateursAPI.d.ts

@@ -6,6 +6,11 @@ import { Utilisateur } from '../model/Utilisateur';
 import { Email } from '../model/Email';
 export declare class UtilisateursAPI extends Core {
     constructor(config: MetariscConfig, client?: Client);
+    /**
+     * Retourne un utilisateur Metarisc.
+     * @param utilisateurId
+     */
+    getUtilisateurDetails(utilisateurId: string): Promise<AxiosResponse<Utilisateur>>;
     /**
      * L'utilisateur connecté retourné par ce point de terminaison utilise le token d'accès généré par le service OpenID Connect afin de le lier à une identité connue de Metarisc. Si l'utilisateur est inconnu une erreur est retournée.
      */
@@ -16,4 +21,9 @@ export declare class UtilisateursAPI extends Core {
      * @param perPage Nombre de résultats demandé
      */
     paginateMoiEmails(page?: number, perPage?: number): Collection<Email>;
+    /**
+     * Retourne une liste des adresses mail publiques d'un utilisateur.
+     * @param utilisateurId
+     */
+    paginateUtilisateurEmails(utilisateurId: string): Collection<Email>;
 }

package/lib/api/UtilisateursAPI.js

@@ -10,6 +10,20 @@ class UtilisateursAPI extends core_1.Core {
     constructor(config, client) {
         super(config, client);
     }
+    /**
+     * Retourne un utilisateur Metarisc.
+     * @param utilisateurId
+     */
+    async getUtilisateurDetails(utilisateurId) {
+        const pathVariable = { 'utilisateur_id': utilisateurId };
+        return this.request({
+            method: 'GET',
+            endpoint: utils_1.default.constructPath(pathVariable, '/utilisateurs/{utilisateur_id}'),
+            headers: {},
+            params: {},
+            body: {}
+        });
+    }
     /**
      * L'utilisateur connecté retourné par ce point de terminaison utilise le token d'accès généré par le service OpenID Connect afin de le lier à une identité connue de Metarisc. Si l'utilisateur est inconnu une erreur est retournée.
      */
@@ -38,5 +52,19 @@ class UtilisateursAPI extends core_1.Core {
             body: {}
         });
     }
+    /**
+     * Retourne une liste des adresses mail publiques d'un utilisateur.
+     * @param utilisateurId
+     */
+    paginateUtilisateurEmails(utilisateurId) {
+        const pathVariable = { 'utilisateur_id': utilisateurId };
+        return this.collect({
+            method: 'GET',
+            endpoint: utils_1.default.constructPath(pathVariable, '/utilisateurs/{utilisateur_id}/emails'),
+            headers: {},
+            params: {},
+            body: {}
+        });
+    }
 }
 exports.UtilisateursAPI = UtilisateursAPI;

package/lib/auth/oauth2.d.ts

@@ -1,19 +1,57 @@
-import { OAuth2Options } from "../core";
+export interface OAuth2Options {
+    client_id?: string;
+    client_secret?: string;
+    response_type?: string;
+    redirect_uri?: string;
+    state?: string;
+    code?: string;
+    scope?: string;
+    [name: string]: string;
+}
+export interface GrantResponse {
+    access_token?: string;
+    expires_in?: number;
+    id_token?: string;
+    refresh_token?: string;
+    refresh_expires_in?: number;
+    session_state?: string;
+    token_type?: string;
+    error?: string;
+    error_description?: string;
+}
+export interface RefreshResponse {
+    access_token: string;
+    token_type: string;
+    expires_in?: number;
+    refresh_token?: string;
+    scope?: string;
+}
 export declare class OAuth2 {
     static AUTHORIZATION_URL: string;
     static ACCESS_TOKEN_URL: string;
+    private options;
     /**
      * Utilisation d'OAuth2 pour récupérer un access token utilisable dans Metarisc.
-     *
-     * La configuration doit contenir au moins :
-     * - CLIENT_ID (Le client_id de l'application inscrite sur Metarisc ID pour communiquer avec Metarisc)
-     * - CLIENT_SECRET (Le client_secret de l'application inscrite sur Metarisc ID pour communiquer avec Metarisc)
-     *
-     * La configuration peut contenir aussi :
-     * - ACCESS_TOKEN_URL
      **/
+    constructor(options: OAuth2Options);
     /**
      * OAuth2 Authorize URL Generator helper.
      */
     static authorizeUrl(options: OAuth2Options): string;
+    /**
+     * OAuth2 Authorize URL Generator helper.
+     */
+    authorizeUrl(): string;
+    /**
+     * Initie le flow Authorization Code https://datatracker.ietf.org/doc/html/rfc6749#section-4.1
+     */
+    getAuthorizationCode(custom?: OAuth2Options): Promise<GrantResponse>;
+    /**
+     * Initie le flow Client Credentials https://datatracker.ietf.org/doc/html/rfc6749#section-4.4
+     */
+    getClientCredentials(custom?: OAuth2Options): Promise<GrantResponse>;
+    /**
+     * Refresh Token (https://datatracker.ietf.org/doc/html/rfc6749#section-1.5)
+     */
+    refreshToken(refresh_token: string, custom?: OAuth2Options): Promise<RefreshResponse>;
 }

package/lib/auth/oauth2.js

@@ -1,25 +1,56 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OAuth2 = void 0;
+const axios_1 = __importDefault(require("axios"));
+const axios_oauth_client_1 = __importDefault(require("axios-oauth-client"));
 class OAuth2 {
     /**
      * Utilisation d'OAuth2 pour récupérer un access token utilisable dans Metarisc.
-     *
-     * La configuration doit contenir au moins :
-     * - CLIENT_ID (Le client_id de l'application inscrite sur Metarisc ID pour communiquer avec Metarisc)
-     * - CLIENT_SECRET (Le client_secret de l'application inscrite sur Metarisc ID pour communiquer avec Metarisc)
-     *
-     * La configuration peut contenir aussi :
-     * - ACCESS_TOKEN_URL
      **/
+    constructor(options) {
+        this.options = options;
+    }
     /**
      * OAuth2 Authorize URL Generator helper.
      */
     static authorizeUrl(options) {
-        const params = new URLSearchParams(options);
+        return (new OAuth2(options)).authorizeUrl();
+    }
+    /**
+     * OAuth2 Authorize URL Generator helper.
+     */
+    authorizeUrl() {
+        const params = new URLSearchParams(this.options);
         return OAuth2.AUTHORIZATION_URL + '?' + params.toString();
     }
+    /**
+     * Initie le flow Authorization Code https://datatracker.ietf.org/doc/html/rfc6749#section-4.1
+     */
+    async getAuthorizationCode(custom) {
+        const options = { ...this.options, ...custom };
+        const fn = axios_oauth_client_1.default.authorizationCode(axios_1.default.create(), OAuth2.ACCESS_TOKEN_URL, options.client_id ?? '', options.client_secret ?? '', options.redirect_uri ?? "", options.code ?? "", options.scope ?? "");
+        return await fn(options.code ?? "", options.scope ?? "");
+    }
+    /**
+     * Initie le flow Client Credentials https://datatracker.ietf.org/doc/html/rfc6749#section-4.4
+     */
+    async getClientCredentials(custom) {
+        const options = { ...this.options, ...custom };
+        const fn = axios_oauth_client_1.default.clientCredentials(axios_1.default.create(), OAuth2.ACCESS_TOKEN_URL, options.client_id ?? '', options.client_secret ?? '');
+        return await fn(options.scope ?? "");
+    }
+    /**
+     * Refresh Token (https://datatracker.ietf.org/doc/html/rfc6749#section-1.5)
+     */
+    async refreshToken(refresh_token, custom) {
+        const options = { ...this.options, ...custom };
+        const fn = axios_oauth_client_1.default.refreshToken(axios_1.default.create(), OAuth2.ACCESS_TOKEN_URL, options.client_id ?? '', options.client_secret ?? '');
+        return await fn(refresh_token);
+    }
 }
 exports.OAuth2 = OAuth2;
-OAuth2.AUTHORIZATION_URL = 'https://lemur-17.cloud-iam.com/auth/realms/metariscoidc/protocol/openid-connect/auth';
-OAuth2.ACCESS_TOKEN_URL = 'https://lemur-17.cloud-iam.com/auth/realms/metariscoidc/protocol/openid-connect/token';
+OAuth2.AUTHORIZATION_URL = 'https://id.metarisc.fr/auth/realms/production/protocol/openid-connect/auth';
+OAuth2.ACCESS_TOKEN_URL = 'https://id.metarisc.fr/auth/realms/production/protocol/openid-connect/token';

package/lib/client.d.ts

@@ -1,5 +1,5 @@
 import { AxiosResponse } from "axios";
-import { GrantResponse, MetariscConfig, OAuth2Options } from './core';
+import { MetariscConfig, OAuth2Options } from "./core";
 interface RequestConfig {
     body?: any;
     headers?: {
@@ -17,14 +17,31 @@ export declare enum AuthMethod {
 }
 export declare class Client {
     private axios;
-    private access_token;
+    private oauth2;
+    private access_token?;
+    private refresh_token?;
     constructor(config: MetariscConfig);
-    authenticate(auth_method: AuthMethod, options: OAuth2Options): Promise<GrantResponse>;
+    authenticate(auth_method: AuthMethod, options: OAuth2Options): Promise<void>;
+    /**
+     * Lance une requête (authentifiée si possible) sur l'API Metarisc.
+     */
     request<T>(config: RequestConfig): Promise<AxiosResponse<T>>;
-    getAuthorizationCode(options: OAuth2Options): Promise<GrantResponse>;
-    getClientCredentials(options: OAuth2Options): Promise<GrantResponse>;
+    /**
+     * Définition de l'Access Token
+     */
     setAccessToken(access_token: string): void;
-    getAccessToken(): string;
+    /**
+     * Récupération de l'Access Token
+     */
+    getAccessToken(): string | undefined;
+    /**
+     * Définition du Refresh Token
+     */
+    setRefreshToken(refresh_token: string): void;
+    /**
+     * Récupération du Refresh Token
+     */
+    getRefreshToken(): string | undefined;
     /**
      * Retourne les headers HTTP par défauts devant être présents dans toutes les requêtes Metarisc.
      */

package/lib/client.js

@@ -6,9 +6,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Client = exports.AuthMethod = void 0;
 const axios_1 = __importDefault(require("axios"));
 const axios_retry_1 = __importDefault(require("axios-retry"));
-const axios_oauth_client_1 = __importDefault(require("axios-oauth-client"));
 const oauth2_1 = require("./auth/oauth2");
 const axios_cache_interceptor_1 = require("axios-cache-interceptor");
+const utils_1 = __importDefault(require("./utils"));
 var AuthMethod;
 (function (AuthMethod) {
     AuthMethod[AuthMethod["CLIENT_CREDENTIALS"] = 0] = "CLIENT_CREDENTIALS";
@@ -16,11 +16,17 @@ var AuthMethod;
 })(AuthMethod = exports.AuthMethod || (exports.AuthMethod = {}));
 class Client {
     constructor(config) {
+        // Paramétrage OAuth2
+        this.oauth2 = new oauth2_1.OAuth2({
+            client_id: config.client_id,
+            client_secret: config.client_secret,
+        });
+        // Initialisation du client HTTP
         this.axios = axios_1.default.create({
-            baseURL: config.metarisc_url ?? 'https://api.metarisc.fr/',
-            'headers': {
-                'common': this.getDefaultHeaders()
-            }
+            baseURL: config.metarisc_url ?? "https://api.metarisc.fr/",
+            headers: {
+                common: this.getDefaultHeaders(),
+            },
         });
         // Axios Interceptors
         // Request interceptors are FILO (First In Last Out)
@@ -29,67 +35,97 @@ class Client {
         // When combining axios-cache-interceptors with other interceptors, you may encounter some inconsistences.
         // See : https://github.com/arthurfiorette/axios-cache-interceptor/issues/449#issuecomment-1370327566
         this.axios = (0, axios_cache_interceptor_1.setupCache)(this.axios);
+        // Axios interceptor : Ajoute l'access token à la requête
+        // L'access token peut venir d'un premier authenticate, ou d'un refresh token obtenu au cours des interceptors
+        this.axios.interceptors.request.use((config) => {
+            config.headers["Authorization"] = this.getAccessToken();
+            return config;
+        });
         // Axios interceptor : Retry strategy
         (0, axios_retry_1.default)(this.axios, {
             retries: 3,
-            retryDelay: axios_retry_1.default.exponentialDelay
+            retryDelay: axios_retry_1.default.exponentialDelay,
+        });
+        // Axios interceptor : Refresh Token (https://datatracker.ietf.org/doc/html/rfc6749#section-1.5)
+        this.axios.interceptors.request.use(async (config) => {
+            // Si l'access_token a expiré on demande un échange avec le refresh token obtenu précedemment
+            // Si le refresh ne fonctionne pas, on ne fait rien
+            if (this.getAccessToken() !== undefined && this.getRefreshToken() !== undefined && utils_1.default.tokenExpired(this.getAccessToken())) {
+                try {
+                    const result = await this.oauth2.refreshToken(this.getRefreshToken());
+                    this.setAccessToken(result.token_type + ' ' + result.access_token);
+                    this.setRefreshToken(result.refresh_token);
+                }
+                catch (e) {
+                    //
+                }
+            }
+            return config;
         });
     }
     async authenticate(auth_method, options) {
-        let result;
-        switch (auth_method) {
-            case AuthMethod.AUTHORIZATION_CODE:
-                result = await this.getAuthorizationCode(options);
-                break;
-            case AuthMethod.CLIENT_CREDENTIALS:
-                result = await this.getClientCredentials(options);
-                break;
-            default:
-                return;
+        if (auth_method === AuthMethod.AUTHORIZATION_CODE) {
+            const response = await this.oauth2.getAuthorizationCode(options);
+            this.setAccessToken(response.token_type + " " + response.access_token);
+            this.setRefreshToken(response.refresh_token);
         }
-        if (result) {
-            const token = result.token_type + ' ' + result.access_token;
-            this.setAccessToken(token);
+        else if (auth_method === AuthMethod.CLIENT_CREDENTIALS) {
+            const response = await this.oauth2.getClientCredentials(options);
+            this.setAccessToken(response.token_type + " " + response.access_token);
+        }
+        else {
+            throw new Error("auth_method inconnue");
         }
-        return result;
     }
+    /**
+     * Lance une requête (authentifiée si possible) sur l'API Metarisc.
+     */
     async request(config) {
-        config.headers['Authorization'] = this.getAccessToken();
         return this.axios.request({
-            method: config.method || 'GET',
-            url: config.endpoint || '/',
+            method: config.method || "GET",
+            url: config.endpoint || "/",
             params: config.params,
             data: config.body,
-            headers: config.headers
+            headers: config.headers,
         });
     }
-    async getAuthorizationCode(options) {
-        const fn = axios_oauth_client_1.default.authorizationCode(axios_1.default.create(), oauth2_1.OAuth2.ACCESS_TOKEN_URL, options.client_id ?? '', options.client_secret ?? '', options.redirect_uri ?? '', options.code ?? '', options.scope ?? '');
-        return await fn(options.code ?? '', options.scope ?? '');
-    }
-    async getClientCredentials(options) {
-        const fn = axios_oauth_client_1.default.clientCredentials(axios_1.default.create(), oauth2_1.OAuth2.ACCESS_TOKEN_URL, options.client_id ?? '', options.client_secret ?? '');
-        return await fn(options.scope ?? '');
-    }
+    /**
+     * Définition de l'Access Token
+     */
     setAccessToken(access_token) {
         this.access_token = access_token;
-        this.axios.interceptors.request.use(function (config) {
-            config.headers['Authorization'] = access_token;
-            return config;
-        });
     }
+    /**
+     * Récupération de l'Access Token
+     */
     getAccessToken() {
         return this.access_token;
     }
+    /**
+     * Définition du Refresh Token
+     */
+    setRefreshToken(refresh_token) {
+        this.refresh_token = refresh_token;
+    }
+    /**
+     * Récupération du Refresh Token
+     */
+    getRefreshToken() {
+        return this.refresh_token;
+    }
     /**
      * Retourne les headers HTTP par défauts devant être présents dans toutes les requêtes Metarisc.
      */
     getDefaultHeaders() {
+        const hasBrowserEnv = typeof window !== 'undefined' && typeof document !== 'undefined'; // https://github.com/axios/axios/blob/v1.x/lib/platform/common/utils.js#L1
         const headers = {};
-        // UA Headers
-        headers['User-Agent'] = 'MetariscJs/dev'; // Format User-Agent (https://www.rfc-editor.org/rfc/rfc9110#name-user-agent)
-        headers['Metarisc-User-Agent'] = JSON.stringify({
-            'lang': 'js'
+        // UA Headers (surcharge le UA uniquement sur un env Server car le navigateur considéra cela comme unsafe)
+        if (!hasBrowserEnv) {
+            headers["User-Agent"] = "MetariscJs/dev"; // Format User-Agent (https://www.rfc-editor.org/rfc/rfc9110#name-user-agent)
+        }
+        headers["Metarisc-User-Agent"] = JSON.stringify({
+            lang: "js",
+            version: 'dev'
         });
         return headers;
     }

package/lib/core.d.ts

@@ -14,10 +14,10 @@ interface RequestConfig {
 }
 export interface MetariscConfig {
     metarisc_url?: string;
+    client_id: string;
+    client_secret?: string;
 }
 export interface OAuth2Options {
-    client_id?: string;
-    client_secret?: string;
     response_type?: string;
     redirect_uri?: string;
     state?: string;
@@ -25,24 +25,14 @@ export interface OAuth2Options {
     scope?: string;
     [name: string]: string;
 }
-export interface GrantResponse {
-    access_token?: string;
-    expires_in?: number;
-    id_token?: string;
-    refresh_token?: string;
-    refresh_expires_in?: number;
-    session_state?: string;
-    token_type?: string;
-    error?: string;
-    error_description?: string;
-}
 export declare class Core {
     protected client: Client;
     protected config: MetariscConfig;
     constructor(config: MetariscConfig, client?: Client);
     request<T>(config: RequestConfig): Promise<AxiosResponse<T>>;
     collect<T>(config: RequestConfig): Collection<T>;
-    authenticate(auth_method: AuthMethod, options: OAuth2Options): Promise<GrantResponse>;
+    authenticate(auth_method: AuthMethod, options: OAuth2Options): Promise<void>;
     setAccessToken(access_token: string): void;
+    setRefreshToken(refresh_token: string): void;
 }
 export {};

package/lib/core.js

@@ -13,16 +13,19 @@ class Core {
     }
     collect(config) {
         return new collection_1.Collection(this, {
-            endpoint: config.endpoint || '/',
+            endpoint: config.endpoint || "/",
             params: config.params,
-            headers: config.headers
+            headers: config.headers,
         });
     }
     async authenticate(auth_method, options) {
-        return await this.client.authenticate(auth_method, options);
+        await this.client.authenticate(auth_method, options);
     }
     setAccessToken(access_token) {
         this.client.setAccessToken(access_token);
     }
+    setRefreshToken(refresh_token) {
+        this.client.setRefreshToken(refresh_token);
+    }
 }
 exports.Core = Core;

package/lib/index.d.ts

@@ -1,16 +1,16 @@
 export { Metarisc } from "./metarisc";
 export { OAuth2 } from "./auth/oauth2";
 export { Core } from "./core";
-export { Collection } from "./collection";
-export { PaginationResults, PaginationData } from "./collection";
-export { AuthMethod } from "./client";
-export { Client } from "./client";
+export { Collection, PaginationData, PaginationResults } from "./collection";
+export { AuthMethod, Client } from "./client";
 export { Tus } from "./tus";
 export { DossiersAPI } from './api/DossiersAPI';
 export { EvenementsAPI } from './api/EvenementsAPI';
 export { FeedAPI } from './api/FeedAPI';
+export { MoiAPI } from './api/MoiAPI';
 export { NotificationsAPI } from './api/NotificationsAPI';
 export { OrganisationsAPI } from './api/OrganisationsAPI';
 export { PEIAPI } from './api/PEIAPI';
 export { PingAPI } from './api/PingAPI';
+export { SupportAPI } from './api/SupportAPI';
 export { UtilisateursAPI } from './api/UtilisateursAPI';