@lidia.poet/sdk 0.2.0

package/dist/index.js

@@ -0,0 +1,1524 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AuthorizationService: () => AuthorizationService,
+  CaseParticipationType: () => CaseParticipationType,
+  CaseRole: () => CaseRole,
+  CaseService: () => CaseService,
+  ConversationService: () => ConversationService,
+  ConversationTemplateService: () => ConversationTemplateService,
+  ConversationType: () => ConversationType,
+  DocumentService: () => DocumentService,
+  DocumentSmartAnswerStatus: () => DocumentSmartAnswerStatus,
+  DocumentStatus: () => DocumentStatus,
+  DocumentType: () => DocumentType,
+  DocumentVisibility: () => DocumentVisibility,
+  FavoriteType: () => FavoriteType,
+  FavoritesService: () => FavoritesService,
+  FolderService: () => FolderService,
+  HealthService: () => HealthService,
+  Language: () => Language,
+  LegisratioService: () => LegisratioService,
+  LidiaClient: () => LidiaClient,
+  LidiaError: () => LidiaError,
+  LidiaSDK: () => LidiaSDK,
+  MessageSenderType: () => MessageSenderType,
+  MessageService: () => MessageService,
+  MessageStatus: () => MessageStatus,
+  NetworkError: () => NetworkError,
+  NotificationService: () => NotificationService,
+  OrganizationService: () => OrganizationService,
+  SmartAnswerService: () => SmartAnswerService,
+  TagService: () => TagService,
+  UserRole: () => UserRole,
+  UserService: () => UserService,
+  ValidationError: () => ValidationError,
+  WebSearchService: () => WebSearchService,
+  WorkflowService: () => WorkflowService,
+  buildQueryString: () => buildQueryString
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors/LidiaError.ts
+var LidiaError = class _LidiaError extends Error {
+  constructor(message, code, status, details) {
+    super(message);
+    this.name = "LidiaError";
+    this.code = code;
+    this.status = status;
+    this.details = details;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _LidiaError);
+    }
+  }
+  /**
+   * Check if this is a validation error
+   */
+  isValidationError() {
+    return this.status === 400 && this.code.includes("validation");
+  }
+  /**
+   * Check if this is an authentication error
+   */
+  isAuthError() {
+    return this.status === 401;
+  }
+  /**
+   * Check if this is an authorization error
+   */
+  isForbiddenError() {
+    return this.status === 403;
+  }
+  /**
+   * Check if this is a not found error
+   */
+  isNotFoundError() {
+    return this.status === 404;
+  }
+  /**
+   * Check if this is a server error
+   */
+  isServerError() {
+    return this.status >= 500;
+  }
+  /**
+   * Get a user-friendly error message
+   */
+  getUserMessage() {
+    switch (this.status) {
+      case 400:
+        return "Invalid request. Please check your input.";
+      case 401:
+        return "Authentication required. Please check your API key.";
+      case 403:
+        return "Access denied. You do not have permission to perform this action.";
+      case 404:
+        return "The requested resource was not found.";
+      case 429:
+        return "Too many requests. Please try again later.";
+      case 500:
+        return "Internal server error. Please try again later.";
+      default:
+        return this.message || "An unexpected error occurred.";
+    }
+  }
+};
+
+// src/errors/NetworkError.ts
+var NetworkError = class _NetworkError extends Error {
+  constructor(message, originalError) {
+    super(message);
+    this.name = "NetworkError";
+    this.originalError = originalError;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _NetworkError);
+    }
+  }
+  /**
+   * Check if this is a timeout error
+   */
+  isTimeoutError() {
+    var _a, _b, _c;
+    return ((_a = this.originalError) == null ? void 0 : _a.code) === "ECONNABORTED" || ((_c = (_b = this.originalError) == null ? void 0 : _b.message) == null ? void 0 : _c.includes("timeout"));
+  }
+  /**
+   * Check if this is a connection error
+   */
+  isConnectionError() {
+    var _a, _b, _c;
+    return ((_a = this.originalError) == null ? void 0 : _a.code) === "ECONNREFUSED" || ((_b = this.originalError) == null ? void 0 : _b.code) === "ENOTFOUND" || ((_c = this.originalError) == null ? void 0 : _c.code) === "ECONNRESET";
+  }
+  /**
+   * Get a user-friendly error message
+   */
+  getUserMessage() {
+    if (this.isTimeoutError()) {
+      return "Request timed out. Please check your connection and try again.";
+    }
+    if (this.isConnectionError()) {
+      return "Unable to connect to the server. Please check your internet connection.";
+    }
+    return "Network error occurred. Please check your connection and try again.";
+  }
+};
+
+// src/client/LidiaClient.ts
+var LidiaClient = class {
+  constructor(config) {
+    this.config = {
+      timeout: 3e4,
+      debug: false,
+      retry: {
+        attempts: 3,
+        delay: 1e3,
+        backoff: 2
+      },
+      ...config
+    };
+  }
+  getAuthHeader() {
+    if (this.config.accessToken) {
+      return { Authorization: `Bearer ${this.config.accessToken}` };
+    }
+    return {};
+  }
+  async makeRequest(url, options = {}) {
+    const fullUrl = url.startsWith("http") ? url : `${this.config.baseUrl}${url}`;
+    const headers = {
+      "Content-Type": "application/json",
+      ...this.getAuthHeader(),
+      ...this.config.headers,
+      ...options.headers
+    };
+    if (this.config.debug) {
+      console.log(`[Lidia SDK] ${options.method || "GET"} ${fullUrl}`);
+    }
+    const retryConfig = this.config.retry ?? { attempts: 1, delay: 1e3, backoff: 2 };
+    let lastError;
+    for (let attempt = 0; attempt < retryConfig.attempts; attempt++) {
+      if (attempt > 0) {
+        const waitTime = retryConfig.delay * Math.pow(retryConfig.backoff ?? 2, attempt - 1);
+        await new Promise((resolve) => setTimeout(resolve, waitTime));
+        if (this.config.debug) {
+          console.log(`[Lidia SDK] Retry attempt ${attempt + 1}/${retryConfig.attempts}`);
+        }
+      }
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+      try {
+        const response = await fetch(fullUrl, {
+          ...options,
+          headers,
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        if (this.config.debug) {
+          console.log(`[Lidia SDK] Response: ${response.status}`);
+        }
+        if (!response.ok) {
+          let errorMessage = `HTTP ${response.status}: ${response.statusText}`;
+          let errorCode = String(response.status);
+          let errorDetails;
+          try {
+            const errorData = await response.json();
+            if (errorData["message"]) errorMessage = String(errorData["message"]);
+            if (errorData["error"]) errorCode = String(errorData["error"]);
+            errorDetails = errorData;
+          } catch {
+          }
+          const err = new LidiaError(errorMessage, errorCode, response.status, errorDetails);
+          if (response.status >= 500 || response.status === 429) {
+            lastError = err;
+            continue;
+          }
+          throw err;
+        }
+        if (response.status === 204) {
+          return void 0;
+        }
+        const contentType = response.headers.get("content-type") ?? "";
+        if (contentType.includes("application/json")) {
+          return await response.json();
+        }
+        return await response.text();
+      } catch (error) {
+        clearTimeout(timeoutId);
+        if (error instanceof LidiaError) {
+          throw error;
+        }
+        if (error instanceof Error && error.name === "AbortError") {
+          lastError = new NetworkError("Request timeout");
+          continue;
+        }
+        lastError = new NetworkError("Network error occurred", error);
+        continue;
+      }
+    }
+    if (this.config.debug && lastError) {
+      console.error(`[Lidia SDK] All retry attempts exhausted:`, lastError);
+    }
+    throw lastError;
+  }
+  async get(url, config) {
+    return this.makeRequest(url, { ...config, method: "GET" });
+  }
+  async post(url, data, config) {
+    const requestConfig = { ...config, method: "POST" };
+    if (data !== void 0) {
+      requestConfig.body = JSON.stringify(data);
+    }
+    return this.makeRequest(url, requestConfig);
+  }
+  async put(url, data, config) {
+    const requestConfig = { ...config, method: "PUT" };
+    if (data !== void 0) {
+      requestConfig.body = JSON.stringify(data);
+    }
+    return this.makeRequest(url, requestConfig);
+  }
+  async patch(url, data, config) {
+    const requestConfig = { ...config, method: "PATCH" };
+    if (data !== void 0) {
+      requestConfig.body = JSON.stringify(data);
+    }
+    return this.makeRequest(url, requestConfig);
+  }
+  async delete(url, data, config) {
+    const requestConfig = { ...config, method: "DELETE" };
+    if (data !== void 0) {
+      requestConfig.body = JSON.stringify(data);
+    }
+    return this.makeRequest(url, requestConfig);
+  }
+  /**
+   * Download a blob (for file downloads)
+   */
+  async downloadBlob(url) {
+    const fullUrl = url.startsWith("http") ? url : `${this.config.baseUrl}${url}`;
+    const headers = {
+      ...this.getAuthHeader(),
+      ...this.config.headers
+    };
+    if (this.config.debug) {
+      console.log(`[Lidia SDK] GET ${fullUrl} (blob download)`);
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+    try {
+      const response = await fetch(fullUrl, {
+        method: "GET",
+        headers,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        throw new NetworkError(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      return response.blob();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof NetworkError) throw error;
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new NetworkError("Download timeout");
+      }
+      throw new NetworkError("Download failed", error);
+    }
+  }
+  setAuthTokens(tokens) {
+    this.authTokens = tokens;
+    this.config.accessToken = tokens.accessToken;
+  }
+  getAuthTokens() {
+    return this.authTokens;
+  }
+  clearAuthTokens() {
+    this.authTokens = void 0;
+    delete this.config.accessToken;
+  }
+  isAuthenticated() {
+    return !!(this.authTokens && this.config.accessToken);
+  }
+  updateConfig(newConfig) {
+    this.config = { ...this.config, ...newConfig };
+  }
+};
+
+// src/services/AuthorizationService.ts
+var AuthorizationService = class {
+  // Refresh 5 minutes before expiry
+  constructor(client, config) {
+    this.autoRefreshInterval = null;
+    this.refreshBufferMinutes = 5;
+    var _a, _b;
+    this.client = client;
+    this.config = config;
+    if (!((_a = config.cognito) == null ? void 0 : _a.region) || !((_b = config.cognito) == null ? void 0 : _b.clientId)) {
+      throw new Error("Cognito configuration (region and clientId) is required for authentication");
+    }
+  }
+  /**
+   * Get the Cognito endpoint URL based on the configured region
+   */
+  getCognitoEndpoint() {
+    return `https://cognito-idp.${this.config.cognito.region}.amazonaws.com/`;
+  }
+  /**
+   * Get the Cognito client ID from config
+   */
+  getClientId() {
+    return this.config.cognito.clientId;
+  }
+  /**
+   * Login with email/username and password using AWS Cognito
+   */
+  async login(credentials) {
+    const username = credentials.username || credentials.email;
+    if (!username) {
+      throw new LidiaError("Username or email is required", "INVALID_CREDENTIALS", 400);
+    }
+    try {
+      const response = await fetch(this.getCognitoEndpoint(), {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/x-amz-json-1.1",
+          "X-Amz-Target": "AWSCognitoIdentityProviderService.InitiateAuth"
+        },
+        body: JSON.stringify({
+          AuthParameters: {
+            USERNAME: username,
+            PASSWORD: credentials.password
+          },
+          AuthFlow: "USER_PASSWORD_AUTH",
+          ClientId: this.getClientId()
+        })
+      });
+      if (!response.ok) {
+        const errorData = await response.json();
+        throw new LidiaError(
+          errorData.message || `Login failed with status ${response.status}`,
+          "LOGIN_FAILED",
+          response.status
+        );
+      }
+      const cognitoResponse = await response.json();
+      const authResult = cognitoResponse.AuthenticationResult;
+      const expiresAt = new Date(Date.now() + authResult.ExpiresIn * 1e3);
+      const tokens = {
+        accessToken: authResult.AccessToken,
+        refreshToken: authResult.RefreshToken,
+        tokenType: authResult.TokenType,
+        expiresIn: authResult.ExpiresIn,
+        expiresAt
+      };
+      this.client.setAuthTokens(tokens);
+      this.startAutoRefresh();
+      return tokens;
+    } catch (error) {
+      if (error instanceof LidiaError) {
+        throw error;
+      }
+      throw new LidiaError(`Login failed: ${error.message}`, "LOGIN_ERROR", 500);
+    }
+  }
+  /**
+   * Refresh authentication tokens using AWS Cognito
+   */
+  async refreshTokens() {
+    const currentTokens = this.client.getAuthTokens();
+    if (!currentTokens) {
+      throw new LidiaError("No tokens available to refresh. Please login first.", "NO_TOKENS", 401);
+    }
+    try {
+      const response = await fetch(this.getCognitoEndpoint(), {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/x-amz-json-1.1",
+          "X-Amz-Target": "AWSCognitoIdentityProviderService.InitiateAuth"
+        },
+        body: JSON.stringify({
+          AuthParameters: {
+            REFRESH_TOKEN: currentTokens.refreshToken
+          },
+          AuthFlow: "REFRESH_TOKEN_AUTH",
+          ClientId: this.getClientId()
+        })
+      });
+      if (!response.ok) {
+        const errorData = await response.json();
+        throw new LidiaError(
+          errorData.message || `Token refresh failed with status ${response.status}`,
+          "REFRESH_FAILED",
+          response.status
+        );
+      }
+      const cognitoResponse = await response.json();
+      const authResult = cognitoResponse.AuthenticationResult;
+      const expiresAt = new Date(Date.now() + authResult.ExpiresIn * 1e3);
+      const tokens = {
+        accessToken: authResult.AccessToken,
+        refreshToken: currentTokens.refreshToken,
+        // Keep the original refresh token
+        tokenType: authResult.TokenType,
+        expiresIn: authResult.ExpiresIn,
+        expiresAt
+      };
+      this.client.setAuthTokens(tokens);
+      this.startAutoRefresh();
+      return tokens;
+    } catch (error) {
+      if (error instanceof LidiaError) {
+        throw error;
+      }
+      throw new LidiaError(`Token refresh failed: ${error.message}`, "REFRESH_ERROR", 500);
+    }
+  }
+  /**
+   * Check if the current access token is expired or will expire soon
+   */
+  isTokenExpired(bufferMinutes = 5) {
+    const tokens = this.client.getAuthTokens();
+    if (!tokens) {
+      return true;
+    }
+    const now = /* @__PURE__ */ new Date();
+    const bufferTime = bufferMinutes * 60 * 1e3;
+    const expirationTime = new Date(tokens.expiresAt.getTime() - bufferTime);
+    return now >= expirationTime;
+  }
+  /**
+   * Automatically refresh tokens if they are expired or about to expire
+   */
+  async ensureValidTokens(bufferMinutes = 5) {
+    if (!this.isTokenExpired(bufferMinutes)) {
+      const tokens = this.client.getAuthTokens();
+      if (tokens) {
+        return tokens;
+      }
+    }
+    return await this.refreshTokens();
+  }
+  /**
+   * Logout and clear tokens
+   */
+  logout() {
+    this.stopAutoRefresh();
+    this.client.clearAuthTokens();
+  }
+  /**
+   * Check if user is authenticated
+   */
+  isAuthenticated() {
+    return this.client.isAuthenticated();
+  }
+  /**
+   * Get current authentication tokens
+   */
+  getAuthTokens() {
+    return this.client.getAuthTokens();
+  }
+  /**
+   * Set authentication tokens manually
+   */
+  setAuthTokens(tokens) {
+    this.client.setAuthTokens(tokens);
+  }
+  /**
+   * Get the current access token
+   */
+  getAccessToken() {
+    const tokens = this.client.getAuthTokens();
+    return tokens == null ? void 0 : tokens.accessToken;
+  }
+  /**
+   * Get the current refresh token
+   */
+  getRefreshToken() {
+    const tokens = this.client.getAuthTokens();
+    return tokens == null ? void 0 : tokens.refreshToken;
+  }
+  /**
+   * Check if tokens will expire within the specified time
+   */
+  willExpireWithin(minutes) {
+    const tokens = this.client.getAuthTokens();
+    if (!tokens) {
+      return true;
+    }
+    const now = /* @__PURE__ */ new Date();
+    const expirationTime = new Date(tokens.expiresAt.getTime() - minutes * 60 * 1e3);
+    return now >= expirationTime;
+  }
+  /**
+   * Initialize with username and password, automatically logging in
+   */
+  async initializeWithCredentials(username, password) {
+    return this.login({ email: username, password });
+  }
+  /**
+   * Initialize with existing Bearer token
+   */
+  initializeWithToken(accessToken, expiresIn) {
+    const tokens = {
+      accessToken,
+      refreshToken: "",
+      // No refresh token available
+      tokenType: "Bearer",
+      expiresIn: expiresIn || 3600,
+      expiresAt: new Date(Date.now() + (expiresIn || 3600) * 1e3)
+    };
+    this.client.setAuthTokens(tokens);
+    this.startAutoRefresh();
+  }
+  /**
+   * Start automatic token refresh based on expiration time
+   */
+  startAutoRefresh() {
+    if (this.autoRefreshInterval) {
+      clearTimeout(this.autoRefreshInterval);
+    }
+    const tokens = this.client.getAuthTokens();
+    if (!tokens || !tokens.refreshToken) {
+      return;
+    }
+    const now = /* @__PURE__ */ new Date();
+    const refreshTime = new Date(
+      tokens.expiresAt.getTime() - this.refreshBufferMinutes * 60 * 1e3
+    );
+    const timeUntilRefresh = refreshTime.getTime() - now.getTime();
+    if (timeUntilRefresh <= 0) {
+      this.performAutoRefresh();
+      return;
+    }
+    this.autoRefreshInterval = setTimeout(() => {
+      this.performAutoRefresh();
+    }, timeUntilRefresh);
+  }
+  /**
+   * Perform automatic token refresh
+   */
+  async performAutoRefresh() {
+    try {
+      await this.refreshTokens();
+    } catch (error) {
+      console.warn("[LidiaSDK] Automatic token refresh failed:", error);
+      this.stopAutoRefresh();
+    }
+  }
+  /**
+   * Stop automatic token refresh
+   */
+  stopAutoRefresh() {
+    if (this.autoRefreshInterval) {
+      clearTimeout(this.autoRefreshInterval);
+      this.autoRefreshInterval = null;
+    }
+  }
+  /**
+   * Cleanup resources
+   */
+  destroy() {
+    this.stopAutoRefresh();
+  }
+};
+
+// src/utils/query.ts
+function buildQueryString(params) {
+  const searchParams = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    if (value === void 0 || value === null) continue;
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (item !== void 0 && item !== null) {
+          searchParams.append(key, String(item));
+        }
+      }
+    } else {
+      searchParams.append(key, String(value));
+    }
+  }
+  const qs = searchParams.toString();
+  return qs ? `?${qs}` : "";
+}
+
+// src/services/CaseService.ts
+var CaseService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Get paginated cases */
+  async find(params) {
+    const qs = buildQueryString(params ?? {});
+    return this.client.get(`/cases${qs}`);
+  }
+  /** Create a new case */
+  async create(data) {
+    return this.client.post("/cases", data);
+  }
+  /** Get a case by ID */
+  async findOne(id) {
+    return this.client.get(`/cases/${id}`);
+  }
+  /** Update a case (partial) */
+  async update(id, data) {
+    return this.client.patch(`/cases/${id}`, data);
+  }
+  /** Delete a case */
+  async delete(id) {
+    return this.client.delete(`/cases/${id}`);
+  }
+  /** Get case participations */
+  async getParticipations(id) {
+    return this.client.get(`/cases/${id}/participations`);
+  }
+  /** Replace all case participations */
+  async replaceParticipations(id, participations) {
+    return this.client.put(`/cases/${id}/participations`, participations);
+  }
+  /** Delete a single case participation */
+  async deleteParticipation(id, participationType, participantId) {
+    return this.client.delete(
+      `/cases/${id}/participations/${participationType}/${participantId}`
+    );
+  }
+};
+
+// src/services/ConversationService.ts
+var ConversationService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** List conversations with filtering and pagination */
+  async find(params) {
+    const qs = buildQueryString(params ?? {});
+    return this.client.get(`/conversations${qs}`);
+  }
+  /** Get conversation by ID */
+  async findOne(id) {
+    return this.client.get(`/conversations/${id}`);
+  }
+  /** Create a new conversation */
+  async create(data) {
+    return this.client.post("/conversations", data);
+  }
+  /** Update a conversation */
+  async update(id, data) {
+    return this.client.patch(`/conversations/${id}`, data);
+  }
+  /** Delete a single conversation */
+  async delete(id) {
+    return this.client.delete(`/conversations/${id}`);
+  }
+  /** Bulk delete conversations */
+  async bulkDelete(conversationIds) {
+    return this.client.delete("/conversations", { ids: conversationIds });
+  }
+  /** Delete all messages from a conversation */
+  async clearHistory(id) {
+    return this.client.delete(`/conversations/${id}/messages`);
+  }
+  /** Export a conversation (or multiple messages) */
+  async export(data) {
+    return this.client.post("/conversations/export", data);
+  }
+  /** Download conversation in the selected format */
+  async download(id, exportType) {
+    return this.client.post(`/conversations/${id}/download/${exportType}`);
+  }
+  /** Save conversation as a document in the archive */
+  async saveToArchive(id, data) {
+    return this.client.post(`/conversations/${id}/save`, data);
+  }
+  /** Add conversation to a case */
+  async addToCase(conversationId, caseId) {
+    return this.client.put(`/conversations/${conversationId}/case/${caseId}`);
+  }
+  /** Remove conversation from case */
+  async removeFromCase(conversationId) {
+    return this.client.delete(`/conversations/${conversationId}/case`);
+  }
+  /** Change conversation's workflow */
+  async setWorkflow(conversationId, workflowId) {
+    return this.client.put(`/conversations/${conversationId}/workflow/${workflowId}`);
+  }
+  /** Remove conversation's workflow */
+  async removeWorkflow(conversationId) {
+    return this.client.delete(`/conversations/${conversationId}/workflow`);
+  }
+  /** Report a conversation to admins */
+  async report(id, data) {
+    return this.client.post(`/conversations/${id}/report`, data);
+  }
+  /** Get AgentCore WebSocket URL for word conversation */
+  async getAgentCoreWsUrl(id) {
+    return this.client.get(`/conversations/${id}/agentcore-ws`);
+  }
+  /** Persist word conversation result from AgentCore */
+  async saveWordResult(id, data) {
+    return this.client.post(`/conversations/${id}/word-result`, data);
+  }
+};
+
+// src/services/ConversationTemplateService.ts
+var ConversationTemplateService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** List all conversation templates */
+  async find(params) {
+    const qs = buildQueryString(params ?? {});
+    return this.client.get(`/conversation-templates${qs}`);
+  }
+  /** Get template by ID */
+  async findOne(id) {
+    return this.client.get(`/conversation-templates/${id}`);
+  }
+  /** Create a new template */
+  async create(data) {
+    return this.client.post("/conversation-templates", data);
+  }
+  /** Update a template */
+  async update(id, data) {
+    return this.client.patch(`/conversation-templates/${id}`, data);
+  }
+  /** Delete a template */
+  async delete(id) {
+    return this.client.delete(`/conversation-templates/${id}`);
+  }
+};
+
+// src/services/DocumentService.ts
+var DocumentService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Search documents and folders with pagination */
+  async find(params) {
+    const qs = buildQueryString(params ?? {});
+    return this.client.get(`/documents${qs}`);
+  }
+  /** Get document details by ID */
+  async findOne(id) {
+    return this.client.get(`/documents/${id}`);
+  }
+  /** Create a document (returns upload URL) */
+  async create(data) {
+    return this.client.post("/documents", data);
+  }
+  /** Update a document */
+  async update(id, data) {
+    return this.client.patch(`/documents/${id}`, data);
+  }
+  /** Bulk delete documents and/or folders */
+  async bulkDelete(ids) {
+    return this.client.delete("/documents", { ids });
+  }
+  /** Download a document (returns download URL) */
+  async download(id) {
+    return this.client.get(`/documents/${id}/download`);
+  }
+  /** Get document preview URL */
+  async preview(id) {
+    return this.client.get(`/documents/${id}/preview`);
+  }
+  /** Bulk export documents as zip */
+  async bulkExport(data) {
+    return this.client.post("/documents/export", data);
+  }
+  /** Move documents and/or folders */
+  async move(data) {
+    return this.client.patch("/documents/move", data);
+  }
+  /** Attach multiple documents to multiple cases */
+  async bulkAttachToCases(data) {
+    return this.client.put("/documents/bulk/attachToCases", data);
+  }
+  /** Attach document to a single case */
+  async attachToCase(documentId, caseId) {
+    return this.client.put(`/documents/${documentId}/cases/${caseId}`);
+  }
+  /** Attach document to conversation */
+  async attachToConversation(documentId, conversationId) {
+    return this.client.put(`/documents/${documentId}/conversations/${conversationId}`);
+  }
+  /** Detach document from conversation */
+  async detachFromConversation(documentId, conversationId) {
+    return this.client.delete(`/documents/${documentId}/conversations/${conversationId}`);
+  }
+  /** Copy document reference into a common folder */
+  async copyToCommonFolder(documentId, commonFolderId) {
+    return this.client.post(
+      `/documents/${documentId}/common/${commonFolderId}`
+    );
+  }
+  /** Sync tags to documents */
+  async syncTags(data) {
+    return this.client.put("/documents/tags", data);
+  }
+};
+
+// src/services/FavoritesService.ts
+var FavoritesService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** List all favorites for the authorized user */
+  async find() {
+    return this.client.get("/favorites");
+  }
+  /** Create a single favorite */
+  async create(data) {
+    return this.client.put("/favorites", data);
+  }
+  /** Create multiple favorites */
+  async createBulk(data) {
+    return this.client.put("/favorites/bulk", data);
+  }
+  /** Delete a single favorite by type and ID */
+  async delete(type, id) {
+    return this.client.delete(`/favorites/${type}/${id}`);
+  }
+};
+
+// src/services/FolderService.ts
+var FolderService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Search folders */
+  async find(params) {
+    const qs = buildQueryString(params);
+    return this.client.get(`/folders${qs}`);
+  }
+  /** Get folder with paginated content */
+  async getContent(id, params) {
+    const qs = buildQueryString(params ?? {});
+    return this.client.get(`/folders/${id}${qs}`);
+  }
+  /** Create a new folder */
+  async create(data) {
+    return this.client.post("/folders", data);
+  }
+  /** Update a folder (rename) */
+  async update(id, data) {
+    return this.client.patch(`/folders/${id}`, data);
+  }
+};
+
+// src/services/HealthService.ts
+var HealthService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Check API health */
+  async check() {
+    return this.client.get("/health");
+  }
+};
+
+// src/services/LegisratioService.ts
+var LegisratioService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Get a judgement text from LegisRatio */
+  async getJudgementText(id) {
+    return this.client.get(`/legisratio/judgement-text/${id}`);
+  }
+  /** Get an article text from LegisRatio */
+  async getLawArticleText(lawId, articleId) {
+    return this.client.get(
+      `/legisratio/law/${lawId}/article-text/${articleId}`
+    );
+  }
+};
+
+// src/services/MessageService.ts
+var MessageService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** List messages with pagination */
+  async find(params) {
+    const qs = buildQueryString(params);
+    return this.client.get(`/messages${qs}`);
+  }
+  /** Get message by ID */
+  async findOne(id) {
+    return this.client.get(`/messages/${id}`);
+  }
+  /** Create a new message */
+  async create(data) {
+    return this.client.post("/messages", data);
+  }
+  /** Create a "continue" message */
+  async continueMessage(data) {
+    return this.client.post("/messages/continue", data);
+  }
+  /** Bookmark or mark a message as relevant */
+  async update(id, data) {
+    return this.client.patch(`/messages/${id}`, data);
+  }
+  /** Cancel the processing of a message */
+  async cancel(id) {
+    return this.client.put(`/messages/${id}/cancel`);
+  }
+  /** Get a citation URL for a message */
+  async getCitation(id, citationKey) {
+    return this.client.get(`/messages/${id}/citations/${citationKey}`);
+  }
+  /** Get a URL registry entry for a message */
+  async getUrlRegistry(id, urlRegistryKey) {
+    return this.client.get(`/messages/${id}/url-registry/${urlRegistryKey}`);
+  }
+  /** Export a specific message */
+  async export(id, exportType, exportMedium) {
+    return this.client.post(`/messages/${id}/export/${exportType}/${exportMedium}`);
+  }
+};
+
+// src/services/NotificationService.ts
+var NotificationService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Get the list of own notifications */
+  async find(params) {
+    const qs = buildQueryString(params ?? {});
+    return this.client.get(`/notifications${qs}`);
+  }
+  /** Acknowledge all notifications */
+  async acknowledgeAll() {
+    return this.client.put("/notifications/acknowledge/all");
+  }
+  /** Acknowledge a specific notification */
+  async acknowledge(id) {
+    return this.client.put(`/notifications/acknowledge/${id}`);
+  }
+  /** Create a notification */
+  async create(notificationType, data) {
+    return this.client.post(`/notifications/${notificationType}`, data);
+  }
+};
+
+// src/services/OrganizationService.ts
+var OrganizationService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Get paginated organizations */
+  async find(params) {
+    const qs = buildQueryString(params ?? {});
+    return this.client.get(`/organizations${qs}`);
+  }
+  /** Create a new organization */
+  async create(data) {
+    return this.client.post("/organizations", data);
+  }
+  /** Get an organization by ID */
+  async findOne(id) {
+    return this.client.get(`/organizations/${id}`);
+  }
+  /** Update an organization */
+  async update(id, data) {
+    return this.client.put(`/organizations/${id}`, data);
+  }
+  /** Delete (disable) an organization */
+  async delete(id) {
+    return this.client.delete(`/organizations/${id}`);
+  }
+  /** Assign quotas to an organization */
+  async assignQuotas(id, data) {
+    return this.client.put(`/organizations/${id}/quotas`, data);
+  }
+  /** Unassign quotas from an organization */
+  async unassignQuotas(id) {
+    return this.client.delete(`/organizations/${id}/quotas`);
+  }
+  /** Assign workflows to an organization */
+  async assignWorkflows(id, data) {
+    return this.client.put(`/organizations/${id}/workflows`, data);
+  }
+};
+
+// src/services/SmartAnswerService.ts
+var SmartAnswerService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Create a new smart answer session */
+  async create(data) {
+    return this.client.post("/smart-answers", data);
+  }
+  /** Get smart answer by ID (with full details) */
+  async findOne(id) {
+    return this.client.get(`/smart-answers/${id}`);
+  }
+  /** Update (rename) a smart answer */
+  async update(id, data) {
+    return this.client.patch(`/smart-answers/${id}`, data);
+  }
+};
+
+// src/services/TagService.ts
+var TagService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** List all tags */
+  async find() {
+    return this.client.get("/tags");
+  }
+  /** Create a new tag */
+  async create(name) {
+    return this.client.post("/tags", { name });
+  }
+  /** Delete a tag */
+  async delete(id) {
+    return this.client.delete(`/tags/${id}`);
+  }
+};
+
+// src/services/UserService.ts
+var UserService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Get paginated users */
+  async find(params) {
+    const qs = buildQueryString(params ?? {});
+    return this.client.get(`/users${qs}`);
+  }
+  /** Create a new user */
+  async create(data) {
+    return this.client.post("/users", data);
+  }
+  /** Get a user by ID */
+  async findOne(id) {
+    return this.client.get(`/users/${id}`);
+  }
+  /** Update a user */
+  async update(id, data) {
+    return this.client.put(`/users/${id}`, data);
+  }
+  /** Delete (disable) a user */
+  async delete(id) {
+    return this.client.delete(`/users/${id}`);
+  }
+  /** Get current authenticated user profile */
+  async me() {
+    return this.client.get("/users/me");
+  }
+  /** Resend invitation email to a user */
+  async resendInvitation(id) {
+    return this.client.post(`/users/${id}/resend-invitation`);
+  }
+};
+
+// src/services/WebSearchService.ts
+var WebSearchService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Create a new web search */
+  async create(data) {
+    return this.client.post("/web-searches", data);
+  }
+  /** Retrieve a specific web search */
+  async findOne(id) {
+    return this.client.get(`/web-searches/${id}`);
+  }
+  /** Update an existing web search */
+  async update(id, data) {
+    return this.client.patch(`/web-searches/${id}`, data);
+  }
+};
+
+// src/services/WorkflowService.ts
+var WorkflowService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Get paginated workflows */
+  async find(params) {
+    const qs = buildQueryString(params ?? {});
+    return this.client.get(`/workflows${qs}`);
+  }
+  /** Create a new workflow */
+  async create(data) {
+    return this.client.post("/workflows", data);
+  }
+  /** Get a workflow by ID (editing view) */
+  async findOne(id) {
+    return this.client.get(`/workflows/${id}`);
+  }
+  /** Update a workflow */
+  async update(id, data) {
+    return this.client.put(`/workflows/${id}`, data);
+  }
+  /** Delete a workflow */
+  async delete(id) {
+    return this.client.delete(`/workflows/${id}`);
+  }
+  /** Get workflow description (for conversation sidebar) */
+  async getDescription(id) {
+    return this.client.get(`/workflows/${id}/description`);
+  }
+  /** List workflow categories */
+  async getCategories() {
+    return this.client.get("/workflows/categories");
+  }
+};
+
+// src/utils/env.ts
+var ENVIRONMENT_PRESETS = {
+  ["Production" /* PRODUCTION */]: {
+    baseUrl: "https://api.lidiatech.ai",
+    region: "eu-central-1",
+    clientId: "10lnfbvtu9lrg1ujeemf2uk0sa"
+  },
+  ["Development" /* DEVELOPMENT */]: {
+    baseUrl: "https://api.dev.lidiatech.ai",
+    region: "eu-west-1",
+    clientId: "4uep6n7bmk8o1b7hs7e5ts7u9"
+  },
+  ["Staging" /* STAGING */]: {
+    baseUrl: "https://api.staging.lidiatech.ai",
+    region: "eu-west-1",
+    clientId: "5og664h80v1tv1md0fsgtmln2u"
+  }
+};
+function getEnvironmentPreset(env) {
+  return ENVIRONMENT_PRESETS[env];
+}
+function parseLidiaEnv(value) {
+  if (!value) return "Production" /* PRODUCTION */;
+  const normalized = value.trim().toLowerCase();
+  switch (normalized) {
+    case "development":
+    case "dev":
+      return "Development" /* DEVELOPMENT */;
+    case "staging":
+    case "stg":
+      return "Staging" /* STAGING */;
+    case "production":
+    case "prod":
+    default:
+      return "Production" /* PRODUCTION */;
+  }
+}
+function getBaseUrlFromEnv() {
+  return process.env["LIDIA_BASE_URL"];
+}
+function isNodeEnvironment() {
+  return typeof process !== "undefined" && process.env !== void 0;
+}
+
+// src/LidiaSDK.ts
+var LidiaSDK = class {
+  constructor(config) {
+    const mergedConfig = this.mergeConfigWithEnv(config);
+    this.client = new LidiaClient(mergedConfig);
+    this.cases = new CaseService(this.client);
+    this.conversations = new ConversationService(this.client);
+    this.conversationTemplates = new ConversationTemplateService(this.client);
+    this.documents = new DocumentService(this.client);
+    this.favorites = new FavoritesService(this.client);
+    this.folders = new FolderService(this.client);
+    this.health = new HealthService(this.client);
+    this.legisratio = new LegisratioService(this.client);
+    this.messages = new MessageService(this.client);
+    this.notifications = new NotificationService(this.client);
+    this.organizations = new OrganizationService(this.client);
+    this.smartAnswers = new SmartAnswerService(this.client);
+    this.tags = new TagService(this.client);
+    this.users = new UserService(this.client);
+    this.webSearches = new WebSearchService(this.client);
+    this.workflows = new WorkflowService(this.client);
+    if (this.shouldInitializeAuth(mergedConfig)) {
+      this.auth = new AuthorizationService(this.client, mergedConfig);
+      this.authInitPromise = this.initializeAuthentication(mergedConfig).catch((error) => {
+        console.warn("[LidiaSDK] Authentication initialization failed:", error);
+      });
+    }
+  }
+  shouldInitializeAuth(config) {
+    var _a, _b;
+    return !!(((_a = config.cognito) == null ? void 0 : _a.region) && ((_b = config.cognito) == null ? void 0 : _b.clientId));
+  }
+  mergeConfigWithEnv(config) {
+    var _a, _b, _c, _d;
+    const mergedConfig = { ...config };
+    if (!mergedConfig.environment && isNodeEnvironment()) {
+      mergedConfig.environment = parseLidiaEnv(process.env["LIDIA_ENV"]);
+    }
+    const environment = mergedConfig.environment ?? "Production" /* PRODUCTION */;
+    const preset = getEnvironmentPreset(environment);
+    if (isNodeEnvironment()) {
+      if (!mergedConfig.baseUrl) {
+        const envBaseUrl = getBaseUrlFromEnv();
+        mergedConfig.baseUrl = envBaseUrl ?? preset.baseUrl;
+      }
+      if (!((_a = mergedConfig.cognito) == null ? void 0 : _a.region) || !((_b = mergedConfig.cognito) == null ? void 0 : _b.clientId)) {
+        const envRegion = process.env["AWS_REGION"];
+        const envClientId = process.env["COGNITO_CLIENT_ID"];
+        mergedConfig.cognito = {
+          region: ((_c = mergedConfig.cognito) == null ? void 0 : _c.region) ?? envRegion ?? preset.region,
+          clientId: ((_d = mergedConfig.cognito) == null ? void 0 : _d.clientId) ?? envClientId ?? preset.clientId
+        };
+      }
+      if (!mergedConfig.username) {
+        const envUsername = process.env["LIDIA_USERNAME"];
+        if (envUsername) {
+          mergedConfig.username = envUsername;
+        }
+      }
+      if (!mergedConfig.password) {
+        const envPassword = process.env["LIDIA_PASSWORD"];
+        if (envPassword) {
+          mergedConfig.password = envPassword;
+        }
+      }
+    }
+    if (!mergedConfig.baseUrl) {
+      mergedConfig.baseUrl = preset.baseUrl;
+    }
+    if (!mergedConfig.cognito) {
+      mergedConfig.cognito = { region: preset.region, clientId: preset.clientId };
+    }
+    return mergedConfig;
+  }
+  async initializeAuthentication(config) {
+    if (!this.auth) return;
+    if (config.username && config.password) {
+      try {
+        await this.auth.initializeWithCredentials(config.username, config.password);
+      } catch (error) {
+        console.warn("[LidiaSDK] Automatic login failed:", error);
+      }
+    } else if (config.accessToken) {
+      this.auth.initializeWithToken(config.accessToken);
+    }
+  }
+  /** Login with email and password using AWS Cognito */
+  async login(credentials) {
+    if (!this.auth) {
+      throw new Error("Authentication service not initialized");
+    }
+    return this.auth.login(credentials);
+  }
+  /** Refresh authentication tokens */
+  async refreshTokens() {
+    if (!this.auth) {
+      throw new Error("Authentication service not initialized");
+    }
+    return this.auth.refreshTokens();
+  }
+  /** Logout and clear tokens */
+  logout() {
+    if (this.auth) {
+      this.auth.logout();
+    }
+  }
+  /** Wait for authentication initialization to complete */
+  async waitForAuthentication() {
+    if (!this.auth) {
+      throw new Error("Authentication service not initialized");
+    }
+    if (this.auth.isAuthenticated()) {
+      return;
+    }
+    if (this.authInitPromise) {
+      await this.authInitPromise;
+    }
+    if (!this.auth.isAuthenticated()) {
+      throw new Error(
+        "Authentication not initialized. Please login manually or check your credentials."
+      );
+    }
+  }
+  /** Check if user is authenticated */
+  isAuthenticated() {
+    var _a;
+    return ((_a = this.auth) == null ? void 0 : _a.isAuthenticated()) ?? false;
+  }
+  /** Get current authentication tokens */
+  getAuthTokens() {
+    var _a;
+    return (_a = this.auth) == null ? void 0 : _a.getAuthTokens();
+  }
+  /** Update SDK configuration */
+  updateConfig(config) {
+    this.client.updateConfig(config);
+  }
+  /** Get the underlying HTTP client for advanced usage */
+  getClient() {
+    return this.client;
+  }
+};
+
+// src/types/case.ts
+var CaseRole = /* @__PURE__ */ ((CaseRole2) => {
+  CaseRole2["ADMIN"] = "ADMIN";
+  CaseRole2["EDITOR"] = "EDITOR";
+  CaseRole2["VIEWER"] = "VIEWER";
+  return CaseRole2;
+})(CaseRole || {});
+var CaseParticipationType = /* @__PURE__ */ ((CaseParticipationType2) => {
+  CaseParticipationType2["USER"] = "USER";
+  CaseParticipationType2["ORGANIZATION"] = "ORGANIZATION";
+  return CaseParticipationType2;
+})(CaseParticipationType || {});
+
+// src/types/conversation.ts
+var ConversationType = /* @__PURE__ */ ((ConversationType2) => {
+  ConversationType2["CONVERSATION"] = "conversation";
+  ConversationType2["WORD"] = "word";
+  ConversationType2["SMART_ANSWER"] = "smartAnswer";
+  ConversationType2["WEB_SEARCH"] = "webSearch";
+  ConversationType2["LEGAL_SEARCH"] = "legalSearch";
+  return ConversationType2;
+})(ConversationType || {});
+
+// src/types/document.ts
+var DocumentType = /* @__PURE__ */ ((DocumentType2) => {
+  DocumentType2["DOCUMENT"] = "DOCUMENT";
+  DocumentType2["REGULATION"] = "REGULATION";
+  DocumentType2["RESEARCH"] = "RESEARCH";
+  DocumentType2["MODEL"] = "MODEL";
+  DocumentType2["FOLDER"] = "FOLDER";
+  return DocumentType2;
+})(DocumentType || {});
+var DocumentVisibility = /* @__PURE__ */ ((DocumentVisibility2) => {
+  DocumentVisibility2["COMMON"] = "COMMON";
+  DocumentVisibility2["PRIVATE"] = "PRIVATE";
+  DocumentVisibility2["CASE"] = "CASE";
+  return DocumentVisibility2;
+})(DocumentVisibility || {});
+var DocumentStatus = /* @__PURE__ */ ((DocumentStatus2) => {
+  DocumentStatus2["UPLOADING"] = "UPLOADING";
+  DocumentStatus2["PROCESSING"] = "PROCESSING";
+  DocumentStatus2["ERROR"] = "ERROR";
+  DocumentStatus2["COMPLETE"] = "COMPLETE";
+  return DocumentStatus2;
+})(DocumentStatus || {});
+var DocumentSmartAnswerStatus = /* @__PURE__ */ ((DocumentSmartAnswerStatus2) => {
+  DocumentSmartAnswerStatus2["NOT_PRESENT"] = "NOT_PRESENT";
+  DocumentSmartAnswerStatus2["PENDING"] = "PENDING";
+  DocumentSmartAnswerStatus2["INDEXED"] = "INDEXED";
+  DocumentSmartAnswerStatus2["FAILED"] = "FAILED";
+  return DocumentSmartAnswerStatus2;
+})(DocumentSmartAnswerStatus || {});
+
+// src/types/favorites.ts
+var FavoriteType = /* @__PURE__ */ ((FavoriteType2) => {
+  FavoriteType2["CONVERSATION"] = "CONVERSATION";
+  FavoriteType2["DOCUMENT"] = "DOCUMENT";
+  FavoriteType2["CASE"] = "CASE";
+  FavoriteType2["WORKFLOW"] = "WORKFLOW";
+  return FavoriteType2;
+})(FavoriteType || {});
+
+// src/types/message.ts
+var MessageSenderType = /* @__PURE__ */ ((MessageSenderType2) => {
+  MessageSenderType2["USER"] = "user";
+  MessageSenderType2["ASSISTANT"] = "assistant";
+  MessageSenderType2["INFO"] = "info";
+  return MessageSenderType2;
+})(MessageSenderType || {});
+var MessageStatus = /* @__PURE__ */ ((MessageStatus2) => {
+  MessageStatus2["PROCESSING"] = "PROCESSING";
+  MessageStatus2["DONE"] = "DONE";
+  MessageStatus2["FAILED"] = "FAILED";
+  MessageStatus2["CANCELED"] = "CANCELED";
+  return MessageStatus2;
+})(MessageStatus || {});
+
+// src/types/user.ts
+var UserRole = /* @__PURE__ */ ((UserRole2) => {
+  UserRole2["ADMIN"] = "ADMIN";
+  UserRole2["ORG_ADMIN"] = "ORG_ADMIN";
+  UserRole2["USER"] = "USER";
+  return UserRole2;
+})(UserRole || {});
+var Language = /* @__PURE__ */ ((Language2) => {
+  Language2["IT"] = "it";
+  Language2["EN"] = "en";
+  return Language2;
+})(Language || {});
+
+// src/errors/ValidationError.ts
+var ValidationError = class _ValidationError extends Error {
+  constructor(message, details = []) {
+    super(message);
+    this.name = "ValidationError";
+    this.details = details;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _ValidationError);
+    }
+  }
+  /**
+   * Get errors for a specific field
+   */
+  getFieldErrors(field) {
+    return this.details.filter((detail) => detail.field === field);
+  }
+  /**
+   * Check if a specific field has errors
+   */
+  hasFieldError(field) {
+    return this.details.some((detail) => detail.field === field);
+  }
+  /**
+   * Get all field names that have errors
+   */
+  getErrorFields() {
+    return [...new Set(this.details.map((detail) => detail.field))];
+  }
+  /**
+   * Get a user-friendly error message
+   */
+  getUserMessage() {
+    if (this.details.length === 0) {
+      return this.message;
+    }
+    const fieldErrors = this.details.map((detail) => `${detail.field}: ${detail.message}`).join(", ");
+    return `${this.message} (${fieldErrors})`;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AuthorizationService,
+  CaseParticipationType,
+  CaseRole,
+  CaseService,
+  ConversationService,
+  ConversationTemplateService,
+  ConversationType,
+  DocumentService,
+  DocumentSmartAnswerStatus,
+  DocumentStatus,
+  DocumentType,
+  DocumentVisibility,
+  FavoriteType,
+  FavoritesService,
+  FolderService,
+  HealthService,
+  Language,
+  LegisratioService,
+  LidiaClient,
+  LidiaError,
+  LidiaSDK,
+  MessageSenderType,
+  MessageService,
+  MessageStatus,
+  NetworkError,
+  NotificationService,
+  OrganizationService,
+  SmartAnswerService,
+  TagService,
+  UserRole,
+  UserService,
+  ValidationError,
+  WebSearchService,
+  WorkflowService,
+  buildQueryString
+});