fireflies-api 0.5.0

package/dist/index.d.cts

@@ -0,0 +1,966 @@
+import { T as TranscriptionChunk, A as ActionItemsFilterOptions, a as AggregatedActionItemsResult, b as ActionItemsMarkdownOptions, M as MeetingInsightsOptions, c as MeetingInsights, d as TranscriptsListParams, S as SearchTranscriptOptions, e as SearchMatch, F as FirefliesClient, W as WebhookPayload, P as ParseOptions, V as VerifyOptions } from './types-C_XxdRd1.cjs';
+export { f as AIApp, g as AIAppsAPI, h as AIAppsListParams, i as ActionItemGrouping, j as ActionItemPreset, k as ActionItemStyle, l as ActiveMeeting, m as ActiveMeetingsParams, n as AddBotParams, o as AggregatedActionItem, p as AudioAPI, B as Bite, q as BiteCaption, r as BiteCreatedFrom, s as BiteSource, t as BiteUser, u as BitesAPI, v as BitesListParams, C as CreateBiteParams, D as DayOfWeekStats, w as DayStats, E as ExportActionItemsParams, x as FirefliesConfig, y as MeetingPrivacy, z as MeetingState, G as MeetingsAPI, H as ParticipantStats, R as RateLimitConfig, I as RateLimitState, J as RealtimeAPI, K as RealtimeConfig, L as RealtimeEvents, N as RealtimeStream, O as RetryConfig, Q as SearchParams, U as SearchResults, X as SpeakerInsightStats, Y as ThrottleConfig, Z as TimeGroupStats, _ as TranscriptGetParams, $ as TranscriptsAPI, a0 as TranscriptsInsightsParams, a1 as TranscriptsMutationsAPI, a2 as TranscriptsQueryScope, a3 as UploadAudioAttendee, a4 as UploadAudioParams, a5 as UserGroup, a6 as UserGroupMember, a7 as UserProfile, a8 as UserRole, a9 as UsersAPI, aa as UsersMutationsAPI, ab as WebhookEventType } from './types-C_XxdRd1.cjs';
+import { T as Transcript, a as ActionItemOptions, b as ActionItem, A as ActionItemsResult } from './action-items-CC9yUxHY.cjs';
+export { c as AIAppOutput, d as AIFilter, e as AppsPreview, C as Channel, f as ChannelMember, M as MeetingAnalytics, g as MeetingAttendance, h as MeetingAttendee, i as MeetingInfo, j as Sentence, k as Sentiments, S as Speaker, l as Summary, m as SummarySection, n as SummaryStatus, U as User, o as extractActionItems } from './action-items-CC9yUxHY.cjs';
+import { a as NormalizationOptions, N as NormalizedMeeting } from './speaker-analytics-l45LXqO1.cjs';
+export { b as NormalizedAnalytics, c as NormalizedAttendee, d as NormalizedChannel, e as NormalizedParticipant, f as NormalizedSentence, g as NormalizedSpeaker, h as NormalizedSummary, S as SpeakerAnalytics, i as SpeakerAnalyticsOptions, j as SpeakerStats, k as analyzeSpeakers } from './speaker-analytics-l45LXqO1.cjs';
+
+/**
+ * Base error class for all Fireflies API errors.
+ * All errors include a code for programmatic handling.
+ */
+declare class FirefliesError extends Error {
+    readonly code: string;
+    readonly status?: number;
+    constructor(message: string, options?: {
+        status?: number;
+        cause?: unknown;
+    });
+}
+/**
+ * Thrown when the API key is invalid or missing.
+ */
+declare class AuthenticationError extends FirefliesError {
+    readonly code = "AUTHENTICATION_ERROR";
+    constructor(message?: string);
+}
+/**
+ * Thrown when rate limits are exceeded.
+ * Check retryAfter for suggested wait time in milliseconds.
+ */
+declare class RateLimitError extends FirefliesError {
+    readonly code = "RATE_LIMIT_ERROR";
+    /** Suggested wait time in milliseconds before retrying. */
+    readonly retryAfter?: number;
+    constructor(message?: string, retryAfter?: number);
+}
+/**
+ * Thrown when a requested resource is not found.
+ */
+declare class NotFoundError extends FirefliesError {
+    readonly code = "NOT_FOUND";
+    constructor(message?: string);
+}
+/**
+ * Thrown when request validation fails.
+ */
+declare class ValidationError extends FirefliesError {
+    readonly code = "VALIDATION_ERROR";
+    constructor(message: string);
+}
+/**
+ * Thrown when the GraphQL API returns errors.
+ */
+declare class GraphQLError extends FirefliesError {
+    readonly code = "GRAPHQL_ERROR";
+    readonly errors: GraphQLErrorDetail[];
+    constructor(message: string, errors: GraphQLErrorDetail[]);
+}
+/**
+ * Detail from a GraphQL error response.
+ */
+interface GraphQLErrorDetail {
+    message: string;
+    path?: string[];
+    extensions?: Record<string, unknown>;
+}
+/**
+ * Thrown when a request times out.
+ */
+declare class TimeoutError extends FirefliesError {
+    readonly code = "TIMEOUT_ERROR";
+    constructor(message?: string);
+}
+/**
+ * Thrown when a network error occurs.
+ */
+declare class NetworkError extends FirefliesError {
+    readonly code = "NETWORK_ERROR";
+    constructor(message: string, cause?: unknown);
+}
+/**
+ * Base error for realtime operations.
+ */
+declare class RealtimeError extends FirefliesError {
+    readonly code: string;
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Thrown when realtime connection fails.
+ */
+declare class ConnectionError extends RealtimeError {
+    readonly code = "CONNECTION_ERROR";
+    constructor(message?: string, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Thrown when stream is accessed after close.
+ */
+declare class StreamClosedError extends RealtimeError {
+    readonly code = "STREAM_CLOSED";
+    constructor(message?: string);
+}
+/**
+ * Thrown when webhook signature verification fails.
+ */
+declare class WebhookVerificationError extends FirefliesError {
+    readonly code = "WEBHOOK_VERIFICATION_FAILED";
+    constructor(message: string);
+}
+/**
+ * Thrown when webhook payload parsing fails.
+ */
+declare class WebhookParseError extends FirefliesError {
+    readonly code = "WEBHOOK_PARSE_FAILED";
+    constructor(message: string);
+}
+/**
+ * Thrown when no chunks received for configured timeout.
+ * Consumer should check if meeting is still active and decide whether to reconnect.
+ */
+declare class ChunkTimeoutError extends RealtimeError {
+    readonly code = "CHUNK_TIMEOUT";
+    readonly timeoutMs: number;
+    constructor(timeoutMs: number);
+}
+
+/**
+ * A speaker turn containing one or more consecutive chunks from the same speaker.
+ */
+interface SpeakerTurn {
+    /** Name of the speaker */
+    speaker: string;
+    /** Combined text from all chunks in this turn */
+    text: string;
+    /** Start time of the first chunk in seconds */
+    startTime: number;
+    /** End time of the last chunk in seconds */
+    endTime: number;
+    /** Original chunks that make up this turn */
+    chunks: TranscriptionChunk[];
+}
+/**
+ * The accumulated transcript state.
+ */
+interface AccumulatedTranscript {
+    /** Speaker turns in chronological order */
+    turns: SpeakerTurn[];
+    /** Unique speaker names in order of first appearance */
+    speakers: string[];
+    /** Total word count across all turns */
+    wordCount: number;
+    /** Duration in seconds from first chunk start to last chunk end */
+    duration: number;
+    /** Total number of final chunks accumulated */
+    chunkCount: number;
+}
+/**
+ * Accumulates streaming transcription chunks into a coherent transcript.
+ *
+ * Chunks from the same speaker are merged into turns. Statistics like word count
+ * and duration are computed on demand.
+ *
+ * @example
+ * ```typescript
+ * const accumulator = new TranscriptAccumulator();
+ *
+ * for await (const chunk of client.realtime.stream(meetingId)) {
+ *   accumulator.add(chunk);
+ *   const transcript = accumulator.getTranscript();
+ *   console.log(`${transcript.speakers.length} speakers, ${transcript.wordCount} words`);
+ * }
+ *
+ * const final = accumulator.getTranscript();
+ * ```
+ */
+declare class TranscriptAccumulator {
+    private turns;
+    private currentTurn;
+    private seenChunkIds;
+    /**
+     * Add a chunk to the accumulator.
+     *
+     * Only final chunks are accumulated; non-final chunks are ignored.
+     * Duplicate chunk IDs are also ignored.
+     *
+     * @param chunk - The transcription chunk to add
+     */
+    add(chunk: TranscriptionChunk): void;
+    /**
+     * Get the current accumulated transcript state.
+     *
+     * Statistics are computed on demand to ensure accuracy.
+     *
+     * @returns The accumulated transcript with turns, speakers, and statistics
+     */
+    getTranscript(): AccumulatedTranscript;
+    /**
+     * Clear all accumulated data.
+     *
+     * Useful for resetting the accumulator between sessions.
+     */
+    clear(): void;
+    private getUniqueSpeakers;
+    private computeWordCount;
+    private computeDuration;
+}
+
+/**
+ * Filter action items by criteria.
+ *
+ * Filters can be combined with AND logic - items must match all specified criteria.
+ *
+ * @param items - Action items to filter
+ * @param options - Filter criteria
+ * @returns Filtered items preserving original type and order
+ *
+ * @example
+ * ```typescript
+ * // Filter to Alice's items with due dates
+ * const filtered = filterActionItems(items, {
+ *   assignees: ['Alice'],
+ *   datedOnly: true,
+ * });
+ * ```
+ */
+declare function filterActionItems<T extends ActionItem>(items: T[], options: ActionItemsFilterOptions): T[];
+/**
+ * Aggregate action items from multiple transcripts.
+ *
+ * Extracts action items from each transcript and attaches source metadata
+ * (transcript ID, title, date) to each item.
+ *
+ * @param transcripts - Transcripts to extract action items from
+ * @param extractionOptions - Options for action item extraction
+ * @param filterOptions - Options to filter extracted items
+ * @returns Aggregated result with items and statistics
+ *
+ * @example
+ * ```typescript
+ * const result = aggregateActionItems(transcripts);
+ * console.log(`${result.totalItems} items from ${result.transcriptsProcessed} meetings`);
+ * ```
+ */
+declare function aggregateActionItems(transcripts: Transcript[], extractionOptions?: ActionItemOptions, filterOptions?: ActionItemsFilterOptions): AggregatedActionItemsResult;
+/**
+ * Format action items as Markdown.
+ *
+ * Supports multiple styles (checkbox, bullet, numbered), grouping options,
+ * inline metadata, and presets for popular tools.
+ *
+ * @param result - Action items result (single or aggregated)
+ * @param options - Formatting options
+ * @returns Formatted markdown string
+ *
+ * @example
+ * ```typescript
+ * const markdown = formatActionItemsMarkdown(result, {
+ *   style: 'checkbox',
+ *   groupBy: 'assignee',
+ *   includeSummary: true,
+ *   preset: 'notion',
+ * });
+ * ```
+ */
+declare function formatActionItemsMarkdown(result: ActionItemsResult | AggregatedActionItemsResult, options?: ActionItemsMarkdownOptions): string;
+
+/**
+ * Options for batch processing.
+ */
+interface BatchOptions {
+    /**
+     * Number of concurrent operations.
+     * Currently only sequential (1) is supported.
+     * @default 1
+     */
+    concurrency?: number;
+    /**
+     * Delay in milliseconds between operations.
+     * @default 100
+     */
+    delayMs?: number;
+    /**
+     * Whether to automatically handle rate limit errors.
+     * When true, waits for retryAfter and retries.
+     * @default true
+     */
+    handleRateLimit?: boolean;
+    /**
+     * Maximum number of rate limit retries per item.
+     * @default 3
+     */
+    maxRateLimitRetries?: number;
+}
+/**
+ * Result of a batch operation on a single item.
+ */
+type BatchResult<T, R> = {
+    item: T;
+    result: R;
+    error?: never;
+} | {
+    item: T;
+    result?: never;
+    error: Error;
+};
+/**
+ * Process items in batch with rate limiting and error handling.
+ *
+ * Yields results as they complete, allowing streaming processing.
+ * On rate limit errors, automatically waits and retries if handleRateLimit is true.
+ *
+ * @param items - Items to process (sync or async iterable)
+ * @param processor - Function to process each item
+ * @param options - Batch processing options
+ * @returns AsyncIterable yielding results (success or error) for each item
+ *
+ * @example
+ * ```typescript
+ * import { batch, FirefliesClient } from 'fireflies-api';
+ *
+ * const client = new FirefliesClient({ apiKey: 'your-api-key' });
+ * const ids = ['id1', 'id2', 'id3'];
+ *
+ * for await (const result of batch(ids, id => client.transcripts.get(id))) {
+ *   if (result.error) {
+ *     console.error(`Failed to fetch ${result.item}: ${result.error.message}`);
+ *   } else {
+ *     console.log(`Got ${result.result.title}`);
+ *   }
+ * }
+ * ```
+ */
+declare function batch<T, R>(items: Iterable<T> | AsyncIterable<T>, processor: (item: T) => Promise<R>, options?: BatchOptions): AsyncIterable<BatchResult<T, R>>;
+/**
+ * Process all items in batch and collect results.
+ *
+ * Unlike the streaming `batch()`, this waits for all items to complete
+ * and returns results as an array.
+ *
+ * @param items - Array of items to process
+ * @param processor - Function to process each item
+ * @param options - Batch processing options plus continueOnError
+ * @returns Array of successful results. When continueOnError is false, results
+ *   match input order. When true, failed items are omitted (array may be shorter).
+ * @throws First error encountered if continueOnError is false (default)
+ *
+ * @example
+ * ```typescript
+ * import { batchAll, FirefliesClient } from 'fireflies-api';
+ *
+ * const client = new FirefliesClient({ apiKey: 'your-api-key' });
+ * const ids = ['id1', 'id2', 'id3'];
+ *
+ * // Throws on first error
+ * const transcripts = await batchAll(ids, id => client.transcripts.get(id));
+ *
+ * // Continues on error, collects successful results
+ * const results = await batchAll(
+ *   ids,
+ *   id => client.transcripts.get(id),
+ *   { continueOnError: true }
+ * );
+ * ```
+ */
+declare function batchAll<T, R>(items: T[], processor: (item: T) => Promise<R>, options?: BatchOptions & {
+    continueOnError?: boolean;
+}): Promise<R[]>;
+
+/**
+ * Extract domain from email address.
+ *
+ * @param email - Email address
+ * @returns Lowercase domain, or empty string if invalid
+ *
+ * @example
+ * ```typescript
+ * extractDomain('user@company.com'); // 'company.com'
+ * extractDomain('User@EXAMPLE.ORG'); // 'example.org'
+ * extractDomain('invalid'); // ''
+ * ```
+ */
+declare function extractDomain(email: string): string;
+/**
+ * Check if any participant has an email outside the given domain.
+ *
+ * @param participants - List of participant email addresses
+ * @param internalDomain - The internal/company domain to check against
+ * @returns True if at least one participant has a different domain
+ *
+ * @example
+ * ```typescript
+ * hasExternalParticipants(['a@company.com', 'b@external.com'], 'company.com'); // true
+ * hasExternalParticipants(['a@company.com', 'b@company.com'], 'company.com'); // false
+ * ```
+ */
+declare function hasExternalParticipants(participants: string[], internalDomain: string): boolean;
+
+/**
+ * A question asked by an external participant.
+ */
+interface ExternalQuestion {
+    /** The question text */
+    text: string;
+    /** Name of the speaker who asked the question */
+    speakerName: string;
+    /** Email of the speaker (if available from attendees) */
+    speakerEmail?: string;
+    /** Index of the sentence in the transcript */
+    sentenceIndex: number;
+    /** Start time as decimal seconds string */
+    startTime: string;
+    /** End time as decimal seconds string */
+    endTime: string;
+}
+/**
+ * Result of finding external participant questions.
+ */
+interface ExternalQuestionsResult {
+    /** List of external participants identified */
+    externalParticipants: Array<{
+        name: string;
+        email?: string;
+    }>;
+    /** Questions asked by external participants */
+    questions: ExternalQuestion[];
+    /** Total count of questions */
+    totalQuestions: number;
+}
+/**
+ * Find questions asked by external participants in a transcript.
+ *
+ * This function analyzes a transcript to identify questions from participants
+ * whose email domains don't match the specified internal domains.
+ *
+ * @param transcript - The transcript to analyze
+ * @param internalDomains - Internal domain(s) to identify internal participants.
+ *   Can be a single domain string (e.g., '@mycompany.com' or 'mycompany.com')
+ *   or an array of domains.
+ * @returns Object containing external participants, their questions, and count
+ *
+ * @example
+ * ```typescript
+ * const transcript = await client.transcripts.get('id');
+ * const result = findExternalParticipantQuestions(transcript, '@mycompany.com');
+ *
+ * console.log(`Found ${result.totalQuestions} questions from external participants`);
+ * for (const q of result.questions) {
+ *   console.log(`${q.speakerName}: ${q.text}`);
+ * }
+ * ```
+ */
+declare function findExternalParticipantQuestions(transcript: Transcript, internalDomains: string | string[]): ExternalQuestionsResult;
+
+/**
+ * Options for transcriptToMarkdown().
+ */
+interface MarkdownExportOptions {
+    /** Include meeting metadata header (title, date, participants, duration). Default: true */
+    includeMetadata?: boolean;
+    /** Include AI-generated summary sections. Default: true */
+    includeSummary?: boolean;
+    /** Include action items section. Default: true */
+    includeActionItems?: boolean;
+    /** Format for action items: checkbox or plain list. Default: 'checkbox' */
+    actionItemFormat?: 'checkbox' | 'list';
+    /** Include timestamps for each sentence. Default: false */
+    includeTimestamps?: boolean;
+    /** How to format speaker names. Default: 'bold' */
+    speakerFormat?: 'bold' | 'plain';
+    /** Group consecutive sentences by same speaker. Default: true */
+    groupBySpeaker?: boolean;
+    /** Write output to file path (Node.js only). If set, also returns the string. */
+    outputPath?: string;
+}
+/**
+ * Options for chunksToMarkdown().
+ */
+interface ChunksExportOptions {
+    /** Meeting title (chunks don't include metadata). Default: 'Live Transcript' */
+    title?: string;
+    /** Include timestamps for each chunk. Default: false */
+    includeTimestamps?: boolean;
+    /** How to format speaker names. Default: 'bold' */
+    speakerFormat?: 'bold' | 'plain';
+    /** Group consecutive chunks by same speaker. Default: true */
+    groupBySpeaker?: boolean;
+    /** Write output to file path (Node.js only). If set, also returns the string. */
+    outputPath?: string;
+}
+/**
+ * Convert a completed Fireflies transcript to well-formatted Markdown.
+ *
+ * @param transcript - The transcript to convert
+ * @param options - Formatting options
+ * @returns Markdown string representation of the transcript
+ *
+ * @example
+ * ```typescript
+ * import { FirefliesClient, transcriptToMarkdown } from 'fireflies-api';
+ *
+ * const client = new FirefliesClient({ apiKey: 'your-api-key' });
+ * const transcript = await client.transcripts.get('transcript-id');
+ *
+ * // Basic usage
+ * const markdown = await transcriptToMarkdown(transcript);
+ *
+ * // With options
+ * const markdown = await transcriptToMarkdown(transcript, {
+ *   includeTimestamps: true,
+ *   actionItemFormat: 'list',
+ * });
+ *
+ * // Write to file
+ * const markdown = await transcriptToMarkdown(transcript, {
+ *   outputPath: './meeting-notes.md',
+ * });
+ * ```
+ */
+declare function transcriptToMarkdown(transcript: Transcript, options?: MarkdownExportOptions): Promise<string>;
+/**
+ * Convert realtime transcription chunks to well-formatted Markdown.
+ *
+ * @param chunks - Array of transcription chunks from realtime stream
+ * @param options - Formatting options
+ * @returns Markdown string representation of the chunks
+ *
+ * @example
+ * ```typescript
+ * import { FirefliesClient, chunksToMarkdown } from 'fireflies-api';
+ *
+ * const client = new FirefliesClient({ apiKey: 'your-api-key' });
+ *
+ * // Accumulate chunks from realtime stream
+ * const chunks: TranscriptionChunk[] = [];
+ * for await (const chunk of client.realtime.stream(meetingId)) {
+ *   chunks.push(chunk);
+ * }
+ *
+ * // Convert to markdown
+ * const markdown = await chunksToMarkdown(chunks);
+ *
+ * // With options
+ * const markdown = await chunksToMarkdown(chunks, {
+ *   title: 'Team Standup',
+ *   includeTimestamps: true,
+ * });
+ * ```
+ */
+declare function chunksToMarkdown(chunks: TranscriptionChunk[], options?: ChunksExportOptions): Promise<string>;
+
+/**
+ * Analyze multiple transcripts to compute aggregate meeting statistics.
+ *
+ * Pure function - no API calls, fully testable. Computes duration totals,
+ * day of week distribution, participant counts, speaker talk times, and
+ * time-based groupings.
+ *
+ * @param transcripts - Array of transcripts to analyze
+ * @param options - Analysis options for filtering and grouping
+ * @returns Aggregate meeting insights
+ *
+ * @example
+ * ```typescript
+ * import { FirefliesClient, analyzeMeetings } from 'fireflies-api';
+ *
+ * const client = new FirefliesClient({ apiKey: 'your-api-key' });
+ *
+ * // Fetch transcripts
+ * const transcripts: Transcript[] = [];
+ * for await (const t of client.transcripts.listAll({ mine: true })) {
+ *   transcripts.push(t);
+ * }
+ *
+ * // Analyze
+ * const insights = analyzeMeetings(transcripts, {
+ *   groupBy: 'week',
+ *   topSpeakersCount: 5,
+ * });
+ *
+ * console.log(`${insights.totalMeetings} meetings, ${insights.totalDurationMinutes} minutes total`);
+ * console.log(`Average: ${insights.averageDurationMinutes} minutes`);
+ * ```
+ */
+declare function analyzeMeetings(transcripts: Transcript[], options?: MeetingInsightsOptions): MeetingInsights;
+
+/**
+ * Options for fetching transcripts from multiple users.
+ */
+interface MultiUserOptions {
+    /**
+     * Whether to deduplicate transcripts by ID across accounts.
+     * Useful when multiple users have access to the same transcripts.
+     * @default true
+     */
+    deduplicate?: boolean;
+    /**
+     * Filter parameters to apply to each account's transcript listing.
+     * Pagination (skip/limit) is handled automatically.
+     */
+    filter?: Omit<TranscriptsListParams, 'skip' | 'limit'>;
+    /**
+     * Delay in milliseconds between yielded transcripts.
+     * Helps throttle processing and reduce memory pressure.
+     * Note: API rate limiting is handled by the underlying client.
+     * @default 100
+     */
+    delayMs?: number;
+}
+/**
+ * A transcript with source tracking information.
+ */
+interface MultiUserTranscript {
+    /** The transcript object */
+    transcript: Transcript;
+    /** API key used to fetch this transcript (for attribution) */
+    sourceApiKey: string;
+    /** Index of the API key in the input array */
+    sourceIndex: number;
+}
+/**
+ * Fetch transcripts from multiple Fireflies accounts with deduplication.
+ *
+ * This function creates a client for each API key and iterates through
+ * all transcripts, optionally deduplicating across accounts.
+ *
+ * @param apiKeys - Array of Fireflies API keys
+ * @param options - Configuration options
+ * @returns AsyncIterable yielding transcripts with source tracking
+ *
+ * @example
+ * ```typescript
+ * import { getMeetingsForMultipleUsers } from 'fireflies-api';
+ *
+ * const apiKeys = [
+ *   process.env.FIREFLIES_API_KEY_USER1!,
+ *   process.env.FIREFLIES_API_KEY_USER2!,
+ * ];
+ *
+ * for await (const { transcript, sourceIndex } of getMeetingsForMultipleUsers(apiKeys)) {
+ *   console.log(`[User ${sourceIndex}] ${transcript.title}`);
+ * }
+ *
+ * // With filtering
+ * for await (const item of getMeetingsForMultipleUsers(apiKeys, {
+ *   filter: { fromDate: '2024-01-01' },
+ *   deduplicate: true,
+ * })) {
+ *   console.log(item.transcript.title);
+ * }
+ * ```
+ */
+declare function getMeetingsForMultipleUsers(apiKeys: string[], options?: MultiUserOptions): AsyncIterable<MultiUserTranscript>;
+
+/**
+ * Options for batch normalization, extending NormalizationOptions.
+ */
+interface BatchNormalizationOptions extends NormalizationOptions {
+    /**
+     * Delay between items in ms.
+     * Since normalization is a pure function, this is typically 0.
+     * @default 0
+     */
+    delayMs?: number;
+}
+/**
+ * Normalize a Fireflies transcript to a provider-agnostic format.
+ *
+ * This function converts Fireflies-specific transcript data to a normalized schema
+ * that can be used across multiple meeting intelligence providers.
+ *
+ * @param transcript - The Fireflies transcript to normalize
+ * @param options - Normalization options
+ * @returns A normalized meeting object
+ *
+ * @example
+ * ```typescript
+ * import { FirefliesClient, normalizeTranscript } from 'fireflies-api';
+ *
+ * const client = new FirefliesClient({ apiKey: 'your-api-key' });
+ * const transcript = await client.transcripts.get({ id: 'transcript-id' });
+ *
+ * const normalized = normalizeTranscript(transcript, {
+ *   timeUnit: 'milliseconds',
+ *   includeRawData: true,
+ * });
+ *
+ * console.log(normalized.id); // "fireflies:transcript-id"
+ * console.log(normalized.duration); // in seconds
+ * ```
+ */
+declare function normalizeTranscript(transcript: Transcript, options?: NormalizationOptions): NormalizedMeeting;
+/**
+ * Create a pre-configured normalizer function.
+ *
+ * Useful when normalizing multiple transcripts with the same options.
+ *
+ * @param options - Normalization options to apply to all transcripts
+ * @returns A function that normalizes transcripts with the configured options
+ *
+ * @example
+ * ```typescript
+ * import { createNormalizer } from 'fireflies-api';
+ *
+ * const normalizer = createNormalizer({
+ *   timeUnit: 'milliseconds',
+ *   includeRawData: false,
+ * });
+ *
+ * // Reuse with same config
+ * const norm1 = normalizer(transcript1);
+ * const norm2 = normalizer(transcript2);
+ * ```
+ */
+declare function createNormalizer(options?: NormalizationOptions): (transcript: Transcript) => NormalizedMeeting;
+/**
+ * Normalize multiple transcripts with streaming and error handling.
+ *
+ * Yields a BatchResult for each transcript, capturing any errors
+ * without stopping iteration.
+ *
+ * @param transcripts - Array or async iterable of transcripts to normalize
+ * @param options - Batch normalization options
+ * @returns AsyncIterable yielding BatchResult for each transcript
+ *
+ * @example
+ * ```typescript
+ * import { normalizeTranscripts } from 'fireflies-api';
+ *
+ * for await (const result of normalizeTranscripts(transcripts)) {
+ *   if (result.error) {
+ *     console.error(`Failed: ${result.item.id}`, result.error);
+ *   } else {
+ *     console.log(result.result.id); // "fireflies:..."
+ *   }
+ * }
+ * ```
+ */
+declare function normalizeTranscripts(transcripts: Transcript[] | AsyncIterable<Transcript>, options?: BatchNormalizationOptions): AsyncIterable<BatchResult<Transcript, NormalizedMeeting>>;
+/**
+ * Normalize multiple transcripts and collect all results.
+ *
+ * Unlike the streaming `normalizeTranscripts()`, this waits for all items
+ * to complete and returns results as an array.
+ *
+ * @param transcripts - Array or async iterable of transcripts to normalize
+ * @param options - Batch normalization options
+ * @returns Array of BatchResult for each transcript
+ *
+ * @example
+ * ```typescript
+ * import { normalizeTranscriptsAll } from 'fireflies-api';
+ *
+ * const results = await normalizeTranscriptsAll(transcripts, {
+ *   timeUnit: 'milliseconds',
+ *   includeRawData: false,
+ * });
+ *
+ * const successful = results.filter(r => !r.error).map(r => r.result);
+ * const failed = results.filter(r => r.error);
+ * ```
+ */
+declare function normalizeTranscriptsAll(transcripts: Transcript[] | AsyncIterable<Transcript>, options?: BatchNormalizationOptions): Promise<BatchResult<Transcript, NormalizedMeeting>[]>;
+
+/**
+ * Create an async iterable that automatically paginates through results.
+ *
+ * @param fetcher - Function that fetches a page of results
+ * @param pageSize - Number of items per page
+ * @returns Async iterable yielding items one at a time
+ *
+ * @example
+ * ```typescript
+ * const items = paginate(
+ *   (skip, limit) => client.transcripts.list({ skip, limit }),
+ *   50
+ * );
+ *
+ * for await (const item of items) {
+ *   console.log(item.title);
+ * }
+ * ```
+ */
+declare function paginate<T>(fetcher: (skip: number, limit: number) => Promise<T[]>, pageSize?: number): AsyncIterable<T>;
+/**
+ * Collect all items from an async iterable into an array.
+ *
+ * @param iterable - Async iterable to collect
+ * @returns Array of all items
+ */
+declare function collectAll<T>(iterable: AsyncIterable<T>): Promise<T[]>;
+
+/**
+ * Search helper functions for searching transcript content.
+ */
+
+/**
+ * Search a single transcript for matching sentences.
+ *
+ * This is a pure function with no API calls, making it fully testable.
+ * It searches the transcript's sentences for text matching the query,
+ * optionally filtering by speaker, questions, or tasks.
+ *
+ * @param transcript - The transcript to search
+ * @param options - Search options including query, filters, and context settings
+ * @returns Array of matches with context
+ *
+ * @example
+ * ```typescript
+ * import { searchTranscript } from 'fireflies-api';
+ *
+ * const matches = searchTranscript(transcript, {
+ *   query: 'budget',
+ *   speakers: ['Alice'],
+ *   filterQuestions: true,
+ *   contextLines: 2,
+ * });
+ *
+ * for (const match of matches) {
+ *   console.log(`${match.sentence.speakerName}: ${match.sentence.text}`);
+ * }
+ * ```
+ */
+declare function searchTranscript(transcript: Transcript, options: SearchTranscriptOptions): SearchMatch[];
+
+/**
+ * A transcript with a guaranteed video URL.
+ */
+interface TranscriptWithVideo {
+    /** The full transcript object */
+    transcript: Transcript;
+    /** URL to download video (expires after 24h) */
+    videoUrl: string;
+}
+/**
+ * Iterate through transcripts that have video recordings.
+ *
+ * This function filters transcripts to only yield those with video_url set.
+ * Video recordings require Business plan or higher.
+ *
+ * @param client - FirefliesClient instance
+ * @param options - Optional filter parameters (pagination is handled automatically)
+ * @returns AsyncIterable yielding transcripts with their video URLs
+ *
+ * @example
+ * ```typescript
+ * import { FirefliesClient, getMeetingVideos } from 'fireflies-api';
+ *
+ * const client = new FirefliesClient({ apiKey: 'your-api-key' });
+ *
+ * for await (const { transcript, videoUrl } of getMeetingVideos(client)) {
+ *   console.log(`${transcript.title}: ${videoUrl}`);
+ * }
+ *
+ * // With filters
+ * for await (const item of getMeetingVideos(client, {
+ *   fromDate: '2024-01-01',
+ *   mine: true,
+ * })) {
+ *   console.log(item.videoUrl);
+ * }
+ * ```
+ */
+declare function getMeetingVideos(client: FirefliesClient, options?: Omit<TranscriptsListParams, 'skip' | 'limit'>): AsyncIterable<TranscriptWithVideo>;
+/**
+ * Check if a transcript has a video recording.
+ *
+ * @param transcript - Transcript to check
+ * @returns true if the transcript has a video URL
+ */
+declare function hasVideo(transcript: Transcript): transcript is Transcript & {
+    video_url: string;
+};
+
+/**
+ * Deduplicates items by a key.
+ * Uses a sliding window to avoid unbounded memory growth.
+ */
+declare class Deduplicator {
+    private seen;
+    private queue;
+    private maxSize;
+    constructor(maxSize?: number);
+    /**
+     * Check if item is a duplicate and mark as seen.
+     * @param key - Unique key to check
+     * @returns true if duplicate, false if new
+     */
+    isDuplicate(key: string): boolean;
+    /**
+     * Clear all tracked keys.
+     */
+    clear(): void;
+    /**
+     * Get current number of tracked keys.
+     */
+    get size(): number;
+}
+
+/**
+ * Type guard to check if a payload is a valid WebhookPayload.
+ *
+ * @param payload - The payload to validate
+ * @returns true if the payload matches the WebhookPayload structure
+ *
+ * @example
+ * ```typescript
+ * if (isValidWebhookPayload(req.body)) {
+ *   // req.body is now typed as WebhookPayload
+ *   console.log(req.body.meetingId);
+ * }
+ * ```
+ */
+declare function isValidWebhookPayload(payload: unknown): payload is WebhookPayload;
+/**
+ * Parse and validate a Fireflies webhook payload.
+ *
+ * Optionally verifies the webhook signature if signature and secret are provided.
+ *
+ * @param payload - The webhook payload to parse
+ * @param options - Optional verification options
+ * @returns The validated WebhookPayload
+ * @throws {WebhookVerificationError} If signature verification fails
+ * @throws {WebhookParseError} If payload structure is invalid
+ *
+ * @example
+ * ```typescript
+ * // Parse without verification
+ * const event = parseWebhookPayload(req.body);
+ * console.log(event.meetingId);
+ *
+ * // Parse with verification
+ * const event = parseWebhookPayload(req.body, {
+ *   signature: req.headers['x-hub-signature'],
+ *   secret: process.env.WEBHOOK_SECRET,
+ * });
+ * ```
+ */
+declare function parseWebhookPayload(payload: unknown, options?: ParseOptions): WebhookPayload;
+
+/**
+ * Verify the authenticity of a Fireflies webhook using HMAC SHA-256.
+ *
+ * Uses timing-safe comparison to prevent timing attacks.
+ *
+ * @param options - Verification options
+ * @returns true if the signature is valid, false otherwise
+ *
+ * @example
+ * ```typescript
+ * const isValid = verifyWebhookSignature({
+ *   payload: req.body,
+ *   signature: req.headers['x-hub-signature'],
+ *   secret: process.env.WEBHOOK_SECRET,
+ * });
+ *
+ * if (!isValid) {
+ *   return res.status(401).send('Invalid signature');
+ * }
+ * ```
+ */
+declare function verifyWebhookSignature(options: VerifyOptions): boolean;
+
+export { type AccumulatedTranscript, ActionItem, ActionItemOptions, ActionItemsFilterOptions, ActionItemsMarkdownOptions, ActionItemsResult, AggregatedActionItemsResult, AuthenticationError, type BatchNormalizationOptions, type BatchOptions, type BatchResult, ChunkTimeoutError, type ChunksExportOptions, ConnectionError, Deduplicator, type ExternalQuestion, type ExternalQuestionsResult, FirefliesClient, FirefliesError, GraphQLError, type GraphQLErrorDetail, type MarkdownExportOptions, MeetingInsights, MeetingInsightsOptions, type MultiUserOptions, type MultiUserTranscript, NetworkError, NormalizationOptions, NormalizedMeeting, NotFoundError, ParseOptions, RateLimitError, RealtimeError, SearchMatch, SearchTranscriptOptions, type SpeakerTurn, StreamClosedError, TimeoutError, Transcript, TranscriptAccumulator, type TranscriptWithVideo, TranscriptionChunk, TranscriptsListParams, ValidationError, VerifyOptions, WebhookParseError, WebhookPayload, WebhookVerificationError, aggregateActionItems, analyzeMeetings, batch, batchAll, chunksToMarkdown, collectAll, createNormalizer, extractDomain, filterActionItems, findExternalParticipantQuestions, formatActionItemsMarkdown, getMeetingVideos, getMeetingsForMultipleUsers, hasExternalParticipants, hasVideo, isValidWebhookPayload, normalizeTranscript, normalizeTranscripts, normalizeTranscriptsAll, paginate, parseWebhookPayload, searchTranscript, transcriptToMarkdown, verifyWebhookSignature };