@scell/sdk 1.0.0

package/dist/index.mjs

@@ -0,0 +1,1748 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/errors.ts
+var errors_exports = {};
+__export(errors_exports, {
+  ScellAuthenticationError: () => ScellAuthenticationError,
+  ScellAuthorizationError: () => ScellAuthorizationError,
+  ScellError: () => ScellError,
+  ScellInsufficientBalanceError: () => ScellInsufficientBalanceError,
+  ScellNetworkError: () => ScellNetworkError,
+  ScellNotFoundError: () => ScellNotFoundError,
+  ScellRateLimitError: () => ScellRateLimitError,
+  ScellServerError: () => ScellServerError,
+  ScellTimeoutError: () => ScellTimeoutError,
+  ScellValidationError: () => ScellValidationError,
+  parseApiError: () => parseApiError
+});
+function parseApiError(status, body, headers) {
+  const errorBody = body;
+  const message = errorBody?.message ?? "Unknown error";
+  const errors = errorBody?.errors ?? {};
+  const code = errorBody?.code;
+  switch (status) {
+    case 401:
+      throw new ScellAuthenticationError(message, body);
+    case 402:
+      throw new ScellInsufficientBalanceError(message, body);
+    case 403:
+      throw new ScellAuthorizationError(message, body);
+    case 404:
+      throw new ScellNotFoundError(message, body);
+    case 422:
+      throw new ScellValidationError(message, errors, body);
+    case 429: {
+      const retryAfter = headers?.get("Retry-After");
+      throw new ScellRateLimitError(
+        message,
+        retryAfter ? parseInt(retryAfter, 10) : void 0,
+        body
+      );
+    }
+    default:
+      if (status >= 500) {
+        throw new ScellServerError(message, status, body);
+      }
+      throw new ScellError(message, status, code, body);
+  }
+}
+var ScellError, ScellAuthenticationError, ScellAuthorizationError, ScellValidationError, ScellRateLimitError, ScellNotFoundError, ScellServerError, ScellInsufficientBalanceError, ScellNetworkError, ScellTimeoutError;
+var init_errors = __esm({
+  "src/errors.ts"() {
+    ScellError = class extends Error {
+      /** HTTP status code */
+      status;
+      /** Error code from API */
+      code;
+      /** Original response body */
+      body;
+      constructor(message, status, code, body) {
+        super(message);
+        this.name = "ScellError";
+        this.status = status;
+        this.code = code;
+        this.body = body;
+        if (Error.captureStackTrace) {
+          Error.captureStackTrace(this, this.constructor);
+        }
+      }
+    };
+    ScellAuthenticationError = class extends ScellError {
+      constructor(message = "Authentication failed", body) {
+        super(message, 401, "AUTHENTICATION_ERROR", body);
+        this.name = "ScellAuthenticationError";
+      }
+    };
+    ScellAuthorizationError = class extends ScellError {
+      constructor(message = "Access denied", body) {
+        super(message, 403, "AUTHORIZATION_ERROR", body);
+        this.name = "ScellAuthorizationError";
+      }
+    };
+    ScellValidationError = class extends ScellError {
+      /** Field-level validation errors */
+      errors;
+      constructor(message, errors = {}, body) {
+        super(message, 422, "VALIDATION_ERROR", body);
+        this.name = "ScellValidationError";
+        this.errors = errors;
+      }
+      /**
+       * Get all error messages as a flat array
+       */
+      getAllMessages() {
+        return Object.values(this.errors).flat();
+      }
+      /**
+       * Get error messages for a specific field
+       */
+      getFieldErrors(field) {
+        return this.errors[field] ?? [];
+      }
+      /**
+       * Check if a specific field has errors
+       */
+      hasFieldError(field) {
+        const fieldErrors = this.errors[field];
+        return fieldErrors !== void 0 && fieldErrors.length > 0;
+      }
+    };
+    ScellRateLimitError = class extends ScellError {
+      /** Seconds to wait before retrying */
+      retryAfter;
+      constructor(message = "Rate limit exceeded", retryAfter, body) {
+        super(message, 429, "RATE_LIMIT_EXCEEDED", body);
+        this.name = "ScellRateLimitError";
+        this.retryAfter = retryAfter;
+      }
+    };
+    ScellNotFoundError = class extends ScellError {
+      constructor(message = "Resource not found", body) {
+        super(message, 404, "NOT_FOUND", body);
+        this.name = "ScellNotFoundError";
+      }
+    };
+    ScellServerError = class extends ScellError {
+      constructor(message = "Internal server error", status = 500, body) {
+        super(message, status, "SERVER_ERROR", body);
+        this.name = "ScellServerError";
+      }
+    };
+    ScellInsufficientBalanceError = class extends ScellError {
+      constructor(message = "Insufficient balance", body) {
+        super(message, 402, "INSUFFICIENT_BALANCE", body);
+        this.name = "ScellInsufficientBalanceError";
+      }
+    };
+    ScellNetworkError = class extends ScellError {
+      originalError;
+      constructor(message, originalError) {
+        super(message, 0, "NETWORK_ERROR");
+        this.name = "ScellNetworkError";
+        this.originalError = originalError;
+      }
+    };
+    ScellTimeoutError = class extends ScellError {
+      constructor(message = "Request timed out") {
+        super(message, 0, "TIMEOUT");
+        this.name = "ScellTimeoutError";
+      }
+    };
+  }
+});
+
+// src/client.ts
+init_errors();
+
+// src/utils/retry.ts
+init_errors();
+var DEFAULT_RETRY_OPTIONS = {
+  maxRetries: 3,
+  baseDelay: 1e3,
+  maxDelay: 3e4,
+  jitterFactor: 0.1
+};
+function isRetryableError(error) {
+  if (error instanceof ScellRateLimitError) {
+    return true;
+  }
+  if (error instanceof ScellServerError) {
+    return true;
+  }
+  if (error instanceof Error && error.name === "ScellNetworkError") {
+    return true;
+  }
+  return false;
+}
+function calculateDelay(attempt, baseDelay, maxDelay, jitterFactor, retryAfter) {
+  if (retryAfter !== void 0 && retryAfter > 0) {
+    return retryAfter * 1e3;
+  }
+  const exponentialDelay = baseDelay * Math.pow(2, attempt);
+  const cappedDelay = Math.min(exponentialDelay, maxDelay);
+  const jitter = cappedDelay * jitterFactor * (Math.random() * 2 - 1);
+  return Math.floor(cappedDelay + jitter);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function withRetry(fn, options = {}) {
+  const maxRetries = options.maxRetries ?? DEFAULT_RETRY_OPTIONS.maxRetries;
+  const baseDelay = options.baseDelay ?? DEFAULT_RETRY_OPTIONS.baseDelay;
+  const maxDelay = options.maxDelay ?? DEFAULT_RETRY_OPTIONS.maxDelay;
+  const jitterFactor = options.jitterFactor ?? DEFAULT_RETRY_OPTIONS.jitterFactor;
+  const isRetryable = options.isRetryable ?? isRetryableError;
+  let lastError;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (attempt >= maxRetries || !isRetryable(error)) {
+        throw error;
+      }
+      const retryAfter = error instanceof ScellRateLimitError ? error.retryAfter : void 0;
+      const delay = calculateDelay(
+        attempt,
+        baseDelay,
+        maxDelay,
+        jitterFactor,
+        retryAfter
+      );
+      await sleep(delay);
+    }
+  }
+  throw lastError;
+}
+function createRetryWrapper(defaultOptions = {}) {
+  return (fn, options = {}) => withRetry(fn, { ...defaultOptions, ...options });
+}
+
+// src/client.ts
+var HttpClient = class {
+  baseUrl;
+  timeout;
+  retryOptions;
+  enableRetry;
+  fetchFn;
+  authMode;
+  authToken;
+  constructor(authMode, authToken, config = {}) {
+    this.authMode = authMode;
+    this.authToken = authToken;
+    this.baseUrl = config.baseUrl ?? "https://api.scell.io/api/v1";
+    this.timeout = config.timeout ?? 3e4;
+    this.retryOptions = config.retry ?? {};
+    this.enableRetry = config.enableRetry ?? true;
+    this.fetchFn = config.fetch ?? fetch;
+  }
+  /**
+   * Build URL with query parameters
+   */
+  buildUrl(path, query) {
+    const url = new URL(path, this.baseUrl);
+    if (query) {
+      for (const [key, value] of Object.entries(query)) {
+        if (value !== void 0) {
+          url.searchParams.set(key, String(value));
+        }
+      }
+    }
+    return url.toString();
+  }
+  /**
+   * Build headers for request
+   */
+  buildHeaders(additionalHeaders) {
+    const headers = {
+      "Content-Type": "application/json",
+      Accept: "application/json",
+      ...additionalHeaders
+    };
+    if (this.authMode === "bearer") {
+      headers["Authorization"] = `Bearer ${this.authToken}`;
+    } else {
+      headers["X-API-Key"] = this.authToken;
+    }
+    return headers;
+  }
+  /**
+   * Execute HTTP request
+   */
+  async executeRequest(config) {
+    const { method, path, body, query, headers, timeout, signal } = config;
+    const url = this.buildUrl(path, query);
+    const requestHeaders = this.buildHeaders(headers);
+    const requestTimeout = timeout ?? this.timeout;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), requestTimeout);
+    const combinedSignal = signal ? new AbortController().signal : controller.signal;
+    if (signal) {
+      signal.addEventListener("abort", () => controller.abort());
+    }
+    try {
+      const fetchOptions = {
+        method,
+        headers: requestHeaders,
+        signal: combinedSignal
+      };
+      if (body !== void 0) {
+        fetchOptions.body = JSON.stringify(body);
+      }
+      const response = await this.fetchFn(url, fetchOptions);
+      clearTimeout(timeoutId);
+      const contentType = response.headers.get("Content-Type") ?? "";
+      let responseBody;
+      if (contentType.includes("application/json")) {
+        responseBody = await response.json();
+      } else {
+        responseBody = await response.text();
+      }
+      if (!response.ok) {
+        parseApiError(response.status, responseBody, response.headers);
+      }
+      return responseBody;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof Error) {
+        if (error.name === "AbortError") {
+          throw new ScellTimeoutError(
+            `Request timed out after ${requestTimeout}ms`
+          );
+        }
+        if (error.name === "TypeError" && error.message.includes("fetch")) {
+          throw new ScellNetworkError("Network request failed", error);
+        }
+      }
+      throw error;
+    }
+  }
+  /**
+   * Execute request with optional retry
+   */
+  async request(config) {
+    const shouldRetry = this.enableRetry && !config.skipRetry;
+    if (shouldRetry) {
+      return withRetry(
+        () => this.executeRequest(config),
+        this.retryOptions
+      );
+    }
+    return this.executeRequest(config);
+  }
+  /**
+   * GET request
+   */
+  async get(path, query, options) {
+    const config = {
+      method: "GET",
+      path,
+      ...options
+    };
+    if (query !== void 0) {
+      config.query = query;
+    }
+    return this.request(config);
+  }
+  /**
+   * POST request
+   */
+  async post(path, body, options) {
+    return this.request({
+      method: "POST",
+      path,
+      body,
+      ...options
+    });
+  }
+  /**
+   * PUT request
+   */
+  async put(path, body, options) {
+    return this.request({
+      method: "PUT",
+      path,
+      body,
+      ...options
+    });
+  }
+  /**
+   * PATCH request
+   */
+  async patch(path, body, options) {
+    return this.request({
+      method: "PATCH",
+      path,
+      body,
+      ...options
+    });
+  }
+  /**
+   * DELETE request
+   */
+  async delete(path, options) {
+    return this.request({
+      method: "DELETE",
+      path,
+      ...options
+    });
+  }
+};
+
+// src/resources/api-keys.ts
+var ApiKeysResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * List all API keys
+   *
+   * @param requestOptions - Request options
+   * @returns List of API keys (without secrets)
+   *
+   * @example
+   * ```typescript
+   * const { data: keys } = await client.apiKeys.list();
+   * keys.forEach(key => {
+   *   console.log(`${key.name}: ${key.key_prefix}...`);
+   * });
+   * ```
+   */
+  async list(requestOptions) {
+    return this.http.get(
+      "/api-keys",
+      void 0,
+      requestOptions
+    );
+  }
+  /**
+   * Get a specific API key
+   *
+   * @param id - API Key UUID
+   * @param requestOptions - Request options
+   * @returns API key details (without secret)
+   *
+   * @example
+   * ```typescript
+   * const { data: key } = await client.apiKeys.get('key-uuid');
+   * console.log(`Last used: ${key.last_used_at}`);
+   * ```
+   */
+  async get(id, requestOptions) {
+    return this.http.get(
+      `/api-keys/${id}`,
+      void 0,
+      requestOptions
+    );
+  }
+  /**
+   * Create a new API key
+   *
+   * Important: The full key is only returned once during creation.
+   * Store it securely - you won't be able to retrieve it again.
+   *
+   * @param input - API key configuration
+   * @param requestOptions - Request options
+   * @returns Created API key with full key value
+   *
+   * @example
+   * ```typescript
+   * const { data: apiKey } = await client.apiKeys.create({
+   *   name: 'Production Integration',
+   *   company_id: 'company-uuid',
+   *   environment: 'production',
+   *   permissions: ['invoices:write', 'signatures:write']
+   * });
+   *
+   * // IMPORTANT: Store this key securely!
+   * // You won't be able to see it again.
+   * console.log('Save this key:', apiKey.key);
+   * ```
+   */
+  async create(input, requestOptions) {
+    return this.http.post(
+      "/api-keys",
+      input,
+      requestOptions
+    );
+  }
+  /**
+   * Delete an API key
+   *
+   * Warning: This will immediately revoke the key and all
+   * requests using it will fail.
+   *
+   * @param id - API Key UUID
+   * @param requestOptions - Request options
+   * @returns Deletion confirmation
+   *
+   * @example
+   * ```typescript
+   * await client.apiKeys.delete('key-uuid');
+   * console.log('API key revoked');
+   * ```
+   */
+  async delete(id, requestOptions) {
+    return this.http.delete(`/api-keys/${id}`, requestOptions);
+  }
+};
+
+// src/resources/auth.ts
+var AuthResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Get current authenticated user
+   *
+   * @param requestOptions - Request options
+   * @returns Current user details
+   *
+   * @example
+   * ```typescript
+   * const { data: user } = await client.auth.me();
+   * console.log(`Logged in as: ${user.name} (${user.email})`);
+   * ```
+   */
+  async me(requestOptions) {
+    return this.http.get(
+      "/auth/me",
+      void 0,
+      requestOptions
+    );
+  }
+  /**
+   * Logout (revoke current token)
+   *
+   * @param requestOptions - Request options
+   * @returns Logout confirmation
+   *
+   * @example
+   * ```typescript
+   * await client.auth.logout();
+   * // Token is now invalid
+   * ```
+   */
+  async logout(requestOptions) {
+    return this.http.post(
+      "/auth/logout",
+      void 0,
+      requestOptions
+    );
+  }
+};
+var ScellAuth = {
+  /**
+   * Default base URL for auth requests
+   */
+  baseUrl: "https://api.scell.io/api/v1",
+  /**
+   * Register a new user
+   *
+   * @param input - Registration data
+   * @param baseUrl - Optional base URL override
+   * @returns Auth response with token
+   *
+   * @example
+   * ```typescript
+   * const auth = await ScellAuth.register({
+   *   name: 'Jane Doe',
+   *   email: 'jane@example.com',
+   *   password: 'MySecurePassword123!',
+   *   password_confirmation: 'MySecurePassword123!'
+   * });
+   *
+   * console.log('Welcome,', auth.user.name);
+   * const client = new ScellClient(auth.token);
+   * ```
+   */
+  async register(input, baseUrl) {
+    const url = `${baseUrl ?? this.baseUrl}/auth/register`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json"
+      },
+      body: JSON.stringify(input)
+    });
+    const body = await response.json();
+    if (!response.ok) {
+      const { parseApiError: parseApiError2 } = await Promise.resolve().then(() => (init_errors(), errors_exports));
+      parseApiError2(response.status, body, response.headers);
+    }
+    return body;
+  },
+  /**
+   * Login an existing user
+   *
+   * @param credentials - Login credentials
+   * @param baseUrl - Optional base URL override
+   * @returns Auth response with token
+   *
+   * @example
+   * ```typescript
+   * const auth = await ScellAuth.login({
+   *   email: 'user@example.com',
+   *   password: 'password'
+   * });
+   *
+   * // Store the token securely
+   * localStorage.setItem('scell_token', auth.token);
+   *
+   * // Create client
+   * const client = new ScellClient(auth.token);
+   * ```
+   */
+  async login(credentials, baseUrl) {
+    const url = `${baseUrl ?? this.baseUrl}/auth/login`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json"
+      },
+      body: JSON.stringify(credentials)
+    });
+    const body = await response.json();
+    if (!response.ok) {
+      const { parseApiError: parseApiError2 } = await Promise.resolve().then(() => (init_errors(), errors_exports));
+      parseApiError2(response.status, body, response.headers);
+    }
+    return body;
+  },
+  /**
+   * Request password reset email
+   *
+   * @param input - Email address
+   * @param baseUrl - Optional base URL override
+   * @returns Confirmation message
+   *
+   * @example
+   * ```typescript
+   * await ScellAuth.forgotPassword({
+   *   email: 'user@example.com'
+   * });
+   * console.log('Check your email for reset link');
+   * ```
+   */
+  async forgotPassword(input, baseUrl) {
+    const url = `${baseUrl ?? this.baseUrl}/auth/forgot-password`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json"
+      },
+      body: JSON.stringify(input)
+    });
+    const body = await response.json();
+    if (!response.ok) {
+      const { parseApiError: parseApiError2 } = await Promise.resolve().then(() => (init_errors(), errors_exports));
+      parseApiError2(response.status, body, response.headers);
+    }
+    return body;
+  },
+  /**
+   * Reset password with token from email
+   *
+   * @param input - Reset password data
+   * @param baseUrl - Optional base URL override
+   * @returns Confirmation message
+   *
+   * @example
+   * ```typescript
+   * await ScellAuth.resetPassword({
+   *   email: 'user@example.com',
+   *   token: 'reset-token-from-email',
+   *   password: 'NewSecurePassword123!',
+   *   password_confirmation: 'NewSecurePassword123!'
+   * });
+   * ```
+   */
+  async resetPassword(input, baseUrl) {
+    const url = `${baseUrl ?? this.baseUrl}/auth/reset-password`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json"
+      },
+      body: JSON.stringify(input)
+    });
+    const body = await response.json();
+    if (!response.ok) {
+      const { parseApiError: parseApiError2 } = await Promise.resolve().then(() => (init_errors(), errors_exports));
+      parseApiError2(response.status, body, response.headers);
+    }
+    return body;
+  }
+};
+
+// src/resources/balance.ts
+var BalanceResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Get current balance and settings
+   *
+   * @param requestOptions - Request options
+   * @returns Current balance details
+   *
+   * @example
+   * ```typescript
+   * const { data: balance } = await client.balance.get();
+   * console.log(`Balance: ${balance.amount} ${balance.currency}`);
+   *
+   * if (balance.amount < balance.low_balance_alert_threshold) {
+   *   console.log('Warning: Low balance!');
+   * }
+   * ```
+   */
+  async get(requestOptions) {
+    return this.http.get(
+      "/balance",
+      void 0,
+      requestOptions
+    );
+  }
+  /**
+   * Reload balance
+   *
+   * Note: This is a simulation endpoint. In production, use Stripe integration.
+   *
+   * @param input - Reload amount (10-10000 EUR)
+   * @param requestOptions - Request options
+   * @returns Reload transaction details
+   *
+   * @example
+   * ```typescript
+   * const { transaction } = await client.balance.reload({ amount: 100 });
+   * console.log(`New balance: ${transaction.balance_after}`);
+   * ```
+   */
+  async reload(input, requestOptions) {
+    return this.http.post(
+      "/balance/reload",
+      input,
+      requestOptions
+    );
+  }
+  /**
+   * Update balance settings
+   *
+   * Configure auto-reload and alert thresholds.
+   *
+   * @param input - Settings to update
+   * @param requestOptions - Request options
+   * @returns Updated settings
+   *
+   * @example
+   * ```typescript
+   * await client.balance.updateSettings({
+   *   auto_reload_enabled: true,
+   *   auto_reload_threshold: 50,
+   *   auto_reload_amount: 200,
+   *   low_balance_alert_threshold: 100,
+   *   critical_balance_alert_threshold: 25
+   * });
+   * ```
+   */
+  async updateSettings(input, requestOptions) {
+    return this.http.put(
+      "/balance/settings",
+      input,
+      requestOptions
+    );
+  }
+  /**
+   * List balance transactions
+   *
+   * @param options - Filter and pagination options
+   * @param requestOptions - Request options
+   * @returns Paginated list of transactions
+   *
+   * @example
+   * ```typescript
+   * // List all invoice debits
+   * const { data, meta } = await client.balance.transactions({
+   *   type: 'debit',
+   *   service: 'invoice',
+   *   from: '2024-01-01',
+   *   to: '2024-01-31'
+   * });
+   *
+   * data.forEach(tx => {
+   *   console.log(`${tx.description}: -${tx.amount} EUR`);
+   * });
+   * ```
+   */
+  async transactions(options = {}, requestOptions) {
+    return this.http.get(
+      "/balance/transactions",
+      options,
+      requestOptions
+    );
+  }
+};
+
+// src/resources/companies.ts
+var CompaniesResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * List all companies for the authenticated user
+   *
+   * @param requestOptions - Request options
+   * @returns List of companies
+   *
+   * @example
+   * ```typescript
+   * const { data: companies } = await client.companies.list();
+   * companies.forEach(c => console.log(c.name, c.status));
+   * ```
+   */
+  async list(requestOptions) {
+    return this.http.get(
+      "/companies",
+      void 0,
+      requestOptions
+    );
+  }
+  /**
+   * Get a specific company by ID
+   *
+   * @param id - Company UUID
+   * @param requestOptions - Request options
+   * @returns Company details
+   *
+   * @example
+   * ```typescript
+   * const { data: company } = await client.companies.get('uuid');
+   * console.log(company.name, company.siret);
+   * ```
+   */
+  async get(id, requestOptions) {
+    return this.http.get(
+      `/companies/${id}`,
+      void 0,
+      requestOptions
+    );
+  }
+  /**
+   * Create a new company
+   *
+   * @param input - Company creation data
+   * @param requestOptions - Request options
+   * @returns Created company
+   *
+   * @example
+   * ```typescript
+   * const { data: company } = await client.companies.create({
+   *   name: 'Acme Corp',
+   *   siret: '12345678901234',
+   *   vat_number: 'FR12345678901',
+   *   legal_form: 'SAS',
+   *   address_line1: '123 Business Street',
+   *   postal_code: '75001',
+   *   city: 'Paris',
+   *   country: 'FR',
+   *   email: 'contact@acme.com',
+   *   phone: '+33 1 23 45 67 89'
+   * });
+   * ```
+   */
+  async create(input, requestOptions) {
+    return this.http.post(
+      "/companies",
+      input,
+      requestOptions
+    );
+  }
+  /**
+   * Update a company
+   *
+   * @param id - Company UUID
+   * @param input - Fields to update
+   * @param requestOptions - Request options
+   * @returns Updated company
+   *
+   * @example
+   * ```typescript
+   * const { data: company } = await client.companies.update('uuid', {
+   *   email: 'new-email@acme.com',
+   *   phone: '+33 1 98 76 54 32'
+   * });
+   * ```
+   */
+  async update(id, input, requestOptions) {
+    return this.http.put(
+      `/companies/${id}`,
+      input,
+      requestOptions
+    );
+  }
+  /**
+   * Delete a company
+   *
+   * @param id - Company UUID
+   * @param requestOptions - Request options
+   * @returns Deletion confirmation
+   *
+   * @example
+   * ```typescript
+   * await client.companies.delete('company-uuid');
+   * ```
+   */
+  async delete(id, requestOptions) {
+    return this.http.delete(
+      `/companies/${id}`,
+      requestOptions
+    );
+  }
+  /**
+   * Initiate KYC verification for a company
+   *
+   * @param id - Company UUID
+   * @param requestOptions - Request options
+   * @returns KYC reference and redirect URL
+   *
+   * @example
+   * ```typescript
+   * const { kyc_reference, redirect_url } = await client.companies.initiateKyc(
+   *   'company-uuid'
+   * );
+   * // Redirect user to redirect_url for KYC verification
+   * ```
+   */
+  async initiateKyc(id, requestOptions) {
+    return this.http.post(
+      `/companies/${id}/kyc`,
+      void 0,
+      requestOptions
+    );
+  }
+  /**
+   * Get KYC verification status
+   *
+   * @param id - Company UUID
+   * @param requestOptions - Request options
+   * @returns Current KYC status
+   *
+   * @example
+   * ```typescript
+   * const status = await client.companies.kycStatus('company-uuid');
+   * if (status.status === 'active') {
+   *   console.log('KYC completed at:', status.kyc_completed_at);
+   * }
+   * ```
+   */
+  async kycStatus(id, requestOptions) {
+    return this.http.get(
+      `/companies/${id}/kyc/status`,
+      void 0,
+      requestOptions
+    );
+  }
+};
+
+// src/resources/invoices.ts
+var InvoicesResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * List invoices with optional filtering
+   *
+   * @param options - Filter and pagination options
+   * @param requestOptions - Request options
+   * @returns Paginated list of invoices
+   *
+   * @example
+   * ```typescript
+   * // List all outgoing invoices
+   * const { data, meta } = await client.invoices.list({
+   *   direction: 'outgoing',
+   *   per_page: 50
+   * });
+   * console.log(`Found ${meta.total} invoices`);
+   * ```
+   */
+  async list(options = {}, requestOptions) {
+    return this.http.get(
+      "/invoices",
+      options,
+      requestOptions
+    );
+  }
+  /**
+   * Get a specific invoice by ID
+   *
+   * @param id - Invoice UUID
+   * @param requestOptions - Request options
+   * @returns Invoice details
+   *
+   * @example
+   * ```typescript
+   * const { data: invoice } = await client.invoices.get('uuid-here');
+   * console.log('Invoice number:', invoice.invoice_number);
+   * ```
+   */
+  async get(id, requestOptions) {
+    return this.http.get(
+      `/invoices/${id}`,
+      void 0,
+      requestOptions
+    );
+  }
+  /**
+   * Create a new invoice
+   *
+   * Note: This endpoint requires API key authentication.
+   * Creating an invoice in production mode will debit your balance.
+   *
+   * @param input - Invoice creation data
+   * @param requestOptions - Request options
+   * @returns Created invoice
+   *
+   * @example
+   * ```typescript
+   * const { data: invoice } = await client.invoices.create({
+   *   invoice_number: 'FACT-2024-001',
+   *   direction: 'outgoing',
+   *   output_format: 'facturx',
+   *   issue_date: '2024-01-15',
+   *   total_ht: 100.00,
+   *   total_tax: 20.00,
+   *   total_ttc: 120.00,
+   *   seller_siret: '12345678901234',
+   *   seller_name: 'My Company',
+   *   seller_address: {
+   *     line1: '1 Rue Example',
+   *     postal_code: '75001',
+   *     city: 'Paris',
+   *     country: 'FR'
+   *   },
+   *   buyer_siret: '98765432109876',
+   *   buyer_name: 'Client Company',
+   *   buyer_address: {
+   *     line1: '2 Avenue Test',
+   *     postal_code: '75002',
+   *     city: 'Paris',
+   *     country: 'FR'
+   *   },
+   *   lines: [{
+   *     description: 'Service prestation',
+   *     quantity: 1,
+   *     unit_price: 100.00,
+   *     tax_rate: 20.00,
+   *     total_ht: 100.00,
+   *     total_tax: 20.00,
+   *     total_ttc: 120.00
+   *   }]
+   * });
+   * ```
+   */
+  async create(input, requestOptions) {
+    return this.http.post(
+      "/invoices",
+      input,
+      requestOptions
+    );
+  }
+  /**
+   * Download invoice file
+   *
+   * @param id - Invoice UUID
+   * @param type - File type to download
+   * @param requestOptions - Request options
+   * @returns Temporary download URL
+   *
+   * @example
+   * ```typescript
+   * // Download PDF version
+   * const { url, expires_at } = await client.invoices.download(
+   *   'invoice-uuid',
+   *   'pdf'
+   * );
+   * console.log('Download before:', expires_at);
+   * ```
+   */
+  async download(id, type, requestOptions) {
+    return this.http.get(
+      `/invoices/${id}/download/${type}`,
+      void 0,
+      requestOptions
+    );
+  }
+  /**
+   * Get invoice audit trail (Piste d'Audit Fiable)
+   *
+   * @param id - Invoice UUID
+   * @param requestOptions - Request options
+   * @returns Audit trail entries with integrity validation
+   *
+   * @example
+   * ```typescript
+   * const { data: entries, integrity_valid } = await client.invoices.auditTrail(
+   *   'invoice-uuid'
+   * );
+   *
+   * if (integrity_valid) {
+   *   console.log('Audit trail is valid');
+   *   entries.forEach(e => console.log(e.action, e.created_at));
+   * }
+   * ```
+   */
+  async auditTrail(id, requestOptions) {
+    return this.http.get(
+      `/invoices/${id}/audit-trail`,
+      void 0,
+      requestOptions
+    );
+  }
+  /**
+   * Convert invoice to another format
+   *
+   * @param input - Conversion parameters
+   * @param requestOptions - Request options
+   * @returns Conversion status
+   *
+   * @example
+   * ```typescript
+   * await client.invoices.convert({
+   *   invoice_id: 'invoice-uuid',
+   *   target_format: 'ubl'
+   * });
+   * ```
+   */
+  async convert(input, requestOptions) {
+    return this.http.post("/invoices/convert", input, requestOptions);
+  }
+};
+
+// src/resources/signatures.ts
+var SignaturesResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * List signature requests with optional filtering
+   *
+   * @param options - Filter and pagination options
+   * @param requestOptions - Request options
+   * @returns Paginated list of signatures
+   *
+   * @example
+   * ```typescript
+   * const { data, meta } = await client.signatures.list({
+   *   status: 'pending',
+   *   per_page: 25
+   * });
+   * console.log(`${meta.total} pending signatures`);
+   * ```
+   */
+  async list(options = {}, requestOptions) {
+    return this.http.get(
+      "/signatures",
+      options,
+      requestOptions
+    );
+  }
+  /**
+   * Get a specific signature by ID
+   *
+   * @param id - Signature UUID
+   * @param requestOptions - Request options
+   * @returns Signature details with signers
+   *
+   * @example
+   * ```typescript
+   * const { data: signature } = await client.signatures.get('uuid-here');
+   * signature.signers?.forEach(signer => {
+   *   console.log(`${signer.full_name}: ${signer.status}`);
+   * });
+   * ```
+   */
+  async get(id, requestOptions) {
+    return this.http.get(
+      `/signatures/${id}`,
+      void 0,
+      requestOptions
+    );
+  }
+  /**
+   * Create a new signature request
+   *
+   * Note: This endpoint requires API key authentication.
+   * Creating a signature in production mode will debit your balance.
+   *
+   * @param input - Signature creation data
+   * @param requestOptions - Request options
+   * @returns Created signature
+   *
+   * @example
+   * ```typescript
+   * import { readFileSync } from 'fs';
+   *
+   * const pdfContent = readFileSync('contract.pdf');
+   * const { data: signature } = await client.signatures.create({
+   *   title: 'Service Agreement',
+   *   description: 'Annual service contract',
+   *   document: pdfContent.toString('base64'),
+   *   document_name: 'contract.pdf',
+   *   signers: [
+   *     {
+   *       first_name: 'Alice',
+   *       last_name: 'Smith',
+   *       email: 'alice@example.com',
+   *       auth_method: 'email'
+   *     },
+   *     {
+   *       first_name: 'Bob',
+   *       last_name: 'Jones',
+   *       phone: '+33612345678',
+   *       auth_method: 'sms'
+   *     }
+   *   ],
+   *   ui_config: {
+   *     logo_url: 'https://mycompany.com/logo.png',
+   *     primary_color: '#3b82f6',
+   *     company_name: 'My Company'
+   *   },
+   *   redirect_complete_url: 'https://myapp.com/signed',
+   *   redirect_cancel_url: 'https://myapp.com/cancelled'
+   * });
+   *
+   * // Send signing URLs to signers
+   * signature.signers?.forEach(signer => {
+   *   console.log(`${signer.email}: ${signer.signing_url}`);
+   * });
+   * ```
+   */
+  async create(input, requestOptions) {
+    return this.http.post(
+      "/signatures",
+      input,
+      requestOptions
+    );
+  }
+  /**
+   * Download signature files
+   *
+   * @param id - Signature UUID
+   * @param type - File type to download
+   * @param requestOptions - Request options
+   * @returns Temporary download URL
+   *
+   * @example
+   * ```typescript
+   * // Download signed document
+   * const { url } = await client.signatures.download(
+   *   'signature-uuid',
+   *   'signed'
+   * );
+   *
+   * // Download audit trail (proof file)
+   * const { url: auditUrl } = await client.signatures.download(
+   *   'signature-uuid',
+   *   'audit_trail'
+   * );
+   * ```
+   */
+  async download(id, type, requestOptions) {
+    return this.http.get(
+      `/signatures/${id}/download/${type}`,
+      void 0,
+      requestOptions
+    );
+  }
+  /**
+   * Send reminder to pending signers
+   *
+   * @param id - Signature UUID
+   * @param requestOptions - Request options
+   * @returns Number of signers reminded
+   *
+   * @example
+   * ```typescript
+   * const { signers_reminded } = await client.signatures.remind('uuid');
+   * console.log(`Reminded ${signers_reminded} signers`);
+   * ```
+   */
+  async remind(id, requestOptions) {
+    return this.http.post(
+      `/signatures/${id}/remind`,
+      void 0,
+      requestOptions
+    );
+  }
+  /**
+   * Cancel a signature request
+   *
+   * Note: Cannot cancel completed signatures.
+   *
+   * @param id - Signature UUID
+   * @param requestOptions - Request options
+   * @returns Cancellation confirmation
+   *
+   * @example
+   * ```typescript
+   * await client.signatures.cancel('signature-uuid');
+   * console.log('Signature cancelled');
+   * ```
+   */
+  async cancel(id, requestOptions) {
+    return this.http.post(
+      `/signatures/${id}/cancel`,
+      void 0,
+      requestOptions
+    );
+  }
+};
+
+// src/resources/webhooks.ts
+var WebhooksResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * List all webhooks
+   *
+   * @param options - Filter options
+   * @param requestOptions - Request options
+   * @returns List of webhooks
+   *
+   * @example
+   * ```typescript
+   * const { data: webhooks } = await client.webhooks.list();
+   * webhooks.forEach(wh => {
+   *   console.log(`${wh.url}: ${wh.is_active ? 'active' : 'inactive'}`);
+   * });
+   * ```
+   */
+  async list(options = {}, requestOptions) {
+    return this.http.get(
+      "/webhooks",
+      options,
+      requestOptions
+    );
+  }
+  /**
+   * Create a new webhook
+   *
+   * Important: The secret is only returned once during creation.
+   * Store it securely - you'll need it to verify webhook signatures.
+   *
+   * @param input - Webhook configuration
+   * @param requestOptions - Request options
+   * @returns Created webhook with secret
+   *
+   * @example
+   * ```typescript
+   * const { data: webhook } = await client.webhooks.create({
+   *   url: 'https://myapp.com/webhooks/scell',
+   *   events: [
+   *     'invoice.created',
+   *     'invoice.validated',
+   *     'signature.completed',
+   *     'balance.low'
+   *   ],
+   *   environment: 'production',
+   *   headers: {
+   *     'X-Custom-Auth': 'my-secret-token'
+   *   },
+   *   retry_count: 5,
+   *   timeout_seconds: 30
+   * });
+   *
+   * // IMPORTANT: Store this secret securely!
+   * await saveWebhookSecret(webhook.id, webhook.secret);
+   * ```
+   */
+  async create(input, requestOptions) {
+    return this.http.post(
+      "/webhooks",
+      input,
+      requestOptions
+    );
+  }
+  /**
+   * Update a webhook
+   *
+   * @param id - Webhook UUID
+   * @param input - Fields to update
+   * @param requestOptions - Request options
+   * @returns Updated webhook
+   *
+   * @example
+   * ```typescript
+   * // Disable a webhook temporarily
+   * await client.webhooks.update('webhook-uuid', {
+   *   is_active: false
+   * });
+   *
+   * // Update events
+   * await client.webhooks.update('webhook-uuid', {
+   *   events: ['invoice.validated', 'signature.completed']
+   * });
+   * ```
+   */
+  async update(id, input, requestOptions) {
+    return this.http.put(
+      `/webhooks/${id}`,
+      input,
+      requestOptions
+    );
+  }
+  /**
+   * Delete a webhook
+   *
+   * @param id - Webhook UUID
+   * @param requestOptions - Request options
+   * @returns Deletion confirmation
+   *
+   * @example
+   * ```typescript
+   * await client.webhooks.delete('webhook-uuid');
+   * ```
+   */
+  async delete(id, requestOptions) {
+    return this.http.delete(`/webhooks/${id}`, requestOptions);
+  }
+  /**
+   * Regenerate webhook secret
+   *
+   * Use this if your secret has been compromised.
+   * The old secret will immediately stop working.
+   *
+   * @param id - Webhook UUID
+   * @param requestOptions - Request options
+   * @returns Webhook with new secret
+   *
+   * @example
+   * ```typescript
+   * const { data: webhook } = await client.webhooks.regenerateSecret(
+   *   'webhook-uuid'
+   * );
+   *
+   * // Update your stored secret
+   * await updateWebhookSecret(webhook.id, webhook.secret);
+   * ```
+   */
+  async regenerateSecret(id, requestOptions) {
+    return this.http.post(
+      `/webhooks/${id}/regenerate-secret`,
+      void 0,
+      requestOptions
+    );
+  }
+  /**
+   * Test webhook by sending a test event
+   *
+   * @param id - Webhook UUID
+   * @param requestOptions - Request options
+   * @returns Test result
+   *
+   * @example
+   * ```typescript
+   * const result = await client.webhooks.test('webhook-uuid');
+   *
+   * if (result.success) {
+   *   console.log(`Success! Response time: ${result.response_time_ms}ms`);
+   * } else {
+   *   console.log(`Failed: ${result.error}`);
+   * }
+   * ```
+   */
+  async test(id, requestOptions) {
+    return this.http.post(
+      `/webhooks/${id}/test`,
+      void 0,
+      requestOptions
+    );
+  }
+  /**
+   * Get webhook delivery logs
+   *
+   * @param id - Webhook UUID
+   * @param options - Pagination options
+   * @param requestOptions - Request options
+   * @returns Paginated list of logs
+   *
+   * @example
+   * ```typescript
+   * const { data: logs } = await client.webhooks.logs('webhook-uuid', {
+   *   per_page: 50
+   * });
+   *
+   * logs.forEach(log => {
+   *   const status = log.success ? 'OK' : 'FAILED';
+   *   console.log(`${log.event} - ${status} (${log.response_time_ms}ms)`);
+   * });
+   * ```
+   */
+  async logs(id, options = {}, requestOptions) {
+    return this.http.get(
+      `/webhooks/${id}/logs`,
+      options,
+      requestOptions
+    );
+  }
+};
+
+// src/utils/webhook-verify.ts
+function parseSignatureHeader(header) {
+  const parts = header.split(",");
+  let timestamp;
+  let signature;
+  for (const part of parts) {
+    const splitIndex = part.indexOf("=");
+    if (splitIndex === -1) continue;
+    const key = part.substring(0, splitIndex);
+    const value = part.substring(splitIndex + 1);
+    if (key === "t") {
+      timestamp = parseInt(value, 10);
+    } else if (key === "v1") {
+      signature = value;
+    }
+  }
+  if (timestamp === void 0 || signature === void 0) {
+    return null;
+  }
+  return { timestamp, signature };
+}
+async function computeSignature(payload, timestamp, secret) {
+  const signedPayload = `${timestamp}.${payload}`;
+  const encoder = new TextEncoder();
+  const keyData = encoder.encode(secret);
+  const messageData = encoder.encode(signedPayload);
+  const cryptoKey = await crypto.subtle.importKey(
+    "raw",
+    keyData,
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const signatureBuffer = await crypto.subtle.sign(
+    "HMAC",
+    cryptoKey,
+    messageData
+  );
+  return Array.from(new Uint8Array(signatureBuffer)).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function secureCompare(a, b) {
+  if (a.length !== b.length) {
+    return false;
+  }
+  let result = 0;
+  for (let i = 0; i < a.length; i++) {
+    result |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  }
+  return result === 0;
+}
+var ScellWebhooks = {
+  /**
+   * Verify webhook signature
+   *
+   * @param payload - Raw request body as string
+   * @param signature - Value of X-Scell-Signature header
+   * @param secret - Your webhook secret (whsec_...)
+   * @param options - Verification options
+   * @returns True if signature is valid
+   *
+   * @example
+   * ```typescript
+   * const isValid = await ScellWebhooks.verifySignature(
+   *   rawBody,
+   *   req.headers['x-scell-signature'],
+   *   'whsec_abc123...'
+   * );
+   * ```
+   */
+  async verifySignature(payload, signature, secret, options = {}) {
+    const { tolerance = 300 } = options;
+    const parsed = parseSignatureHeader(signature);
+    if (!parsed) {
+      return false;
+    }
+    const { timestamp, signature: providedSignature } = parsed;
+    const now = Math.floor(Date.now() / 1e3);
+    if (Math.abs(now - timestamp) > tolerance) {
+      return false;
+    }
+    const expectedSignature = await computeSignature(payload, timestamp, secret);
+    return secureCompare(expectedSignature, providedSignature);
+  },
+  /**
+   * Verify webhook signature synchronously using Node.js crypto
+   * (Only works in Node.js environment)
+   *
+   * @param payload - Raw request body as string
+   * @param signature - Value of X-Scell-Signature header
+   * @param secret - Your webhook secret (whsec_...)
+   * @param options - Verification options
+   * @returns True if signature is valid
+   */
+  verifySignatureSync(payload, signature, secret, options = {}) {
+    const { tolerance = 300 } = options;
+    const parsed = parseSignatureHeader(signature);
+    if (!parsed) {
+      return false;
+    }
+    const { timestamp, signature: providedSignature } = parsed;
+    const now = Math.floor(Date.now() / 1e3);
+    if (Math.abs(now - timestamp) > tolerance) {
+      return false;
+    }
+    const crypto2 = __require("crypto");
+    const signedPayload = `${timestamp}.${payload}`;
+    const expectedSignature = crypto2.createHmac("sha256", secret).update(signedPayload).digest("hex");
+    try {
+      return crypto2.timingSafeEqual(
+        Buffer.from(expectedSignature),
+        Buffer.from(providedSignature)
+      );
+    } catch {
+      return false;
+    }
+  },
+  /**
+   * Parse webhook payload
+   *
+   * @param payload - Raw request body as string
+   * @returns Parsed webhook payload
+   *
+   * @example
+   * ```typescript
+   * const event = ScellWebhooks.parsePayload<InvoiceWebhookData>(rawBody);
+   * if (event.event === 'invoice.validated') {
+   *   console.log('Invoice validated:', event.data.invoice_number);
+   * }
+   * ```
+   */
+  parsePayload(payload) {
+    return JSON.parse(payload);
+  },
+  /**
+   * Construct a test webhook event for local testing
+   *
+   * @param event - Event type
+   * @param data - Event data
+   * @param secret - Webhook secret for signing
+   * @returns Object with payload and headers for testing
+   */
+  async constructTestEvent(event, data, secret) {
+    const timestamp = Math.floor(Date.now() / 1e3);
+    const webhookPayload = {
+      event,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      data
+    };
+    const payload = JSON.stringify(webhookPayload);
+    const signature = await computeSignature(payload, timestamp, secret);
+    return {
+      payload,
+      headers: {
+        "X-Scell-Signature": `t=${timestamp},v1=${signature}`,
+        "X-Scell-Event": event,
+        "X-Scell-Delivery": crypto.randomUUID(),
+        "Content-Type": "application/json"
+      }
+    };
+  }
+};
+
+// src/index.ts
+init_errors();
+var ScellClient = class {
+  http;
+  /** Authentication operations */
+  auth;
+  /** Company management */
+  companies;
+  /** API key management */
+  apiKeys;
+  /** Balance and transactions */
+  balance;
+  /** Webhook management */
+  webhooks;
+  /** Invoice listing (read-only via dashboard) */
+  invoices;
+  /** Signature listing (read-only via dashboard) */
+  signatures;
+  /**
+   * Create a new Scell Dashboard Client
+   *
+   * @param token - Bearer token from login
+   * @param config - Client configuration
+   *
+   * @example
+   * ```typescript
+   * const client = new ScellClient('your-bearer-token', {
+   *   baseUrl: 'https://api.scell.io/api/v1',
+   *   timeout: 30000,
+   *   retry: { maxRetries: 3 }
+   * });
+   * ```
+   */
+  constructor(token, config = {}) {
+    this.http = new HttpClient("bearer", token, config);
+    this.auth = new AuthResource(this.http);
+    this.companies = new CompaniesResource(this.http);
+    this.apiKeys = new ApiKeysResource(this.http);
+    this.balance = new BalanceResource(this.http);
+    this.webhooks = new WebhooksResource(this.http);
+    this.invoices = new InvoicesResource(this.http);
+    this.signatures = new SignaturesResource(this.http);
+  }
+};
+var ScellApiClient = class {
+  http;
+  /** Invoice operations (create, download, convert) */
+  invoices;
+  /** Signature operations (create, download, remind, cancel) */
+  signatures;
+  /**
+   * Create a new Scell API Client
+   *
+   * @param apiKey - Your API key (from dashboard)
+   * @param config - Client configuration
+   *
+   * @example
+   * ```typescript
+   * // Production client
+   * const client = new ScellApiClient('sk_live_xxx');
+   *
+   * // Sandbox client
+   * const sandboxClient = new ScellApiClient('sk_test_xxx', {
+   *   baseUrl: 'https://api.scell.io/api/v1/sandbox'
+   * });
+   * ```
+   */
+  constructor(apiKey, config = {}) {
+    this.http = new HttpClient("api-key", apiKey, config);
+    this.invoices = new InvoicesResource(this.http);
+    this.signatures = new SignaturesResource(this.http);
+  }
+};
+
+export { ScellApiClient, ScellAuth, ScellAuthenticationError, ScellAuthorizationError, ScellClient, ScellError, ScellInsufficientBalanceError, ScellNetworkError, ScellNotFoundError, ScellRateLimitError, ScellServerError, ScellTimeoutError, ScellValidationError, ScellWebhooks, createRetryWrapper, withRetry };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map