wispr-flow-sdk-unofficial 0.1.0

package/dist/core/auth.d.ts

@@ -0,0 +1,422 @@
+/**
+ * Wispr Flow Authentication Module
+ *
+ * Handles user authentication via Supabase or Wispr API.
+ * Supports email/password login and token refresh.
+ */
+import { z } from 'zod';
+export { SUPABASE_ANON_KEY } from './constants';
+export declare const SupabaseUserSchema: z.ZodObject<{
+    id: z.ZodString;
+    aud: z.ZodString;
+    role: z.ZodString;
+    email: z.ZodString;
+    email_confirmed_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    phone: z.ZodOptional<z.ZodString>;
+    confirmed_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    last_sign_in_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    app_metadata: z.ZodObject<{
+        provider: z.ZodString;
+        providers: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        provider: string;
+        providers: string[];
+    }, {
+        provider: string;
+        providers: string[];
+    }>;
+    user_metadata: z.ZodObject<{
+        email: z.ZodString;
+        email_verified: z.ZodBoolean;
+        full_name: z.ZodOptional<z.ZodString>;
+        phone_verified: z.ZodOptional<z.ZodBoolean>;
+        sub: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        email: string;
+        email_verified: boolean;
+        sub: string;
+        full_name?: string | undefined;
+        phone_verified?: boolean | undefined;
+    }, {
+        email: string;
+        email_verified: boolean;
+        sub: string;
+        full_name?: string | undefined;
+        phone_verified?: boolean | undefined;
+    }>;
+    identities: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
+    created_at: z.ZodOptional<z.ZodString>;
+    updated_at: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    email: string;
+    role: string;
+    id: string;
+    aud: string;
+    app_metadata: {
+        provider: string;
+        providers: string[];
+    };
+    user_metadata: {
+        email: string;
+        email_verified: boolean;
+        sub: string;
+        full_name?: string | undefined;
+        phone_verified?: boolean | undefined;
+    };
+    email_confirmed_at?: string | null | undefined;
+    phone?: string | undefined;
+    confirmed_at?: string | null | undefined;
+    last_sign_in_at?: string | null | undefined;
+    identities?: unknown[] | undefined;
+    created_at?: string | undefined;
+    updated_at?: string | undefined;
+}, {
+    email: string;
+    role: string;
+    id: string;
+    aud: string;
+    app_metadata: {
+        provider: string;
+        providers: string[];
+    };
+    user_metadata: {
+        email: string;
+        email_verified: boolean;
+        sub: string;
+        full_name?: string | undefined;
+        phone_verified?: boolean | undefined;
+    };
+    email_confirmed_at?: string | null | undefined;
+    phone?: string | undefined;
+    confirmed_at?: string | null | undefined;
+    last_sign_in_at?: string | null | undefined;
+    identities?: unknown[] | undefined;
+    created_at?: string | undefined;
+    updated_at?: string | undefined;
+}>;
+export type SupabaseUser = z.infer<typeof SupabaseUserSchema>;
+export declare const SupabaseSessionSchema: z.ZodObject<{
+    access_token: z.ZodString;
+    token_type: z.ZodString;
+    expires_in: z.ZodNumber;
+    expires_at: z.ZodNumber;
+    refresh_token: z.ZodString;
+    user: z.ZodObject<{
+        id: z.ZodString;
+        aud: z.ZodString;
+        role: z.ZodString;
+        email: z.ZodString;
+        email_confirmed_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        phone: z.ZodOptional<z.ZodString>;
+        confirmed_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        last_sign_in_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        app_metadata: z.ZodObject<{
+            provider: z.ZodString;
+            providers: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            provider: string;
+            providers: string[];
+        }, {
+            provider: string;
+            providers: string[];
+        }>;
+        user_metadata: z.ZodObject<{
+            email: z.ZodString;
+            email_verified: z.ZodBoolean;
+            full_name: z.ZodOptional<z.ZodString>;
+            phone_verified: z.ZodOptional<z.ZodBoolean>;
+            sub: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            email: string;
+            email_verified: boolean;
+            sub: string;
+            full_name?: string | undefined;
+            phone_verified?: boolean | undefined;
+        }, {
+            email: string;
+            email_verified: boolean;
+            sub: string;
+            full_name?: string | undefined;
+            phone_verified?: boolean | undefined;
+        }>;
+        identities: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
+        created_at: z.ZodOptional<z.ZodString>;
+        updated_at: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        email: string;
+        role: string;
+        id: string;
+        aud: string;
+        app_metadata: {
+            provider: string;
+            providers: string[];
+        };
+        user_metadata: {
+            email: string;
+            email_verified: boolean;
+            sub: string;
+            full_name?: string | undefined;
+            phone_verified?: boolean | undefined;
+        };
+        email_confirmed_at?: string | null | undefined;
+        phone?: string | undefined;
+        confirmed_at?: string | null | undefined;
+        last_sign_in_at?: string | null | undefined;
+        identities?: unknown[] | undefined;
+        created_at?: string | undefined;
+        updated_at?: string | undefined;
+    }, {
+        email: string;
+        role: string;
+        id: string;
+        aud: string;
+        app_metadata: {
+            provider: string;
+            providers: string[];
+        };
+        user_metadata: {
+            email: string;
+            email_verified: boolean;
+            sub: string;
+            full_name?: string | undefined;
+            phone_verified?: boolean | undefined;
+        };
+        email_confirmed_at?: string | null | undefined;
+        phone?: string | undefined;
+        confirmed_at?: string | null | undefined;
+        last_sign_in_at?: string | null | undefined;
+        identities?: unknown[] | undefined;
+        created_at?: string | undefined;
+        updated_at?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    user: {
+        email: string;
+        role: string;
+        id: string;
+        aud: string;
+        app_metadata: {
+            provider: string;
+            providers: string[];
+        };
+        user_metadata: {
+            email: string;
+            email_verified: boolean;
+            sub: string;
+            full_name?: string | undefined;
+            phone_verified?: boolean | undefined;
+        };
+        email_confirmed_at?: string | null | undefined;
+        phone?: string | undefined;
+        confirmed_at?: string | null | undefined;
+        last_sign_in_at?: string | null | undefined;
+        identities?: unknown[] | undefined;
+        created_at?: string | undefined;
+        updated_at?: string | undefined;
+    };
+    access_token: string;
+    token_type: string;
+    expires_in: number;
+    expires_at: number;
+    refresh_token: string;
+}, {
+    user: {
+        email: string;
+        role: string;
+        id: string;
+        aud: string;
+        app_metadata: {
+            provider: string;
+            providers: string[];
+        };
+        user_metadata: {
+            email: string;
+            email_verified: boolean;
+            sub: string;
+            full_name?: string | undefined;
+            phone_verified?: boolean | undefined;
+        };
+        email_confirmed_at?: string | null | undefined;
+        phone?: string | undefined;
+        confirmed_at?: string | null | undefined;
+        last_sign_in_at?: string | null | undefined;
+        identities?: unknown[] | undefined;
+        created_at?: string | undefined;
+        updated_at?: string | undefined;
+    };
+    access_token: string;
+    token_type: string;
+    expires_in: number;
+    expires_at: number;
+    refresh_token: string;
+}>;
+export type SupabaseSession = z.infer<typeof SupabaseSessionSchema>;
+export declare const WisprSignInResponseSchema: z.ZodObject<{
+    message: z.ZodString;
+    access_token: z.ZodString;
+    refresh_token: z.ZodString;
+    first_name: z.ZodNullable<z.ZodString>;
+    last_name: z.ZodNullable<z.ZodString>;
+    onboarding_completed: z.ZodBoolean;
+    error: z.ZodNullable<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    error: string | null;
+    access_token: string;
+    refresh_token: string;
+    first_name: string | null;
+    last_name: string | null;
+    onboarding_completed: boolean;
+}, {
+    message: string;
+    error: string | null;
+    access_token: string;
+    refresh_token: string;
+    first_name: string | null;
+    last_name: string | null;
+    onboarding_completed: boolean;
+}>;
+export type WisprSignInResponse = z.infer<typeof WisprSignInResponseSchema>;
+export declare const UserStatusSchema: z.ZodObject<{
+    exists: z.ZodBoolean;
+    provider: z.ZodOptional<z.ZodString>;
+    verified: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    exists: boolean;
+    provider?: string | undefined;
+    verified?: boolean | undefined;
+}, {
+    exists: boolean;
+    provider?: string | undefined;
+    verified?: boolean | undefined;
+}>;
+export type UserStatus = z.infer<typeof UserStatusSchema>;
+export interface AuthCredentials {
+    email: string;
+    password: string;
+}
+export interface AuthSession {
+    accessToken: string;
+    refreshToken: string;
+    userUuid: string;
+    email: string;
+    expiresAt: number;
+    firstName?: string;
+    lastName?: string;
+}
+/**
+ * Wispr Flow Authentication Client
+ *
+ * Provides methods to authenticate users and manage sessions.
+ *
+ * @example
+ * ```typescript
+ * const auth = new WisprAuth();
+ *
+ * // Sign in with email/password
+ * const session = await auth.signIn({
+ *   email: 'user@example.com',
+ *   password: 'password123',
+ * });
+ *
+ * console.log('Access token:', session.accessToken);
+ * console.log('User ID:', session.userUuid);
+ *
+ * // Use session with WisprClient
+ * const client = new WisprClient({
+ *   accessToken: session.accessToken,
+ *   userUuid: session.userUuid,
+ * });
+ * ```
+ */
+export declare class WisprAuth {
+    private readonly supabaseUrl;
+    private readonly supabaseAnonKey;
+    private readonly wisprApiUrl;
+    private currentSession;
+    constructor(options?: {
+        supabaseUrl?: string;
+        supabaseAnonKey?: string;
+        wisprApiUrl?: string;
+    });
+    /**
+     * Get common headers for Supabase requests
+     */
+    private getSupabaseHeaders;
+    /**
+     * Check if a user exists by email
+     *
+     * @param email - User email address
+     * @returns User status
+     */
+    checkUserStatus(email: string): Promise<UserStatus>;
+    /**
+     * Sign in with email and password using Supabase directly
+     *
+     * This is the recommended method as it returns the full session
+     * including refresh token and user details.
+     *
+     * @param credentials - Email and password
+     * @returns Authentication session
+     */
+    signInWithSupabase(credentials: AuthCredentials): Promise<AuthSession>;
+    /**
+     * Sign in with email and password using Wispr API
+     *
+     * Alternative method that goes through Wispr's backend.
+     *
+     * @param credentials - Email and password
+     * @returns Authentication session
+     */
+    signInWithWisprApi(credentials: AuthCredentials): Promise<AuthSession>;
+    /**
+     * Sign in with email and password (uses Supabase by default)
+     *
+     * @param credentials - Email and password
+     * @returns Authentication session
+     */
+    signIn(credentials: AuthCredentials): Promise<AuthSession>;
+    /**
+     * Refresh the access token using the refresh token
+     *
+     * @param refreshToken - Optional refresh token (uses current session if not provided)
+     * @returns New authentication session
+     */
+    refreshSession(refreshToken?: string): Promise<AuthSession>;
+    /**
+     * Sign out and clear the current session
+     */
+    signOut(): Promise<void>;
+    /**
+     * Get the current session
+     *
+     * @returns Current session or null if not signed in
+     */
+    getSession(): AuthSession | null;
+    /**
+     * Check if the current session is expired
+     *
+     * @param bufferSeconds - Buffer time in seconds before actual expiry (default: 60)
+     * @returns True if session is expired or will expire within buffer time
+     */
+    isSessionExpired(bufferSeconds?: number): boolean;
+    /**
+     * Get a valid access token, refreshing if necessary
+     *
+     * @returns Valid access token
+     */
+    getValidAccessToken(): Promise<string>;
+    /**
+     * Decode JWT payload (without verification)
+     */
+    private decodeJwtPayload;
+}
+/**
+ * Create a new auth client instance
+ */
+export declare function createAuth(options?: {
+    supabaseUrl?: string;
+    supabaseAnonKey?: string;
+    wisprApiUrl?: string;
+}): WisprAuth;
+//# sourceMappingURL=auth.d.ts.map

package/dist/core/auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../src/core/auth.ts"],"names":[],"mappings":"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"}

package/dist/core/client.d.ts

@@ -0,0 +1,99 @@
+import { type TranscriptionRequest, type TranscriptionResponse, type WarmupResponse, type WisprConfig } from '../types';
+import type { WisprAuth } from './auth';
+/**
+ * Configuration options for WisprClient
+ */
+export interface WisprClientOptions extends Partial<WisprConfig> {
+    /** Supabase JWT access token (required if auth not provided) */
+    accessToken?: string;
+    /** User UUID from Supabase (required if auth not provided) */
+    userUuid?: string;
+    /** WisprAuth instance for automatic token refresh */
+    auth?: WisprAuth;
+    /** Buffer time in seconds before token expiry to trigger refresh (default: 60) */
+    tokenRefreshBuffer?: number;
+}
+/**
+ * Wispr Flow SDK Client
+ *
+ * Provides methods to interact with the unofficial Wispr Flow API
+ * for voice-to-text transcription.
+ *
+ * @example
+ * ```typescript
+ * // Option 1: Manual token management
+ * const client = new WisprClient({
+ *   accessToken: 'your-supabase-jwt-token',
+ *   userUuid: 'your-user-uuid',
+ * });
+ *
+ * // Option 2: Automatic token refresh with WisprAuth
+ * const auth = new WisprAuth();
+ * await auth.signIn({ email: 'user@example.com', password: 'password' });
+ * const client = new WisprClient({ auth });
+ *
+ * // Warmup the service
+ * await client.warmup();
+ *
+ * // Transcribe audio
+ * const result = await client.transcribe({
+ *   audioData: base64AudioData,
+ * });
+ *
+ * console.log(result.pipeline_text);
+ * ```
+ */
+export declare class WisprClient {
+    private config;
+    private readonly logger;
+    private readonly apiBaseUrl;
+    private readonly basetenUrl;
+    private readonly basetenApiKey;
+    private readonly auth?;
+    private readonly tokenRefreshBuffer;
+    constructor(options: WisprClientOptions);
+    /**
+     * Ensure access token is valid, refresh if needed
+     */
+    private ensureValidToken;
+    /**
+     * Get common headers for Wispr API requests
+     */
+    private getWisprHeaders;
+    /**
+     * Get headers for Baseten API requests
+     */
+    private getBasetenHeaders;
+    /**
+     * Make an HTTP request with error handling
+     */
+    private request;
+    /**
+     * Warmup the transcription service
+     *
+     * Call this before making transcription requests to reduce latency.
+     *
+     * @returns Warmup status response
+     */
+    warmup(): Promise<WarmupResponse>;
+    /**
+     * Transcribe audio to text
+     *
+     * @param request - Transcription request options
+     * @returns Transcription response with text results
+     */
+    transcribe(request?: TranscriptionRequest): Promise<TranscriptionResponse>;
+    /**
+     * Build context object for transcription
+     */
+    private buildContext;
+    /**
+     * Get the current configuration (without sensitive data)
+     */
+    getConfig(): Omit<WisprConfig, 'accessToken' | 'basetenApiKey'>;
+    /**
+     * Update the access token (e.g., after token refresh)
+     */
+    updateAccessToken(newToken: string): void;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/core/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/core/client.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,oBAAoB,EACzB,KAAK,qBAAqB,EAE1B,KAAK,cAAc,EAEnB,KAAK,WAAW,EAMjB,MAAM,UAAU,CAAC;AAUlB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAC;AAExC;;GAEG;AACH,MAAM,WAAW,kBAAmB,SAAQ,OAAO,CAAC,WAAW,CAAC;IAC9D,gEAAgE;IAChE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,8DAA8D;IAC9D,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,qDAAqD;IACrD,IAAI,CAAC,EAAE,SAAS,CAAC;IACjB,kFAAkF;IAClF,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,MAAM,CAAc;IAC5B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;IACvC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAY;IAClC,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAS;gBAEhC,OAAO,EAAE,kBAAkB;IAqDvC;;OAEG;YACW,gBAAgB;IAkB9B;;OAEG;IACH,OAAO,CAAC,eAAe;IAUvB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAQzB;;OAEG;YACW,OAAO;IAoDrB;;;;;;OAMG;IACG,MAAM,IAAI,OAAO,CAAC,cAAc,CAAC;IAmBvC;;;;;OAKG;IACG,UAAU,CAAC,OAAO,GAAE,oBAAyB,GAAG,OAAO,CAAC,qBAAqB,CAAC;IAmDpF;;OAEG;IACH,OAAO,CAAC,YAAY;IAyBpB;;OAEG;IACH,SAAS,IAAI,IAAI,CAAC,WAAW,EAAE,aAAa,GAAG,eAAe,CAAC;IAU/D;;OAEG;IACH,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;CAI1C"}

package/dist/core/constants.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Default API endpoints and configuration
+ *
+ * All sensitive values are loaded from environment variables.
+ * Set these in your .env file or environment.
+ */
+/** Wispr Flow API base URL */
+export declare const WISPR_API_BASE_URL: string;
+/** Baseten transcription API URL */
+export declare const BASETEN_API_URL: string;
+/** Default Baseten API key */
+export declare const DEFAULT_BASETEN_API_KEY: string;
+/** Supabase instance URL for authentication */
+export declare const SUPABASE_URL: string;
+/** Supabase anonymous key */
+export declare const SUPABASE_ANON_KEY: string;
+/** Default client version to report */
+export declare const DEFAULT_CLIENT_VERSION: string;
+/** Default request timeout in milliseconds */
+export declare const DEFAULT_TIMEOUT_MS = 30000;
+/** API endpoints */
+export declare const ENDPOINTS: {
+    /** Warmup endpoint to prepare the service */
+    readonly WARMUP: "/warmup";
+    /** Baseten transcription endpoint */
+    readonly BASETEN_TRANSCRIBE: "/environments/production/run_remote";
+};
+/** Supported audio formats */
+export declare const AUDIO_CONFIG: {
+    /** Sample rate in Hz */
+    readonly SAMPLE_RATE: 16000;
+    /** Number of audio channels */
+    readonly CHANNELS: 1;
+    /** Bits per sample */
+    readonly BITS_PER_SAMPLE: 16;
+    /** Audio format */
+    readonly FORMAT: "pcm_wav";
+    /** Maximum audio duration in seconds */
+    readonly MAX_DURATION_SECONDS: 360;
+    /** Maximum audio size in bytes */
+    readonly MAX_SIZE_BYTES: number;
+};
+/** Supported languages (ISO 639-1 codes) */
+export declare const SUPPORTED_LANGUAGES: readonly ["en", "es", "fr", "de", "it", "pt", "nl", "pl", "ru", "ja", "ko", "zh", "ar", "hi", "tr", "vi", "th", "id", "ms", "sv", "da", "no", "fi", "cs", "sk", "hu", "ro", "bg", "uk", "he", "el"];
+export type SupportedLanguage = (typeof SUPPORTED_LANGUAGES)[number];
+/**
+ * Validate that required environment variables are set
+ */
+export declare function validateEnvConfig(): {
+    valid: boolean;
+    missing: string[];
+};
+//# sourceMappingURL=constants.d.ts.map

package/dist/core/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/core/constants.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAWH,8BAA8B;AAC9B,eAAO,MAAM,kBAAkB,QAAsD,CAAC;AAEtF,oCAAoC;AACpC,eAAO,MAAM,eAAe,QAAwB,CAAC;AAErD,8BAA8B;AAC9B,eAAO,MAAM,uBAAuB,QAA4B,CAAC;AAEjE,+CAA+C;AAC/C,eAAO,MAAM,YAAY,QAAyB,CAAC;AAEnD,6BAA6B;AAC7B,eAAO,MAAM,iBAAiB,QAA8B,CAAC;AAE7D,uCAAuC;AACvC,eAAO,MAAM,sBAAsB,QAA4C,CAAC;AAEhF,8CAA8C;AAC9C,eAAO,MAAM,kBAAkB,QAAQ,CAAC;AAExC,oBAAoB;AACpB,eAAO,MAAM,SAAS;IACpB,6CAA6C;;IAE7C,qCAAqC;;CAE7B,CAAC;AAEX,8BAA8B;AAC9B,eAAO,MAAM,YAAY;IACvB,wBAAwB;;IAExB,+BAA+B;;IAE/B,sBAAsB;;IAEtB,mBAAmB;;IAEnB,wCAAwC;;IAExC,kCAAkC;;CAE1B,CAAC;AAEX,4CAA4C;AAC5C,eAAO,MAAM,mBAAmB,qMAgCtB,CAAC;AAEX,MAAM,MAAM,iBAAiB,GAAG,CAAC,OAAO,mBAAmB,CAAC,CAAC,MAAM,CAAC,CAAC;AAErE;;GAEG;AACH,wBAAgB,iBAAiB,IAAI;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,CASzE"}

package/dist/index.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Wispr Flow SDK - Unofficial TypeScript SDK for Wispr Flow voice-to-text API
+ *
+ * @example
+ * ```typescript
+ * import { WisprAuth, WisprClient } from 'wispr-flow-sdk';
+ *
+ * // Authenticate
+ * const auth = new WisprAuth();
+ * const session = await auth.signIn({
+ *   email: 'user@example.com',
+ *   password: 'password123',
+ * });
+ *
+ * // Create client with session
+ * const client = new WisprClient({
+ *   accessToken: session.accessToken,
+ *   userUuid: session.userUuid,
+ * });
+ *
+ * // Warmup the service (reduces latency)
+ * await client.warmup();
+ *
+ * // Transcribe audio (base64 encoded WAV)
+ * const result = await client.transcribe({
+ *   audioData: base64AudioData,
+ * });
+ *
+ * console.log(result.pipeline_text);
+ * ```
+ *
+ * @packageDocumentation
+ */
+export { WisprClient } from './core/client';
+export { WisprAuth, createAuth, SUPABASE_ANON_KEY, type AuthCredentials, type AuthSession, type SupabaseSession, type SupabaseUser, type WisprSignInResponse, type UserStatus, } from './core/auth';
+export { AUDIO_CONFIG, BASETEN_API_URL, DEFAULT_BASETEN_API_KEY, DEFAULT_CLIENT_VERSION, DEFAULT_TIMEOUT_MS, ENDPOINTS, SUPPORTED_LANGUAGES, SUPABASE_URL, WISPR_API_BASE_URL, type SupportedLanguage, } from './core/constants';
+export { WisprConfigSchema, type WisprConfig, AppContextSchema, type AppContext, TextboxContentsSchema, type TextboxContents, ConversationMessageSchema, type ConversationMessage, ConversationSchema, type Conversation, TranscriptionContextSchema, type TranscriptionContext, TranscriptionMetadataSchema, type TranscriptionMetadata, TranscriptionRequestSchema, type TranscriptionRequest, WarmupResponseSchema, type WarmupResponse, ComponentTimesSchema, type ComponentTimes, TranscriptionResponseSchema, type TranscriptionResponse, WisprError, WisprAuthError, WisprApiError, WisprValidationError, WisprTimeoutError, } from './types';
+export { createLogger, createTimeoutSignal, fromBase64, fromBase64ToBytes, generateUuid, retry, sleep, toBase64, type Logger, } from './utils';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAGH,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAG5C,OAAO,EACL,SAAS,EACT,UAAU,EACV,iBAAiB,EACjB,KAAK,eAAe,EACpB,KAAK,WAAW,EAChB,KAAK,eAAe,EACpB,KAAK,YAAY,EACjB,KAAK,mBAAmB,EACxB,KAAK,UAAU,GAChB,MAAM,aAAa,CAAC;AAGrB,OAAO,EACL,YAAY,EACZ,eAAe,EACf,uBAAuB,EACvB,sBAAsB,EACtB,kBAAkB,EAClB,SAAS,EACT,mBAAmB,EACnB,YAAY,EACZ,kBAAkB,EAClB,KAAK,iBAAiB,GACvB,MAAM,kBAAkB,CAAC;AAG1B,OAAO,EAEL,iBAAiB,EACjB,KAAK,WAAW,EAEhB,gBAAgB,EAChB,KAAK,UAAU,EACf,qBAAqB,EACrB,KAAK,eAAe,EACpB,yBAAyB,EACzB,KAAK,mBAAmB,EACxB,kBAAkB,EAClB,KAAK,YAAY,EACjB,0BAA0B,EAC1B,KAAK,oBAAoB,EACzB,2BAA2B,EAC3B,KAAK,qBAAqB,EAC1B,0BAA0B,EAC1B,KAAK,oBAAoB,EAEzB,oBAAoB,EACpB,KAAK,cAAc,EACnB,oBAAoB,EACpB,KAAK,cAAc,EACnB,2BAA2B,EAC3B,KAAK,qBAAqB,EAE1B,UAAU,EACV,cAAc,EACd,aAAa,EACb,oBAAoB,EACpB,iBAAiB,GAClB,MAAM,SAAS,CAAC;AAGjB,OAAO,EACL,YAAY,EACZ,mBAAmB,EACnB,UAAU,EACV,iBAAiB,EACjB,YAAY,EACZ,KAAK,EACL,KAAK,EACL,QAAQ,EACR,KAAK,MAAM,GACZ,MAAM,SAAS,CAAC"}