@churchapps/content-provider-helper 0.0.1 → 0.0.3

package/dist/index.d.cts

@@ -1,241 +1,99 @@
-/**
- * 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 */
+    status: "loading" | "awaiting_user" | "polling" | "success" | "error" | "expired";
     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.
- */
+type AuthType = "none" | "oauth_pkce" | "device_flow" | "form_login";
 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 */
+    type: "folder";
     id: string;
-    /** Display title */
     title: string;
-    /** Optional thumbnail/cover image URL */
     image?: string;
-    /** Provider-specific data for navigation (e.g., level, parentId) */
+    isLeaf?: boolean;
+    path: string;
     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 */
+    type: "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 */
+    mediaType: "video" | "image";
     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 */
+    actionType: "play" | "add-on" | "other";
     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;
@@ -244,26 +102,17 @@ interface FeedFileInterface {
     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;
@@ -273,447 +122,513 @@ interface FeedVenueInterface {
     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()`.
- */
+type MediaLicenseStatus = "valid" | "expired" | "not_licensed" | "unknown";
 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;
 }
+/**
+ * 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[]>;
+    getPresentations(path: string, auth?: ContentProviderAuthData | null): Promise<Plan | null>;
+    getPlaylist?(path: string, auth?: ContentProviderAuthData | null, resolution?: number): Promise<ContentFile[] | null>;
+    getInstructions?(path: string, auth?: ContentProviderAuthData | null): Promise<Instructions | null>;
+    getExpandedInstructions?(path: string, auth?: ContentProviderAuthData | null): Promise<Instructions | null>;
+    checkMediaLicense?(mediaId: string, auth?: ContentProviderAuthData | null): Promise<MediaLicenseResult | null>;
+}
+/**
+ * @deprecated Use IProvider instead. This interface will be removed in a future version.
+ */
+interface IContentProvider {
+    readonly id: string;
+    readonly name: string;
+    readonly logos: ProviderLogos;
+    readonly config: ContentProviderConfig;
+    browse(path?: string | null, auth?: ContentProviderAuthData | null): Promise<ContentItem[]>;
+    getPresentations(path: string, auth?: ContentProviderAuthData | null): Promise<Plan | null>;
+    getPlaylist(path: string, auth?: ContentProviderAuthData | null, resolution?: number): Promise<ContentFile[] | null>;
+    getInstructions(path: string, auth?: ContentProviderAuthData | null): Promise<Instructions | null>;
+    getExpandedInstructions(path: string, auth?: ContentProviderAuthData | null): Promise<Instructions | null>;
+    requiresAuth(): boolean;
+    getCapabilities(): ProviderCapabilities;
+    checkMediaLicense(mediaId: string, auth?: ContentProviderAuthData | null): Promise<MediaLicenseResult | null>;
+}
+/**
+ * @deprecated Use auth helpers directly (OAuthHelper, DeviceFlowHelper, TokenHelper) with provider.config.
+ * This interface will be removed in a future version.
+ */
+interface IAuthProvider {
+    getAuthTypes(): AuthType[];
+    isAuthValid(auth: ContentProviderAuthData | null | undefined): boolean;
+    isTokenExpired(auth: ContentProviderAuthData): boolean;
+    refreshToken(auth: ContentProviderAuthData): Promise<ContentProviderAuthData | null>;
+    generateCodeVerifier(): string;
+    generateCodeChallenge(verifier: string): Promise<string>;
+    buildAuthUrl(codeVerifier: string, redirectUri: string, state?: string): Promise<{
+        url: string;
+        challengeMethod: string;
+    }>;
+    exchangeCodeForTokens(code: string, codeVerifier: string, redirectUri: string): Promise<ContentProviderAuthData | null>;
+    supportsDeviceFlow(): boolean;
+    initiateDeviceFlow(): Promise<DeviceAuthorizationResponse | null>;
+    pollDeviceFlowToken(deviceCode: string): Promise<DeviceFlowPollResult>;
+    calculatePollDelay(baseInterval?: number, slowDownCount?: number): number;
+}
+
+declare function detectMediaType(url: string, explicitType?: string): "video" | "image";
+declare function createFolder(id: string, title: string, path: string, image?: string, providerData?: Record<string, unknown>, isLeaf?: boolean): ContentFolder;
+declare function createFile(id: string, title: string, url: string, options?: {
+    mediaType?: "video" | "image";
+    image?: string;
+    muxPlaybackId?: string;
+    providerData?: Record<string, unknown>;
+}): ContentFile;
 
 /**
- * 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'
+ * 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 detectMediaType(url: string, explicitType?: string): 'video' | 'image';
+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;
+
+declare function presentationsToPlaylist(plan: Plan): ContentFile[];
+declare function presentationsToInstructions(plan: Plan): Instructions;
+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 collapseInstructions(instructions: Instructions, maxDepth?: number): Instructions;
+declare function playlistToPresentations(files: ContentFile[], planName?: string, sectionName?: string): Plan;
+declare function playlistToInstructions(files: ContentFile[], venueName?: string): Instructions;
+declare const playlistToExpandedInstructions: typeof playlistToInstructions;
+
+declare const FormatConverters_collapseInstructions: typeof collapseInstructions;
+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_presentationsToInstructions: typeof presentationsToInstructions;
+declare const FormatConverters_presentationsToPlaylist: typeof presentationsToPlaylist;
+declare namespace FormatConverters {
+  export { FormatConverters_collapseInstructions as collapseInstructions, 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_presentationsToInstructions as presentationsToInstructions, FormatConverters_presentationsToPlaylist as presentationsToPlaylist };
+}
+
+interface FormatResolverOptions {
+    allowLossy?: boolean;
+}
+interface ResolvedFormatMeta {
+    isNative: boolean;
+    sourceFormat?: "playlist" | "presentations" | "instructions" | "expandedInstructions";
+    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;
+    }>;
+    getPresentations(path: string, auth?: ContentProviderAuthData | null): Promise<Plan | null>;
+    getPresentationsWithMeta(path: string, auth?: ContentProviderAuthData | null): Promise<{
+        data: Plan | null;
+        meta: ResolvedFormatMeta;
+    }>;
+    getInstructions(path: string, auth?: ContentProviderAuthData | null): Promise<Instructions | null>;
+    getInstructionsWithMeta(path: string, auth?: ContentProviderAuthData | null): Promise<{
+        data: Instructions | null;
+        meta: ResolvedFormatMeta;
+    }>;
+    getExpandedInstructions(path: string, auth?: ContentProviderAuthData | null): Promise<Instructions | null>;
+    getExpandedInstructionsWithMeta(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>;
+}
 
 /**
- * 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
+ * @deprecated Use IProvider interface instead. Providers should implement IProvider directly
+ * and use helper classes (OAuthHelper, TokenHelper, DeviceFlowHelper, ApiHelper) via composition.
+ * This class will be removed in a future version.
  */
-declare abstract class ContentProvider {
-    /** Unique identifier for the provider (e.g., 'lessonschurch', 'aplay') */
+declare abstract class ContentProvider implements IContentProvider, IAuthProvider {
     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
-     */
+    protected readonly oauthHelper: OAuthHelper;
+    protected readonly tokenHelper: TokenHelper;
+    protected readonly deviceFlowHelper: DeviceFlowHelper;
+    protected readonly apiHelper: ApiHelper;
+    abstract browse(path?: string | null, auth?: ContentProviderAuthData | null): Promise<ContentItem[]>;
+    abstract getPresentations(path: string, auth?: ContentProviderAuthData | null): Promise<Plan | null>;
+    getPlaylist(path: string, auth?: ContentProviderAuthData | null, _resolution?: number): Promise<ContentFile[] | null>;
+    getInstructions(path: string, auth?: ContentProviderAuthData | null): Promise<Instructions | null>;
+    getExpandedInstructions(path: string, auth?: ContentProviderAuthData | null): Promise<Instructions | null>;
     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
-     */
+    refreshToken(auth: ContentProviderAuthData): Promise<ContentProviderAuthData | null>;
     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 apiRequest<T>(path: string, auth?: ContentProviderAuthData | null, method?: "GET" | "POST", body?: unknown): Promise<T | null>;
+    protected createFolder(id: string, title: string, path: string, image?: string, providerData?: Record<string, unknown>, isLeaf?: boolean): ContentFolder;
     protected createFile(id: string, title: string, url: string, options?: {
-        mediaType?: 'video' | 'image';
+        mediaType?: "video" | "image";
         image?: string;
         muxPlaybackId?: string;
         providerData?: Record<string, unknown>;
     }): ContentFile;
 }
 
-declare class APlayProvider extends ContentProvider {
+/**
+ * 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;
-    getCapabilities(): ProviderCapabilities;
-    browse(folder?: ContentFolder | null, auth?: ContentProviderAuthData | null): Promise<ContentItem[]>;
-    private getProductFolders;
+    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;
-    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.
-     */
+    getPresentations(path: string, auth?: ContentProviderAuthData | null): Promise<Plan | null>;
     checkMediaLicense(mediaId: string, auth?: ContentProviderAuthData | null): Promise<MediaLicenseResult | null>;
 }
 
-declare class SignPresenterProvider extends ContentProvider {
+/**
+ * SignPresenter Provider
+ *
+ * Path structure:
+ *   /playlists                    -> list playlists
+ *   /playlists/{playlistId}       -> list messages (files)
+ */
+declare class SignPresenterProvider implements IProvider {
+    private readonly apiHelper;
+    private apiRequest;
     readonly id = "signpresenter";
     readonly name = "SignPresenter";
     readonly logos: ProviderLogos;
     readonly config: ContentProviderConfig;
-    getCapabilities(): ProviderCapabilities;
-    browse(folder?: ContentFolder | null, auth?: ContentProviderAuthData | null): Promise<ContentItem[]>;
+    readonly requiresAuth = true;
+    readonly authTypes: AuthType[];
+    readonly capabilities: ProviderCapabilities;
+    browse(path?: string | null, auth?: ContentProviderAuthData | null): Promise<ContentItem[]>;
+    private getPlaylists;
     private getMessages;
-    getPresentations(folder: ContentFolder, auth?: ContentProviderAuthData | null): Promise<Plan | null>;
+    getPresentations(path: string, auth?: ContentProviderAuthData | null): Promise<Plan | null>;
 }
 
-declare class LessonsChurchProvider extends ContentProvider {
+/**
+ * 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;
-    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[]>;
+    readonly requiresAuth = false;
+    readonly authTypes: AuthType[];
+    readonly capabilities: ProviderCapabilities;
+    getPlaylist(path: string, _auth?: ContentProviderAuthData | null, resolution?: number): Promise<ContentFile[] | null>;
+    private apiRequest;
+    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;
     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>;
+    getPresentations(path: string, _auth?: ContentProviderAuthData | null): Promise<Plan | null>;
+    getInstructions(path: string, _auth?: ContentProviderAuthData | null): Promise<Instructions | null>;
+    getExpandedInstructions(path: string, _auth?: ContentProviderAuthData | null): Promise<Instructions | null>;
+    private normalizeItemType;
     private getEmbedUrl;
     private convertVenueToPlan;
 }
 
-declare class B1ChurchProvider extends ContentProvider {
+declare class B1ChurchProvider implements IProvider {
+    private readonly apiHelper;
+    private apiRequest;
     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<{
+    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 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[]>;
+    browse(path?: string | null, authData?: ContentProviderAuthData | null): Promise<ContentItem[]>;
+    getPresentations(path: string, authData?: ContentProviderAuthData | null): Promise<Plan | null>;
+    getInstructions(path: string, authData?: ContentProviderAuthData | null): Promise<Instructions | null>;
+    getExpandedInstructions(path: string, authData?: ContentProviderAuthData | null): Promise<Instructions | null>;
+    private processInstructionItems;
+    getPlaylist(path: string, authData?: ContentProviderAuthData | null, resolution?: number): Promise<ContentFile[] | null>;
 }
 
-declare class PlanningCenterProvider extends ContentProvider {
+/**
+ * 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;
-    requiresAuth(): boolean;
-    getCapabilities(): ProviderCapabilities;
-    browse(folder?: ContentFolder | null, auth?: ContentProviderAuthData | null): Promise<ContentItem[]>;
+    readonly requiresAuth = true;
+    readonly authTypes: AuthType[];
+    readonly capabilities: ProviderCapabilities;
+    browse(path?: string | null, auth?: ContentProviderAuthData | null): Promise<ContentItem[]>;
+    private getServiceTypes;
     private getPlans;
     private getPlanItems;
-    getPresentations(folder: ContentFolder, auth?: ContentProviderAuthData | null): Promise<Plan | null>;
+    getPresentations(path: string, auth?: ContentProviderAuthData | null): Promise<Plan | null>;
     private convertToPresentation;
     private convertSongToPresentation;
     private convertMediaToPresentation;
     private formatDate;
 }
 
-declare class BibleProjectProvider extends ContentProvider {
+/**
+ * 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;
-    requiresAuth(): boolean;
-    getCapabilities(): ProviderCapabilities;
-    browse(folder?: ContentFolder | null, _auth?: ContentProviderAuthData | null): Promise<ContentItem[]>;
-    getPresentations(_folder: ContentFolder, _auth?: ContentProviderAuthData | null): Promise<Plan | null>;
+    readonly requiresAuth = false;
+    readonly authTypes: AuthType[];
+    readonly capabilities: ProviderCapabilities;
+    browse(path?: string | null, _auth?: ContentProviderAuthData | null): Promise<ContentItem[]>;
+    private getCollections;
+    private getLessonFolders;
+    private getVideoFile;
+    getPresentations(path: string, _auth?: ContentProviderAuthData | null): Promise<Plan | null>;
+    getPlaylist(path: string, _auth?: ContentProviderAuthData | null, _resolution?: number): Promise<ContentFile[] | null>;
+    private slugify;
+}
+
+/**
+ * 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[]>;
+    private getCollections;
+    private getStudyFolders;
     private getLessonFolders;
+    private getLessonFiles;
+    getPresentations(path: string, _auth?: ContentProviderAuthData | null): Promise<Plan | null>;
+    getPlaylist(path: string, _auth?: ContentProviderAuthData | null, _resolution?: number): Promise<ContentFile[] | null>;
+    getExpandedInstructions(path: string, _auth?: ContentProviderAuthData | null): Promise<Instructions | null>;
     private slugify;
+    private groupFilesIntoActions;
+    private getBaseName;
 }
 
 /**
  * Get a provider by ID.
  */
-declare function getProvider(providerId: string): ContentProvider | null;
+declare function getProvider(providerId: string): IProvider | null;
 /**
  * Get all registered providers.
  */
-declare function getAllProviders(): ContentProvider[];
+declare function getAllProviders(): IProvider[];
 /**
  * Register a custom provider.
  */
-declare function registerProvider(provider: ContentProvider): void;
+declare function registerProvider(provider: IProvider): void;
 /**
  * Get provider configuration by ID (for backward compatibility).
  */
@@ -721,8 +636,9 @@ declare function getProviderConfig(providerId: string): ContentProviderConfig |
 /**
  * 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(): ProviderInfo[];
+declare function getAvailableProviders(ids?: string[]): ProviderInfo[];
 
 /**
  * @churchapps/content-provider-helper
@@ -730,4 +646,4 @@ declare function getAvailableProviders(): ProviderInfo[];
  */
 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 };
+export { APlayProvider, ApiHelper, type AuthType, B1ChurchProvider, BibleProjectProvider, type ContentFile, type ContentFolder, type ContentItem, ContentProvider, type ContentProviderAuthData, type ContentProviderConfig, type DeviceAuthorizationResponse, DeviceFlowHelper, type DeviceFlowPollResult, type DeviceFlowState, type FeedActionInterface, type FeedFileInterface, type FeedSectionInterface, type FeedVenueInterface, FormatConverters, FormatResolver, type FormatResolverOptions, HighVoltageKidsProvider, type IAuthProvider, type IContentProvider, type IProvider, type InstructionItem, type Instructions, 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, collapseInstructions, createFile, createFolder, detectMediaType, expandedInstructionsToPlaylist, expandedInstructionsToPresentations, getAllProviders, getAvailableProviders, getProvider, getProviderConfig, getSegment, instructionsToPlaylist, instructionsToPresentations, isContentFile, isContentFolder, parsePath, playlistToExpandedInstructions, playlistToInstructions, playlistToPresentations, presentationsToExpandedInstructions, presentationsToInstructions, presentationsToPlaylist, registerProvider };