@churchapps/content-providers 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,671 @@
+interface ContentProviderAuthData {
+    access_token: string;
+    refresh_token: string;
+    token_type: string;
+    created_at: number;
+    expires_in: number;
+    scope: string;
+}
+/** A single endpoint value - either a static string or a function that generates a path */
+type EndpointValue = string | ((...args: string[]) => string);
+/** Configuration for provider API endpoints */
+type EndpointsConfig = Record<string, EndpointValue>;
+interface ContentProviderConfig {
+    id: string;
+    name: string;
+    apiBase: string;
+    oauthBase: string;
+    clientId: string;
+    scopes: string[];
+    supportsDeviceFlow?: boolean;
+    deviceAuthEndpoint?: string;
+    endpoints: EndpointsConfig;
+}
+interface DeviceAuthorizationResponse {
+    device_code: string;
+    user_code: string;
+    verification_uri: string;
+    verification_uri_complete?: string;
+    expires_in: number;
+    interval?: number;
+}
+interface DeviceFlowState {
+    status: "loading" | "awaiting_user" | "polling" | "success" | "error" | "expired";
+    deviceAuth?: DeviceAuthorizationResponse;
+    error?: string;
+    pollCount?: number;
+}
+type AuthType = "none" | "oauth_pkce" | "device_flow" | "form_login";
+interface ProviderLogos {
+    light: string;
+    dark: string;
+}
+interface ProviderInfo {
+    id: string;
+    name: string;
+    logos: ProviderLogos;
+    implemented: boolean;
+    requiresAuth: boolean;
+    authTypes: AuthType[];
+    capabilities: ProviderCapabilities;
+}
+interface ContentFolder {
+    type: "folder";
+    id: string;
+    title: string;
+    thumbnail?: string;
+    isLeaf?: boolean;
+    path: string;
+}
+interface ContentFile {
+    type: "file";
+    id: string;
+    title: string;
+    mediaType: "video" | "image";
+    thumbnail?: string;
+    url: string;
+    downloadUrl?: string;
+    muxPlaybackId?: string;
+    decryptionKey?: string;
+    mediaId?: string;
+    pingbackUrl?: string;
+    seconds?: number;
+    loop?: boolean;
+    loopVideo?: boolean;
+    streamUrl?: string;
+    /** Provider-specific metadata that varies by provider implementation */
+    providerData?: Record<string, unknown>;
+}
+type ContentItem = ContentFolder | ContentFile;
+declare function isContentFolder(item: ContentItem): item is ContentFolder;
+declare function isContentFile(item: ContentItem): item is ContentFile;
+type DeviceFlowPollResult = ContentProviderAuthData | {
+    error: string;
+    shouldSlowDown?: boolean;
+} | null;
+interface PlanPresentation {
+    id: string;
+    name: string;
+    actionType: "play" | "other";
+    files: ContentFile[];
+    providerData?: Record<string, unknown>;
+}
+interface PlanSection {
+    id: string;
+    name: string;
+    presentations: PlanPresentation[];
+}
+interface Plan {
+    id: string;
+    name: string;
+    description?: string;
+    thumbnail?: string;
+    sections: PlanSection[];
+    allFiles: ContentFile[];
+}
+interface FeedFileInterface {
+    id?: string;
+    name?: string;
+    url?: string;
+    streamUrl?: string;
+    seconds?: number;
+    fileType?: string;
+    thumbnail?: string;
+}
+interface FeedActionInterface {
+    id?: string;
+    actionType?: string;
+    content?: string;
+    files?: FeedFileInterface[];
+}
+interface FeedSectionInterface {
+    id?: string;
+    name?: string;
+    actions?: FeedActionInterface[];
+}
+interface FeedVenueInterface {
+    id?: string;
+    lessonId?: string;
+    name?: string;
+    lessonName?: string;
+    lessonDescription?: string;
+    lessonImage?: string;
+    sections?: FeedSectionInterface[];
+}
+interface InstructionItem {
+    id?: string;
+    itemType?: string;
+    relatedId?: string;
+    label?: string;
+    actionType?: string;
+    content?: string;
+    seconds?: number;
+    children?: InstructionItem[];
+    downloadUrl?: string;
+    thumbnail?: string;
+}
+interface Instructions {
+    name?: string;
+    items: InstructionItem[];
+}
+interface VenueActionInterface {
+    id?: string;
+    name?: string;
+    actionType?: string;
+    seconds?: number;
+}
+interface VenueSectionActionsInterface {
+    id?: string;
+    name?: string;
+    actions?: VenueActionInterface[];
+}
+interface VenueActionsResponseInterface {
+    venueName?: string;
+    sections?: VenueSectionActionsInterface[];
+}
+interface ProviderCapabilities {
+    browse: boolean;
+    presentations: boolean;
+    playlist: boolean;
+    instructions: boolean;
+    mediaLicensing: boolean;
+}
+type MediaLicenseStatus = "valid" | "expired" | "not_licensed" | "unknown";
+interface MediaLicenseResult {
+    mediaId: string;
+    status: MediaLicenseStatus;
+    message?: string;
+    expiresAt?: string | number;
+}
+/**
+ * Core provider interface - all providers should implement this
+ */
+interface IProvider {
+    readonly id: string;
+    readonly name: string;
+    readonly logos: ProviderLogos;
+    readonly config: ContentProviderConfig;
+    readonly requiresAuth: boolean;
+    readonly capabilities: ProviderCapabilities;
+    readonly authTypes: AuthType[];
+    browse(path?: string | null, auth?: ContentProviderAuthData | null): Promise<ContentItem[]>;
+    supportsDeviceFlow(): boolean;
+    generateCodeVerifier?(): string;
+    buildAuthUrl?(codeVerifier: string, redirectUri: string, state?: string): Promise<{
+        url: string;
+        challengeMethod: string;
+    }>;
+    exchangeCodeForTokens?(code: string, codeVerifier: string, redirectUri: string): Promise<ContentProviderAuthData | null>;
+    initiateDeviceFlow?(): Promise<DeviceAuthorizationResponse | null>;
+    pollDeviceFlowToken?(deviceCode: string): Promise<DeviceFlowPollResult>;
+    getPlaylist?(path: string, auth?: ContentProviderAuthData | null, resolution?: number): Promise<ContentFile[] | null>;
+    getInstructions?(path: string, auth?: ContentProviderAuthData | null): Promise<Instructions | null>;
+    checkMediaLicense?(mediaId: string, auth?: ContentProviderAuthData | null): Promise<MediaLicenseResult | null>;
+}
+
+declare function detectMediaType(url: string, explicitType?: string): "video" | "image";
+declare function createFolder(id: string, title: string, path: string, thumbnail?: string, isLeaf?: boolean): ContentFolder;
+declare function createFile(id: string, title: string, url: string, options?: {
+    mediaType?: "video" | "image";
+    thumbnail?: string;
+    muxPlaybackId?: string;
+    seconds?: number;
+    loop?: boolean;
+    loopVideo?: boolean;
+    streamUrl?: string;
+}): ContentFile;
+
+/**
+ * Path parsing utilities for content providers.
+ * Paths follow the format: /segment1/segment2/segment3/...
+ * Example: /lessons/programId/studyId/lessonId/venueId
+ */
+interface ParsedPath {
+    segments: string[];
+    depth: number;
+}
+/**
+ * Parse a path string into segments and depth.
+ * @param path - The path to parse (e.g., "/lessons/abc123/def456")
+ * @returns Object with segments array and depth count
+ */
+declare function parsePath(path: string | null | undefined): ParsedPath;
+/**
+ * Get a specific segment from a path by index.
+ * @param path - The path to parse
+ * @param index - Zero-based index of the segment to retrieve
+ * @returns The segment at the given index, or null if not found
+ */
+declare function getSegment(path: string | null | undefined, index: number): string | null;
+/**
+ * Build a path string from segments.
+ * @param segments - Array of path segments
+ * @returns Path string with leading slash
+ */
+declare function buildPath(segments: string[]): string;
+/**
+ * Append a segment to an existing path.
+ * @param basePath - The base path
+ * @param segment - The segment to append
+ * @returns New path with segment appended
+ */
+declare function appendToPath(basePath: string | null | undefined, segment: string): string;
+
+/**
+ * Navigate to a specific item using a dot-notation path.
+ * Path format: "0.2.1" means items[0].children[2].children[1]
+ */
+declare function navigateToPath(instructions: Instructions, path: string): InstructionItem | null;
+/**
+ * Generate a path string for an item given its position in the tree.
+ * Used when selecting an item to store its path.
+ */
+declare function generatePath(indices: number[]): string;
+
+interface DurationEstimationConfig {
+    secondsPerImage: number;
+    wordsPerMinute: number;
+}
+declare const DEFAULT_DURATION_CONFIG: DurationEstimationConfig;
+/**
+ * Count words in text (splits on whitespace)
+ */
+declare function countWords(text: string): number;
+/**
+ * Estimate duration for image content
+ * @returns Duration in seconds (default: 15)
+ */
+declare function estimateImageDuration(config?: Partial<DurationEstimationConfig>): number;
+/**
+ * Estimate duration for text content based on word count
+ * @param text - The text content
+ * @param config - Optional configuration overrides
+ * @returns Duration in seconds
+ */
+declare function estimateTextDuration(text: string, config?: Partial<DurationEstimationConfig>): number;
+/**
+ * Estimate duration based on media type
+ * @param mediaType - "video" | "image" | "text"
+ * @param options - Text content or word count for text estimation
+ * @returns Duration in seconds (0 for video/unknown)
+ */
+declare function estimateDuration(mediaType: "video" | "image" | "text", options?: {
+    text?: string;
+    wordCount?: number;
+    config?: Partial<DurationEstimationConfig>;
+}): number;
+
+declare function presentationsToPlaylist(plan: Plan): ContentFile[];
+declare function presentationsToExpandedInstructions(plan: Plan): Instructions;
+declare function instructionsToPlaylist(instructions: Instructions): ContentFile[];
+declare const expandedInstructionsToPlaylist: typeof instructionsToPlaylist;
+declare function instructionsToPresentations(instructions: Instructions, planId?: string): Plan;
+declare const expandedInstructionsToPresentations: typeof instructionsToPresentations;
+declare function playlistToPresentations(files: ContentFile[], planName?: string, sectionName?: string): Plan;
+declare function playlistToInstructions(files: ContentFile[], name?: string): Instructions;
+declare const playlistToExpandedInstructions: typeof playlistToInstructions;
+
+declare const FormatConverters_expandedInstructionsToPlaylist: typeof expandedInstructionsToPlaylist;
+declare const FormatConverters_expandedInstructionsToPresentations: typeof expandedInstructionsToPresentations;
+declare const FormatConverters_instructionsToPlaylist: typeof instructionsToPlaylist;
+declare const FormatConverters_instructionsToPresentations: typeof instructionsToPresentations;
+declare const FormatConverters_playlistToExpandedInstructions: typeof playlistToExpandedInstructions;
+declare const FormatConverters_playlistToInstructions: typeof playlistToInstructions;
+declare const FormatConverters_playlistToPresentations: typeof playlistToPresentations;
+declare const FormatConverters_presentationsToExpandedInstructions: typeof presentationsToExpandedInstructions;
+declare const FormatConverters_presentationsToPlaylist: typeof presentationsToPlaylist;
+declare namespace FormatConverters {
+  export { FormatConverters_expandedInstructionsToPlaylist as expandedInstructionsToPlaylist, FormatConverters_expandedInstructionsToPresentations as expandedInstructionsToPresentations, FormatConverters_instructionsToPlaylist as instructionsToPlaylist, FormatConverters_instructionsToPresentations as instructionsToPresentations, FormatConverters_playlistToExpandedInstructions as playlistToExpandedInstructions, FormatConverters_playlistToInstructions as playlistToInstructions, FormatConverters_playlistToPresentations as playlistToPresentations, FormatConverters_presentationsToExpandedInstructions as presentationsToExpandedInstructions, FormatConverters_presentationsToPlaylist as presentationsToPlaylist };
+}
+
+interface FormatResolverOptions {
+    allowLossy?: boolean;
+}
+interface ResolvedFormatMeta {
+    isNative: boolean;
+    sourceFormat?: "playlist" | "presentations" | "instructions";
+    isLossy: boolean;
+}
+declare class FormatResolver {
+    private provider;
+    private options;
+    constructor(provider: IProvider, options?: FormatResolverOptions);
+    getProvider(): IProvider;
+    /** Extract the last segment from a path to use as fallback ID/title */
+    private getIdFromPath;
+    getPlaylist(path: string, auth?: ContentProviderAuthData | null): Promise<ContentFile[] | null>;
+    getPlaylistWithMeta(path: string, auth?: ContentProviderAuthData | null): Promise<{
+        data: ContentFile[] | null;
+        meta: ResolvedFormatMeta;
+    }>;
+    getInstructions(path: string, auth?: ContentProviderAuthData | null): Promise<Instructions | null>;
+    getInstructionsWithMeta(path: string, auth?: ContentProviderAuthData | null): Promise<{
+        data: Instructions | null;
+        meta: ResolvedFormatMeta;
+    }>;
+}
+
+declare class OAuthHelper {
+    generateCodeVerifier(): string;
+    generateCodeChallenge(verifier: string): Promise<string>;
+    buildAuthUrl(config: ContentProviderConfig, codeVerifier: string, redirectUri: string, state?: string): Promise<{
+        url: string;
+        challengeMethod: string;
+    }>;
+    exchangeCodeForTokens(config: ContentProviderConfig, _providerId: string, code: string, codeVerifier: string, redirectUri: string): Promise<ContentProviderAuthData | null>;
+}
+
+declare class TokenHelper {
+    isAuthValid(auth: ContentProviderAuthData | null | undefined): boolean;
+    isTokenExpired(auth: ContentProviderAuthData): boolean;
+    refreshToken(config: ContentProviderConfig, auth: ContentProviderAuthData): Promise<ContentProviderAuthData | null>;
+}
+
+declare class DeviceFlowHelper {
+    supportsDeviceFlow(config: ContentProviderConfig): boolean;
+    initiateDeviceFlow(config: ContentProviderConfig): Promise<DeviceAuthorizationResponse | null>;
+    pollDeviceFlowToken(config: ContentProviderConfig, deviceCode: string): Promise<DeviceFlowPollResult>;
+    calculatePollDelay(baseInterval?: number, slowDownCount?: number): number;
+}
+
+declare class ApiHelper {
+    createAuthHeaders(auth: ContentProviderAuthData | null | undefined): Record<string, string> | null;
+    apiRequest<T>(config: ContentProviderConfig, _providerId: string, path: string, auth?: ContentProviderAuthData | null, method?: "GET" | "POST", body?: unknown): Promise<T | null>;
+}
+
+/**
+ * APlay Provider
+ *
+ * Path structure (variable depth based on module products):
+ *   /modules                                              -> list modules
+ *   /modules/{moduleId}                                   -> list products OR libraries (depends on module)
+ *   /modules/{moduleId}/products/{productId}              -> list libraries (if module has multiple products)
+ *   /modules/{moduleId}/products/{productId}/{libraryId}  -> media files
+ *   /modules/{moduleId}/libraries/{libraryId}             -> media files (if module has 0-1 products)
+ */
+declare class APlayProvider implements IProvider {
+    private readonly apiHelper;
+    private apiRequest;
+    readonly id = "aplay";
+    readonly name = "APlay";
+    readonly logos: ProviderLogos;
+    readonly config: ContentProviderConfig;
+    readonly requiresAuth = true;
+    readonly authTypes: AuthType[];
+    readonly capabilities: ProviderCapabilities;
+    browse(path?: string | null, auth?: ContentProviderAuthData | null): Promise<ContentItem[]>;
+    private getModules;
+    private getModuleContent;
+    private getLibraryFolders;
+    private getMediaFiles;
+    getPlaylist(path: string, auth?: ContentProviderAuthData | null, _resolution?: number): Promise<ContentFile[] | null>;
+    getInstructions(path: string, auth?: ContentProviderAuthData | null): Promise<Instructions | null>;
+    checkMediaLicense(mediaId: string, auth?: ContentProviderAuthData | null): Promise<MediaLicenseResult | null>;
+    supportsDeviceFlow(): boolean;
+}
+
+/**
+ * SignPresenter Provider
+ *
+ * Path structure:
+ *   /playlists                    -> list playlists
+ *   /playlists/{playlistId}       -> list messages (files)
+ */
+declare class SignPresenterProvider implements IProvider {
+    private readonly apiHelper;
+    private readonly oauthHelper;
+    private readonly deviceFlowHelper;
+    private apiRequest;
+    readonly id = "signpresenter";
+    readonly name = "SignPresenter";
+    readonly logos: ProviderLogos;
+    readonly config: ContentProviderConfig;
+    readonly requiresAuth = true;
+    readonly authTypes: AuthType[];
+    readonly capabilities: ProviderCapabilities;
+    browse(path?: string | null, auth?: ContentProviderAuthData | null): Promise<ContentItem[]>;
+    private getPlaylists;
+    private getMessages;
+    getPlaylist(path: string, auth?: ContentProviderAuthData | null, _resolution?: number): Promise<ContentFile[] | null>;
+    getInstructions(path: string, auth?: ContentProviderAuthData | null): Promise<Instructions | null>;
+    supportsDeviceFlow(): boolean;
+    generateCodeVerifier(): string;
+    buildAuthUrl(codeVerifier: string, redirectUri: string, state?: string): Promise<{
+        url: string;
+        challengeMethod: string;
+    }>;
+    exchangeCodeForTokens(code: string, codeVerifier: string, redirectUri: string): Promise<ContentProviderAuthData | null>;
+    initiateDeviceFlow(): Promise<DeviceAuthorizationResponse | null>;
+    pollDeviceFlowToken(deviceCode: string): Promise<DeviceFlowPollResult>;
+}
+
+/**
+ * LessonsChurch Provider
+ *
+ * Path structure:
+ *   /lessons                                            -> programs
+ *   /lessons/{programId}                                -> studies
+ *   /lessons/{programId}/{studyId}                      -> lessons
+ *   /lessons/{programId}/{studyId}/{lessonId}           -> venues
+ *   /lessons/{programId}/{studyId}/{lessonId}/{venueId} -> playlist files
+ *
+ *   /addons                                             -> categories
+ *   /addons/{category}                                  -> add-on files
+ */
+declare class LessonsChurchProvider implements IProvider {
+    readonly id = "lessonschurch";
+    readonly name = "Lessons.church";
+    readonly logos: ProviderLogos;
+    readonly config: ContentProviderConfig;
+    readonly requiresAuth = false;
+    readonly authTypes: AuthType[];
+    readonly capabilities: ProviderCapabilities;
+    getPlaylist(path: string, _auth?: ContentProviderAuthData | null, resolution?: number): Promise<ContentFile[] | null>;
+    browse(path?: string | null, _auth?: ContentProviderAuthData | null): Promise<ContentItem[]>;
+    private browseLessons;
+    private getPrograms;
+    private getStudies;
+    private getLessons;
+    private getVenues;
+    private getPlaylistFiles;
+    private browseAddOns;
+    private getAddOnCategories;
+    private getAddOnsByCategory;
+    getInstructions(path: string, _auth?: ContentProviderAuthData | null): Promise<Instructions | null>;
+    supportsDeviceFlow(): boolean;
+}
+
+declare class B1ChurchProvider implements IProvider {
+    private readonly apiHelper;
+    private readonly externalContentCache;
+    private apiRequest;
+    readonly id = "b1church";
+    readonly name = "B1.Church";
+    readonly logos: ProviderLogos;
+    readonly config: ContentProviderConfig;
+    private appBase;
+    readonly requiresAuth = true;
+    readonly authTypes: AuthType[];
+    readonly capabilities: ProviderCapabilities;
+    buildAuthUrl(codeVerifier: string, redirectUri: string, state?: string): Promise<{
+        url: string;
+        challengeMethod: string;
+    }>;
+    exchangeCodeForTokensWithPKCE(code: string, redirectUri: string, codeVerifier: string): Promise<ContentProviderAuthData | null>;
+    exchangeCodeForTokensWithSecret(code: string, redirectUri: string, clientSecret: string): Promise<ContentProviderAuthData | null>;
+    refreshTokenWithSecret(authData: ContentProviderAuthData, clientSecret: string): Promise<ContentProviderAuthData | null>;
+    initiateDeviceFlow(): Promise<DeviceAuthorizationResponse | null>;
+    pollDeviceFlowToken(deviceCode: string): Promise<DeviceFlowPollResult>;
+    browse(path?: string | null, authData?: ContentProviderAuthData | null): Promise<ContentItem[]>;
+    getInstructions(path: string, authData?: ContentProviderAuthData | null): Promise<Instructions | null>;
+    private processInstructionItems;
+    private findItemByPath;
+    private findPresentationByPath;
+    getPlaylist(path: string, authData?: ContentProviderAuthData | null, resolution?: number): Promise<ContentFile[] | null>;
+    supportsDeviceFlow(): boolean;
+}
+
+declare class DropboxProvider implements IProvider {
+    private readonly oauthHelper;
+    readonly id = "dropbox";
+    readonly name = "Dropbox";
+    readonly logos: ProviderLogos;
+    readonly config: ContentProviderConfig;
+    readonly requiresAuth = true;
+    readonly authTypes: AuthType[];
+    readonly capabilities: ProviderCapabilities;
+    private dropboxPost;
+    private listAllEntries;
+    private getSharedLink;
+    private sharedLinkToRawUrl;
+    private getTemporaryLink;
+    private resolveFileLinks;
+    private checkIsLeaf;
+    browse(path?: string | null, auth?: ContentProviderAuthData | null): Promise<ContentItem[]>;
+    getPlaylist(path: string, auth?: ContentProviderAuthData | null, _resolution?: number): Promise<ContentFile[] | null>;
+    getInstructions(path: string, auth?: ContentProviderAuthData | null): Promise<Instructions | null>;
+    supportsDeviceFlow(): boolean;
+    generateCodeVerifier(): string;
+    buildAuthUrl(codeVerifier: string, redirectUri: string, state?: string): Promise<{
+        url: string;
+        challengeMethod: string;
+    }>;
+    exchangeCodeForTokens(code: string, codeVerifier: string, redirectUri: string): Promise<ContentProviderAuthData | null>;
+}
+
+/**
+ * PlanningCenter Provider
+ *
+ * Path structure:
+ *   /serviceTypes                            -> list service types
+ *   /serviceTypes/{serviceTypeId}            -> list plans
+ *   /serviceTypes/{serviceTypeId}/{planId}   -> plan items (leaf)
+ */
+declare class PlanningCenterProvider implements IProvider {
+    private readonly apiHelper;
+    private apiRequest;
+    readonly id = "planningcenter";
+    readonly name = "Planning Center";
+    readonly logos: ProviderLogos;
+    readonly config: ContentProviderConfig;
+    private readonly ONE_WEEK_MS;
+    readonly requiresAuth = true;
+    readonly authTypes: AuthType[];
+    readonly capabilities: ProviderCapabilities;
+    browse(path?: string | null, auth?: ContentProviderAuthData | null): Promise<ContentItem[]>;
+    private getServiceTypes;
+    private getPlans;
+    private getPlanItems;
+    supportsDeviceFlow(): boolean;
+}
+
+/**
+ * BibleProject Provider
+ *
+ * Path structure:
+ *   /                              -> list collections
+ *   /{collectionSlug}              -> list videos in collection
+ *   /{collectionSlug}/{videoId}    -> single video
+ */
+declare class BibleProjectProvider implements IProvider {
+    readonly id = "bibleproject";
+    readonly name = "The Bible Project";
+    readonly logos: ProviderLogos;
+    readonly config: ContentProviderConfig;
+    private data;
+    readonly requiresAuth = false;
+    readonly authTypes: AuthType[];
+    readonly capabilities: ProviderCapabilities;
+    browse(path?: string | null, _auth?: ContentProviderAuthData | null): Promise<ContentItem[]>;
+    private getCollections;
+    private getLessonFolders;
+    private getVideoFile;
+    getPlaylist(path: string, _auth?: ContentProviderAuthData | null, _resolution?: number): Promise<ContentFile[] | null>;
+    getInstructions(path: string, _auth?: ContentProviderAuthData | null): Promise<Instructions | null>;
+    supportsDeviceFlow(): boolean;
+}
+
+/**
+ * HighVoltageKids Provider
+ *
+ * Path structure:
+ *   /                                          -> list collections (Elementary, Preschool)
+ *   /{collectionSlug}                          -> list studies
+ *   /{collectionSlug}/{studyId}                -> list lessons
+ *   /{collectionSlug}/{studyId}/{lessonId}     -> lesson files (leaf)
+ */
+declare class HighVoltageKidsProvider implements IProvider {
+    readonly id = "highvoltagekids";
+    readonly name = "High Voltage Kids";
+    readonly logos: ProviderLogos;
+    readonly config: ContentProviderConfig;
+    private data;
+    readonly requiresAuth = false;
+    readonly authTypes: AuthType[];
+    readonly capabilities: ProviderCapabilities;
+    browse(path?: string | null, _auth?: ContentProviderAuthData | null): Promise<ContentItem[]>;
+    getPlaylist(path: string, _auth?: ContentProviderAuthData | null, _resolution?: number): Promise<ContentFile[] | null>;
+    getInstructions(path: string, _auth?: ContentProviderAuthData | null): Promise<Instructions | null>;
+    supportsDeviceFlow(): boolean;
+}
+
+/**
+ * Jesus Film Project Provider
+ *
+ * Uses the public Arclight API to browse video content from jesusfilm.org.
+ *
+ * Path structure:
+ *   /                                    -> categories (Feature Films, Series, Collections)
+ *   /{category}                          -> list items in category
+ *   /{category}/{mediaComponentId}       -> single video file
+ */
+declare class JesusFilmProvider implements IProvider {
+    readonly id = "jesusfilm";
+    readonly name = "Jesus Film Project";
+    readonly logos: ProviderLogos;
+    readonly config: ContentProviderConfig;
+    readonly requiresAuth = false;
+    readonly authTypes: AuthType[];
+    readonly capabilities: ProviderCapabilities;
+    private fetchApi;
+    browse(path?: string | null, _auth?: ContentProviderAuthData | null): Promise<ContentItem[]>;
+    private getCategories;
+    private getItemsInCategory;
+    private getVideoFile;
+    private extractMuxPlaybackId;
+    getPlaylist(path: string, _auth?: ContentProviderAuthData | null, _resolution?: number): Promise<ContentFile[] | null>;
+    private fetchVideoFiles;
+    getInstructions(path: string, _auth?: ContentProviderAuthData | null): Promise<Instructions | null>;
+    supportsDeviceFlow(): boolean;
+}
+
+/**
+ * Get a provider by ID.
+ */
+declare function getProvider(providerId: string): IProvider | null;
+/**
+ * Get all registered providers.
+ */
+declare function getAllProviders(): IProvider[];
+/**
+ * Register a custom provider.
+ */
+declare function registerProvider(provider: IProvider): void;
+/**
+ * Get provider configuration by ID (for backward compatibility).
+ */
+declare function getProviderConfig(providerId: string): ContentProviderConfig | null;
+/**
+ * Get list of available providers with their info including logos and auth types.
+ * Includes both implemented providers and coming soon providers.
+ * @param ids - Optional array of provider IDs to filter the results. If provided, only providers with matching IDs will be returned.
+ */
+declare function getAvailableProviders(ids?: string[]): ProviderInfo[];
+
+/**
+ * @churchapps/content-provider-helper
+ * Helper classes for interacting with third party content providers
+ */
+declare const VERSION = "0.0.5";
+
+export { APlayProvider, ApiHelper, type AuthType, B1ChurchProvider, BibleProjectProvider, type ContentFile, type ContentFolder, type ContentItem, type ContentProviderAuthData, type ContentProviderConfig, DEFAULT_DURATION_CONFIG, type DeviceAuthorizationResponse, DeviceFlowHelper, type DeviceFlowPollResult, type DeviceFlowState, DropboxProvider, type DurationEstimationConfig, type EndpointValue, type EndpointsConfig, type FeedActionInterface, type FeedFileInterface, type FeedSectionInterface, type FeedVenueInterface, FormatConverters, FormatResolver, type FormatResolverOptions, HighVoltageKidsProvider, type IProvider, type InstructionItem, type Instructions, JesusFilmProvider, LessonsChurchProvider, type MediaLicenseResult, type MediaLicenseStatus, OAuthHelper, type Plan, type PlanPresentation, type PlanSection, PlanningCenterProvider, type ProviderCapabilities, type ProviderInfo, type ProviderLogos, type ResolvedFormatMeta, SignPresenterProvider, TokenHelper, VERSION, type VenueActionInterface, type VenueActionsResponseInterface, type VenueSectionActionsInterface, appendToPath, buildPath, countWords, createFile, createFolder, detectMediaType, estimateDuration, estimateImageDuration, estimateTextDuration, generatePath, getAllProviders, getAvailableProviders, getProvider, getProviderConfig, getSegment, isContentFile, isContentFolder, navigateToPath, parsePath, registerProvider };