@churchapps/content-provider-helper 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,733 @@
+/**
+ * OAuth token data returned after successful authentication.
+ */
+interface ContentProviderAuthData {
+    /** The access token for API requests */
+    access_token: string;
+    /** The refresh token for obtaining new access tokens */
+    refresh_token: string;
+    /** Token type, typically "Bearer" */
+    token_type: string;
+    /** Unix timestamp (seconds) when the token was created */
+    created_at: number;
+    /** Token lifetime in seconds */
+    expires_in: number;
+    /** Space-separated list of granted scopes */
+    scope: string;
+}
+/**
+ * Configuration for a content provider's API and OAuth settings.
+ */
+interface ContentProviderConfig {
+    /** Unique identifier for the provider */
+    id: string;
+    /** Display name of the provider */
+    name: string;
+    /** Base URL for API requests */
+    apiBase: string;
+    /** Base URL for OAuth endpoints */
+    oauthBase: string;
+    /** OAuth client ID */
+    clientId: string;
+    /** OAuth scopes to request */
+    scopes: string[];
+    /** Whether the provider supports device flow authentication */
+    supportsDeviceFlow?: boolean;
+    /** Endpoint path for device authorization (relative to oauthBase) */
+    deviceAuthEndpoint?: string;
+    /** API endpoint paths - can be static strings or functions that generate paths */
+    endpoints: Record<string, string | ((...args: string[]) => string)>;
+}
+/**
+ * Response from the device authorization endpoint (RFC 8628).
+ */
+interface DeviceAuthorizationResponse {
+    /** Device verification code for polling */
+    device_code: string;
+    /** User code to display for manual entry */
+    user_code: string;
+    /** URL where user should authenticate */
+    verification_uri: string;
+    /** Complete URL with user code pre-filled */
+    verification_uri_complete?: string;
+    /** Seconds until the codes expire */
+    expires_in: number;
+    /** Minimum polling interval in seconds */
+    interval?: number;
+}
+/**
+ * Current state of a device flow authentication process.
+ */
+interface DeviceFlowState {
+    /**
+     * Current status of the device flow.
+     * - `loading`: Initiating device flow
+     * - `awaiting_user`: Waiting for user to authenticate
+     * - `polling`: Polling for token
+     * - `success`: Authentication completed
+     * - `error`: An error occurred
+     * - `expired`: Device code expired
+     */
+    status: 'loading' | 'awaiting_user' | 'polling' | 'success' | 'error' | 'expired';
+    /** Device authorization response data */
+    deviceAuth?: DeviceAuthorizationResponse;
+    /** Error message if status is 'error' */
+    error?: string;
+    /** Number of poll attempts made */
+    pollCount?: number;
+}
+/**
+ * Authentication type supported by a provider.
+ * - `none`: No authentication required (public API)
+ * - `oauth_pkce`: OAuth 2.0 with PKCE
+ * - `device_flow`: OAuth 2.0 Device Authorization Flow (RFC 8628)
+ * - `form_login`: Form-based login (username/password) with session cookies
+ */
+type AuthType = 'none' | 'oauth_pkce' | 'device_flow' | 'form_login';
+/**
+ * Provider logo URLs for light and dark themes.
+ */
+interface ProviderLogos {
+    /** Logo URL for light theme backgrounds */
+    light: string;
+    /** Logo URL for dark theme backgrounds */
+    dark: string;
+}
+/**
+ * Information about a content provider.
+ */
+interface ProviderInfo {
+    /** Unique identifier for the provider */
+    id: string;
+    /** Display name of the provider */
+    name: string;
+    /** Provider logos */
+    logos: ProviderLogos;
+    /** Whether the provider is fully implemented */
+    implemented: boolean;
+    /** Whether the provider requires authentication */
+    requiresAuth: boolean;
+    /** Supported authentication types */
+    authTypes: AuthType[];
+    /** Provider capabilities */
+    capabilities: ProviderCapabilities;
+}
+/**
+ * A folder in the content hierarchy. Can be navigated into to retrieve child items.
+ */
+interface ContentFolder {
+    /** Discriminator for type narrowing. Always `'folder'` */
+    type: 'folder';
+    /** Unique identifier for this folder */
+    id: string;
+    /** Display title */
+    title: string;
+    /** Optional thumbnail/cover image URL */
+    image?: string;
+    /** Provider-specific data for navigation (e.g., level, parentId) */
+    providerData?: Record<string, unknown>;
+}
+/**
+ * A playable media file (video or image).
+ */
+interface ContentFile {
+    /** Discriminator for type narrowing. Always `'file'` */
+    type: 'file';
+    /** Unique identifier for this file */
+    id: string;
+    /** Display title */
+    title: string;
+    /**
+     * Media type of the file.
+     * - `video`: Video content (.mp4, .webm, .m3u8, etc.)
+     * - `image`: Image content (.jpg, .png, etc.)
+     */
+    mediaType: 'video' | 'image';
+    /** Optional preview/cover image URL */
+    image?: string;
+    /** URL to the media file */
+    url: string;
+    /**
+     * Optional URL for embedded preview/player.
+     * - For iframe-based providers (e.g., Lessons.church): an embed URL
+     * - For direct media providers: same as url, or omitted to use url directly
+     */
+    embedUrl?: string;
+    /** Mux playback ID for Mux-hosted videos */
+    muxPlaybackId?: string;
+    /** Decryption key for encrypted media (provider-specific) */
+    decryptionKey?: string;
+    /** Provider-specific media ID for tracking/licensing */
+    mediaId?: string;
+    /** URL to ping after 30+ seconds of playback (licensing requirement) */
+    pingbackUrl?: string;
+    /** Provider-specific data (e.g., duration, loop settings) */
+    providerData?: Record<string, unknown>;
+}
+/**
+ * A content item - either a folder or a file.
+ */
+type ContentItem = ContentFolder | ContentFile;
+/**
+ * Type guard to check if a ContentItem is a ContentFolder.
+ */
+declare function isContentFolder(item: ContentItem): item is ContentFolder;
+/**
+ * Type guard to check if a ContentItem is a ContentFile.
+ */
+declare function isContentFile(item: ContentItem): item is ContentFile;
+/**
+ * Result from polling the device flow token endpoint.
+ * - `ContentProviderAuthData`: Authentication succeeded
+ * - `{ error, shouldSlowDown }`: Still pending or should slow down
+ * - `null`: Authentication failed or expired
+ */
+type DeviceFlowPollResult = ContentProviderAuthData | {
+    error: string;
+    shouldSlowDown?: boolean;
+} | null;
+/**
+ * A presentation within a plan section (e.g., a song, video, or activity).
+ */
+interface PlanPresentation {
+    /** Unique identifier */
+    id: string;
+    /** Display name */
+    name: string;
+    /**
+     * Type of action/presentation.
+     * - `play`: Main playable content
+     * - `add-on`: Supplementary content
+     * - `other`: Non-playable item (song lyrics, notes, etc.)
+     */
+    actionType: 'play' | 'add-on' | 'other';
+    /** Media files associated with this presentation */
+    files: ContentFile[];
+}
+/**
+ * A section within a plan containing multiple presentations.
+ */
+interface PlanSection {
+    /** Unique identifier */
+    id: string;
+    /** Section name (e.g., "Worship", "Message", "Closing") */
+    name: string;
+    /** Presentations within this section */
+    presentations: PlanPresentation[];
+}
+/**
+ * A complete plan/service with sections and presentations.
+ * Returned by `getPresentations()`.
+ */
+interface Plan {
+    /** Unique identifier */
+    id: string;
+    /** Plan name */
+    name: string;
+    /** Optional description */
+    description?: string;
+    /** Optional cover image URL */
+    image?: string;
+    /** Ordered sections in the plan */
+    sections: PlanSection[];
+    /** Flat list of all files in the plan */
+    allFiles: ContentFile[];
+}
+/**
+ * A file within a venue feed.
+ */
+interface FeedFileInterface {
+    id?: string;
+    name?: string;
+    url?: string;
+    streamUrl?: string;
+    seconds?: number;
+    fileType?: string;
+}
+/**
+ * An action within a venue feed section.
+ */
+interface FeedActionInterface {
+    id?: string;
+    actionType?: string;
+    content?: string;
+    files?: FeedFileInterface[];
+}
+/**
+ * A section within a venue feed.
+ */
+interface FeedSectionInterface {
+    id?: string;
+    name?: string;
+    actions?: FeedActionInterface[];
+}
+/**
+ * Complete venue feed data from Lessons.church API.
+ */
+interface FeedVenueInterface {
+    id?: string;
+    lessonId?: string;
+    name?: string;
+    lessonName?: string;
+    lessonDescription?: string;
+    lessonImage?: string;
+    sections?: FeedSectionInterface[];
+}
+/**
+ * An item in the instruction hierarchy.
+ */
+interface InstructionItem {
+    /** Unique identifier */
+    id?: string;
+    /** Type of instruction item */
+    itemType?: string;
+    /** ID of related content */
+    relatedId?: string;
+    /** Display label */
+    label?: string;
+    /** Description or notes */
+    description?: string;
+    /** Duration in seconds */
+    seconds?: number;
+    /** Child instruction items */
+    children?: InstructionItem[];
+    /** URL for embedded content viewer */
+    embedUrl?: string;
+}
+/**
+ * Instructions/run sheet for a venue.
+ * Returned by `getInstructions()` and `getExpandedInstructions()`.
+ */
+interface Instructions {
+    /** Name of the venue */
+    venueName?: string;
+    /** Hierarchical list of instruction items */
+    items: InstructionItem[];
+}
+/**
+ * An action within a venue section.
+ */
+interface VenueActionInterface {
+    id?: string;
+    name?: string;
+    actionType?: string;
+    seconds?: number;
+}
+/**
+ * A section with its actions.
+ */
+interface VenueSectionActionsInterface {
+    id?: string;
+    name?: string;
+    actions?: VenueActionInterface[];
+}
+/**
+ * Response containing venue actions organized by section.
+ */
+interface VenueActionsResponseInterface {
+    venueName?: string;
+    sections?: VenueSectionActionsInterface[];
+}
+/**
+ * Capabilities supported by a content provider.
+ */
+interface ProviderCapabilities {
+    /** Whether the provider supports browsing content hierarchy */
+    browse: boolean;
+    /** Whether `getPresentations()` returns structured plan data */
+    presentations: boolean;
+    /** Whether `getPlaylist()` returns a flat list of media files */
+    playlist: boolean;
+    /** Whether `getInstructions()` returns instruction data */
+    instructions: boolean;
+    /** Whether `getExpandedInstructions()` returns expanded instruction data */
+    expandedInstructions: boolean;
+    /** Whether `checkMediaLicense()` returns license information */
+    mediaLicensing: boolean;
+}
+/**
+ * License status for media content.
+ */
+type MediaLicenseStatus = 'valid' | 'expired' | 'not_licensed' | 'unknown';
+/**
+ * Response from `checkMediaLicense()`.
+ */
+interface MediaLicenseResult {
+    /** The media ID that was checked */
+    mediaId: string;
+    /** Current license status */
+    status: MediaLicenseStatus;
+    /** Human-readable message about the license */
+    message?: string;
+    /** When the license expires (ISO 8601 string or Unix timestamp) */
+    expiresAt?: string | number;
+}
+
+/**
+ * Detects whether a URL points to a video or image file.
+ * @param url - The URL to check
+ * @param explicitType - Optional explicit type from API response (e.g., 'video', 'image')
+ * @returns 'video' or 'image'
+ */
+declare function detectMediaType(url: string, explicitType?: string): 'video' | 'image';
+
+/**
+ * Abstract base class for content providers.
+ * Extend this class to create a custom provider.
+ *
+ * ## Main Methods (for consumers)
+ *
+ * ### Content Browsing
+ * - `browse(folder?, auth?)` - Browse content hierarchy (root if no folder, or folder contents)
+ *
+ * ### Structured Data
+ * - `getPresentations(folder, auth?)` - Get structured plan with sections and presentations
+ * - `getInstructions(folder, auth?)` - Get instruction/run sheet data
+ * - `getExpandedInstructions(folder, auth?)` - Get expanded instructions with actions
+ *
+ * ### Provider Info
+ * - `requiresAuth()` - Whether authentication is needed
+ * - `getCapabilities()` - What features the provider supports
+ * - `getAuthTypes()` - Supported authentication methods
+ *
+ * ### Authentication (OAuth 2.0 PKCE)
+ * - `buildAuthUrl(codeVerifier, redirectUri)` - Build OAuth authorization URL
+ * - `exchangeCodeForTokens(code, codeVerifier, redirectUri)` - Exchange code for tokens
+ * - `refreshToken(auth)` - Refresh an expired access token
+ * - `isAuthValid(auth)` - Check if auth data is still valid
+ *
+ * ### Device Flow Authentication (RFC 8628)
+ * - `supportsDeviceFlow()` - Whether device flow is supported
+ * - `initiateDeviceFlow()` - Start device authorization
+ * - `pollDeviceFlowToken(deviceCode)` - Poll for token after user authorizes
+ */
+declare abstract class ContentProvider {
+    /** Unique identifier for the provider (e.g., 'lessonschurch', 'aplay') */
+    abstract readonly id: string;
+    /** Display name of the provider */
+    abstract readonly name: string;
+    /** Provider logos for light and dark themes */
+    abstract readonly logos: ProviderLogos;
+    /** Provider configuration including API endpoints and OAuth settings */
+    abstract readonly config: ContentProviderConfig;
+    /**
+     * Browse the content hierarchy. If folder is null/undefined, returns root-level items.
+     * If folder is provided, returns items within that folder.
+     * @param folder - Optional folder to browse into (null/undefined for root)
+     * @param auth - Optional authentication data
+     * @returns Array of content items (folders and/or files)
+     */
+    abstract browse(folder?: ContentFolder | null, auth?: ContentProviderAuthData | null): Promise<ContentItem[]>;
+    /**
+     * Get a structured plan with sections and presentations for a folder.
+     * @param folder - The folder to get presentations for (typically a venue or playlist)
+     * @param auth - Optional authentication data
+     * @returns Plan object with sections, presentations, and files, or null if not supported
+     */
+    abstract getPresentations(folder: ContentFolder, auth?: ContentProviderAuthData | null): Promise<Plan | null>;
+    /**
+     * Get a flat list of media files (playlist) for a folder.
+     * Override in subclass if the provider supports playlists.
+     * @param _folder - The folder to get playlist for (typically a venue or playlist folder)
+     * @param _auth - Optional authentication data
+     * @param _resolution - Optional resolution hint for video quality
+     * @returns Array of ContentFile objects, or null if not supported
+     */
+    getPlaylist(_folder: ContentFolder, _auth?: ContentProviderAuthData | null, _resolution?: number): Promise<ContentFile[] | null>;
+    /**
+     * Get instruction/run sheet data for a folder.
+     * Override in subclass if the provider supports instructions.
+     * @param _folder - The folder to get instructions for
+     * @param _auth - Optional authentication data
+     * @returns Instructions object, or null if not supported
+     */
+    getInstructions(_folder: ContentFolder, _auth?: ContentProviderAuthData | null): Promise<Instructions | null>;
+    /**
+     * Get expanded instruction data with actions for a folder.
+     * Override in subclass if the provider supports expanded instructions.
+     * @param _folder - The folder to get expanded instructions for
+     * @param _auth - Optional authentication data
+     * @returns Instructions object with expanded action data, or null if not supported
+     */
+    getExpandedInstructions(_folder: ContentFolder, _auth?: ContentProviderAuthData | null): Promise<Instructions | null>;
+    /**
+     * Check if this provider requires authentication.
+     * @returns true if authentication is required
+     */
+    requiresAuth(): boolean;
+    /**
+     * Get the capabilities supported by this provider.
+     * Override in subclass to indicate supported features.
+     * @returns ProviderCapabilities object
+     */
+    getCapabilities(): ProviderCapabilities;
+    /**
+     * Check the license status for a specific media item.
+     * Override in subclass if the provider requires license validation.
+     * @param _mediaId - The media ID to check
+     * @param _auth - Optional authentication data
+     * @returns MediaLicenseResult object, or null if not supported
+     */
+    checkMediaLicense(_mediaId: string, _auth?: ContentProviderAuthData | null): Promise<MediaLicenseResult | null>;
+    /**
+     * Get the authentication types supported by this provider.
+     * @returns Array of supported AuthType values ('none', 'oauth_pkce', 'device_flow')
+     */
+    getAuthTypes(): AuthType[];
+    /**
+     * Check if the provided auth data is still valid (not expired).
+     * @param auth - Authentication data to validate
+     * @returns true if auth is valid and not expired
+     */
+    isAuthValid(auth: ContentProviderAuthData | null | undefined): boolean;
+    /**
+     * Check if a token is expired (with 5-minute buffer).
+     * @param auth - Authentication data to check
+     * @returns true if token is expired or will expire within 5 minutes
+     */
+    isTokenExpired(auth: ContentProviderAuthData): boolean;
+    /**
+     * Generate a random code verifier for PKCE.
+     * @returns A 64-character random string
+     */
+    generateCodeVerifier(): string;
+    /**
+     * Generate a code challenge from a code verifier using SHA-256.
+     * @param verifier - The code verifier string
+     * @returns Base64url-encoded SHA-256 hash of the verifier
+     */
+    generateCodeChallenge(verifier: string): Promise<string>;
+    /**
+     * Build the OAuth authorization URL for PKCE flow.
+     * @param codeVerifier - The code verifier (store this for token exchange)
+     * @param redirectUri - The redirect URI to return to after authorization
+     * @param state - Optional state parameter for CSRF protection (defaults to provider ID)
+     * @returns Object with authorization URL and challenge method
+     */
+    buildAuthUrl(codeVerifier: string, redirectUri: string, state?: string): Promise<{
+        url: string;
+        challengeMethod: string;
+    }>;
+    /**
+     * Exchange an authorization code for access and refresh tokens.
+     * @param code - The authorization code from the callback
+     * @param codeVerifier - The original code verifier used to generate the challenge
+     * @param redirectUri - The redirect URI (must match the one used in buildAuthUrl)
+     * @returns Authentication data, or null if exchange failed
+     */
+    exchangeCodeForTokens(code: string, codeVerifier: string, redirectUri: string): Promise<ContentProviderAuthData | null>;
+    /**
+     * Refresh an expired access token using the refresh token.
+     * @param auth - The current authentication data (must include refresh_token)
+     * @returns New authentication data, or null if refresh failed
+     */
+    refreshToken(auth: ContentProviderAuthData): Promise<ContentProviderAuthData | null>;
+    /**
+     * Check if this provider supports device flow authentication.
+     * @returns true if device flow is supported
+     */
+    supportsDeviceFlow(): boolean;
+    /**
+     * Initiate the device authorization flow (RFC 8628).
+     * @returns Device authorization response with user_code and verification_uri, or null if not supported
+     */
+    initiateDeviceFlow(): Promise<DeviceAuthorizationResponse | null>;
+    /**
+     * Poll for a token after user has authorized the device.
+     * @param deviceCode - The device_code from initiateDeviceFlow response
+     * @returns Auth data if successful, error object if pending/slow_down, or null if failed/expired
+     */
+    pollDeviceFlowToken(deviceCode: string): Promise<DeviceFlowPollResult>;
+    /**
+     * Calculate the delay between device flow poll attempts.
+     * @param baseInterval - Base interval in seconds (default: 5)
+     * @param slowDownCount - Number of slow_down responses received
+     * @returns Delay in milliseconds
+     */
+    calculatePollDelay(baseInterval?: number, slowDownCount?: number): number;
+    /**
+     * Create authorization headers for API requests.
+     * @param auth - Authentication data
+     * @returns Headers object with Authorization header, or null if no auth
+     */
+    protected createAuthHeaders(auth: ContentProviderAuthData | null | undefined): Record<string, string> | null;
+    /**
+     * Make an authenticated API request.
+     * @param path - API endpoint path (appended to config.apiBase)
+     * @param auth - Optional authentication data
+     * @param method - HTTP method (default: 'GET')
+     * @param body - Optional request body (for POST requests)
+     * @returns Parsed JSON response, or null if request failed
+     */
+    protected apiRequest<T>(path: string, auth?: ContentProviderAuthData | null, method?: 'GET' | 'POST', body?: unknown): Promise<T | null>;
+    /**
+     * Helper to create a ContentFolder object.
+     * @param id - Unique identifier
+     * @param title - Display title
+     * @param image - Optional image URL
+     * @param providerData - Optional provider-specific data
+     * @returns ContentFolder object
+     */
+    protected createFolder(id: string, title: string, image?: string, providerData?: Record<string, unknown>): ContentFolder;
+    /**
+     * Helper to create a ContentFile object with automatic media type detection.
+     * @param id - Unique identifier
+     * @param title - Display title
+     * @param url - Media URL
+     * @param options - Optional properties (mediaType, image, muxPlaybackId, providerData)
+     * @returns ContentFile object
+     */
+    protected createFile(id: string, title: string, url: string, options?: {
+        mediaType?: 'video' | 'image';
+        image?: string;
+        muxPlaybackId?: string;
+        providerData?: Record<string, unknown>;
+    }): ContentFile;
+}
+
+declare class APlayProvider extends ContentProvider {
+    readonly id = "aplay";
+    readonly name = "APlay";
+    readonly logos: ProviderLogos;
+    readonly config: ContentProviderConfig;
+    getCapabilities(): ProviderCapabilities;
+    browse(folder?: ContentFolder | null, auth?: ContentProviderAuthData | null): Promise<ContentItem[]>;
+    private getProductFolders;
+    private getLibraryFolders;
+    private getMediaFiles;
+    getPresentations(folder: ContentFolder, auth?: ContentProviderAuthData | null): Promise<Plan | null>;
+    /**
+     * Check the license status for a specific media item.
+     * Returns license information including pingback URL if licensed.
+     */
+    checkMediaLicense(mediaId: string, auth?: ContentProviderAuthData | null): Promise<MediaLicenseResult | null>;
+}
+
+declare class SignPresenterProvider extends ContentProvider {
+    readonly id = "signpresenter";
+    readonly name = "SignPresenter";
+    readonly logos: ProviderLogos;
+    readonly config: ContentProviderConfig;
+    getCapabilities(): ProviderCapabilities;
+    browse(folder?: ContentFolder | null, auth?: ContentProviderAuthData | null): Promise<ContentItem[]>;
+    private getMessages;
+    getPresentations(folder: ContentFolder, auth?: ContentProviderAuthData | null): Promise<Plan | null>;
+}
+
+declare class LessonsChurchProvider extends ContentProvider {
+    readonly id = "lessonschurch";
+    readonly name = "Lessons.church";
+    readonly logos: ProviderLogos;
+    readonly config: ContentProviderConfig;
+    requiresAuth(): boolean;
+    getCapabilities(): ProviderCapabilities;
+    getPlaylist(folder: ContentFolder, _auth?: ContentProviderAuthData | null, resolution?: number): Promise<ContentFile[] | null>;
+    protected apiRequest<T>(path: string): Promise<T | null>;
+    browse(folder?: ContentFolder | null, _auth?: ContentProviderAuthData | null, resolution?: number): Promise<ContentItem[]>;
+    private getPrograms;
+    private getStudies;
+    private getLessons;
+    private getVenues;
+    private getPlaylistFiles;
+    private getAddOnCategories;
+    private getAddOnsByCategory;
+    private convertAddOnToFile;
+    getPresentations(folder: ContentFolder, _auth?: ContentProviderAuthData | null, resolution?: number): Promise<Plan | null>;
+    getInstructions(folder: ContentFolder, _auth?: ContentProviderAuthData | null): Promise<Instructions | null>;
+    getExpandedInstructions(folder: ContentFolder, _auth?: ContentProviderAuthData | null): Promise<Instructions | null>;
+    private getEmbedUrl;
+    private convertVenueToPlan;
+}
+
+declare class B1ChurchProvider extends ContentProvider {
+    readonly id = "b1church";
+    readonly name = "B1.Church";
+    readonly logos: ProviderLogos;
+    readonly config: ContentProviderConfig;
+    private appBase;
+    requiresAuth(): boolean;
+    getCapabilities(): ProviderCapabilities;
+    buildAuthUrl(_codeVerifier: string, redirectUri: string, state?: string): Promise<{
+        url: string;
+        challengeMethod: string;
+    }>;
+    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 content hierarchy:
+     * - Root: List of ministries (groups with "ministry" tag)
+     * - Ministry: List of plan types
+     * - PlanType: List of plans (leaf nodes)
+     *
+     * Plans are leaf nodes - use getPresentations(), getPlaylist(), getInstructions()
+     * to get plan content.
+     */
+    browse(folder?: ContentFolder | null, authData?: ContentProviderAuthData | null): Promise<ContentItem[]>;
+    getPresentations(folder: ContentFolder, authData?: ContentProviderAuthData | null): Promise<Plan | null>;
+    getInstructions(folder: ContentFolder, authData?: ContentProviderAuthData | null): Promise<Instructions | null>;
+    getPlaylist(folder: ContentFolder, authData?: ContentProviderAuthData | null): Promise<ContentFile[]>;
+}
+
+declare class PlanningCenterProvider extends ContentProvider {
+    readonly id = "planningcenter";
+    readonly name = "Planning Center";
+    readonly logos: ProviderLogos;
+    readonly config: ContentProviderConfig;
+    private readonly ONE_WEEK_MS;
+    requiresAuth(): boolean;
+    getCapabilities(): ProviderCapabilities;
+    browse(folder?: ContentFolder | null, auth?: ContentProviderAuthData | null): Promise<ContentItem[]>;
+    private getPlans;
+    private getPlanItems;
+    getPresentations(folder: ContentFolder, auth?: ContentProviderAuthData | null): Promise<Plan | null>;
+    private convertToPresentation;
+    private convertSongToPresentation;
+    private convertMediaToPresentation;
+    private formatDate;
+}
+
+declare class BibleProjectProvider extends ContentProvider {
+    readonly id = "bibleproject";
+    readonly name = "The Bible Project";
+    readonly logos: ProviderLogos;
+    readonly config: ContentProviderConfig;
+    private data;
+    requiresAuth(): boolean;
+    getCapabilities(): ProviderCapabilities;
+    browse(folder?: ContentFolder | null, _auth?: ContentProviderAuthData | null): Promise<ContentItem[]>;
+    getPresentations(_folder: ContentFolder, _auth?: ContentProviderAuthData | null): Promise<Plan | null>;
+    private getLessonFolders;
+    private slugify;
+}
+
+/**
+ * Get a provider by ID.
+ */
+declare function getProvider(providerId: string): ContentProvider | null;
+/**
+ * Get all registered providers.
+ */
+declare function getAllProviders(): ContentProvider[];
+/**
+ * Register a custom provider.
+ */
+declare function registerProvider(provider: ContentProvider): 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.
+ */
+declare function getAvailableProviders(): ProviderInfo[];
+
+/**
+ * @churchapps/content-provider-helper
+ * Helper classes for interacting with third party content providers
+ */
+declare const VERSION = "0.0.1";
+
+export { APlayProvider, type AuthType, B1ChurchProvider, BibleProjectProvider, type ContentFile, type ContentFolder, type ContentItem, ContentProvider, type ContentProviderAuthData, type ContentProviderConfig, type DeviceAuthorizationResponse, type DeviceFlowPollResult, type DeviceFlowState, type FeedActionInterface, type FeedFileInterface, type FeedSectionInterface, type FeedVenueInterface, type InstructionItem, type Instructions, LessonsChurchProvider, type MediaLicenseResult, type MediaLicenseStatus, type Plan, type PlanPresentation, type PlanSection, PlanningCenterProvider, type ProviderCapabilities, type ProviderInfo, type ProviderLogos, SignPresenterProvider, VERSION, type VenueActionInterface, type VenueActionsResponseInterface, type VenueSectionActionsInterface, detectMediaType, getAllProviders, getAvailableProviders, getProvider, getProviderConfig, isContentFile, isContentFolder, registerProvider };