@paceful/sdk 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,1052 @@
+import React from 'react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+
+/**
+ * Paceful SDK Types
+ */
+interface PacefulConfig {
+    apiKey: string;
+    baseUrl?: string;
+    timeout?: number;
+    retries?: number;
+}
+interface RegisterUserParams {
+    externalId: string;
+    email?: string;
+    metadata?: Record<string, unknown>;
+}
+interface PartnerUser {
+    id: string;
+    externalId: string;
+    email?: string;
+    metadata?: Record<string, unknown>;
+    createdAt: string;
+}
+type MoodLevel = 1 | 2 | 3 | 4 | 5;
+interface LogMoodParams {
+    externalId: string;
+    mood: MoodLevel;
+    note?: string;
+    factors?: string[];
+    timestamp?: string;
+}
+interface MoodEntry {
+    id: string;
+    mood: MoodLevel;
+    note?: string;
+    factors?: string[];
+    loggedAt: string;
+}
+interface MoodHistoryParams {
+    externalId: string;
+    startDate?: string;
+    endDate?: string;
+    limit?: number;
+}
+interface CreateJournalParams {
+    externalId: string;
+    content: string;
+    promptId?: string;
+    mood?: MoodLevel;
+}
+interface JournalEntry {
+    id: string;
+    content: string;
+    promptId?: string;
+    mood?: MoodLevel;
+    sentimentScore?: number;
+    themes?: string[];
+    createdAt: string;
+}
+interface JournalHistoryParams {
+    externalId: string;
+    startDate?: string;
+    endDate?: string;
+    limit?: number;
+}
+type ERSStage = 'healing' | 'rebuilding' | 'ready';
+interface ERSDimensions {
+    emotionalStability: number;
+    selfAwareness: number;
+    socialConnection: number;
+    purposeClarity: number;
+    resilienceGrowth: number;
+}
+interface ERSScore {
+    userId: string;
+    ersScore: number;
+    stage: ERSStage;
+    dimensions: ERSDimensions;
+    calculatedAt: string;
+    trend?: {
+        direction: 'up' | 'down' | 'stable';
+        weeklyChange: number;
+        daysTracked: number;
+    };
+}
+interface ERSCalculateResult {
+    ersScore: number;
+    stage: ERSStage;
+    dimensions: ERSDimensions;
+    previousScore: number | null;
+    change: number | null;
+    dataPointsUsed: number;
+}
+interface ERSBatchResult {
+    results: Array<{
+        externalId: string;
+        ersScore: number | null;
+        stage: ERSStage | null;
+        calculatedAt: string | null;
+    }>;
+    totalRequested: number;
+    totalReturned: number;
+}
+type AnalyticsPeriod = '7d' | '30d' | '90d' | 'all';
+interface AnalyticsSummary {
+    totalUsers: number;
+    averageErs: number | null;
+    stageDistribution: {
+        healing: number;
+        rebuilding: number;
+        ready: number;
+    };
+    engagementMetrics: {
+        avgMoodLogsPerWeek: number;
+        avgJournalEntriesPerWeek: number;
+    };
+    period: AnalyticsPeriod;
+}
+type WebhookEvent = 'ers.stage_changed' | 'ers.score_threshold' | 'mood.critical' | 'mood.logged' | 'journal.created';
+interface RegisterWebhookParams {
+    url: string;
+    events: WebhookEvent[];
+}
+interface WebhookRegistration {
+    webhookId: string;
+    secret: string;
+    events: WebhookEvent[];
+    status: 'created' | 'updated';
+}
+interface Webhook {
+    id: string;
+    url: string;
+    events: WebhookEvent[];
+    isActive: boolean;
+    createdAt: string;
+}
+interface ApiResponse<T> {
+    success: boolean;
+    data?: T;
+    error?: {
+        message: string;
+        code: string;
+    };
+}
+interface PaginatedResponse<T> {
+    items: T[];
+    total: number;
+    hasMore: boolean;
+    cursor?: string;
+}
+
+/**
+ * HTTP Client for Paceful API
+ */
+
+interface RequestOptions {
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    path: string;
+    body?: Record<string, unknown>;
+    query?: Record<string, string | number | boolean | undefined>;
+}
+declare class HttpClient {
+    private readonly apiKey;
+    private readonly baseUrl;
+    private readonly timeout;
+    private readonly maxRetries;
+    constructor(config: PacefulConfig);
+    request<T>(options: RequestOptions): Promise<T>;
+    private sleep;
+    get<T>(path: string, query?: RequestOptions['query']): Promise<T>;
+    post<T>(path: string, body?: Record<string, unknown>): Promise<T>;
+    put<T>(path: string, body?: Record<string, unknown>): Promise<T>;
+    patch<T>(path: string, body?: Record<string, unknown>): Promise<T>;
+    delete<T>(path: string): Promise<T>;
+}
+
+/**
+ * Users Module
+ * Manage partner users in the Paceful system
+ */
+
+declare class Users {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * Register a new user or update existing user metadata
+     *
+     * @param params - User registration parameters
+     * @returns The registered or updated user
+     *
+     * @example
+     * ```typescript
+     * const user = await paceful.users.register({
+     *   externalId: 'user_123',
+     *   email: 'user@example.com',
+     *   metadata: { plan: 'premium' }
+     * });
+     * ```
+     */
+    register(params: RegisterUserParams): Promise<PartnerUser>;
+    /**
+     * Get a user by their external ID
+     *
+     * @param externalId - Your system's user identifier
+     * @returns The user if found
+     *
+     * @example
+     * ```typescript
+     * const user = await paceful.users.get('user_123');
+     * ```
+     */
+    get(externalId: string): Promise<PartnerUser>;
+    /**
+     * Update a user's metadata
+     *
+     * @param externalId - Your system's user identifier
+     * @param metadata - New metadata to merge with existing
+     * @returns The updated user
+     *
+     * @example
+     * ```typescript
+     * const user = await paceful.users.update('user_123', {
+     *   metadata: { plan: 'enterprise' }
+     * });
+     * ```
+     */
+    update(externalId: string, params: {
+        email?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<PartnerUser>;
+    /**
+     * List all users for this partner
+     *
+     * @param params - Pagination parameters
+     * @returns Paginated list of users
+     *
+     * @example
+     * ```typescript
+     * const { items, total, hasMore } = await paceful.users.list({ limit: 50 });
+     * ```
+     */
+    list(params?: {
+        limit?: number;
+        cursor?: string;
+    }): Promise<{
+        items: PartnerUser[];
+        total: number;
+        hasMore: boolean;
+        cursor?: string;
+    }>;
+    /**
+     * Delete a user and all their data
+     *
+     * @param externalId - Your system's user identifier
+     *
+     * @example
+     * ```typescript
+     * await paceful.users.delete('user_123');
+     * ```
+     */
+    delete(externalId: string): Promise<void>;
+}
+
+/**
+ * Mood Module
+ * Track and retrieve mood data for users
+ */
+
+declare class Mood {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * Log a mood entry for a user
+     *
+     * @param params - Mood log parameters
+     * @returns The created mood entry
+     *
+     * @example
+     * ```typescript
+     * const entry = await paceful.mood.log({
+     *   externalId: 'user_123',
+     *   mood: 4,
+     *   note: 'Feeling productive today',
+     *   factors: ['work', 'exercise']
+     * });
+     * ```
+     */
+    log(params: LogMoodParams): Promise<MoodEntry>;
+    /**
+     * Get mood history for a user
+     *
+     * @param params - History query parameters
+     * @returns List of mood entries
+     *
+     * @example
+     * ```typescript
+     * const history = await paceful.mood.history({
+     *   externalId: 'user_123',
+     *   startDate: '2024-01-01',
+     *   limit: 30
+     * });
+     * ```
+     */
+    history(params: MoodHistoryParams): Promise<MoodEntry[]>;
+    /**
+     * Get the latest mood entry for a user
+     *
+     * @param externalId - Your system's user identifier
+     * @returns The most recent mood entry or null
+     *
+     * @example
+     * ```typescript
+     * const latest = await paceful.mood.latest('user_123');
+     * if (latest) {
+     *   console.log(`Last mood: ${latest.mood}`);
+     * }
+     * ```
+     */
+    latest(externalId: string): Promise<MoodEntry | null>;
+    /**
+     * Get mood statistics for a user over a time period
+     *
+     * @param externalId - Your system's user identifier
+     * @param period - Time period ('7d', '30d', '90d', 'all')
+     * @returns Mood statistics
+     *
+     * @example
+     * ```typescript
+     * const stats = await paceful.mood.stats('user_123', '30d');
+     * console.log(`Average mood: ${stats.average}`);
+     * ```
+     */
+    stats(externalId: string, period?: '7d' | '30d' | '90d' | 'all'): Promise<{
+        average: number;
+        count: number;
+        highest: number;
+        lowest: number;
+        trend: 'up' | 'down' | 'stable';
+    }>;
+}
+
+/**
+ * Journal Module
+ * Create and retrieve journal entries for users
+ */
+
+declare class Journal {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * Create a journal entry for a user
+     *
+     * @param params - Journal entry parameters
+     * @returns The created journal entry with AI analysis
+     *
+     * @example
+     * ```typescript
+     * const entry = await paceful.journal.create({
+     *   externalId: 'user_123',
+     *   content: 'Today I reflected on my progress...',
+     *   mood: 4
+     * });
+     *
+     * console.log('Themes:', entry.themes);
+     * console.log('Sentiment:', entry.sentimentScore);
+     * ```
+     */
+    create(params: CreateJournalParams): Promise<JournalEntry>;
+    /**
+     * Get journal history for a user
+     *
+     * @param params - History query parameters
+     * @returns List of journal entries
+     *
+     * @example
+     * ```typescript
+     * const entries = await paceful.journal.history({
+     *   externalId: 'user_123',
+     *   limit: 10
+     * });
+     * ```
+     */
+    history(params: JournalHistoryParams): Promise<JournalEntry[]>;
+    /**
+     * Get a specific journal entry
+     *
+     * @param externalId - Your system's user identifier
+     * @param entryId - The journal entry ID
+     * @returns The journal entry
+     *
+     * @example
+     * ```typescript
+     * const entry = await paceful.journal.get('user_123', 'entry_abc');
+     * ```
+     */
+    get(externalId: string, entryId: string): Promise<JournalEntry>;
+    /**
+     * Get available journal prompts
+     *
+     * @returns List of prompts categorized by theme
+     *
+     * @example
+     * ```typescript
+     * const prompts = await paceful.journal.prompts();
+     * const gratitudePrompts = prompts.gratitude;
+     * ```
+     */
+    prompts(): Promise<Record<string, Array<{
+        id: string;
+        text: string;
+    }>>>;
+    /**
+     * Get journal statistics for a user
+     *
+     * @param externalId - Your system's user identifier
+     * @param period - Time period ('7d', '30d', '90d', 'all')
+     * @returns Journal statistics
+     *
+     * @example
+     * ```typescript
+     * const stats = await paceful.journal.stats('user_123', '30d');
+     * console.log(`Entries this month: ${stats.count}`);
+     * ```
+     */
+    stats(externalId: string, period?: '7d' | '30d' | '90d' | 'all'): Promise<{
+        count: number;
+        avgSentiment: number;
+        topThemes: string[];
+        streakDays: number;
+    }>;
+}
+
+/**
+ * ERS (Emotional Readiness Score) Module
+ * Calculate and retrieve ERS scores for users
+ */
+
+declare class ERS {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * Get the current ERS score for a user
+     * Returns cached score if recent (< 24 hours), otherwise calculates fresh
+     *
+     * @param externalId - Your system's user identifier
+     * @returns The user's ERS score with trend data
+     *
+     * @example
+     * ```typescript
+     * const ers = await paceful.ers.get('user_123');
+     *
+     * console.log(`ERS Score: ${ers.ersScore}`);
+     * console.log(`Stage: ${ers.stage}`);
+     * console.log(`Trend: ${ers.trend?.direction}`);
+     * ```
+     */
+    get(externalId: string): Promise<ERSScore>;
+    /**
+     * Force a fresh ERS calculation for a user
+     * Useful after significant user activity
+     *
+     * @param externalId - Your system's user identifier
+     * @returns Fresh calculation results with change data
+     *
+     * @example
+     * ```typescript
+     * const result = await paceful.ers.calculate('user_123');
+     *
+     * if (result.change !== null) {
+     *   console.log(`Score changed by ${result.change} points`);
+     * }
+     * ```
+     */
+    calculate(externalId: string): Promise<ERSCalculateResult>;
+    /**
+     * Get ERS scores for multiple users in a single request
+     * Maximum 50 users per request
+     *
+     * @param externalIds - Array of your system's user identifiers
+     * @returns Batch results with scores for each user
+     *
+     * @example
+     * ```typescript
+     * const batch = await paceful.ers.batch(['user_1', 'user_2', 'user_3']);
+     *
+     * for (const result of batch.results) {
+     *   console.log(`${result.externalId}: ${result.ersScore}`);
+     * }
+     * ```
+     */
+    batch(externalIds: string[]): Promise<ERSBatchResult>;
+    /**
+     * Get ERS score history for a user
+     *
+     * @param externalId - Your system's user identifier
+     * @param params - Query parameters
+     * @returns Historical ERS scores
+     *
+     * @example
+     * ```typescript
+     * const history = await paceful.ers.history('user_123', {
+     *   period: '30d',
+     *   granularity: 'daily'
+     * });
+     * ```
+     */
+    history(externalId: string, params?: {
+        period?: '7d' | '30d' | '90d' | 'all';
+        granularity?: 'daily' | 'weekly';
+    }): Promise<Array<{
+        score: number;
+        stage: string;
+        date: string;
+    }>>;
+    /**
+     * Set up alerts for ERS threshold crossings
+     *
+     * @param params - Alert configuration
+     * @returns The created alert configuration
+     *
+     * @example
+     * ```typescript
+     * await paceful.ers.setThresholdAlert({
+     *   externalId: 'user_123',
+     *   threshold: 40,
+     *   direction: 'below',
+     *   webhookUrl: 'https://yourapp.com/alerts'
+     * });
+     * ```
+     */
+    setThresholdAlert(params: {
+        externalId: string;
+        threshold: number;
+        direction: 'above' | 'below';
+        webhookUrl?: string;
+    }): Promise<{
+        alertId: string;
+    }>;
+}
+
+/**
+ * Analytics Module
+ * Get aggregate analytics for your partner account
+ */
+
+declare class Analytics {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * Get aggregate analytics summary for all your users
+     *
+     * @param period - Time period for analytics ('7d', '30d', '90d', 'all')
+     * @returns Aggregate analytics summary
+     *
+     * @example
+     * ```typescript
+     * const summary = await paceful.analytics.summary('30d');
+     *
+     * console.log(`Total users: ${summary.totalUsers}`);
+     * console.log(`Average ERS: ${summary.averageErs}`);
+     * console.log(`Healing stage: ${summary.stageDistribution.healing * 100}%`);
+     * ```
+     */
+    summary(period?: AnalyticsPeriod): Promise<AnalyticsSummary>;
+    /**
+     * Get engagement metrics over time
+     *
+     * @param params - Query parameters
+     * @returns Time series engagement data
+     *
+     * @example
+     * ```typescript
+     * const engagement = await paceful.analytics.engagement({
+     *   period: '30d',
+     *   granularity: 'daily'
+     * });
+     *
+     * for (const point of engagement.dataPoints) {
+     *   console.log(`${point.date}: ${point.activeUsers} active users`);
+     * }
+     * ```
+     */
+    engagement(params?: {
+        period?: AnalyticsPeriod;
+        granularity?: 'daily' | 'weekly';
+    }): Promise<{
+        dataPoints: Array<{
+            date: string;
+            activeUsers: number;
+            moodLogs: number;
+            journalEntries: number;
+        }>;
+        totals: {
+            activeUsers: number;
+            moodLogs: number;
+            journalEntries: number;
+        };
+    }>;
+    /**
+     * Get ERS distribution across all users
+     *
+     * @param period - Time period for analytics
+     * @returns ERS distribution data
+     *
+     * @example
+     * ```typescript
+     * const distribution = await paceful.analytics.ersDistribution('30d');
+     *
+     * console.log('Score ranges:');
+     * for (const bucket of distribution.buckets) {
+     *   console.log(`${bucket.range}: ${bucket.count} users`);
+     * }
+     * ```
+     */
+    ersDistribution(period?: AnalyticsPeriod): Promise<{
+        buckets: Array<{
+            range: string;
+            min: number;
+            max: number;
+            count: number;
+            percentage: number;
+        }>;
+        stageDistribution: {
+            healing: number;
+            rebuilding: number;
+            ready: number;
+        };
+    }>;
+    /**
+     * Get retention metrics
+     *
+     * @param period - Time period for analytics
+     * @returns Retention and churn data
+     *
+     * @example
+     * ```typescript
+     * const retention = await paceful.analytics.retention('30d');
+     *
+     * console.log(`Day 7 retention: ${retention.day7}%`);
+     * console.log(`Day 30 retention: ${retention.day30}%`);
+     * ```
+     */
+    retention(period?: AnalyticsPeriod): Promise<{
+        day1: number;
+        day7: number;
+        day14: number;
+        day30: number;
+        weeklyActive: number;
+        monthlyActive: number;
+    }>;
+    /**
+     * Export analytics data as CSV
+     *
+     * @param params - Export parameters
+     * @returns Download URL for the CSV
+     *
+     * @example
+     * ```typescript
+     * const { downloadUrl } = await paceful.analytics.export({
+     *   type: 'user_summary',
+     *   period: '30d'
+     * });
+     * ```
+     */
+    export(params: {
+        type: 'user_summary' | 'ers_scores' | 'engagement';
+        period?: AnalyticsPeriod;
+        format?: 'csv' | 'json';
+    }): Promise<{
+        downloadUrl: string;
+        expiresAt: string;
+    }>;
+}
+
+/**
+ * Webhooks Module
+ * Manage webhook endpoints for real-time event notifications
+ */
+
+declare class Webhooks {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * Register a webhook endpoint for receiving events
+     * Updates existing webhook if same URL already registered
+     *
+     * @param params - Webhook configuration
+     * @returns Webhook registration details including secret
+     *
+     * @example
+     * ```typescript
+     * const webhook = await paceful.webhooks.register({
+     *   url: 'https://yourapp.com/webhooks/paceful',
+     *   events: ['ers.stage_changed', 'mood.critical']
+     * });
+     *
+     * // Store the secret securely for signature verification
+     * console.log('Webhook secret:', webhook.secret);
+     * ```
+     */
+    register(params: RegisterWebhookParams): Promise<WebhookRegistration>;
+    /**
+     * List all registered webhooks
+     *
+     * @returns Array of webhook configurations
+     *
+     * @example
+     * ```typescript
+     * const webhooks = await paceful.webhooks.list();
+     *
+     * for (const webhook of webhooks) {
+     *   console.log(`${webhook.url}: ${webhook.events.join(', ')}`);
+     * }
+     * ```
+     */
+    list(): Promise<Webhook[]>;
+    /**
+     * Get a specific webhook by ID
+     *
+     * @param webhookId - The webhook ID
+     * @returns Webhook configuration
+     *
+     * @example
+     * ```typescript
+     * const webhook = await paceful.webhooks.get('webhook_abc123');
+     * ```
+     */
+    get(webhookId: string): Promise<Webhook>;
+    /**
+     * Update a webhook's configuration
+     *
+     * @param webhookId - The webhook ID
+     * @param params - Updated configuration
+     * @returns Updated webhook
+     *
+     * @example
+     * ```typescript
+     * await paceful.webhooks.update('webhook_abc123', {
+     *   events: ['ers.stage_changed', 'mood.critical', 'journal.created']
+     * });
+     * ```
+     */
+    update(webhookId: string, params: {
+        url?: string;
+        events?: WebhookEvent[];
+        isActive?: boolean;
+    }): Promise<Webhook>;
+    /**
+     * Delete a webhook
+     *
+     * @param webhookId - The webhook ID
+     *
+     * @example
+     * ```typescript
+     * await paceful.webhooks.delete('webhook_abc123');
+     * ```
+     */
+    delete(webhookId: string): Promise<void>;
+    /**
+     * Test a webhook by sending a test event
+     *
+     * @param webhookId - The webhook ID
+     * @returns Test result
+     *
+     * @example
+     * ```typescript
+     * const result = await paceful.webhooks.test('webhook_abc123');
+     *
+     * if (result.success) {
+     *   console.log('Webhook is working!');
+     * } else {
+     *   console.error('Test failed:', result.error);
+     * }
+     * ```
+     */
+    test(webhookId: string): Promise<{
+        success: boolean;
+        statusCode?: number;
+        responseTime?: number;
+        error?: string;
+    }>;
+    /**
+     * Get delivery history for a webhook
+     *
+     * @param webhookId - The webhook ID
+     * @param params - Query parameters
+     * @returns Delivery history
+     *
+     * @example
+     * ```typescript
+     * const history = await paceful.webhooks.deliveryHistory('webhook_abc123', {
+     *   limit: 20
+     * });
+     *
+     * for (const delivery of history) {
+     *   console.log(`${delivery.event}: ${delivery.status}`);
+     * }
+     * ```
+     */
+    deliveryHistory(webhookId: string, params?: {
+        limit?: number;
+        status?: 'success' | 'failed';
+    }): Promise<Array<{
+        id: string;
+        event: WebhookEvent;
+        status: 'success' | 'failed';
+        statusCode?: number;
+        attempts: number;
+        deliveredAt: string;
+        payload: Record<string, unknown>;
+    }>>;
+    /**
+     * Rotate the webhook secret
+     *
+     * @param webhookId - The webhook ID
+     * @returns New webhook secret
+     *
+     * @example
+     * ```typescript
+     * const { secret } = await paceful.webhooks.rotateSecret('webhook_abc123');
+     *
+     * // Update your server with the new secret
+     * console.log('New secret:', secret);
+     * ```
+     */
+    rotateSecret(webhookId: string): Promise<{
+        secret: string;
+    }>;
+    /**
+     * Verify a webhook signature
+     * Call this method to validate incoming webhook requests
+     *
+     * @param payload - Raw request body as string
+     * @param signature - Value of X-Paceful-Signature header
+     * @param secret - Your webhook secret
+     * @returns Whether the signature is valid
+     *
+     * @example
+     * ```typescript
+     * // In your webhook handler:
+     * const isValid = Webhooks.verifySignature(
+     *   rawBody,
+     *   request.headers['x-paceful-signature'],
+     *   process.env.PACEFUL_WEBHOOK_SECRET
+     * );
+     *
+     * if (!isValid) {
+     *   return res.status(401).send('Invalid signature');
+     * }
+     * ```
+     */
+    static verifySignature(payload: string, signature: string, secret: string): boolean;
+}
+
+/**
+ * Paceful SDK Client
+ * Main entry point for the Paceful Partner API
+ */
+
+declare class PacefulClient {
+    private readonly http;
+    /**
+     * Users module for managing partner users
+     */
+    readonly users: Users;
+    /**
+     * Mood module for tracking mood entries
+     */
+    readonly mood: Mood;
+    /**
+     * Journal module for managing journal entries
+     */
+    readonly journal: Journal;
+    /**
+     * ERS module for emotional readiness scores
+     */
+    readonly ers: ERS;
+    /**
+     * Analytics module for aggregate insights
+     */
+    readonly analytics: Analytics;
+    /**
+     * Webhooks module for event notifications
+     */
+    readonly webhooks: Webhooks;
+    /**
+     * Create a new Paceful client
+     *
+     * @param config - Configuration options
+     *
+     * @example
+     * ```typescript
+     * import { PacefulClient } from '@paceful/sdk';
+     *
+     * const paceful = new PacefulClient({
+     *   apiKey: process.env.PACEFUL_API_KEY,
+     * });
+     *
+     * // Register a user
+     * const user = await paceful.users.register({
+     *   externalId: 'user_123',
+     *   email: 'user@example.com'
+     * });
+     *
+     * // Log a mood entry
+     * await paceful.mood.log({
+     *   externalId: 'user_123',
+     *   mood: 4,
+     *   note: 'Feeling good today'
+     * });
+     *
+     * // Get ERS score
+     * const ers = await paceful.ers.get('user_123');
+     * console.log(`ERS: ${ers.ersScore}, Stage: ${ers.stage}`);
+     * ```
+     */
+    constructor(config: PacefulConfig);
+    /**
+     * Check API connectivity and authentication
+     *
+     * @returns Health check result
+     *
+     * @example
+     * ```typescript
+     * const health = await paceful.healthCheck();
+     * if (health.ok) {
+     *   console.log('API is reachable');
+     * }
+     * ```
+     */
+    healthCheck(): Promise<{
+        ok: boolean;
+        partnerId: string;
+        rateLimit: {
+            remaining: number;
+            limit: number;
+            resetAt: string;
+        };
+    }>;
+}
+
+/**
+ * Paceful SDK Error Classes
+ */
+declare class PacefulError extends Error {
+    readonly code: string;
+    readonly statusCode?: number;
+    readonly details?: Record<string, unknown>;
+    constructor(message: string, code: string, statusCode?: number, details?: Record<string, unknown>);
+}
+declare class PacefulAuthError extends PacefulError {
+    constructor(message?: string);
+}
+declare class PacefulRateLimitError extends PacefulError {
+    readonly retryAfter: number;
+    constructor(retryAfter?: number);
+}
+declare class PacefulNotFoundError extends PacefulError {
+    constructor(resource?: string);
+}
+declare class PacefulValidationError extends PacefulError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+declare class PacefulNetworkError extends PacefulError {
+    constructor(message?: string);
+}
+
+interface PacefulContextValue {
+    apiKey: string;
+    userId: string;
+    baseUrl: string;
+}
+declare function usePaceful(): PacefulContextValue;
+interface PacefulProviderProps {
+    apiKey: string;
+    userId: string;
+    baseUrl?: string;
+    children: React.ReactNode;
+}
+declare function PacefulProvider({ apiKey, userId, baseUrl, children }: PacefulProviderProps): React.FunctionComponentElement<React.ProviderProps<PacefulContextValue | null>>;
+
+interface MoodWidgetProps {
+    apiKey?: string;
+    userId?: string;
+    baseUrl?: string;
+    theme?: 'light' | 'dark';
+    brandColor?: string;
+    compact?: boolean;
+    showStreak?: boolean;
+    onComplete?: (mood: {
+        logged: boolean;
+        moodId: string;
+        timestamp: string;
+    }) => void;
+    onError?: (error: Error) => void;
+    className?: string;
+}
+declare function MoodWidget({ apiKey: propApiKey, userId: propUserId, baseUrl: propBaseUrl, theme, brandColor, compact, showStreak, onComplete, onError, className, }: MoodWidgetProps): react_jsx_runtime.JSX.Element;
+
+interface JournalWidgetProps {
+    apiKey?: string;
+    userId?: string;
+    baseUrl?: string;
+    theme?: 'light' | 'dark';
+    brandColor?: string;
+    showPrompt?: boolean;
+    showAIReflection?: boolean;
+    maxLength?: number;
+    placeholder?: string;
+    onComplete?: (entry: {
+        entryId: string;
+        sentiment: string;
+        aiReflection: string;
+    }) => void;
+    onError?: (error: Error) => void;
+    className?: string;
+}
+declare function JournalWidget({ apiKey: propApiKey, userId: propUserId, baseUrl: propBaseUrl, theme, brandColor, showPrompt, showAIReflection, maxLength, placeholder, onComplete, onError, className, }: JournalWidgetProps): react_jsx_runtime.JSX.Element;
+
+interface ERSDisplayProps {
+    apiKey?: string;
+    userId?: string;
+    baseUrl?: string;
+    theme?: 'light' | 'dark';
+    brandColor?: string;
+    showDimensions?: boolean;
+    showTrend?: boolean;
+    compact?: boolean;
+    onLoad?: (ers: ERSData) => void;
+    onError?: (error: Error) => void;
+    className?: string;
+}
+interface ERSData {
+    ersScore: number;
+    stage: 'healing' | 'rebuilding' | 'ready';
+    dimensions: {
+        emotionalStability: number;
+        selfAwareness: number;
+        socialConnection: number;
+        purposeClarity: number;
+        resilienceGrowth: number;
+    };
+    trend?: {
+        direction: 'up' | 'down' | 'stable';
+        weeklyChange: number;
+        daysTracked: number;
+    };
+}
+declare function ERSDisplay({ apiKey: propApiKey, userId: propUserId, baseUrl: propBaseUrl, theme, brandColor, showDimensions, showTrend, compact, onLoad, onError, className, }: ERSDisplayProps): react_jsx_runtime.JSX.Element | null;
+
+export { Analytics, type AnalyticsPeriod, type AnalyticsSummary, type ApiResponse, type CreateJournalParams, ERS, type ERSBatchResult, type ERSCalculateResult, type ERSDimensions, ERSDisplay, type ERSScore, type ERSStage, Journal, type JournalEntry, type JournalHistoryParams, JournalWidget, type LogMoodParams, Mood, type MoodEntry, type MoodHistoryParams, type MoodLevel, MoodWidget, PacefulAuthError, PacefulClient, type PacefulConfig, PacefulError, PacefulNetworkError, PacefulNotFoundError, PacefulProvider, PacefulRateLimitError, PacefulValidationError, type PaginatedResponse, type PartnerUser, type RegisterUserParams, type RegisterWebhookParams, Users, type Webhook, type WebhookEvent, type WebhookRegistration, Webhooks, PacefulClient as default, usePaceful };