@scell/sdk 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,2292 @@
+/**
+ * Retry utility with exponential backoff and jitter
+ *
+ * @packageDocumentation
+ */
+/**
+ * Retry configuration options
+ */
+interface RetryOptions {
+    /** Maximum number of retry attempts (default: 3) */
+    maxRetries?: number | undefined;
+    /** Base delay in milliseconds (default: 1000) */
+    baseDelay?: number | undefined;
+    /** Maximum delay in milliseconds (default: 30000) */
+    maxDelay?: number | undefined;
+    /** Jitter factor (0-1, default: 0.1) */
+    jitterFactor?: number | undefined;
+    /** Custom function to determine if error is retryable */
+    isRetryable?: ((error: unknown) => boolean) | undefined;
+}
+/**
+ * Execute a function with retry logic
+ *
+ * @param fn - Async function to execute
+ * @param options - Retry options
+ * @returns Result of the function
+ *
+ * @example
+ * ```typescript
+ * const result = await withRetry(
+ *   () => client.invoices.create(data),
+ *   { maxRetries: 5 }
+ * );
+ * ```
+ */
+declare function withRetry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;
+/**
+ * Create a retry wrapper with pre-configured options
+ *
+ * @example
+ * ```typescript
+ * const retry = createRetryWrapper({ maxRetries: 5 });
+ * const result = await retry(() => client.invoices.create(data));
+ * ```
+ */
+declare function createRetryWrapper(defaultOptions?: RetryOptions): <T>(fn: () => Promise<T>, options?: RetryOptions) => Promise<T>;
+
+/**
+ * Scell HTTP Client
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Authentication mode
+ */
+type AuthMode = 'bearer' | 'api-key';
+/**
+ * Client configuration options
+ */
+interface ClientConfig {
+    /** Base URL for the API (default: https://api.scell.io/api/v1) */
+    baseUrl?: string | undefined;
+    /** Request timeout in milliseconds (default: 30000) */
+    timeout?: number | undefined;
+    /** Retry configuration */
+    retry?: RetryOptions | undefined;
+    /** Enable automatic retries (default: true) */
+    enableRetry?: boolean | undefined;
+    /** Custom fetch implementation */
+    fetch?: typeof fetch | undefined;
+}
+/**
+ * Request options for individual requests
+ */
+interface RequestOptions {
+    /** Override timeout for this request */
+    timeout?: number | undefined;
+    /** Skip retry for this request */
+    skipRetry?: boolean | undefined;
+    /** Additional headers */
+    headers?: Record<string, string> | undefined;
+    /** Abort signal */
+    signal?: AbortSignal | undefined;
+}
+/**
+ * HTTP client for Scell API
+ */
+declare class HttpClient {
+    private readonly baseUrl;
+    private readonly timeout;
+    private readonly retryOptions;
+    private readonly enableRetry;
+    private readonly fetchFn;
+    private readonly authMode;
+    private readonly authToken;
+    constructor(authMode: AuthMode, authToken: string, config?: ClientConfig);
+    /**
+     * Build URL with query parameters
+     */
+    private buildUrl;
+    /**
+     * Build headers for request
+     */
+    private buildHeaders;
+    /**
+     * Execute HTTP request
+     */
+    private executeRequest;
+    /**
+     * Execute request with optional retry
+     */
+    private request;
+    /**
+     * GET request
+     */
+    get<T>(path: string, query?: Record<string, string | number | boolean | undefined>, options?: RequestOptions): Promise<T>;
+    /**
+     * POST request
+     */
+    post<T>(path: string, body?: unknown, options?: RequestOptions): Promise<T>;
+    /**
+     * PUT request
+     */
+    put<T>(path: string, body?: unknown, options?: RequestOptions): Promise<T>;
+    /**
+     * PATCH request
+     */
+    patch<T>(path: string, body?: unknown, options?: RequestOptions): Promise<T>;
+    /**
+     * DELETE request
+     */
+    delete<T>(path: string, options?: RequestOptions): Promise<T>;
+}
+
+/**
+ * Common types used across the SDK
+ */
+/**
+ * Environment mode for API operations
+ */
+type Environment = 'sandbox' | 'production';
+/**
+ * ISO 8601 date string (YYYY-MM-DD)
+ */
+type DateString = string;
+/**
+ * ISO 8601 datetime string
+ */
+type DateTimeString = string;
+/**
+ * UUID string
+ */
+type UUID = string;
+/**
+ * French SIRET number (14 digits)
+ */
+type Siret = string;
+/**
+ * French SIREN number (9 digits)
+ */
+type Siren = string;
+/**
+ * Currency code (ISO 4217)
+ */
+type CurrencyCode = string;
+/**
+ * Address structure
+ */
+interface Address {
+    line1: string;
+    line2?: string | undefined;
+    postal_code: string;
+    city: string;
+    country?: string | undefined;
+}
+/**
+ * Pagination metadata
+ */
+interface PaginationMeta {
+    current_page: number;
+    last_page: number;
+    per_page: number;
+    total: number;
+}
+/**
+ * Paginated response wrapper
+ */
+interface PaginatedResponse<T> {
+    data: T[];
+    meta: PaginationMeta;
+}
+/**
+ * Single item response wrapper
+ */
+interface SingleResponse<T> {
+    data: T;
+}
+/**
+ * Message response
+ */
+interface MessageResponse {
+    message: string;
+}
+/**
+ * Message with data response
+ */
+interface MessageWithDataResponse<T> {
+    message: string;
+    data: T;
+}
+/**
+ * Pagination options for list requests
+ */
+interface PaginationOptions {
+    page?: number | undefined;
+    per_page?: number | undefined;
+}
+/**
+ * Date range filter options
+ */
+interface DateRangeOptions {
+    from?: DateString | undefined;
+    to?: DateString | undefined;
+}
+/**
+ * API error response structure
+ */
+interface ApiErrorResponse {
+    message: string;
+    errors?: Record<string, string[]> | undefined;
+    code?: string | undefined;
+}
+
+/**
+ * API Key entity
+ */
+interface ApiKey {
+    id: UUID;
+    name: string;
+    company_id: UUID;
+    key_prefix: string;
+    environment: Environment;
+    permissions: string[];
+    rate_limit: number;
+    last_used_at: DateTimeString | null;
+    expires_at: DateTimeString | null;
+    created_at: DateTimeString;
+}
+/**
+ * API Key with full key (returned on creation only)
+ */
+interface ApiKeyWithSecret extends ApiKey {
+    key: string;
+}
+/**
+ * API Key creation input
+ */
+interface CreateApiKeyInput {
+    name: string;
+    company_id: UUID;
+    environment: Environment;
+    permissions?: string[] | undefined;
+    expires_at?: DateTimeString | undefined;
+}
+
+/**
+ * API Keys Resource
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * API Keys resource
+ *
+ * @example
+ * ```typescript
+ * // Create an API key for a company
+ * const apiKey = await client.apiKeys.create({
+ *   name: 'Production Key',
+ *   company_id: 'company-uuid',
+ *   environment: 'production'
+ * });
+ *
+ * // Store the key securely!
+ * console.log('API Key:', apiKey.key);
+ * ```
+ */
+declare class ApiKeysResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * 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}...`);
+     * });
+     * ```
+     */
+    list(requestOptions?: RequestOptions): Promise<{
+        data: ApiKey[];
+    }>;
+    /**
+     * 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}`);
+     * ```
+     */
+    get(id: string, requestOptions?: RequestOptions): Promise<SingleResponse<ApiKey>>;
+    /**
+     * 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);
+     * ```
+     */
+    create(input: CreateApiKeyInput, requestOptions?: RequestOptions): Promise<MessageWithDataResponse<ApiKeyWithSecret>>;
+    /**
+     * 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');
+     * ```
+     */
+    delete(id: string, requestOptions?: RequestOptions): Promise<MessageResponse>;
+}
+
+/**
+ * User entity
+ */
+interface User {
+    id: UUID;
+    name: string;
+    email: string;
+    email_verified_at: DateTimeString | null;
+    is_admin: boolean;
+    created_at: DateTimeString;
+    updated_at: DateTimeString;
+}
+/**
+ * Login credentials
+ */
+interface LoginCredentials {
+    email: string;
+    password: string;
+}
+/**
+ * Registration input
+ */
+interface RegisterInput {
+    name: string;
+    email: string;
+    password: string;
+    password_confirmation: string;
+}
+/**
+ * Auth response with token
+ */
+interface AuthResponse {
+    message: string;
+    user: User;
+    token: string;
+}
+/**
+ * Password reset request input
+ */
+interface ForgotPasswordInput {
+    email: string;
+}
+/**
+ * Password reset input
+ */
+interface ResetPasswordInput {
+    email: string;
+    token: string;
+    password: string;
+    password_confirmation: string;
+}
+
+/**
+ * Auth Resource
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Auth API resource
+ *
+ * Note: Most auth endpoints are only used during initial setup.
+ * After login, use the returned token to create a ScellClient.
+ *
+ * @example
+ * ```typescript
+ * // Login and get token
+ * const auth = await ScellAuth.login({
+ *   email: 'user@example.com',
+ *   password: 'password'
+ * });
+ *
+ * // Create client with token
+ * const client = new ScellClient(auth.token);
+ *
+ * // Get current user
+ * const user = await client.auth.me();
+ * ```
+ */
+declare class AuthResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * 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})`);
+     * ```
+     */
+    me(requestOptions?: RequestOptions): Promise<SingleResponse<User>>;
+    /**
+     * Logout (revoke current token)
+     *
+     * @param requestOptions - Request options
+     * @returns Logout confirmation
+     *
+     * @example
+     * ```typescript
+     * await client.auth.logout();
+     * // Token is now invalid
+     * ```
+     */
+    logout(requestOptions?: RequestOptions): Promise<MessageResponse>;
+}
+/**
+ * Static auth methods (don't require authentication)
+ *
+ * @example
+ * ```typescript
+ * import { ScellAuth } from '@scell/sdk';
+ *
+ * // Register new user
+ * const auth = await ScellAuth.register({
+ *   name: 'John Doe',
+ *   email: 'john@example.com',
+ *   password: 'securepassword123',
+ *   password_confirmation: 'securepassword123'
+ * });
+ *
+ * // Login existing user
+ * const auth = await ScellAuth.login({
+ *   email: 'john@example.com',
+ *   password: 'securepassword123'
+ * });
+ *
+ * // Use the token
+ * const client = new ScellClient(auth.token);
+ * ```
+ */
+declare const ScellAuth: {
+    /**
+     * Default base URL for auth requests
+     */
+    baseUrl: string;
+    /**
+     * 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);
+     * ```
+     */
+    register(input: RegisterInput, baseUrl?: string): Promise<AuthResponse>;
+    /**
+     * 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);
+     * ```
+     */
+    login(credentials: LoginCredentials, baseUrl?: string): Promise<AuthResponse>;
+    /**
+     * 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');
+     * ```
+     */
+    forgotPassword(input: ForgotPasswordInput, baseUrl?: string): Promise<MessageResponse>;
+    /**
+     * 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!'
+     * });
+     * ```
+     */
+    resetPassword(input: ResetPasswordInput, baseUrl?: string): Promise<MessageResponse>;
+};
+
+/**
+ * Transaction type
+ */
+type TransactionType = 'credit' | 'debit';
+/**
+ * Transaction service
+ */
+type TransactionService = 'invoice' | 'signature' | 'manual' | 'admin';
+/**
+ * Balance entity
+ */
+interface Balance {
+    amount: number;
+    currency: CurrencyCode;
+    auto_reload_enabled: boolean;
+    auto_reload_threshold: number | null;
+    auto_reload_amount: number | null;
+    low_balance_alert_threshold: number;
+    critical_balance_alert_threshold: number;
+}
+/**
+ * Transaction entity
+ */
+interface Transaction {
+    id: UUID;
+    type: TransactionType;
+    service: TransactionService;
+    amount: number;
+    balance_before: number;
+    balance_after: number;
+    description: string;
+    reference_type: string | null;
+    reference_id: UUID | null;
+    created_at: DateTimeString;
+}
+/**
+ * Balance reload input
+ */
+interface ReloadBalanceInput {
+    /** Amount to reload (10-10000 EUR) */
+    amount: number;
+}
+/**
+ * Balance reload response
+ */
+interface ReloadBalanceResponse {
+    message: string;
+    transaction: {
+        id: UUID;
+        amount: number;
+        balance_after: number;
+    };
+}
+/**
+ * Balance settings update input
+ */
+interface UpdateBalanceSettingsInput {
+    auto_reload_enabled?: boolean | undefined;
+    auto_reload_threshold?: number | undefined;
+    auto_reload_amount?: number | undefined;
+    low_balance_alert_threshold?: number | undefined;
+    critical_balance_alert_threshold?: number | undefined;
+}
+/**
+ * Transaction list filter options
+ */
+interface TransactionListOptions extends PaginationOptions, DateRangeOptions {
+    type?: TransactionType | undefined;
+    service?: TransactionService | undefined;
+}
+
+/**
+ * Balance Resource
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Balance API resource
+ *
+ * @example
+ * ```typescript
+ * // Check balance
+ * const balance = await client.balance.get();
+ * console.log(`Current balance: ${balance.amount} ${balance.currency}`);
+ *
+ * // Reload balance
+ * await client.balance.reload({ amount: 100 });
+ *
+ * // View transactions
+ * const transactions = await client.balance.transactions({
+ *   type: 'debit',
+ *   service: 'invoice'
+ * });
+ * ```
+ */
+declare class BalanceResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * 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!');
+     * }
+     * ```
+     */
+    get(requestOptions?: RequestOptions): Promise<SingleResponse<Balance>>;
+    /**
+     * 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}`);
+     * ```
+     */
+    reload(input: ReloadBalanceInput, requestOptions?: RequestOptions): Promise<ReloadBalanceResponse>;
+    /**
+     * 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
+     * });
+     * ```
+     */
+    updateSettings(input: UpdateBalanceSettingsInput, requestOptions?: RequestOptions): Promise<MessageWithDataResponse<Partial<Balance>>>;
+    /**
+     * 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`);
+     * });
+     * ```
+     */
+    transactions(options?: TransactionListOptions, requestOptions?: RequestOptions): Promise<PaginatedResponse<Transaction>>;
+}
+
+/**
+ * Company KYC status
+ */
+type CompanyStatus = 'pending_kyc' | 'active' | 'suspended';
+/**
+ * Company entity
+ */
+interface Company {
+    id: UUID;
+    name: string;
+    siret: Siret;
+    siren: Siren | null;
+    vat_number: string | null;
+    legal_form: string | null;
+    address_line1: string;
+    address_line2: string | null;
+    postal_code: string;
+    city: string;
+    country: string;
+    phone: string | null;
+    email: string | null;
+    website: string | null;
+    logo_url: string | null;
+    status: CompanyStatus;
+    kyc_completed_at: DateTimeString | null;
+    created_at: DateTimeString;
+    updated_at: DateTimeString;
+}
+/**
+ * Company creation input
+ */
+interface CreateCompanyInput {
+    name: string;
+    siret: Siret;
+    vat_number?: string | undefined;
+    legal_form?: string | undefined;
+    address_line1: string;
+    address_line2?: string | undefined;
+    postal_code: string;
+    city: string;
+    country?: string | undefined;
+    phone?: string | undefined;
+    email?: string | undefined;
+    website?: string | undefined;
+}
+/**
+ * Company update input
+ */
+interface UpdateCompanyInput {
+    name?: string | undefined;
+    siret?: Siret | undefined;
+    vat_number?: string | undefined;
+    legal_form?: string | undefined;
+    address_line1?: string | undefined;
+    address_line2?: string | undefined;
+    postal_code?: string | undefined;
+    city?: string | undefined;
+    country?: string | undefined;
+    phone?: string | undefined;
+    email?: string | undefined;
+    website?: string | undefined;
+}
+/**
+ * KYC initiation response
+ */
+interface KycInitiateResponse {
+    message: string;
+    kyc_reference: string;
+    redirect_url: string;
+}
+/**
+ * KYC status response
+ */
+interface KycStatusResponse {
+    status: CompanyStatus;
+    kyc_reference: string | null;
+    kyc_completed_at: DateTimeString | null;
+    message: string;
+}
+
+/**
+ * Companies Resource
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Companies API resource
+ *
+ * @example
+ * ```typescript
+ * // Create a company
+ * const company = await client.companies.create({
+ *   name: 'My Company',
+ *   siret: '12345678901234',
+ *   address_line1: '1 Rue de la Paix',
+ *   postal_code: '75001',
+ *   city: 'Paris'
+ * });
+ *
+ * // Initiate KYC
+ * const kyc = await client.companies.initiateKyc(company.id);
+ * console.log('KYC URL:', kyc.redirect_url);
+ * ```
+ */
+declare class CompaniesResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * 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));
+     * ```
+     */
+    list(requestOptions?: RequestOptions): Promise<{
+        data: Company[];
+    }>;
+    /**
+     * 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);
+     * ```
+     */
+    get(id: string, requestOptions?: RequestOptions): Promise<SingleResponse<Company>>;
+    /**
+     * 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'
+     * });
+     * ```
+     */
+    create(input: CreateCompanyInput, requestOptions?: RequestOptions): Promise<MessageWithDataResponse<Company>>;
+    /**
+     * 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'
+     * });
+     * ```
+     */
+    update(id: string, input: UpdateCompanyInput, requestOptions?: RequestOptions): Promise<MessageWithDataResponse<Company>>;
+    /**
+     * Delete a company
+     *
+     * @param id - Company UUID
+     * @param requestOptions - Request options
+     * @returns Deletion confirmation
+     *
+     * @example
+     * ```typescript
+     * await client.companies.delete('company-uuid');
+     * ```
+     */
+    delete(id: string, requestOptions?: RequestOptions): Promise<MessageResponse>;
+    /**
+     * 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
+     * ```
+     */
+    initiateKyc(id: string, requestOptions?: RequestOptions): Promise<KycInitiateResponse>;
+    /**
+     * 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);
+     * }
+     * ```
+     */
+    kycStatus(id: string, requestOptions?: RequestOptions): Promise<KycStatusResponse>;
+}
+
+/**
+ * Invoice direction
+ */
+type InvoiceDirection = 'outgoing' | 'incoming';
+/**
+ * Invoice output format
+ */
+type InvoiceFormat = 'facturx' | 'ubl' | 'cii';
+/**
+ * Invoice status
+ */
+type InvoiceStatus = 'draft' | 'pending' | 'validated' | 'converted' | 'transmitted' | 'accepted' | 'rejected' | 'error';
+/**
+ * Invoice download file type
+ */
+type InvoiceDownloadType = 'original' | 'converted' | 'pdf';
+/**
+ * Invoice line item
+ */
+interface InvoiceLine {
+    line_number: number;
+    description: string;
+    quantity: number;
+    unit_price: number;
+    tax_rate: number;
+    total_ht: number;
+    total_tax: number;
+    total_ttc: number;
+}
+/**
+ * Invoice party (seller or buyer)
+ */
+interface InvoiceParty {
+    siret: Siret;
+    name: string;
+    address: Address;
+}
+/**
+ * Invoice entity
+ */
+interface Invoice {
+    id: UUID;
+    external_id: string | null;
+    invoice_number: string;
+    direction: InvoiceDirection;
+    output_format: InvoiceFormat;
+    issue_date: DateString;
+    due_date: DateString | null;
+    currency: CurrencyCode;
+    total_ht: number;
+    total_tax: number;
+    total_ttc: number;
+    seller: InvoiceParty;
+    buyer: InvoiceParty;
+    lines: InvoiceLine[] | null;
+    status: InvoiceStatus;
+    status_message: string | null;
+    environment: Environment;
+    archive_enabled: boolean;
+    amount_charged: number | null;
+    created_at: DateTimeString;
+    validated_at: DateTimeString | null;
+    transmitted_at: DateTimeString | null;
+    completed_at: DateTimeString | null;
+}
+/**
+ * Invoice line input for creation
+ */
+interface InvoiceLineInput {
+    description: string;
+    quantity: number;
+    unit_price: number;
+    tax_rate: number;
+    total_ht: number;
+    total_tax: number;
+    total_ttc: number;
+}
+/**
+ * Invoice creation input
+ */
+interface CreateInvoiceInput {
+    /** Your external reference ID */
+    external_id?: string | undefined;
+    /** Invoice number (required) */
+    invoice_number: string;
+    /** Direction: outgoing (sale) or incoming (purchase) */
+    direction: InvoiceDirection;
+    /** Output format for electronic invoice */
+    output_format: InvoiceFormat;
+    /** Issue date (YYYY-MM-DD) */
+    issue_date: DateString;
+    /** Due date (YYYY-MM-DD) */
+    due_date?: DateString | undefined;
+    /** Currency code (default: EUR) */
+    currency?: CurrencyCode | undefined;
+    /** Total excluding tax */
+    total_ht: number;
+    /** Total tax amount */
+    total_tax: number;
+    /** Total including tax */
+    total_ttc: number;
+    /** Seller SIRET (14 digits) */
+    seller_siret: Siret;
+    /** Seller company name */
+    seller_name: string;
+    /** Seller address */
+    seller_address: Address;
+    /** Buyer SIRET (14 digits) */
+    buyer_siret: Siret;
+    /** Buyer company name */
+    buyer_name: string;
+    /** Buyer address */
+    buyer_address: Address;
+    /** Invoice line items */
+    lines: InvoiceLineInput[];
+    /** Enable 10-year archiving */
+    archive_enabled?: boolean | undefined;
+}
+/**
+ * Invoice list filter options
+ */
+interface InvoiceListOptions {
+    company_id?: UUID | undefined;
+    direction?: InvoiceDirection | undefined;
+    status?: InvoiceStatus | undefined;
+    environment?: Environment | undefined;
+    from?: DateString | undefined;
+    to?: DateString | undefined;
+    per_page?: number | undefined;
+}
+/**
+ * Invoice conversion input
+ */
+interface ConvertInvoiceInput {
+    invoice_id: UUID;
+    target_format: InvoiceFormat;
+}
+/**
+ * Invoice download response
+ */
+interface InvoiceDownloadResponse {
+    url: string;
+    expires_at: DateTimeString;
+}
+/**
+ * Audit trail entry
+ */
+interface AuditTrailEntry {
+    action: string;
+    details: string;
+    actor_ip: string | null;
+    created_at: DateTimeString;
+}
+/**
+ * Audit trail response
+ */
+interface AuditTrailResponse {
+    data: AuditTrailEntry[];
+    integrity_valid: boolean;
+}
+
+/**
+ * Invoices Resource
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Invoices API resource
+ *
+ * @example
+ * ```typescript
+ * // List invoices
+ * const invoices = await client.invoices.list({
+ *   direction: 'outgoing',
+ *   status: 'validated'
+ * });
+ *
+ * // Create an invoice
+ * const invoice = await client.invoices.create({
+ *   invoice_number: 'FACT-2024-001',
+ *   direction: 'outgoing',
+ *   output_format: 'facturx',
+ *   // ...
+ * });
+ *
+ * // Download invoice
+ * const download = await client.invoices.download(invoice.id, 'pdf');
+ * console.log('Download URL:', download.url);
+ * ```
+ */
+declare class InvoicesResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * 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`);
+     * ```
+     */
+    list(options?: InvoiceListOptions, requestOptions?: RequestOptions): Promise<PaginatedResponse<Invoice>>;
+    /**
+     * 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);
+     * ```
+     */
+    get(id: string, requestOptions?: RequestOptions): Promise<SingleResponse<Invoice>>;
+    /**
+     * 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
+     *   }]
+     * });
+     * ```
+     */
+    create(input: CreateInvoiceInput, requestOptions?: RequestOptions): Promise<MessageWithDataResponse<Invoice>>;
+    /**
+     * 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);
+     * ```
+     */
+    download(id: string, type: InvoiceDownloadType, requestOptions?: RequestOptions): Promise<InvoiceDownloadResponse>;
+    /**
+     * 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));
+     * }
+     * ```
+     */
+    auditTrail(id: string, requestOptions?: RequestOptions): Promise<AuditTrailResponse>;
+    /**
+     * 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'
+     * });
+     * ```
+     */
+    convert(input: ConvertInvoiceInput, requestOptions?: RequestOptions): Promise<{
+        message: string;
+        invoice_id: string;
+        target_format: string;
+    }>;
+}
+
+/**
+ * Signer authentication method
+ */
+type SignerAuthMethod = 'email' | 'sms' | 'both';
+/**
+ * Signer status
+ */
+type SignerStatus = 'pending' | 'signed' | 'refused';
+/**
+ * Signature status
+ */
+type SignatureStatus = 'pending' | 'waiting_signers' | 'partially_signed' | 'completed' | 'refused' | 'expired' | 'error';
+/**
+ * Signature download file type
+ */
+type SignatureDownloadType = 'original' | 'signed' | 'audit_trail';
+/**
+ * Signature position on document
+ */
+interface SignaturePosition {
+    page: number;
+    x: number;
+    y: number;
+    width?: number | undefined;
+    height?: number | undefined;
+}
+/**
+ * UI customization for signature page (white-label)
+ */
+interface SignatureUIConfig {
+    logo_url?: string | undefined;
+    primary_color?: string | undefined;
+    company_name?: string | undefined;
+}
+/**
+ * Signer entity
+ */
+interface Signer {
+    id: UUID;
+    first_name: string;
+    last_name: string;
+    full_name: string;
+    email: string | null;
+    phone: string | null;
+    auth_method: SignerAuthMethod;
+    status: SignerStatus;
+    signing_url: string | null;
+    signed_at: DateTimeString | null;
+    refused_at: DateTimeString | null;
+}
+/**
+ * Signature entity
+ */
+interface Signature {
+    id: UUID;
+    external_id: string | null;
+    title: string;
+    description: string | null;
+    document_name: string;
+    document_size: number;
+    signers: Signer[] | null;
+    status: SignatureStatus;
+    status_message: string | null;
+    environment: Environment;
+    archive_enabled: boolean;
+    amount_charged: number | null;
+    expires_at: DateTimeString | null;
+    created_at: DateTimeString;
+    completed_at: DateTimeString | null;
+}
+/**
+ * Signer input for creation
+ */
+interface SignerInput {
+    first_name: string;
+    last_name: string;
+    email?: string | undefined;
+    phone?: string | undefined;
+    auth_method: SignerAuthMethod;
+}
+/**
+ * Signature creation input
+ */
+interface CreateSignatureInput {
+    /** Your external reference ID */
+    external_id?: string | undefined;
+    /** Document title */
+    title: string;
+    /** Document description */
+    description?: string | undefined;
+    /** Base64-encoded document content */
+    document: string;
+    /** Document filename */
+    document_name: string;
+    /** List of signers (1-10) */
+    signers: SignerInput[];
+    /** Signature positions on the document */
+    signature_positions?: SignaturePosition[] | undefined;
+    /** White-label UI customization */
+    ui_config?: SignatureUIConfig | undefined;
+    /** Redirect URL after completion */
+    redirect_complete_url?: string | undefined;
+    /** Redirect URL after cancellation */
+    redirect_cancel_url?: string | undefined;
+    /** Expiration date (default: 30 days) */
+    expires_at?: DateTimeString | undefined;
+    /** Enable 10-year archiving */
+    archive_enabled?: boolean | undefined;
+}
+/**
+ * Signature list filter options
+ */
+interface SignatureListOptions {
+    company_id?: UUID | undefined;
+    status?: SignatureStatus | undefined;
+    environment?: Environment | undefined;
+    per_page?: number | undefined;
+}
+/**
+ * Signature download response
+ */
+interface SignatureDownloadResponse {
+    url: string;
+    expires_at: DateTimeString;
+}
+/**
+ * Signature reminder response
+ */
+interface SignatureRemindResponse {
+    message: string;
+    signers_reminded: number;
+}
+
+/**
+ * Signatures Resource
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Signatures API resource
+ *
+ * @example
+ * ```typescript
+ * // Create a signature request
+ * const signature = await client.signatures.create({
+ *   title: 'Employment Contract',
+ *   document: btoa(pdfContent), // Base64 encoded
+ *   document_name: 'contract.pdf',
+ *   signers: [{
+ *     first_name: 'John',
+ *     last_name: 'Doe',
+ *     email: 'john@example.com',
+ *     auth_method: 'email'
+ *   }]
+ * });
+ *
+ * // Send reminder
+ * await client.signatures.remind(signature.id);
+ * ```
+ */
+declare class SignaturesResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * 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`);
+     * ```
+     */
+    list(options?: SignatureListOptions, requestOptions?: RequestOptions): Promise<PaginatedResponse<Signature>>;
+    /**
+     * 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}`);
+     * });
+     * ```
+     */
+    get(id: string, requestOptions?: RequestOptions): Promise<SingleResponse<Signature>>;
+    /**
+     * 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}`);
+     * });
+     * ```
+     */
+    create(input: CreateSignatureInput, requestOptions?: RequestOptions): Promise<MessageWithDataResponse<Signature>>;
+    /**
+     * 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'
+     * );
+     * ```
+     */
+    download(id: string, type: SignatureDownloadType, requestOptions?: RequestOptions): Promise<SignatureDownloadResponse>;
+    /**
+     * 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`);
+     * ```
+     */
+    remind(id: string, requestOptions?: RequestOptions): Promise<SignatureRemindResponse>;
+    /**
+     * 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');
+     * ```
+     */
+    cancel(id: string, requestOptions?: RequestOptions): Promise<MessageResponse>;
+}
+
+/**
+ * Available webhook events
+ */
+type WebhookEvent = 'invoice.created' | 'invoice.validated' | 'invoice.transmitted' | 'invoice.accepted' | 'invoice.rejected' | 'invoice.error' | 'signature.created' | 'signature.waiting' | 'signature.signed' | 'signature.completed' | 'signature.refused' | 'signature.expired' | 'signature.error' | 'balance.low' | 'balance.critical';
+/**
+ * Webhook entity
+ */
+interface Webhook {
+    id: UUID;
+    company_id: UUID | null;
+    url: string;
+    events: WebhookEvent[];
+    is_active: boolean;
+    environment: Environment;
+    retry_count: number;
+    timeout_seconds: number;
+    failure_count: number;
+    last_triggered_at: DateTimeString | null;
+    last_success_at: DateTimeString | null;
+    last_failure_at: DateTimeString | null;
+    created_at: DateTimeString;
+}
+/**
+ * Webhook with secret (returned on creation)
+ */
+interface WebhookWithSecret extends Webhook {
+    secret: string;
+}
+/**
+ * Webhook creation input
+ */
+interface CreateWebhookInput {
+    url: string;
+    events: WebhookEvent[];
+    environment: Environment;
+    headers?: Record<string, string> | undefined;
+    retry_count?: number | undefined;
+    timeout_seconds?: number | undefined;
+}
+/**
+ * Webhook update input
+ */
+interface UpdateWebhookInput {
+    url?: string | undefined;
+    events?: WebhookEvent[] | undefined;
+    is_active?: boolean | undefined;
+    headers?: Record<string, string> | undefined;
+    retry_count?: number | undefined;
+    timeout_seconds?: number | undefined;
+}
+/**
+ * Webhook list filter options
+ */
+interface WebhookListOptions {
+    company_id?: UUID | undefined;
+}
+/**
+ * Webhook test response
+ */
+interface WebhookTestResponse {
+    success: boolean;
+    status_code?: number | undefined;
+    response_time_ms?: number | undefined;
+    error?: string | undefined;
+}
+/**
+ * Webhook log entry
+ */
+interface WebhookLog {
+    id: UUID;
+    event: string;
+    payload: Record<string, unknown>;
+    response_status: number | null;
+    response_body: string | null;
+    response_time_ms: number | null;
+    success: boolean;
+    error_message: string | null;
+    created_at: DateTimeString;
+}
+/**
+ * Webhook payload structure (received by your endpoint)
+ */
+interface WebhookPayload<T = unknown> {
+    event: WebhookEvent;
+    timestamp: DateTimeString;
+    data: T;
+}
+/**
+ * Invoice webhook payload data
+ */
+interface InvoiceWebhookData {
+    id: UUID;
+    invoice_number: string;
+    status: string;
+    environment: Environment;
+}
+/**
+ * Signature webhook payload data
+ */
+interface SignatureWebhookData {
+    id: UUID;
+    title: string;
+    status: string;
+    environment: Environment;
+    signer_id?: UUID | undefined;
+    signer_email?: string | undefined;
+}
+/**
+ * Balance webhook payload data
+ */
+interface BalanceWebhookData {
+    amount: number;
+    currency: string;
+    threshold: number;
+}
+
+/**
+ * Webhooks Resource
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Webhooks API resource
+ *
+ * @example
+ * ```typescript
+ * // Create a webhook
+ * const webhook = await client.webhooks.create({
+ *   url: 'https://myapp.com/webhooks/scell',
+ *   events: ['invoice.validated', 'signature.completed'],
+ *   environment: 'production'
+ * });
+ *
+ * // Store the secret securely!
+ * console.log('Webhook secret:', webhook.secret);
+ *
+ * // Test the webhook
+ * const test = await client.webhooks.test(webhook.id);
+ * console.log('Test success:', test.success);
+ * ```
+ */
+declare class WebhooksResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * 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'}`);
+     * });
+     * ```
+     */
+    list(options?: WebhookListOptions, requestOptions?: RequestOptions): Promise<{
+        data: Webhook[];
+    }>;
+    /**
+     * 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);
+     * ```
+     */
+    create(input: CreateWebhookInput, requestOptions?: RequestOptions): Promise<MessageWithDataResponse<WebhookWithSecret>>;
+    /**
+     * 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']
+     * });
+     * ```
+     */
+    update(id: string, input: UpdateWebhookInput, requestOptions?: RequestOptions): Promise<MessageWithDataResponse<Webhook>>;
+    /**
+     * Delete a webhook
+     *
+     * @param id - Webhook UUID
+     * @param requestOptions - Request options
+     * @returns Deletion confirmation
+     *
+     * @example
+     * ```typescript
+     * await client.webhooks.delete('webhook-uuid');
+     * ```
+     */
+    delete(id: string, requestOptions?: RequestOptions): Promise<MessageResponse>;
+    /**
+     * 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);
+     * ```
+     */
+    regenerateSecret(id: string, requestOptions?: RequestOptions): Promise<MessageWithDataResponse<WebhookWithSecret>>;
+    /**
+     * 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}`);
+     * }
+     * ```
+     */
+    test(id: string, requestOptions?: RequestOptions): Promise<WebhookTestResponse>;
+    /**
+     * 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)`);
+     * });
+     * ```
+     */
+    logs(id: string, options?: {
+        per_page?: number;
+    }, requestOptions?: RequestOptions): Promise<PaginatedResponse<WebhookLog>>;
+}
+
+/**
+ * Webhook signature verification utility
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Signature verification options
+ */
+interface VerifySignatureOptions {
+    /** Tolerance in seconds for timestamp validation (default: 300 = 5 minutes) */
+    tolerance?: number | undefined;
+}
+/**
+ * Scell Webhook signature verification utilities
+ *
+ * @example
+ * ```typescript
+ * import { ScellWebhooks } from '@scell/sdk';
+ *
+ * // In your webhook endpoint
+ * app.post('/webhooks/scell', async (req, res) => {
+ *   const signature = req.headers['x-scell-signature'];
+ *   const payload = JSON.stringify(req.body);
+ *
+ *   const isValid = await ScellWebhooks.verifySignature(
+ *     payload,
+ *     signature,
+ *     process.env.WEBHOOK_SECRET
+ *   );
+ *
+ *   if (!isValid) {
+ *     return res.status(401).send('Invalid signature');
+ *   }
+ *
+ *   // Process the webhook
+ *   const event = ScellWebhooks.parsePayload(payload);
+ *   console.log('Received event:', event.event);
+ * });
+ * ```
+ */
+declare const 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...'
+     * );
+     * ```
+     */
+    verifySignature(payload: string, signature: string, secret: string, options?: VerifySignatureOptions): Promise<boolean>;
+    /**
+     * 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: string, signature: string, secret: string, options?: VerifySignatureOptions): boolean;
+    /**
+     * 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<T = unknown>(payload: string): WebhookPayload<T>;
+    /**
+     * 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
+     */
+    constructTestEvent<T>(event: string, data: T, secret: string): Promise<{
+        payload: string;
+        headers: Record<string, string>;
+    }>;
+};
+
+/**
+ * Scell SDK Error Classes
+ *
+ * @packageDocumentation
+ */
+/**
+ * Base error class for all Scell API errors
+ */
+declare class ScellError extends Error {
+    /** HTTP status code */
+    readonly status: number;
+    /** Error code from API */
+    readonly code: string | undefined;
+    /** Original response body */
+    readonly body: unknown;
+    constructor(message: string, status: number, code?: string, body?: unknown);
+}
+/**
+ * Error thrown when authentication fails (401)
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await client.invoices.list();
+ * } catch (error) {
+ *   if (error instanceof ScellAuthenticationError) {
+ *     console.log('Invalid or expired token');
+ *   }
+ * }
+ * ```
+ */
+declare class ScellAuthenticationError extends ScellError {
+    constructor(message?: string, body?: unknown);
+}
+/**
+ * Error thrown when authorization fails (403)
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await client.admin.users();
+ * } catch (error) {
+ *   if (error instanceof ScellAuthorizationError) {
+ *     console.log('Insufficient permissions');
+ *   }
+ * }
+ * ```
+ */
+declare class ScellAuthorizationError extends ScellError {
+    constructor(message?: string, body?: unknown);
+}
+/**
+ * Error thrown when validation fails (422)
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await client.invoices.create(invalidData);
+ * } catch (error) {
+ *   if (error instanceof ScellValidationError) {
+ *     console.log('Validation errors:', error.errors);
+ *   }
+ * }
+ * ```
+ */
+declare class ScellValidationError extends ScellError {
+    /** Field-level validation errors */
+    readonly errors: Record<string, string[]>;
+    constructor(message: string, errors?: Record<string, string[]>, body?: unknown);
+    /**
+     * Get all error messages as a flat array
+     */
+    getAllMessages(): string[];
+    /**
+     * Get error messages for a specific field
+     */
+    getFieldErrors(field: string): string[];
+    /**
+     * Check if a specific field has errors
+     */
+    hasFieldError(field: string): boolean;
+}
+/**
+ * Error thrown when rate limit is exceeded (429)
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await client.invoices.create(data);
+ * } catch (error) {
+ *   if (error instanceof ScellRateLimitError) {
+ *     console.log(`Retry after ${error.retryAfter} seconds`);
+ *   }
+ * }
+ * ```
+ */
+declare class ScellRateLimitError extends ScellError {
+    /** Seconds to wait before retrying */
+    readonly retryAfter: number | undefined;
+    constructor(message?: string, retryAfter?: number, body?: unknown);
+}
+/**
+ * Error thrown when a resource is not found (404)
+ */
+declare class ScellNotFoundError extends ScellError {
+    constructor(message?: string, body?: unknown);
+}
+/**
+ * Error thrown when the API returns a server error (5xx)
+ */
+declare class ScellServerError extends ScellError {
+    constructor(message?: string, status?: number, body?: unknown);
+}
+/**
+ * Error thrown when insufficient balance for an operation
+ */
+declare class ScellInsufficientBalanceError extends ScellError {
+    constructor(message?: string, body?: unknown);
+}
+/**
+ * Error thrown for network-related issues
+ */
+declare class ScellNetworkError extends ScellError {
+    readonly originalError: Error;
+    constructor(message: string, originalError: Error);
+}
+/**
+ * Error thrown when request times out
+ */
+declare class ScellTimeoutError extends ScellError {
+    constructor(message?: string);
+}
+
+/**
+ * Scell.io Official TypeScript SDK
+ *
+ * @packageDocumentation
+ *
+ * @example
+ * ```typescript
+ * import { ScellClient, ScellApiClient, ScellAuth, ScellWebhooks } from '@scell/sdk';
+ *
+ * // Dashboard client (Bearer token)
+ * const auth = await ScellAuth.login({ email, password });
+ * const client = new ScellClient(auth.token);
+ *
+ * // API client (X-API-Key)
+ * const apiClient = new ScellApiClient('your-api-key');
+ *
+ * // Create invoice
+ * const invoice = await apiClient.invoices.create({...});
+ *
+ * // Verify webhook
+ * const isValid = await ScellWebhooks.verifySignature(payload, signature, secret);
+ * ```
+ */
+
+/**
+ * Scell Dashboard Client
+ *
+ * Use this client for dashboard/user operations with Bearer token authentication.
+ *
+ * @example
+ * ```typescript
+ * import { ScellClient, ScellAuth } from '@scell/sdk';
+ *
+ * // Login first
+ * const auth = await ScellAuth.login({
+ *   email: 'user@example.com',
+ *   password: 'password'
+ * });
+ *
+ * // Create client
+ * const client = new ScellClient(auth.token);
+ *
+ * // Use the client
+ * const companies = await client.companies.list();
+ * const balance = await client.balance.get();
+ * ```
+ */
+declare class ScellClient {
+    private readonly http;
+    /** Authentication operations */
+    readonly auth: AuthResource;
+    /** Company management */
+    readonly companies: CompaniesResource;
+    /** API key management */
+    readonly apiKeys: ApiKeysResource;
+    /** Balance and transactions */
+    readonly balance: BalanceResource;
+    /** Webhook management */
+    readonly webhooks: WebhooksResource;
+    /** Invoice listing (read-only via dashboard) */
+    readonly invoices: InvoicesResource;
+    /** Signature listing (read-only via dashboard) */
+    readonly signatures: SignaturesResource;
+    /**
+     * 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: string, config?: ClientConfig);
+}
+/**
+ * Scell API Client
+ *
+ * Use this client for external API operations with X-API-Key authentication.
+ * This is the client you'll use for creating invoices and signatures.
+ *
+ * @example
+ * ```typescript
+ * import { ScellApiClient } from '@scell/sdk';
+ *
+ * const client = new ScellApiClient('your-api-key');
+ *
+ * // Create an invoice
+ * const invoice = await client.invoices.create({
+ *   invoice_number: 'FACT-2024-001',
+ *   direction: 'outgoing',
+ *   output_format: 'facturx',
+ *   // ...
+ * });
+ *
+ * // Create a signature request
+ * const signature = await client.signatures.create({
+ *   title: 'Contract',
+ *   document: btoa(pdfContent),
+ *   document_name: 'contract.pdf',
+ *   signers: [{...}]
+ * });
+ * ```
+ */
+declare class ScellApiClient {
+    private readonly http;
+    /** Invoice operations (create, download, convert) */
+    readonly invoices: InvoicesResource;
+    /** Signature operations (create, download, remind, cancel) */
+    readonly signatures: SignaturesResource;
+    /**
+     * 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: string, config?: ClientConfig);
+}
+
+export { type Address, type ApiErrorResponse, type ApiKey, type ApiKeyWithSecret, type AuditTrailEntry, type AuditTrailResponse, type AuthResponse, type Balance, type BalanceWebhookData, type ClientConfig, type Company, type CompanyStatus, type ConvertInvoiceInput, type CreateApiKeyInput, type CreateCompanyInput, type CreateInvoiceInput, type CreateSignatureInput, type CreateWebhookInput, type CurrencyCode, type DateRangeOptions, type DateString, type DateTimeString, type Environment, type ForgotPasswordInput, type Invoice, type InvoiceDirection, type InvoiceDownloadResponse, type InvoiceDownloadType, type InvoiceFormat, type InvoiceLine, type InvoiceLineInput, type InvoiceListOptions, type InvoiceParty, type InvoiceStatus, type InvoiceWebhookData, type KycInitiateResponse, type KycStatusResponse, type LoginCredentials, type MessageResponse, type MessageWithDataResponse, type PaginatedResponse, type PaginationMeta, type PaginationOptions, type RegisterInput, type ReloadBalanceInput, type ReloadBalanceResponse, type ResetPasswordInput, type RetryOptions, ScellApiClient, ScellAuth, ScellAuthenticationError, ScellAuthorizationError, ScellClient, ScellError, ScellInsufficientBalanceError, ScellNetworkError, ScellNotFoundError, ScellRateLimitError, ScellServerError, ScellTimeoutError, ScellValidationError, ScellWebhooks, type Signature, type SignatureDownloadResponse, type SignatureDownloadType, type SignatureListOptions, type SignaturePosition, type SignatureRemindResponse, type SignatureStatus, type SignatureUIConfig, type SignatureWebhookData, type Signer, type SignerAuthMethod, type SignerInput, type SignerStatus, type SingleResponse, type Siren, type Siret, type Transaction, type TransactionListOptions, type TransactionService, type TransactionType, type UUID, type UpdateBalanceSettingsInput, type UpdateCompanyInput, type UpdateWebhookInput, type User, type VerifySignatureOptions, type Webhook, type WebhookEvent, type WebhookListOptions, type WebhookLog, type WebhookPayload, type WebhookTestResponse, type WebhookWithSecret, createRetryWrapper, withRetry };