@happyvertical/social 0.74.8

package/dist/index.d.ts

@@ -0,0 +1,1114 @@
+/**
+ * OAuth authorization options
+ */
+export declare interface AuthorizationOptions {
+    /**
+     * OAuth scopes to request
+     */
+    scopes?: string[];
+    /**
+     * State parameter for CSRF protection
+     */
+    state?: string;
+    /**
+     * Code verifier for PKCE
+     */
+    codeVerifier?: string;
+    /**
+     * Redirect URI
+     */
+    redirectUri?: string;
+}
+
+/**
+ * OAuth authorization result
+ */
+export declare interface AuthorizationResult {
+    /**
+     * Authorization URL to redirect user to
+     */
+    url: string;
+    /**
+     * State parameter (for verification)
+     */
+    state: string;
+    /**
+     * Code verifier (for PKCE, store securely)
+     */
+    codeVerifier?: string;
+}
+
+/**
+ * Authentication result
+ */
+export declare interface AuthResult {
+    /**
+     * Access token
+     */
+    accessToken: string;
+    /**
+     * Refresh token (if available)
+     */
+    refreshToken?: string;
+    /**
+     * Token expiration time
+     */
+    expiresAt?: Date;
+    /**
+     * Token type (usually 'Bearer')
+     */
+    tokenType?: string;
+    /**
+     * Granted scopes
+     */
+    scopes?: string[];
+}
+
+/**
+ * Base configuration for social platform adapters
+ */
+export declare interface BaseSocialConfig {
+    /**
+     * Platform type
+     */
+    type: SocialPlatformType;
+    /**
+     * Rate limiting configuration (applies at SDK level)
+     */
+    rateLimit?: {
+        /**
+         * Maximum requests per minute
+         */
+        requestsPerMinute?: number;
+        /**
+         * Maximum concurrent requests
+         */
+        maxConcurrent?: number;
+    };
+    /**
+     * Request timeout in milliseconds
+     * @default 30000
+     */
+    timeout?: number;
+    /**
+     * Controls whether publish calls create public content.
+     * Defaults to public for backward compatibility.
+     */
+    publishMode?: PublishMode;
+}
+
+/**
+ * Bluesky adapter for publishing via AT Protocol
+ *
+ * @example
+ * ```typescript
+ * const bluesky = new BlueskyAdapter({
+ *   type: 'bluesky',
+ *   identifier: 'myhandle.bsky.social',
+ *   password: 'app-password', // Use app password, not main password
+ * });
+ *
+ * await bluesky.authenticate();
+ *
+ * const result = await bluesky.publishText({
+ *   text: 'Breaking news from Bentley!',
+ *   linkUrl: 'https://example.com/article',
+ * });
+ * ```
+ */
+export declare class BlueskyAdapter implements SocialPlatform {
+    readonly platform: "bluesky";
+    private config;
+    private session?;
+    constructor(config: BlueskyConfig);
+    private get pdsUrl();
+    authenticate(): Promise<AuthResult>;
+    refreshToken(refreshJwt: string): Promise<AuthResult>;
+    publishVideo(_video: VideoPost): Promise<PostResult>;
+    publishImage(image: ImagePost): Promise<PostResult>;
+    publishText(text: TextPost): Promise<PostResult>;
+    publishLink(link: LinkPost): Promise<PostResult>;
+    private createPost;
+    getPost(postId: string): Promise<Post>;
+    deletePost(postId: string): Promise<void>;
+    getAnalytics(postId: string): Promise<PostAnalytics>;
+    getCapabilities(): PlatformCapabilities;
+    /**
+     * Get reply reference for threading
+     */
+    private getReplyRef;
+    /**
+     * Build post text with hashtags
+     */
+    private buildPostText;
+    /**
+     * Handle API errors
+     */
+    private handleError;
+}
+
+/**
+ * Bluesky configuration
+ */
+export declare interface BlueskyConfig extends BaseSocialConfig {
+    type: 'bluesky';
+    /**
+     * Handle or DID
+     */
+    identifier: string;
+    /**
+     * App password (not main password)
+     */
+    password: string;
+    /**
+     * PDS URL (optional, defaults to bsky.social)
+     */
+    pdsUrl?: string;
+}
+
+/**
+ * OAuth code exchange parameters
+ */
+export declare interface CodeExchangeParams {
+    /**
+     * Authorization code from callback
+     */
+    code: string;
+    /**
+     * State parameter (for verification)
+     */
+    state?: string;
+    /**
+     * Code verifier (for PKCE)
+     */
+    codeVerifier?: string;
+    /**
+     * Redirect URI (must match authorization request)
+     */
+    redirectUri?: string;
+}
+
+/**
+ * Facebook Page adapter for publishing feed posts and Page videos.
+ */
+export declare class FacebookPageAdapter implements SocialPlatform {
+    readonly platform: "facebook";
+    private config;
+    constructor(config: FacebookPageConfig);
+    private get graphUrl();
+    authenticate(): Promise<AuthResult>;
+    refreshToken(_refreshToken: string): Promise<AuthResult>;
+    publishText(text: TextPost): Promise<PostResult>;
+    publishLink(link: LinkPost): Promise<PostResult>;
+    publishImage(image: ImagePost): Promise<PostResult>;
+    publishVideo(video: VideoPost): Promise<PostResult>;
+    getPost(postId: string): Promise<Post>;
+    deletePost(postId: string): Promise<void>;
+    getAnalytics(postId: string): Promise<PostAnalytics>;
+    getCapabilities(): PlatformCapabilities;
+    private createFeedPost;
+    private toPostResult;
+    private safetyFeedFields;
+    private safetyResultStatus;
+    private buildPostText;
+    private parseInsights;
+    private sumPositiveReactions;
+    private handleError;
+}
+
+/**
+ * Facebook Page configuration
+ */
+export declare interface FacebookPageConfig extends BaseSocialConfig {
+    type: 'facebook';
+    /**
+     * Page access token with pages_manage_posts permission
+     */
+    accessToken: string;
+    /**
+     * Facebook Page ID
+     */
+    pageId: string;
+    /**
+     * Optional Graph API version.
+     * @default v24.0
+     */
+    apiVersion?: string;
+}
+
+/**
+ * Factory function to create a social platform adapter
+ *
+ * @example
+ * ```typescript
+ * import { getSocial } from '@happyvertical/social';
+ *
+ * // YouTube
+ * const youtube = await getSocial({
+ *   type: 'youtube',
+ *   clientId: 'your-client-id',
+ *   clientSecret: 'your-client-secret',
+ *   accessToken: 'user-access-token',
+ * });
+ *
+ * // Bluesky
+ * const bluesky = await getSocial({
+ *   type: 'bluesky',
+ *   identifier: 'handle.bsky.social',
+ *   password: 'app-password',
+ * });
+ *
+ * // X (Twitter)
+ * const x = await getSocial({
+ *   type: 'x',
+ *   apiKey: 'consumer-key',
+ *   apiSecret: 'consumer-secret',
+ *   accessToken: 'user-access-token',
+ *   accessSecret: 'user-access-secret',
+ * });
+ *
+ * // Threads
+ * const threads = await getSocial({
+ *   type: 'threads',
+ *   accessToken: 'user-access-token',
+ *   userId: 'threads-user-id',
+ * });
+ *
+ * // Publish text
+ * const result = await youtube.publishText({
+ *   text: 'Hello from Bentley!',
+ * });
+ * ```
+ */
+export declare function getSocial(config: SocialConfig): Promise<SocialPlatform>;
+
+/**
+ * Create multiple social platform adapters at once
+ *
+ * @example
+ * ```typescript
+ * import { getSocialMulti } from '@happyvertical/social';
+ *
+ * const adapters = await getSocialMulti([
+ *   { type: 'youtube', clientId: '...', clientSecret: '...', accessToken: '...' },
+ *   { type: 'bluesky', identifier: '...', password: '...' },
+ * ]);
+ *
+ * // Publish to all platforms
+ * const results = await Promise.all(
+ *   adapters.map(adapter => adapter.publishText({ text: 'Hello!' }))
+ * );
+ * ```
+ */
+export declare function getSocialMulti(configs: SocialConfig[]): Promise<SocialPlatform[]>;
+
+/**
+ * Image post content
+ */
+export declare interface ImagePost {
+    /**
+     * Image file buffer or URL
+     */
+    file: Buffer | string;
+    /**
+     * MIME type for the image file. Detected from URLs and common buffer
+     * signatures when omitted.
+     */
+    mimeType?: string;
+    /**
+     * Alt text for accessibility
+     */
+    altText?: string;
+    /**
+     * Post description/caption
+     */
+    description?: string;
+    /**
+     * Hashtags to include
+     */
+    tags?: string[];
+    /**
+     * Link URL to include
+     */
+    linkUrl?: string;
+    /**
+     * Scheduled publish time
+     */
+    scheduledAt?: Date;
+    /**
+     * Override the adapter/account default link behavior for this post.
+     */
+    linkBehavior?: LinkBehavior;
+}
+
+/**
+ * How adapters should attach links to posts.
+ */
+export declare type LinkBehavior = 'inline' | 'attachment' | 'reply' | 'none';
+
+/**
+ * Link post content
+ */
+export declare interface LinkPost {
+    /**
+     * URL to share
+     */
+    url: string;
+    /**
+     * Post text/caption
+     */
+    text?: string;
+    /**
+     * Link title for platforms that support link cards
+     */
+    title?: string;
+    /**
+     * Link description for platforms that support link cards
+     */
+    description?: string;
+    /**
+     * Hashtags to include
+     */
+    tags?: string[];
+    /**
+     * Scheduled publish time
+     */
+    scheduledAt?: Date;
+    /**
+     * Override the adapter/account default link behavior for this post.
+     */
+    linkBehavior?: LinkBehavior;
+}
+
+/**
+ * Platform capabilities
+ */
+export declare interface PlatformCapabilities {
+    /**
+     * Supports video posts
+     */
+    video: boolean;
+    /**
+     * Supports image posts
+     */
+    image: boolean;
+    /**
+     * Supports text-only posts
+     */
+    text: boolean;
+    /**
+     * Supports first-class link posts or link attachments
+     */
+    link: boolean;
+    /**
+     * Supports native link attachments/cards instead of plain inline URLs
+     */
+    linkAttachment?: boolean;
+    /**
+     * Supports scheduled posting
+     */
+    scheduling: boolean;
+    /**
+     * Supports analytics retrieval
+     */
+    analytics: boolean;
+    /**
+     * Analytics can include raw platform payloads
+     */
+    rawAnalytics?: boolean;
+    /**
+     * Safety modes supported by this adapter.
+     */
+    publishModes?: PublishMode[];
+    /**
+     * Supports a non-public remote staging step before final publish.
+     */
+    staging?: boolean;
+    /**
+     * Supports creating private, unpublished, or scheduled platform content.
+     */
+    privatePublishing?: boolean;
+    /**
+     * Media publishing requires a publicly accessible URL, not a Buffer upload
+     */
+    requiresPublicMediaUrl?: boolean;
+    /**
+     * Maximum video duration in seconds
+     */
+    maxVideoLength: number;
+    /**
+     * Maximum video file size in bytes
+     */
+    maxVideoSize: number;
+    /**
+     * Supported video formats
+     */
+    supportedVideoFormats: string[];
+    /**
+     * Supported aspect ratios
+     */
+    aspectRatios: string[];
+    /**
+     * Maximum text length
+     */
+    maxTextLength: number;
+    /**
+     * Maximum number of hashtags
+     */
+    maxHashtags?: number;
+    /**
+     * Supported high-level post types
+     */
+    supportedPostTypes?: Array<'text' | 'image' | 'video' | 'link'>;
+}
+
+/**
+ * Retrieved post data
+ */
+export declare interface Post {
+    /**
+     * Platform-specific post ID
+     */
+    id: string;
+    /**
+     * Public URL of the post
+     */
+    url: string;
+    /**
+     * Post type
+     */
+    type: 'video' | 'image' | 'text' | 'link';
+    /**
+     * Post title (if applicable)
+     */
+    title?: string;
+    /**
+     * Post description/caption
+     */
+    description?: string;
+    /**
+     * When the post was published
+     */
+    publishedAt: Date;
+    /**
+     * Current visibility
+     */
+    visibility: 'public' | 'unlisted' | 'private';
+    /**
+     * Basic analytics
+     */
+    analytics?: PostAnalytics;
+}
+
+/**
+ * Post analytics
+ */
+export declare interface PostAnalytics {
+    /**
+     * View/impression count
+     */
+    views?: number;
+    /**
+     * Impression count when the platform distinguishes it from views
+     */
+    impressions?: number;
+    /**
+     * Like/favorite count
+     */
+    likes?: number;
+    /**
+     * Comment count
+     */
+    comments?: number;
+    /**
+     * Share/repost count
+     */
+    shares?: number;
+    /**
+     * Click count (for links)
+     */
+    clicks?: number;
+    /**
+     * Raw platform analytics payload for debugging and future reporting
+     */
+    raw?: unknown;
+    /**
+     * When analytics were last updated
+     */
+    lastUpdated?: Date;
+}
+
+/**
+ * Result from publishing a post
+ */
+export declare interface PostResult {
+    /**
+     * Platform-specific post ID
+     */
+    id: string;
+    /**
+     * Public URL of the post
+     */
+    url: string;
+    /**
+     * Publication status
+     */
+    status: 'published' | 'scheduled' | 'processing' | 'staged' | 'dry_run';
+    /**
+     * When the post was/will be published
+     */
+    publishedAt?: Date;
+    /**
+     * Scheduled time (if scheduled)
+     */
+    scheduledAt?: Date;
+    /**
+     * Platform-specific metadata
+     */
+    metadata?: Record<string, any>;
+}
+
+/**
+ * Safety mode for publish operations.
+ * - dry_run: Build and validate payloads without platform API writes
+ * - stage_remote: Use non-public staging endpoints where available
+ * - private_or_scheduled: Create a non-public/private/scheduled platform object where available
+ * - public: Publish publicly
+ */
+export declare type PublishMode = 'dry_run' | 'stage_remote' | 'private_or_scheduled' | 'public';
+
+/**
+ * Publish content to multiple platforms at once
+ *
+ * @example
+ * ```typescript
+ * import { publishToAll, getSocialMulti } from '@happyvertical/social';
+ *
+ * const adapters = await getSocialMulti([...]);
+ *
+ * const results = await publishToAll(adapters, {
+ *   type: 'text',
+ *   text: 'Breaking news from Bentley!',
+ *   linkUrl: 'https://example.com/article',
+ *   tags: ['news', 'local'],
+ * });
+ * ```
+ */
+export declare function publishToAll(adapters: SocialPlatform[], content: {
+    type: 'text' | 'image' | 'video' | 'link';
+    text?: string;
+    description?: string;
+    file?: Buffer | string;
+    title?: string;
+    linkUrl?: string;
+    url?: string;
+    tags?: string[];
+    altText?: string;
+    mimeType?: string;
+    thumbnail?: Buffer | string;
+    thumbnailMimeType?: string;
+}): Promise<Map<string, {
+    success: boolean;
+    result?: unknown;
+    error?: Error;
+}>>;
+
+/**
+ * Authentication error
+ */
+export declare class SocialAuthError extends SocialError {
+    constructor(platform: SocialPlatformType, message?: string);
+}
+
+/**
+ * Union of all platform configurations
+ */
+export declare type SocialConfig = YouTubeConfig | ThreadsConfig | FacebookPageConfig | XConfig | BlueskyConfig;
+
+/**
+ * Error thrown by social platform operations
+ */
+export declare class SocialError extends Error {
+    code: string;
+    platform?: SocialPlatformType | undefined;
+    statusCode?: number | undefined;
+    constructor(message: string, code: string, platform?: SocialPlatformType | undefined, statusCode?: number | undefined);
+}
+
+/**
+ * Social platform interface
+ */
+export declare interface SocialPlatform {
+    /**
+     * Platform type
+     */
+    readonly platform: SocialPlatformType;
+    /**
+     * Authenticate or refresh authentication
+     */
+    authenticate(credentials?: Record<string, string>): Promise<AuthResult>;
+    /**
+     * Refresh expired token
+     */
+    refreshToken(refreshToken: string): Promise<AuthResult>;
+    /**
+     * Publish a video post
+     */
+    publishVideo(video: VideoPost): Promise<PostResult>;
+    /**
+     * Publish an image post
+     */
+    publishImage(image: ImagePost): Promise<PostResult>;
+    /**
+     * Publish a text post
+     */
+    publishText(text: TextPost): Promise<PostResult>;
+    /**
+     * Publish a link post
+     */
+    publishLink(link: LinkPost): Promise<PostResult>;
+    /**
+     * Get a post by ID
+     */
+    getPost(postId: string): Promise<Post>;
+    /**
+     * Delete a post
+     */
+    deletePost(postId: string): Promise<void>;
+    /**
+     * Get analytics for a post
+     */
+    getAnalytics(postId: string): Promise<PostAnalytics>;
+    /**
+     * Get platform capabilities
+     */
+    getCapabilities(): PlatformCapabilities;
+}
+
+/**
+ * Social Platform Types
+ *
+ * Unified interface for publishing to social media platforms.
+ */
+/**
+ * Supported social platforms
+ */
+export declare type SocialPlatformType = 'youtube' | 'threads' | 'x' | 'bluesky' | 'facebook';
+
+/**
+ * Rate limit error
+ */
+export declare class SocialRateLimitError extends SocialError {
+    retryAfter?: number | undefined;
+    constructor(platform: SocialPlatformType, retryAfter?: number | undefined);
+}
+
+/**
+ * Text post content
+ */
+export declare interface TextPost {
+    /**
+     * Post text content
+     */
+    text: string;
+    /**
+     * Hashtags to include
+     */
+    tags?: string[];
+    /**
+     * Link URL to include
+     */
+    linkUrl?: string;
+    /**
+     * Scheduled publish time
+     */
+    scheduledAt?: Date;
+    /**
+     * Reply to post ID (for threads/replies)
+     */
+    replyTo?: string;
+    /**
+     * Override the adapter/account default link behavior for this post.
+     */
+    linkBehavior?: LinkBehavior;
+}
+
+/**
+ * Threads adapter for publishing via Meta Graph API
+ *
+ * @example
+ * ```typescript
+ * const threads = new ThreadsAdapter({
+ *   type: 'threads',
+ *   accessToken: 'user-access-token',
+ *   userId: 'threads-user-id',
+ * });
+ *
+ * await threads.authenticate();
+ *
+ * const result = await threads.publishText({
+ *   text: 'Breaking news from Bentley!',
+ *   linkUrl: 'https://example.com/article',
+ * });
+ * ```
+ */
+export declare class ThreadsAdapter implements SocialPlatform {
+    readonly platform: "threads";
+    private config;
+    constructor(config: ThreadsConfig);
+    authenticate(): Promise<AuthResult>;
+    refreshToken(_refreshToken: string): Promise<AuthResult>;
+    publishVideo(video: VideoPost): Promise<PostResult>;
+    publishImage(image: ImagePost): Promise<PostResult>;
+    publishText(text: TextPost): Promise<PostResult>;
+    publishLink(link: LinkPost): Promise<PostResult>;
+    /**
+     * Wait for media container to finish processing
+     */
+    private waitForContainer;
+    /**
+     * Publish a prepared container
+     */
+    private publishContainer;
+    /**
+     * Upload buffer to temporary storage and return URL
+     * Note: In production, this would upload to a CDN or storage service
+     */
+    private uploadToTempStorage;
+    getPost(postId: string): Promise<Post>;
+    deletePost(_postId: string): Promise<void>;
+    getAnalytics(postId: string): Promise<PostAnalytics>;
+    getCapabilities(): PlatformCapabilities;
+    /**
+     * Build post text with hashtags and link
+     */
+    private buildPostText;
+    /**
+     * Parse insights data into PostAnalytics
+     */
+    private parseInsights;
+    /**
+     * Map Threads media type to our type
+     */
+    private mapMediaType;
+    /**
+     * Handle API errors
+     */
+    private handleError;
+}
+
+/**
+ * Threads (Meta) configuration
+ */
+export declare interface ThreadsConfig extends BaseSocialConfig {
+    type: 'threads';
+    /**
+     * Access token from Meta OAuth
+     */
+    accessToken: string;
+    /**
+     * Instagram/Threads user ID
+     */
+    userId: string;
+}
+
+/**
+ * Video post content
+ */
+export declare interface VideoPost {
+    /**
+     * Video file buffer or URL
+     */
+    file: Buffer | string;
+    /**
+     * MIME type for the video file. Detected from URLs and common buffer
+     * signatures when omitted.
+     */
+    mimeType?: string;
+    /**
+     * Video title (YouTube, some platforms)
+     */
+    title?: string;
+    /**
+     * Post description/caption
+     */
+    description?: string;
+    /**
+     * Custom thumbnail image
+     */
+    thumbnail?: Buffer | string;
+    /**
+     * MIME type for the thumbnail image. Detected from URLs and common buffer
+     * signatures when omitted.
+     */
+    thumbnailMimeType?: string;
+    /**
+     * Hashtags to include
+     */
+    tags?: string[];
+    /**
+     * Link URL to include (e.g., article link)
+     */
+    linkUrl?: string;
+    /**
+     * Visibility setting
+     * @default 'public'
+     */
+    visibility?: 'public' | 'unlisted' | 'private';
+    /**
+     * Scheduled publish time (if supported)
+     */
+    scheduledAt?: Date;
+    /**
+     * Category ID (YouTube)
+     */
+    categoryId?: string;
+    /**
+     * Whether this is a Short (YouTube)
+     */
+    isShort?: boolean;
+    /**
+     * Override the adapter/account default link behavior for this post.
+     */
+    linkBehavior?: LinkBehavior;
+}
+
+/**
+ * X (Twitter) adapter for publishing
+ *
+ * @example
+ * ```typescript
+ * const x = new XAdapter({
+ *   type: 'x',
+ *   apiKey: 'consumer-key',
+ *   apiSecret: 'consumer-secret',
+ *   accessToken: 'user-access-token',
+ *   accessSecret: 'user-access-secret',
+ * });
+ *
+ * await x.authenticate();
+ *
+ * const result = await x.publishText({
+ *   text: 'Breaking news from Bentley!',
+ *   linkUrl: 'https://example.com/article',
+ * });
+ * ```
+ */
+export declare class XAdapter implements SocialPlatform {
+    readonly platform: "x";
+    private config;
+    private logger;
+    constructor(config: XConfig);
+    /**
+     * Generate OAuth 1.0a signature for request
+     */
+    private generateOAuthSignature;
+    private generateNonce;
+    private percentEncode;
+    private hmacSha1;
+    authenticate(): Promise<AuthResult>;
+    refreshToken(refreshToken: string): Promise<AuthResult>;
+    private basicAuthHeader;
+    publishVideo(video: VideoPost): Promise<PostResult>;
+    publishImage(image: ImagePost): Promise<PostResult>;
+    publishText(text: TextPost): Promise<PostResult>;
+    publishLink(link: LinkPost): Promise<PostResult>;
+    /**
+     * Upload media to Twitter
+     */
+    private uploadMedia;
+    private readMediaData;
+    /**
+     * Upload media using X API v2 and OAuth 2.0 user context.
+     */
+    private uploadMediaV2;
+    /**
+     * Upload media using legacy OAuth 1.0a upload endpoints.
+     */
+    private uploadMediaOAuth1;
+    /**
+     * Wait for media processing to complete
+     */
+    private waitForProcessing;
+    /**
+     * Set alt text for uploaded media
+     * Uses JSON body as required by metadata/create endpoint
+     */
+    private setMediaAltText;
+    /**
+     * Post link as reply (algorithm-friendly pattern)
+     */
+    private postLinkReply;
+    getPost(postId: string): Promise<Post>;
+    deletePost(postId: string): Promise<void>;
+    getAnalytics(postId: string): Promise<PostAnalytics>;
+    getCapabilities(): PlatformCapabilities;
+    private resolveLinkBehavior;
+    private usesOAuth2;
+    private requireOAuth1Config;
+    /**
+     * Build post text with hashtags
+     */
+    private buildPostText;
+    private truncatePostText;
+    private resolvePostType;
+    private inferMediaTypeFromKey;
+    /**
+     * Make authenticated request to Twitter API v2
+     */
+    private makeRequest;
+    private makeBearerUploadRequest;
+    /**
+     * Make authenticated request to Twitter Upload API
+     */
+    private makeUploadRequest;
+    /**
+     * Handle API errors
+     */
+    private handleError;
+}
+
+/**
+ * X (Twitter) configuration
+ */
+export declare interface XConfig extends BaseSocialConfig {
+    type: 'x';
+    /**
+     * Authentication mode. OAuth 2.0 is used when accessSecret is omitted.
+     *
+     * @default 'oauth1' when accessSecret is present, otherwise 'oauth2'
+     */
+    authType?: 'oauth1' | 'oauth2';
+    /**
+     * API key (consumer key) for OAuth 1.0a.
+     */
+    apiKey?: string;
+    /**
+     * API secret (consumer secret) for OAuth 1.0a.
+     */
+    apiSecret?: string;
+    /**
+     * User access token.
+     */
+    accessToken: string;
+    /**
+     * User access token secret for OAuth 1.0a.
+     */
+    accessSecret?: string;
+    /**
+     * OAuth 2.0 client ID for refresh-token flows.
+     */
+    clientId?: string;
+    /**
+     * OAuth 2.0 client secret for confidential clients.
+     */
+    clientSecret?: string;
+    /**
+     * OAuth 2.0 refresh token.
+     */
+    refreshToken?: string;
+    /**
+     * Default handling for links.
+     * @default 'inline'
+     */
+    linkBehavior?: LinkBehavior;
+}
+
+/**
+ * YouTube adapter for video publishing
+ *
+ * @example
+ * ```typescript
+ * const youtube = new YouTubeAdapter({
+ *   type: 'youtube',
+ *   clientId: 'your-client-id',
+ *   clientSecret: 'your-client-secret',
+ *   accessToken: 'user-access-token',
+ *   refreshToken: 'user-refresh-token',
+ * });
+ *
+ * const result = await youtube.publishVideo({
+ *   file: videoBuffer,
+ *   title: 'Breaking News',
+ *   description: 'Latest updates...',
+ *   tags: ['news', 'local'],
+ *   isShort: true,
+ * });
+ * ```
+ */
+export declare class YouTubeAdapter implements SocialPlatform {
+    readonly platform: "youtube";
+    private config;
+    private logger;
+    private currentAccessToken?;
+    constructor(config: YouTubeConfig);
+    /**
+     * Generate OAuth authorization URL
+     */
+    getAuthorizationUrl(options?: AuthorizationOptions): AuthorizationResult;
+    /**
+     * Exchange authorization code for tokens
+     */
+    exchangeCode(params: CodeExchangeParams): Promise<AuthResult>;
+    authenticate(): Promise<AuthResult>;
+    refreshToken(refreshToken: string): Promise<AuthResult>;
+    publishVideo(video: VideoPost): Promise<PostResult>;
+    /**
+     * Upload custom thumbnail
+     * @returns true if upload succeeded, false otherwise
+     */
+    private uploadThumbnail;
+    publishImage(_image: ImagePost): Promise<PostResult>;
+    publishText(_text: TextPost): Promise<PostResult>;
+    publishLink(_link: LinkPost): Promise<PostResult>;
+    getPost(postId: string): Promise<Post>;
+    deletePost(postId: string): Promise<void>;
+    getAnalytics(postId: string): Promise<PostAnalytics>;
+    getCapabilities(): PlatformCapabilities;
+    /**
+     * Build description with link and hashtags
+     */
+    private buildDescription;
+    private parseMetric;
+    /**
+     * Handle API errors
+     */
+    private handleError;
+    /**
+     * Generate PKCE code verifier
+     */
+    private generateCodeVerifier;
+    /**
+     * Generate PKCE code challenge from verifier using S256
+     */
+    private generateCodeChallenge;
+}
+
+/**
+ * YouTube configuration
+ */
+export declare interface YouTubeConfig extends BaseSocialConfig {
+    type: 'youtube';
+    /**
+     * OAuth2 client ID
+     */
+    clientId: string;
+    /**
+     * OAuth2 client secret
+     */
+    clientSecret: string;
+    /**
+     * Access token (from OAuth flow)
+     */
+    accessToken?: string;
+    /**
+     * Refresh token (from OAuth flow)
+     */
+    refreshToken?: string;
+    /**
+     * Redirect URI for OAuth
+     */
+    redirectUri?: string;
+}
+
+export { }