@olastudio/social-media-sdk 0.1.0 → 0.1.2

package/dist/index.js

@@ -1,174 +1,2229 @@
 'use strict';
 
-require('./chunk-BX3RO5PW.js');
-var chunkPJ4KYVHH_js = require('./chunk-PJ4KYVHH.js');
-var chunk7QAMNVQU_js = require('./chunk-7QAMNVQU.js');
-var chunkER5A6TIL_js = require('./chunk-ER5A6TIL.js');
-var chunkQRGJXASL_js = require('./chunk-QRGJXASL.js');
-require('./chunk-B6NUTR54.js');
-var chunkHPLIHYLQ_js = require('./chunk-HPLIHYLQ.js');
-
-
-
-Object.defineProperty(exports, "FacebookAPI", {
-  enumerable: true,
-  get: function () { return chunkPJ4KYVHH_js.FacebookAPI; }
-});
-Object.defineProperty(exports, "FacebookAuth", {
-  enumerable: true,
-  get: function () { return chunkPJ4KYVHH_js.FacebookAuth; }
-});
-Object.defineProperty(exports, "FacebookProvider", {
-  enumerable: true,
-  get: function () { return chunkPJ4KYVHH_js.FacebookProvider; }
-});
-Object.defineProperty(exports, "FacebookScopesBusiness", {
-  enumerable: true,
-  get: function () { return chunkPJ4KYVHH_js.FacebookScopesBusiness; }
-});
-Object.defineProperty(exports, "FacebookScopesUser", {
-  enumerable: true,
-  get: function () { return chunkPJ4KYVHH_js.FacebookScopesUser; }
-});
-Object.defineProperty(exports, "InstagramAPI", {
-  enumerable: true,
-  get: function () { return chunk7QAMNVQU_js.InstagramAPI; }
-});
-Object.defineProperty(exports, "InstagramAuth", {
-  enumerable: true,
-  get: function () { return chunk7QAMNVQU_js.InstagramAuth; }
-});
-Object.defineProperty(exports, "InstagramProvider", {
-  enumerable: true,
-  get: function () { return chunk7QAMNVQU_js.InstagramProvider; }
-});
-Object.defineProperty(exports, "InstagramScopes", {
-  enumerable: true,
-  get: function () { return chunk7QAMNVQU_js.InstagramScopes; }
-});
-Object.defineProperty(exports, "FACEBOOK_GRAPH_API_BASE_URL", {
-  enumerable: true,
-  get: function () { return chunkER5A6TIL_js.FACEBOOK_GRAPH_API_BASE_URL; }
-});
-Object.defineProperty(exports, "FACEBOOK_GRAPH_API_VERSION", {
-  enumerable: true,
-  get: function () { return chunkER5A6TIL_js.FACEBOOK_GRAPH_API_VERSION; }
-});
-Object.defineProperty(exports, "FACEBOOK_OAUTH_AUTHORIZATION_URL", {
-  enumerable: true,
-  get: function () { return chunkER5A6TIL_js.FACEBOOK_OAUTH_AUTHORIZATION_URL; }
-});
-Object.defineProperty(exports, "HttpClient", {
-  enumerable: true,
-  get: function () { return chunkER5A6TIL_js.HttpClient; }
-});
-Object.defineProperty(exports, "INSIGHTS_PERIODS", {
-  enumerable: true,
-  get: function () { return chunkER5A6TIL_js.INSIGHTS_PERIODS; }
-});
-Object.defineProperty(exports, "INSTAGRAM_ACCOUNT_METRICS", {
-  enumerable: true,
-  get: function () { return chunkER5A6TIL_js.INSTAGRAM_ACCOUNT_METRICS; }
-});
-Object.defineProperty(exports, "INSTAGRAM_DEMOGRAPHICS_METRICS", {
-  enumerable: true,
-  get: function () { return chunkER5A6TIL_js.INSTAGRAM_DEMOGRAPHICS_METRICS; }
-});
-Object.defineProperty(exports, "INSTAGRAM_MEDIA_METRICS_COMMON", {
-  enumerable: true,
-  get: function () { return chunkER5A6TIL_js.INSTAGRAM_MEDIA_METRICS_COMMON; }
-});
-Object.defineProperty(exports, "INSTAGRAM_REELS_METRICS", {
-  enumerable: true,
-  get: function () { return chunkER5A6TIL_js.INSTAGRAM_REELS_METRICS; }
-});
-Object.defineProperty(exports, "INSTAGRAM_STORIES_METRICS", {
-  enumerable: true,
-  get: function () { return chunkER5A6TIL_js.INSTAGRAM_STORIES_METRICS; }
-});
-Object.defineProperty(exports, "METRIC_PRESETS", {
-  enumerable: true,
-  get: function () { return chunkER5A6TIL_js.METRIC_PRESETS; }
-});
-Object.defineProperty(exports, "PAGE_METRICS_LIFETIME", {
-  enumerable: true,
-  get: function () { return chunkER5A6TIL_js.PAGE_METRICS_LIFETIME; }
-});
-Object.defineProperty(exports, "PAGE_METRICS_PERIODIC", {
-  enumerable: true,
-  get: function () { return chunkER5A6TIL_js.PAGE_METRICS_PERIODIC; }
-});
-Object.defineProperty(exports, "PHOTO_METRICS", {
-  enumerable: true,
-  get: function () { return chunkER5A6TIL_js.PHOTO_METRICS; }
-});
-Object.defineProperty(exports, "POST_METRICS", {
-  enumerable: true,
-  get: function () { return chunkER5A6TIL_js.POST_METRICS; }
-});
-Object.defineProperty(exports, "REELS_METRICS", {
-  enumerable: true,
-  get: function () { return chunkER5A6TIL_js.REELS_METRICS; }
-});
-Object.defineProperty(exports, "REELS_METRICS_EXTENDED", {
-  enumerable: true,
-  get: function () { return chunkER5A6TIL_js.REELS_METRICS_EXTENDED; }
-});
-Object.defineProperty(exports, "VIDEO_METRICS", {
-  enumerable: true,
-  get: function () { return chunkER5A6TIL_js.VIDEO_METRICS; }
-});
-Object.defineProperty(exports, "TIKTOK_API_BASE_URL", {
-  enumerable: true,
-  get: function () { return chunkQRGJXASL_js.TIKTOK_API_BASE_URL; }
-});
-Object.defineProperty(exports, "TIKTOK_API_VERSION", {
-  enumerable: true,
-  get: function () { return chunkQRGJXASL_js.TIKTOK_API_VERSION; }
-});
-Object.defineProperty(exports, "TIKTOK_DEFAULT_SCOPES", {
-  enumerable: true,
-  get: function () { return chunkQRGJXASL_js.TIKTOK_DEFAULT_SCOPES; }
-});
-Object.defineProperty(exports, "TIKTOK_OAUTH_AUTHORIZATION_URL", {
-  enumerable: true,
-  get: function () { return chunkQRGJXASL_js.TIKTOK_OAUTH_AUTHORIZATION_URL; }
-});
-Object.defineProperty(exports, "TIKTOK_OAUTH_REVOKE_URL", {
-  enumerable: true,
-  get: function () { return chunkQRGJXASL_js.TIKTOK_OAUTH_REVOKE_URL; }
-});
-Object.defineProperty(exports, "TIKTOK_OAUTH_TOKEN_URL", {
-  enumerable: true,
-  get: function () { return chunkQRGJXASL_js.TIKTOK_OAUTH_TOKEN_URL; }
-});
-Object.defineProperty(exports, "TikTokAPI", {
-  enumerable: true,
-  get: function () { return chunkQRGJXASL_js.TikTokAPI; }
-});
-Object.defineProperty(exports, "TikTokAuth", {
-  enumerable: true,
-  get: function () { return chunkQRGJXASL_js.TikTokAuth; }
-});
-Object.defineProperty(exports, "TikTokProvider", {
-  enumerable: true,
-  get: function () { return chunkQRGJXASL_js.TikTokProvider; }
-});
-Object.defineProperty(exports, "TikTokScopes", {
-  enumerable: true,
-  get: function () { return chunkQRGJXASL_js.TikTokScopes; }
-});
-Object.defineProperty(exports, "APIError", {
-  enumerable: true,
-  get: function () { return chunkHPLIHYLQ_js.APIError; }
-});
-Object.defineProperty(exports, "AuthError", {
-  enumerable: true,
-  get: function () { return chunkHPLIHYLQ_js.AuthError; }
-});
-Object.defineProperty(exports, "BaseError", {
-  enumerable: true,
-  get: function () { return chunkHPLIHYLQ_js.BaseError; }
-});
+// core/errors/BaseError.ts
+var BaseError = class extends Error {
+  constructor(message, code, details) {
+    super(message);
+    this.name = this.constructor.name;
+    this.code = code;
+    this.details = details;
+    Error.captureStackTrace(this, this.constructor);
+  }
+};
+
+// core/errors/AuthError.ts
+var AuthError = class extends BaseError {
+  constructor(message, code, details) {
+    super(message, code, details);
+    this.name = "AuthError";
+  }
+};
+
+// core/errors/APIError.ts
+var APIError = class extends BaseError {
+  constructor(message, statusCode, code, details) {
+    super(message, code, details);
+    this.name = "APIError";
+    this.statusCode = statusCode;
+  }
+};
+
+// core/http/HttpClient.ts
+var HttpClient = class {
+  constructor(config) {
+    this.config = {
+      timeout: 3e4,
+      // 30 seconds default
+      headers: {
+        "Content-Type": "application/json"
+      },
+      ...config
+    };
+  }
+  /**
+   * Generic request
+   */
+  async request(endpoint, options = {}) {
+    const url = this.buildURL(endpoint, options.params);
+    const method = options.method || "GET";
+    const headers = {
+      ...this.config.headers,
+      ...options.headers
+    };
+    if (this.config.accessToken) {
+      headers["Authorization"] = `Bearer ${this.config.accessToken}`;
+    }
+    const config = {
+      method,
+      headers,
+      signal: this.createAbortSignal(options.timeout || this.config.timeout)
+    };
+    if (options.body && method !== "GET") {
+      if (headers["Content-Type"] === "application/json") {
+        config.body = JSON.stringify(options.body);
+      } else if (headers["Content-Type"] === "application/x-www-form-urlencoded") {
+        config.body = this.encodeFormBody(options.body);
+      } else {
+        config.body = options.body;
+      }
+    }
+    try {
+      const response = await fetch(url, config);
+      return await this.handleResponse(response);
+    } catch (error) {
+      if (error instanceof APIError) {
+        throw error;
+      }
+      throw new APIError(
+        `Network error: ${error instanceof Error ? error.message : "Unknown error"}`,
+        0,
+        "NETWORK_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * GET request
+   */
+  async get(endpoint, params) {
+    return this.request(endpoint, { method: "GET", params });
+  }
+  /**
+   * POST request
+   */
+  async post(endpoint, body) {
+    return this.request(endpoint, { method: "POST", body });
+  }
+  /**
+   * PUT request
+   */
+  async put(endpoint, body) {
+    return this.request(endpoint, { method: "PUT", body });
+  }
+  /**
+   * DELETE request
+   */
+  async delete(endpoint) {
+    return this.request(endpoint, { method: "DELETE" });
+  }
+  /**
+   * Build URL with query params
+   */
+  buildURL(endpoint, params) {
+    const url = endpoint.startsWith("http") ? endpoint : `${this.config.baseURL}${endpoint}`;
+    if (!params || Object.keys(params).length === 0) {
+      return url;
+    }
+    const queryString = Object.entries(params).filter(([_, value]) => value !== void 0 && value !== null).map(
+      ([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`
+    ).join("&");
+    return queryString ? `${url}?${queryString}` : url;
+  }
+  /**
+   * Encode body as form-urlencoded
+   */
+  encodeFormBody(body) {
+    return Object.entries(body).filter(([_, value]) => value !== void 0 && value !== null).map(
+      ([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`
+    ).join("&");
+  }
+  /**
+   * Create AbortSignal for timeout
+   */
+  createAbortSignal(timeout) {
+    if (!timeout) return void 0;
+    const controller = new AbortController();
+    setTimeout(() => controller.abort(), timeout);
+    return controller.signal;
+  }
+  /**
+   * Handle HTTP response
+   */
+  async handleResponse(response) {
+    let data;
+    const contentType = response.headers.get("content-type");
+    if (contentType?.includes("application/json")) {
+      data = await response.json();
+    } else {
+      data = await response.text();
+    }
+    if (!response.ok) {
+      const errorMessage = data?.error?.message || data?.message || "API request failed";
+      const errorCode = data?.error?.code || data?.code || response.status;
+      throw new APIError(errorMessage, response.status, errorCode, data);
+    }
+    return data;
+  }
+  /**
+   * Update access token
+   */
+  setAccessToken(token) {
+    this.config.accessToken = token;
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+};
+
+// core/constants.ts
+var FACEBOOK_GRAPH_API_VERSION = "v24.0";
+var FACEBOOK_GRAPH_API_BASE_URL = `https://graph.facebook.com/${FACEBOOK_GRAPH_API_VERSION}`;
+var FACEBOOK_OAUTH_AUTHORIZATION_URL = `https://www.facebook.com/${FACEBOOK_GRAPH_API_VERSION}/dialog/oauth`;
+
+// core/insights.constants.ts
+var PAGE_METRICS_LIFETIME = [
+  "page_fans_country",
+  "page_fans_city",
+  "page_fans_gender_age"
+];
+var PAGE_METRICS_PERIODIC = [
+  "page_views_total",
+  "page_views",
+  "page_post_engagements",
+  "page_fans_online",
+  "page_fans_online_per_day",
+  "page_video_views",
+  "page_daily_follows",
+  "page_daily_unfollows"
+];
+var POST_METRICS = [
+  "post_engaged_users",
+  "post_negative_feedback",
+  "post_engaged_fan",
+  "post_clicks",
+  "post_clicks_unique",
+  "post_reactions_by_type_total"
+];
+var VIDEO_METRICS = [
+  "total_video_views",
+  "total_video_views_unique",
+  "total_video_views_autoplayed",
+  "total_video_views_clicked_to_play",
+  "total_video_views_organic",
+  "total_video_views_organic_unique",
+  "total_video_views_paid",
+  "total_video_views_paid_unique",
+  "total_video_avg_time_watched",
+  "total_video_view_total_time",
+  "total_video_complete_views",
+  "total_video_complete_views_unique",
+  "total_video_complete_views_organic",
+  "total_video_complete_views_organic_unique",
+  "total_video_complete_views_paid",
+  "total_video_complete_views_paid_unique"
+];
+var REELS_METRICS = [
+  "blue_reels_play_count",
+  "post_video_avg_time_watched",
+  "post_video_views",
+  "post_video_social_actions"
+];
+var REELS_METRICS_EXTENDED = [
+  "plays",
+  "comments",
+  "likes",
+  "shares",
+  "reach",
+  "total_plays",
+  "average_minutes_viewed",
+  "minutes_viewed"
+];
+var PHOTO_METRICS = [
+  "photo_views",
+  "photo_reach",
+  "engaged_users"
+];
+var INSTAGRAM_ACCOUNT_METRICS = [
+  "views",
+  "reach",
+  "accounts_engaged",
+  "total_interactions",
+  "likes",
+  "comments",
+  "shares",
+  "saves",
+  "follows_and_unfollows",
+  "profile_links_taps",
+  "profile_views"
+];
+var INSTAGRAM_DEMOGRAPHICS_METRICS = [
+  "follower_demographics",
+  "reached_audience_demographics",
+  "engaged_audience_demographics"
+];
+var INSTAGRAM_MEDIA_METRICS_COMMON = [
+  "views",
+  "reach",
+  "likes",
+  "comments",
+  "shares",
+  "saved",
+  "total_interactions"
+];
+var INSTAGRAM_REELS_METRICS = [
+  "plays",
+  "reach",
+  "likes",
+  "comments",
+  "shares",
+  "saved",
+  "total_interactions"
+];
+var INSTAGRAM_STORIES_METRICS = [
+  "exits",
+  "replies",
+  "taps_forward",
+  "taps_back",
+  "views",
+  "reach"
+];
+var INSIGHTS_PERIODS = {
+  DAY: "day",
+  WEEK: "week",
+  DAYS_28: "days_28",
+  MONTH: "month",
+  LIFETIME: "lifetime"
+};
+var METRIC_PRESETS = {
+  // Facebook Page quick overview
+  PAGE_OVERVIEW: ["page_views_total", "page_post_engagements", "page_video_views"],
+  // Facebook Video performance
+  VIDEO_PERFORMANCE: ["total_video_views", "total_video_avg_time_watched", "total_video_complete_views"],
+  // Facebook Reels performance
+  REELS_PERFORMANCE: ["blue_reels_play_count", "post_video_avg_time_watched", "post_video_social_actions"],
+  // Instagram account overview
+  INSTAGRAM_OVERVIEW: ["views", "reach", "accounts_engaged", "total_interactions"],
+  // Instagram content engagement
+  INSTAGRAM_ENGAGEMENT: ["likes", "comments", "shares", "saves"]
+};
+
+// providers/facebook/api/FacebookAPI.ts
+var FacebookAPI = class {
+  constructor(config, accessToken) {
+    this.config = config;
+    this.accessToken = accessToken;
+    this.httpClient = new HttpClient({
+      baseURL: FACEBOOK_GRAPH_API_BASE_URL,
+      accessToken: this.accessToken
+    });
+  }
+  /**
+   * Generic request
+   */
+  async request(endpoint, options = {}) {
+    if (this.accessToken && !options.params?.access_token) {
+      options.params = {
+        ...options.params,
+        access_token: this.accessToken
+      };
+    }
+    return this.httpClient.request(endpoint, options);
+  }
+  /**
+   * GET request
+   */
+  async get(endpoint, params) {
+    return this.request(endpoint, { method: "GET", params });
+  }
+  /**
+   * POST request
+   */
+  async post(endpoint, body) {
+    return this.request(endpoint, { method: "POST", body });
+  }
+  /**
+   * PUT request
+   */
+  async put(endpoint, body) {
+    return this.request(endpoint, { method: "PUT", body });
+  }
+  /**
+   * DELETE request
+   */
+  async delete(endpoint) {
+    return this.request(endpoint, { method: "DELETE" });
+  }
+  /**
+   * Update access token
+   */
+  setAccessToken(token) {
+    this.accessToken = token;
+    this.httpClient.setAccessToken(token);
+  }
+  /**
+   * Get current access token
+   */
+  getAccessToken() {
+    return this.accessToken;
+  }
+  // ============= Facebook-specific methods =============
+  /**
+   * Get user's pages
+   */
+  async getPages(userAccessToken) {
+    try {
+      const token = userAccessToken || this.accessToken;
+      if (!token) {
+        throw new APIError("Access token is required", 401, "NO_TOKEN");
+      }
+      const response = await this.get("/me/accounts", {
+        fields: "id,name,access_token,picture",
+        access_token: token
+      });
+      return response.data;
+    } catch (error) {
+      throw new APIError(
+        `Failed to fetch Facebook pages: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "PAGES_FETCH_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Publish post to Facebook page
+   */
+  async publishPost(params) {
+    const { pageId, pageAccessToken, message, imageUrl, scheduledPublishTime } = params;
+    try {
+      let endpoint = `/${pageId}/`;
+      const body = {
+        access_token: pageAccessToken
+      };
+      if (scheduledPublishTime) {
+        body.published = false;
+        body.scheduled_publish_time = scheduledPublishTime;
+      }
+      if (imageUrl) {
+        endpoint += "photos";
+        body.url = imageUrl;
+        if (message) body.caption = message;
+      } else if (message) {
+        endpoint += "feed";
+        body.message = message;
+      } else {
+        throw new APIError(
+          "Either message or imageUrl must be provided",
+          400,
+          "INVALID_PARAMS"
+        );
+      }
+      const response = await this.request(endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded"
+        },
+        body
+      });
+      return response;
+    } catch (error) {
+      throw new APIError(
+        `Failed to publish post: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "POST_PUBLISH_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Delete Facebook post
+   */
+  async deletePost(postId, pageAccessToken) {
+    try {
+      const response = await this.delete(
+        `/${postId}?access_token=${pageAccessToken}`
+      );
+      return response.success === true;
+    } catch (error) {
+      throw new APIError(
+        `Failed to delete post: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "POST_DELETE_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Get page information
+   */
+  async getPage(pageId, fields) {
+    try {
+      const fieldsParam = fields?.join(",") || "id,name,access_token,picture";
+      return await this.get(`/${pageId}`, {
+        fields: fieldsParam
+      });
+    } catch (error) {
+      throw new APIError(
+        `Failed to fetch page info: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "PAGE_FETCH_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Debug/validate a Facebook access token
+   * Uses Facebook's debug_token endpoint
+   *
+   * @param inputToken - The token to validate
+   * @param appAccessToken - App token (app_id|app_secret)
+   * @returns Token debug information
+   */
+  async debugToken(inputToken, appAccessToken) {
+    try {
+      return await this.get("/debug_token", {
+        input_token: inputToken,
+        access_token: appAccessToken
+      });
+    } catch (error) {
+      throw new APIError(
+        `Failed to debug token: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "TOKEN_DEBUG_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Get page insights/analytics
+   * @param pageId - Facebook Page ID
+   * @param options - Insights options
+   * @returns Page insights data
+   */
+  async getPageInsights(pageId, options) {
+    try {
+      const params = {
+        metric: options.metric.join(","),
+        period: options.period || "day"
+      };
+      if (options.since) params.since = options.since;
+      if (options.until) params.until = options.until;
+      const response = await this.get(`/${pageId}/insights`, params);
+      return response;
+    } catch (error) {
+      throw new APIError(
+        `Failed to fetch page insights: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "INSIGHTS_FETCH_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Get page fans count (total followers)
+   * @param pageId - Facebook Page ID
+   * @returns Page with fan count
+   */
+  async getPageFansCount(pageId) {
+    try {
+      return await this.get(`/${pageId}`, {
+        fields: "id,fan_count"
+      });
+    } catch (error) {
+      throw new APIError(
+        `Failed to fetch page fans count: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "FANS_COUNT_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Get page overview with key metrics
+   * @param pageId - Facebook Page ID
+   * @returns Page overview data
+   */
+  async getPageOverview(pageId) {
+    try {
+      const response = await this.get(`/${pageId}`, {
+        fields: "id,name,followers_count,fan_count"
+      });
+      return {
+        id: response.id,
+        name: response.name,
+        followers_count: response.followers_count || response.fan_count || 0,
+        fan_count: response.fan_count
+      };
+    } catch (error) {
+      throw new APIError(
+        `Failed to fetch page overview: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "PAGE_OVERVIEW_ERROR",
+        error
+      );
+    }
+  }
+  // ============= Video Insights Methods =============
+  /**
+   * Get video insights
+   * @param videoId - Facebook Video ID
+   * @param metrics - Specific metrics to fetch (defaults to common metrics)
+   * @returns Video insights data
+   */
+  async getVideoInsights(videoId, metrics) {
+    try {
+      const metricsToFetch = metrics || METRIC_PRESETS.VIDEO_PERFORMANCE;
+      const response = await this.get(
+        `/${videoId}/video_insights`,
+        {
+          metric: metricsToFetch.join(",")
+        }
+      );
+      return response;
+    } catch (error) {
+      throw new APIError(
+        `Failed to fetch video insights: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "VIDEO_INSIGHTS_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Get video insights with parsed values
+   * @param videoId - Facebook Video ID
+   * @returns Parsed video insights
+   */
+  async getVideoInsightsParsed(videoId) {
+    try {
+      const response = await this.getVideoInsights(videoId, [...VIDEO_METRICS.slice(0, 8)]);
+      const insights = { id: videoId };
+      for (const item of response.data) {
+        const value = item.values?.[0]?.value ?? item.total_value?.value;
+        if (typeof value !== "number") continue;
+        switch (item.name) {
+          case "total_video_views":
+            insights.total_views = value;
+            break;
+          case "total_video_views_unique":
+            insights.unique_views = value;
+            break;
+          case "total_video_avg_time_watched":
+            insights.avg_time_watched = value;
+            break;
+          case "total_video_complete_views":
+            insights.complete_views = value;
+            break;
+          case "total_video_views_organic":
+            insights.organic_views = value;
+            break;
+          case "total_video_views_paid":
+            insights.paid_views = value;
+            break;
+          case "total_video_view_total_time":
+            insights.total_time_watched = value;
+            break;
+        }
+      }
+      return insights;
+    } catch (error) {
+      throw new APIError(
+        `Failed to fetch parsed video insights: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "VIDEO_INSIGHTS_PARSED_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Get page videos with basic info
+   * @param pageId - Facebook Page ID
+   * @param limit - Number of videos to fetch
+   * @returns List of videos
+   */
+  async getPageVideos(pageId, limit = 25) {
+    try {
+      return await this.get(`/${pageId}/videos`, {
+        fields: "id,title,description,created_time,length",
+        limit
+      });
+    } catch (error) {
+      throw new APIError(
+        `Failed to fetch page videos: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "PAGE_VIDEOS_ERROR",
+        error
+      );
+    }
+  }
+  // ============= Reels Insights Methods =============
+  /**
+   * Get reels insights
+   * @param reelId - Facebook Reel ID
+   * @param metrics - Specific metrics to fetch
+   * @returns Reels insights data
+   */
+  async getReelsInsights(reelId, metrics) {
+    try {
+      const metricsToFetch = metrics || METRIC_PRESETS.REELS_PERFORMANCE;
+      const response = await this.get(
+        `/${reelId}/video_insights`,
+        {
+          metric: metricsToFetch.join(",")
+        }
+      );
+      return response;
+    } catch (error) {
+      throw new APIError(
+        `Failed to fetch reels insights: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "REELS_INSIGHTS_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Get reels insights with parsed values
+   * @param reelId - Facebook Reel ID
+   * @returns Parsed reels insights
+   */
+  async getReelsInsightsParsed(reelId) {
+    try {
+      const response = await this.getReelsInsights(reelId, [...REELS_METRICS]);
+      const insights = { id: reelId };
+      for (const item of response.data) {
+        const value = item.values?.[0]?.value ?? item.total_value?.value;
+        if (typeof value !== "number") continue;
+        switch (item.name) {
+          case "blue_reels_play_count":
+            insights.plays = value;
+            break;
+          case "post_video_avg_time_watched":
+            insights.avg_time_watched = value;
+            break;
+          case "post_video_views":
+            insights.total_plays = value;
+            break;
+        }
+      }
+      try {
+        const postResponse = await this.get(`/${reelId}`, {
+          fields: "reactions.summary(true),comments.summary(true),shares"
+        });
+        insights.likes = postResponse.reactions?.summary?.total_count;
+        insights.comments = postResponse.comments?.summary?.total_count;
+        insights.shares = postResponse.shares?.count;
+      } catch {
+      }
+      return insights;
+    } catch (error) {
+      throw new APIError(
+        `Failed to fetch parsed reels insights: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "REELS_INSIGHTS_PARSED_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Get page reels
+   * @param pageId - Facebook Page ID
+   * @param limit - Number of reels to fetch
+   * @returns List of reels
+   */
+  async getPageReels(pageId, limit = 25) {
+    try {
+      return await this.get(`/${pageId}/video_reels`, {
+        fields: "id,description,created_time",
+        limit
+      });
+    } catch (error) {
+      throw new APIError(
+        `Failed to fetch page reels: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "PAGE_REELS_ERROR",
+        error
+      );
+    }
+  }
+  // ============= Post Insights Methods =============
+  /**
+   * Get post insights
+   * @param postId - Facebook Post ID
+   * @param metrics - Specific metrics to fetch
+   * @returns Post insights data
+   */
+  async getPostInsights(postId, metrics) {
+    try {
+      const metricsToFetch = metrics || [...POST_METRICS];
+      const response = await this.get(
+        `/${postId}/insights`,
+        {
+          metric: metricsToFetch.join(",")
+        }
+      );
+      return response;
+    } catch (error) {
+      throw new APIError(
+        `Failed to fetch post insights: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "POST_INSIGHTS_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Get post insights with parsed values
+   * @param postId - Facebook Post ID
+   * @returns Parsed post insights
+   */
+  async getPostInsightsParsed(postId) {
+    try {
+      const response = await this.getPostInsights(postId);
+      const insights = { id: postId };
+      for (const item of response.data) {
+        const value = item.values?.[0]?.value ?? item.total_value?.value;
+        switch (item.name) {
+          case "post_engaged_users":
+            if (typeof value === "number") insights.engaged_users = value;
+            break;
+          case "post_clicks":
+            if (typeof value === "number") insights.clicks = value;
+            break;
+          case "post_negative_feedback":
+            if (typeof value === "number") insights.negative_feedback = value;
+            break;
+          case "post_reactions_by_type_total":
+            if (typeof value === "object") insights.reactions_by_type = value;
+            break;
+        }
+      }
+      return insights;
+    } catch (error) {
+      throw new APIError(
+        `Failed to fetch parsed post insights: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "POST_INSIGHTS_PARSED_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Get page posts/feed
+   * @param pageId - Facebook Page ID
+   * @param limit - Number of posts to fetch
+   * @returns List of posts
+   */
+  async getPagePosts(pageId, limit = 25) {
+    try {
+      return await this.get(`/${pageId}/feed`, {
+        fields: "id,message,created_time,type",
+        limit
+      });
+    } catch (error) {
+      throw new APIError(
+        `Failed to fetch page posts: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "PAGE_POSTS_ERROR",
+        error
+      );
+    }
+  }
+  // ============= Photo Insights Methods =============
+  /**
+   * Get photo insights
+   * @param photoId - Facebook Photo ID
+   * @param metrics - Specific metrics to fetch
+   * @returns Photo insights data
+   */
+  async getPhotoInsights(photoId, metrics) {
+    try {
+      const metricsToFetch = metrics || [...PHOTO_METRICS];
+      const response = await this.get(
+        `/${photoId}/insights`,
+        {
+          metric: metricsToFetch.join(",")
+        }
+      );
+      return response;
+    } catch (error) {
+      throw new APIError(
+        `Failed to fetch photo insights: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "PHOTO_INSIGHTS_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Get photo insights with parsed values
+   * @param photoId - Facebook Photo ID
+   * @returns Parsed photo insights
+   */
+  async getPhotoInsightsParsed(photoId) {
+    try {
+      const response = await this.getPhotoInsights(photoId);
+      const insights = { id: photoId };
+      for (const item of response.data) {
+        const value = item.values?.[0]?.value ?? item.total_value?.value;
+        if (typeof value !== "number") continue;
+        switch (item.name) {
+          case "photo_views":
+            insights.views = value;
+            break;
+          case "photo_reach":
+            insights.reach = value;
+            break;
+          case "engaged_users":
+            insights.engaged_users = value;
+            break;
+        }
+      }
+      return insights;
+    } catch (error) {
+      throw new APIError(
+        `Failed to fetch parsed photo insights: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "PHOTO_INSIGHTS_PARSED_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Get page photos
+   * @param pageId - Facebook Page ID
+   * @param limit - Number of photos to fetch
+   * @returns List of photos
+   */
+  async getPagePhotos(pageId, limit = 25) {
+    try {
+      return await this.get(`/${pageId}/photos`, {
+        fields: "id,name,created_time",
+        type: "uploaded",
+        limit
+      });
+    } catch (error) {
+      throw new APIError(
+        `Failed to fetch page photos: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "PAGE_PHOTOS_ERROR",
+        error
+      );
+    }
+  }
+  // ============= Batch/Helper Methods =============
+  /**
+   * Get quick insights summary for a page
+   * Combines key metrics in a single call
+   * @param pageId - Facebook Page ID
+   * @param period - Period for time-based metrics
+   * @returns Summary of page insights
+   */
+  async getPageInsightsSummary(pageId, period = "days_28") {
+    try {
+      const overview = await this.getPageOverview(pageId);
+      const insightsResponse = await this.getPageInsights(pageId, {
+        metric: [...METRIC_PRESETS.PAGE_OVERVIEW],
+        period
+      });
+      const engagement = {};
+      for (const item of insightsResponse.data) {
+        const values = item.values || [];
+        const total = values.reduce((sum, v) => sum + (typeof v.value === "number" ? v.value : 0), 0);
+        switch (item.name) {
+          case "page_views_total":
+            engagement.views = total;
+            break;
+          case "page_post_engagements":
+            engagement.post_engagements = total;
+            break;
+          case "page_video_views":
+            engagement.video_views = total;
+            break;
+        }
+      }
+      return { overview, engagement };
+    } catch (error) {
+      throw new APIError(
+        `Failed to fetch page insights summary: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "PAGE_SUMMARY_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Get current API version (read-only)
+   */
+  getApiVersion() {
+    return FACEBOOK_GRAPH_API_VERSION;
+  }
+};
+
+// providers/facebook/auth/FacebookAuth.ts
+var FacebookAuth = class {
+  constructor(config) {
+    this.config = config;
+    this.httpClient = new HttpClient({
+      baseURL: FACEBOOK_GRAPH_API_BASE_URL
+    });
+  }
+  /**
+   * Exchange Facebook token for session
+   * In Expo + Supabase, this is handled in the app
+   * This function only validates and gets profile info
+   */
+  async exchangeToken(facebookToken) {
+    try {
+      const profile = await this.getProfile(facebookToken);
+      return {
+        accessToken: facebookToken,
+        user: profile
+      };
+    } catch (error) {
+      throw new AuthError(
+        `Failed to exchange Facebook token: ${error instanceof Error ? error.message : "Unknown error"}`,
+        "TOKEN_EXCHANGE_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Get Facebook user profile
+   */
+  async getProfile(accessToken) {
+    try {
+      const profile = await this.httpClient.get("/me", {
+        fields: "id,name,email,picture",
+        access_token: accessToken
+      });
+      return {
+        id: profile.id,
+        name: profile.name,
+        email: profile.email,
+        picture: profile.picture?.data?.url
+      };
+    } catch (error) {
+      throw new AuthError(
+        `Failed to fetch Facebook profile: ${error instanceof Error ? error.message : "Unknown error"}`,
+        "PROFILE_FETCH_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Exchange short-lived token for long-lived token
+   */
+  async exchangeForLongLivedToken(params) {
+    try {
+      const response = await this.httpClient.get(
+        "/oauth/access_token",
+        {
+          grant_type: "fb_exchange_token",
+          client_id: params.appId,
+          client_secret: params.appSecret,
+          fb_exchange_token: params.shortLivedToken
+        }
+      );
+      return response.access_token;
+    } catch (error) {
+      throw new AuthError(
+        `Failed to exchange for long-lived token: ${error instanceof Error ? error.message : "Unknown error"}`,
+        "LONG_LIVED_TOKEN_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Get OAuth configuration for Facebook
+   */
+  getOAuthConfig(scopes, redirectUri) {
+    return {
+      authorizationEndpoint: FACEBOOK_OAUTH_AUTHORIZATION_URL,
+      tokenEndpoint: `${FACEBOOK_GRAPH_API_BASE_URL}/oauth/access_token`,
+      clientId: this.config.appId,
+      clientSecret: this.config.appSecret,
+      redirectUri,
+      scopes,
+      responseType: "token",
+      extraParams: {
+        display: "popup"
+      }
+    };
+  }
+  /**
+   * Get authorization URL
+   */
+  getAuthorizationUrl(scopes, redirectUri, state) {
+    const params = new URLSearchParams({
+      client_id: this.config.appId,
+      redirect_uri: redirectUri,
+      scope: scopes.join(","),
+      response_type: "token",
+      display: "popup",
+      ...state && { state }
+    });
+    return `${FACEBOOK_OAUTH_AUTHORIZATION_URL}?${params.toString()}`;
+  }
+  /**
+   * Get current API version (read-only)
+   */
+  getApiVersion() {
+    return FACEBOOK_GRAPH_API_VERSION;
+  }
+};
+
+// providers/facebook/FacebookProvider.ts
+var FacebookProvider = class {
+  constructor(config) {
+    this.name = "facebook";
+    this.config = config;
+    this.auth = new FacebookAuth(config);
+    this.api = new FacebookAPI(config);
+  }
+  /**
+   * Create new API instance with access token
+   */
+  createAPIClient(accessToken) {
+    return new FacebookAPI(this.config, accessToken);
+  }
+  /**
+   * Update access token of existing API client
+   */
+  setAccessToken(accessToken) {
+    this.api.setAccessToken(accessToken);
+  }
+  /**
+   * Get current access token
+   */
+  getAccessToken() {
+    return this.api.getAccessToken();
+  }
+};
+
+// providers/facebook/types/index.ts
+var FacebookScopesBusiness = /* @__PURE__ */ ((FacebookScopesBusiness2) => {
+  FacebookScopesBusiness2["PUBLIC_PROFILE"] = "public_profile";
+  FacebookScopesBusiness2["EMAIL"] = "email";
+  FacebookScopesBusiness2["PAGES_SHOW_LIST"] = "pages_show_list";
+  FacebookScopesBusiness2["PAGES_READ_ENGAGEMENT"] = "pages_read_engagement";
+  FacebookScopesBusiness2["PAGES_MANAGE_POSTS"] = "pages_manage_posts";
+  FacebookScopesBusiness2["ADS_MANAGEMENT"] = "ads_management";
+  FacebookScopesBusiness2["ADS_READ"] = "ads_read";
+  FacebookScopesBusiness2["BUSINESS_MANAGEMENT"] = "business_management";
+  FacebookScopesBusiness2["CATALOG_MANAGEMENT"] = "catalog_management";
+  FacebookScopesBusiness2["COMMERCE_ACCOUNT_MANAGE_ORDERS"] = "commerce_account_manage_orders";
+  FacebookScopesBusiness2["COMMERCE_ACCOUNT_READ_ORDERS"] = "commerce_account_read_orders";
+  FacebookScopesBusiness2["COMMERCE_ACCOUNT_READ_REPORTS"] = "commerce_account_read_reports";
+  FacebookScopesBusiness2["COMMERCE_ACCOUNT_READ_SETTINGS"] = "commerce_account_read_settings";
+  FacebookScopesBusiness2["COMMERCE_MANAGE_ACCOUNTS"] = "commerce_manage_accounts";
+  FacebookScopesBusiness2["INSTAGRAM_BASIC"] = "instagram_basic";
+  FacebookScopesBusiness2["INSTAGRAM_CONTENT_PUBLISH"] = "instagram_content_publish";
+  FacebookScopesBusiness2["INSTAGRAM_MANAGE_COMMENTS"] = "instagram_manage_comments";
+  FacebookScopesBusiness2["INSTAGRAM_MANAGE_INSIGHTS"] = "instagram_manage_insights";
+  FacebookScopesBusiness2["INSTAGRAM_MANAGE_MESSAGES"] = "instagram_manage_messages";
+  FacebookScopesBusiness2["INSTAGRAM_SHOPPING_TAG_PRODUCTS"] = "instagram_shopping_tag_products";
+  FacebookScopesBusiness2["LEADS_RETRIEVAL"] = "leads_retrieval";
+  FacebookScopesBusiness2["MANAGE_APP_SOLUTIONS"] = "manage_app_solutions";
+  FacebookScopesBusiness2["MANAGE_FUNDRAISERS"] = "manage_fundraisers";
+  FacebookScopesBusiness2["PAGES_MANAGE_CTA"] = "pages_manage_cta";
+  FacebookScopesBusiness2["PAGE_EVENTS"] = "page_events";
+  FacebookScopesBusiness2["PAGES_MANAGE_ADS"] = "pages_manage_ads";
+  FacebookScopesBusiness2["PAGES_MANAGE_ENGAGEMENT"] = "pages_manage_engagement";
+  FacebookScopesBusiness2["PAGES_MANAGE_INSTANT_ARTICLES"] = "pages_manage_instant_articles";
+  FacebookScopesBusiness2["PAGES_MANAGE_METADATA"] = "pages_manage_metadata";
+  FacebookScopesBusiness2["PAGES_MESSAGING"] = "pages_messaging";
+  FacebookScopesBusiness2["PAGES_READ_USER_CONTENT"] = "pages_read_user_content";
+  FacebookScopesBusiness2["PRIVATE_COMPUTATION_ACCESS"] = "private_computation_access";
+  FacebookScopesBusiness2["PUBLISH_VIDEO"] = "publish_video";
+  FacebookScopesBusiness2["READ_INSIGHTS"] = "read_insights";
+  FacebookScopesBusiness2["READ_AUDIENCE_NETWORK_INSIGHTS"] = "read_audience_network_insights";
+  FacebookScopesBusiness2["WHATSAPP_BUSINESS_MANAGEMENT"] = "whatsapp_business_management";
+  FacebookScopesBusiness2["WHATSAPP_BUSINESS_MESSAGING"] = "whatsapp_business_messaging";
+  return FacebookScopesBusiness2;
+})(FacebookScopesBusiness || {});
+var FacebookScopesUser = /* @__PURE__ */ ((FacebookScopesUser2) => {
+  FacebookScopesUser2["PUBLIC_PROFILE"] = "public_profile";
+  FacebookScopesUser2["EMAIL"] = "email";
+  FacebookScopesUser2["USER_FRIENDS"] = "user_friends";
+  return FacebookScopesUser2;
+})(FacebookScopesUser || {});
+
+// providers/instagram/auth/InstagramAuth.ts
+var InstagramAuth = class {
+  constructor(config) {
+    this.config = config;
+    this.httpClient = new HttpClient({
+      baseURL: FACEBOOK_GRAPH_API_BASE_URL
+    });
+  }
+  /**
+   * Exchange Instagram/Facebook token for session
+   */
+  async exchangeToken(instagramToken) {
+    try {
+      const profile = await this.getProfile(instagramToken);
+      return {
+        accessToken: instagramToken,
+        user: profile
+      };
+    } catch (error) {
+      throw new AuthError(
+        `Failed to exchange Instagram token: ${error instanceof Error ? error.message : "Unknown error"}`,
+        "TOKEN_EXCHANGE_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Get Instagram user profile
+   * First gets Facebook profile, then Instagram Business profile
+   */
+  async getProfile(accessToken) {
+    try {
+      const response = await this.httpClient.get("/me/accounts", {
+        fields: "instagram_business_account",
+        access_token: accessToken
+      });
+      if (!response.data || response.data.length === 0) {
+        throw new AuthError(
+          "No Instagram business account found",
+          "NO_INSTAGRAM_ACCOUNT"
+        );
+      }
+      const instagramAccountId = response.data[0]?.instagram_business_account?.id;
+      if (!instagramAccountId) {
+        throw new AuthError(
+          "No Instagram business account ID found",
+          "NO_INSTAGRAM_ACCOUNT_ID"
+        );
+      }
+      const profile = await this.httpClient.get(
+        `/${instagramAccountId}`,
+        {
+          fields: "id,username,name,account_type,profile_picture_url",
+          access_token: accessToken
+        }
+      );
+      return {
+        id: profile.id,
+        name: profile.name || profile.username,
+        username: profile.username,
+        picture: profile.profile_picture_url
+      };
+    } catch (error) {
+      throw new AuthError(
+        `Failed to fetch Instagram profile: ${error instanceof Error ? error.message : "Unknown error"}`,
+        "PROFILE_FETCH_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Get OAuth configuration for Instagram
+   * Instagram uses the same OAuth flow as Facebook
+   */
+  getOAuthConfig(scopes, redirectUri) {
+    return {
+      authorizationEndpoint: FACEBOOK_OAUTH_AUTHORIZATION_URL,
+      tokenEndpoint: `${FACEBOOK_GRAPH_API_BASE_URL}/oauth/access_token`,
+      clientId: this.config.appId,
+      clientSecret: this.config.appSecret,
+      redirectUri,
+      scopes,
+      responseType: "token",
+      extraParams: {
+        display: "popup"
+      }
+    };
+  }
+  /**
+   * Get authorization URL
+   */
+  getAuthorizationUrl(scopes, redirectUri, state) {
+    const params = new URLSearchParams({
+      client_id: this.config.appId,
+      redirect_uri: redirectUri,
+      scope: scopes.join(","),
+      response_type: "token",
+      display: "popup",
+      ...state && { state }
+    });
+    return `${FACEBOOK_OAUTH_AUTHORIZATION_URL}?${params.toString()}`;
+  }
+  /**
+   * Get current API version (read-only)
+   */
+  getApiVersion() {
+    return FACEBOOK_GRAPH_API_VERSION;
+  }
+};
+
+// providers/instagram/api/InstagramAPI.ts
+var InstagramAPI = class {
+  constructor(config, accessToken) {
+    this.config = config;
+    this.accessToken = accessToken;
+    this.httpClient = new HttpClient({
+      baseURL: FACEBOOK_GRAPH_API_BASE_URL,
+      accessToken: this.accessToken
+    });
+  }
+  /**
+   * Generic request
+   */
+  async request(endpoint, options = {}) {
+    if (this.accessToken && !options.params?.access_token) {
+      options.params = {
+        ...options.params,
+        access_token: this.accessToken
+      };
+    }
+    return this.httpClient.request(endpoint, options);
+  }
+  /**
+   * GET request
+   */
+  async get(endpoint, params) {
+    return this.request(endpoint, { method: "GET", params });
+  }
+  /**
+   * POST request
+   */
+  async post(endpoint, body) {
+    return this.request(endpoint, { method: "POST", body });
+  }
+  /**
+   * PUT request
+   */
+  async put(endpoint, body) {
+    return this.request(endpoint, { method: "PUT", body });
+  }
+  /**
+   * DELETE request
+   */
+  async delete(endpoint) {
+    return this.request(endpoint, { method: "DELETE" });
+  }
+  /**
+   * Update access token
+   */
+  setAccessToken(token) {
+    this.accessToken = token;
+    this.httpClient.setAccessToken(token);
+  }
+  /**
+   * Get current access token
+   */
+  getAccessToken() {
+    return this.accessToken;
+  }
+  // ============= Instagram-specific methods =============
+  /**
+   * Get user's Instagram Business account (single account from first page)
+   */
+  async getAccount(pageAccessToken) {
+    try {
+      const token = pageAccessToken || this.accessToken;
+      if (!token) {
+        throw new APIError("Access token is required", 401, "NO_TOKEN");
+      }
+      const response = await this.get("/me/accounts", {
+        fields: "instagram_business_account",
+        access_token: token
+      });
+      if (!response.data || response.data.length === 0) {
+        throw new APIError(
+          "No Instagram business account found",
+          404,
+          "NO_INSTAGRAM_ACCOUNT"
+        );
+      }
+      const instagramAccountId = response.data[0]?.instagram_business_account?.id;
+      if (!instagramAccountId) {
+        throw new APIError(
+          "No Instagram business account ID found",
+          404,
+          "NO_INSTAGRAM_ACCOUNT_ID"
+        );
+      }
+      const account = await this.get(
+        `/${instagramAccountId}`,
+        {
+          fields: "id,username,name,profile_picture_url,followers_count,follows_count,media_count",
+          access_token: token
+        }
+      );
+      return account;
+    } catch (error) {
+      throw new APIError(
+        `Failed to fetch Instagram account: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "ACCOUNT_FETCH_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Get all Instagram Business accounts linked to user's Facebook pages
+   * Returns all Instagram accounts from all connected Facebook pages
+   */
+  async getInstagramAccounts(userAccessToken) {
+    try {
+      const token = userAccessToken || this.accessToken;
+      if (!token) {
+        throw new APIError("Access token is required", 401, "NO_TOKEN");
+      }
+      const response = await this.get("/me/accounts", {
+        fields: "id,name,instagram_business_account{id,username,name,profile_picture_url,followers_count,follows_count,media_count}",
+        access_token: token
+      });
+      if (!response.data || response.data.length === 0) {
+        console.log("   \u2139\uFE0F No Facebook pages found");
+        return [];
+      }
+      const instagramAccounts = [];
+      for (const page of response.data) {
+        if (page.instagram_business_account) {
+          instagramAccounts.push({
+            id: page.instagram_business_account.id,
+            username: page.instagram_business_account.username,
+            name: page.instagram_business_account.name,
+            profile_picture_url: page.instagram_business_account.profile_picture_url,
+            followers_count: page.instagram_business_account.followers_count,
+            follows_count: page.instagram_business_account.follows_count,
+            media_count: page.instagram_business_account.media_count
+          });
+        }
+      }
+      console.log(`   \u2705 Found ${instagramAccounts.length} Instagram account(s)`);
+      return instagramAccounts;
+    } catch (error) {
+      throw new APIError(
+        `Failed to fetch Instagram accounts: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "ACCOUNTS_FETCH_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Get Instagram media
+   */
+  async getMedia(instagramAccountId, limit = 25) {
+    try {
+      const response = await this.get(
+        `/${instagramAccountId}/media`,
+        {
+          fields: "id,media_type,media_url,thumbnail_url,permalink,caption,timestamp,like_count,comments_count",
+          limit
+        }
+      );
+      return response.data;
+    } catch (error) {
+      throw new APIError(
+        `Failed to fetch Instagram media: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "MEDIA_FETCH_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Publish photo to Instagram (2-step process)
+   */
+  async publishPhoto(params) {
+    const { instagramAccountId, imageUrl, caption } = params;
+    if (!imageUrl) {
+      throw new APIError(
+        "Image URL is required for photo posts",
+        400,
+        "INVALID_PARAMS"
+      );
+    }
+    try {
+      const containerResponse = await this.post(
+        `/${instagramAccountId}/media`,
+        {
+          image_url: imageUrl,
+          caption: caption || ""
+        }
+      );
+      const publishResponse = await this.post(
+        `/${instagramAccountId}/media_publish`,
+        {
+          creation_id: containerResponse.id
+        }
+      );
+      return publishResponse;
+    } catch (error) {
+      throw new APIError(
+        `Failed to publish photo: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "PHOTO_PUBLISH_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Publish video to Instagram (2-step process)
+   */
+  async publishVideo(params) {
+    const { instagramAccountId, videoUrl, caption } = params;
+    if (!videoUrl) {
+      throw new APIError(
+        "Video URL is required for video posts",
+        400,
+        "INVALID_PARAMS"
+      );
+    }
+    try {
+      const containerResponse = await this.post(
+        `/${instagramAccountId}/media`,
+        {
+          media_type: "VIDEO",
+          video_url: videoUrl,
+          caption: caption || ""
+        }
+      );
+      const publishResponse = await this.post(
+        `/${instagramAccountId}/media_publish`,
+        {
+          creation_id: containerResponse.id
+        }
+      );
+      return publishResponse;
+    } catch (error) {
+      throw new APIError(
+        `Failed to publish video: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "VIDEO_PUBLISH_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Delete Instagram media
+   */
+  async deleteMedia(mediaId) {
+    try {
+      const response = await this.delete(
+        `/${mediaId}`
+      );
+      return response.success === true;
+    } catch (error) {
+      throw new APIError(
+        `Failed to delete media: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "MEDIA_DELETE_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Get Instagram account insights
+   */
+  async getAccountInsights(instagramAccountId, params) {
+    try {
+      const { metric, period, metric_type, since, until } = params;
+      const response = await this.get(
+        `/${instagramAccountId}/insights`,
+        {
+          metric: metric.join(","),
+          period: period || "day",
+          metric_type: metric_type || "total_value",
+          ...since && { since },
+          ...until && { until }
+        }
+      );
+      return response;
+    } catch (error) {
+      throw new APIError(
+        `Failed to fetch insights: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "INSIGHTS_FETCH_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Get specific media insights
+   */
+  async getMediaInsights(mediaId, metrics) {
+    try {
+      const response = await this.get(
+        `/${mediaId}/insights`,
+        {
+          metric: metrics.join(",")
+        }
+      );
+      return response;
+    } catch (error) {
+      throw new APIError(
+        `Failed to fetch media insights: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "MEDIA_INSIGHTS_ERROR",
+        error
+      );
+    }
+  }
+  // ============= Enhanced Insights Methods =============
+  /**
+   * Get account insights with default metrics
+   * Uses updated metrics (views instead of impressions)
+   * @param instagramAccountId - Instagram Account ID
+   * @param period - Period for metrics
+   * @returns Account insights
+   */
+  async getAccountInsightsOverview(instagramAccountId, period = "days_28") {
+    return this.getAccountInsights(instagramAccountId, {
+      metric: [...METRIC_PRESETS.INSTAGRAM_OVERVIEW],
+      period,
+      metric_type: "total_value"
+    });
+  }
+  /**
+   * Get account summary with parsed values
+   * @param instagramAccountId - Instagram Account ID
+   * @param period - Period for metrics
+   * @returns Parsed account summary
+   */
+  async getAccountSummary(instagramAccountId, period = "days_28") {
+    try {
+      const account = await this.get(`/${instagramAccountId}`, {
+        fields: "id,username,followers_count"
+      });
+      const insights = await this.getAccountInsightsOverview(instagramAccountId, period);
+      const summary = {
+        id: account.id,
+        username: account.username,
+        followers_count: account.followers_count || 0
+      };
+      for (const item of insights.data) {
+        const value = item.total_value?.value ?? item.values?.[0]?.value;
+        if (typeof value !== "number") continue;
+        switch (item.name) {
+          case "views":
+            summary.views = value;
+            break;
+          case "reach":
+            summary.reach = value;
+            break;
+          case "accounts_engaged":
+            summary.accounts_engaged = value;
+            break;
+          case "total_interactions":
+            summary.total_interactions = value;
+            break;
+        }
+      }
+      return summary;
+    } catch (error) {
+      throw new APIError(
+        `Failed to fetch account summary: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "ACCOUNT_SUMMARY_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Get media insights based on media type
+   * Automatically selects appropriate metrics
+   * @param mediaId - Media ID
+   * @param mediaType - Type of media
+   * @returns Media insights
+   */
+  async getMediaInsightsByType(mediaId, mediaType) {
+    let metrics;
+    switch (mediaType) {
+      case "REELS":
+        metrics = INSTAGRAM_REELS_METRICS;
+        break;
+      case "VIDEO":
+        metrics = [...INSTAGRAM_MEDIA_METRICS_COMMON, "plays"];
+        break;
+      default:
+        metrics = INSTAGRAM_MEDIA_METRICS_COMMON;
+    }
+    return this.getMediaInsights(mediaId, [...metrics]);
+  }
+  /**
+   * Get media insights with parsed values
+   * @param mediaId - Media ID
+   * @param mediaType - Type of media
+   * @returns Parsed media insights
+   */
+  async getMediaInsightsParsed(mediaId, mediaType = "IMAGE") {
+    try {
+      const response = await this.getMediaInsightsByType(mediaId, mediaType);
+      const insights = {
+        id: mediaId,
+        media_type: mediaType
+      };
+      for (const item of response.data) {
+        const value = item.total_value?.value ?? item.values?.[0]?.value;
+        if (typeof value !== "number") continue;
+        switch (item.name) {
+          case "views":
+            insights.views = value;
+            break;
+          case "reach":
+            insights.reach = value;
+            break;
+          case "likes":
+            insights.likes = value;
+            break;
+          case "comments":
+            insights.comments = value;
+            break;
+          case "shares":
+            insights.shares = value;
+            break;
+          case "saved":
+            insights.saves = value;
+            break;
+          case "plays":
+            insights.plays = value;
+            break;
+          case "total_interactions":
+            insights.total_interactions = value;
+            break;
+        }
+      }
+      return insights;
+    } catch (error) {
+      throw new APIError(
+        `Failed to fetch parsed media insights: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "MEDIA_INSIGHTS_PARSED_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Get story insights
+   * @param storyId - Story media ID
+   * @returns Story insights
+   */
+  async getStoryInsights(storyId) {
+    return this.getMediaInsights(storyId, [...INSTAGRAM_STORIES_METRICS]);
+  }
+  /**
+   * Get reels insights
+   * @param reelId - Reel media ID
+   * @returns Reel insights
+   */
+  async getReelInsights(reelId) {
+    return this.getMediaInsights(reelId, [...INSTAGRAM_REELS_METRICS]);
+  }
+  /**
+   * Get engagement metrics for account
+   * @param instagramAccountId - Instagram Account ID
+   * @param period - Period for metrics
+   * @returns Engagement insights
+   */
+  async getEngagementInsights(instagramAccountId, period = "days_28") {
+    return this.getAccountInsights(instagramAccountId, {
+      metric: [...METRIC_PRESETS.INSTAGRAM_ENGAGEMENT],
+      period,
+      metric_type: "total_value"
+    });
+  }
+  /**
+   * Get demographics insights for account
+   * @param instagramAccountId - Instagram Account ID
+   * @param breakdown - Demographic breakdown type
+   * @returns Demographics insights
+   */
+  async getDemographicsInsights(instagramAccountId, breakdown = "country") {
+    try {
+      const response = await this.get(
+        `/${instagramAccountId}/insights`,
+        {
+          metric: "follower_demographics",
+          period: "lifetime",
+          metric_type: "total_value",
+          breakdown
+        }
+      );
+      return response;
+    } catch (error) {
+      throw new APIError(
+        `Failed to fetch demographics insights: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "DEMOGRAPHICS_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Get current API version (read-only)
+   */
+  getApiVersion() {
+    return FACEBOOK_GRAPH_API_VERSION;
+  }
+};
+
+// providers/instagram/InstagramProvider.ts
+var InstagramProvider = class {
+  constructor(config) {
+    this.name = "instagram";
+    this.config = config;
+    this.auth = new InstagramAuth(config);
+    this.api = new InstagramAPI(config);
+  }
+  /**
+   * Create new API instance with access token
+   */
+  createAPIClient(accessToken) {
+    return new InstagramAPI(this.config, accessToken);
+  }
+  /**
+   * Update access token of existing API client
+   */
+  setAccessToken(accessToken) {
+    this.api.setAccessToken(accessToken);
+  }
+  /**
+   * Get current access token
+   */
+  getAccessToken() {
+    return this.api.getAccessToken();
+  }
+};
+
+// providers/instagram/types/index.ts
+var InstagramScopes = /* @__PURE__ */ ((InstagramScopes2) => {
+  InstagramScopes2["BASIC"] = "instagram_basic";
+  InstagramScopes2["CONTENT_PUBLISH"] = "instagram_content_publish";
+  InstagramScopes2["MANAGE_COMMENTS"] = "instagram_manage_comments";
+  InstagramScopes2["MANAGE_INSIGHTS"] = "instagram_manage_insights";
+  InstagramScopes2["MANAGE_MESSAGES"] = "instagram_manage_messages";
+  InstagramScopes2["SHOPPING_TAG_PRODUCTS"] = "instagram_shopping_tag_products";
+  return InstagramScopes2;
+})(InstagramScopes || {});
+
+// providers/tiktok/constants.ts
+var TIKTOK_API_VERSION = "v2";
+var TIKTOK_API_BASE_URL = `https://open.tiktokapis.com/${TIKTOK_API_VERSION}`;
+var TIKTOK_OAUTH_AUTHORIZATION_URL = "https://www.tiktok.com/v2/auth/authorize/";
+var TIKTOK_OAUTH_TOKEN_URL = "https://open.tiktokapis.com/v2/oauth/token/";
+var TIKTOK_OAUTH_REVOKE_URL = "https://open.tiktokapis.com/v2/oauth/revoke/";
+var TikTokScopes = {
+  // User info scopes
+  USER_INFO_BASIC: "user.info.basic",
+  USER_INFO_PROFILE: "user.info.profile",
+  USER_INFO_STATS: "user.info.stats",
+  // Video scopes
+  VIDEO_LIST: "video.list",
+  VIDEO_PUBLISH: "video.publish",
+  VIDEO_UPLOAD: "video.upload"
+};
+var TIKTOK_DEFAULT_SCOPES = [
+  TikTokScopes.USER_INFO_BASIC,
+  TikTokScopes.USER_INFO_PROFILE,
+  TikTokScopes.USER_INFO_STATS,
+  TikTokScopes.VIDEO_LIST,
+  TikTokScopes.VIDEO_PUBLISH,
+  TikTokScopes.VIDEO_UPLOAD
+];
+
+// providers/tiktok/api/index.ts
+var TikTokAPI = class {
+  constructor(config, accessToken) {
+    this._config = config;
+    this.accessToken = accessToken;
+  }
+  /**
+   * Set access token
+   */
+  setAccessToken(accessToken) {
+    this.accessToken = accessToken;
+  }
+  /**
+   * Get current access token
+   */
+  getAccessToken() {
+    return this.accessToken;
+  }
+  /**
+   * Make authenticated API request
+   */
+  async request(endpoint, options = {}) {
+    if (!this.accessToken) {
+      throw new Error("Access token is required");
+    }
+    const url = `${TIKTOK_API_BASE_URL}${endpoint}`;
+    const response = await fetch(url, {
+      ...options,
+      headers: {
+        "Authorization": `Bearer ${this.accessToken}`,
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+    const data = await response.json();
+    if (data.error && data.error.code !== "ok") {
+      throw new Error(data.error.message || "TikTok API error");
+    }
+    return data;
+  }
+  /**
+   * Get user info
+   * @see https://developers.tiktok.com/doc/tiktok-api-v2-get-user-info
+   */
+  async getUserInfo(fields) {
+    const defaultFields = [
+      "open_id",
+      "union_id",
+      "avatar_url",
+      "avatar_url_100",
+      "avatar_large_url",
+      "display_name",
+      "bio_description",
+      "profile_deep_link",
+      "is_verified",
+      "follower_count",
+      "following_count",
+      "likes_count",
+      "video_count"
+    ];
+    const params = new URLSearchParams({
+      fields: (fields || defaultFields).join(",")
+    });
+    const response = await this.request(
+      `/user/info/?${params.toString()}`
+    );
+    return response.data.user;
+  }
+  /**
+   * Get user's videos
+   * @see https://developers.tiktok.com/doc/tiktok-api-v2-video-list
+   */
+  async getVideoList(options) {
+    const defaultFields = [
+      "id",
+      "create_time",
+      "cover_image_url",
+      "share_url",
+      "video_description",
+      "duration",
+      "height",
+      "width",
+      "title",
+      "embed_html",
+      "embed_link",
+      "like_count",
+      "comment_count",
+      "share_count",
+      "view_count"
+    ];
+    const body = {
+      max_count: options?.maxCount || 20,
+      cursor: options?.cursor,
+      fields: options?.fields || defaultFields
+    };
+    const response = await this.request("/video/list/", {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+    return response.data;
+  }
+  /**
+   * Initialize direct video upload
+   * @see https://developers.tiktok.com/doc/tiktok-api-v2-post-publish-video-init
+   */
+  async initVideoUpload(options) {
+    const response = await this.request(
+      "/post/publish/video/init/",
+      {
+        method: "POST",
+        body: JSON.stringify({
+          source_info: options.sourceInfo,
+          post_info: options.postInfo
+        })
+      }
+    );
+    return response.data;
+  }
+  /**
+   * Get publish status
+   * @see https://developers.tiktok.com/doc/tiktok-api-v2-post-publish-status-fetch
+   */
+  async getPublishStatus(publishId) {
+    const response = await this.request(
+      "/post/publish/status/fetch/",
+      {
+        method: "POST",
+        body: JSON.stringify({ publish_id: publishId })
+      }
+    );
+    return response.data;
+  }
+  /**
+   * Get account insights (aggregated from user info and recent videos)
+   * TikTok doesn't have a dedicated insights API like Instagram/Facebook,
+   * so we compute metrics from user info and video stats
+   */
+  async getAccountInsights() {
+    const userInfo = await this.getUserInfo();
+    const videoList = await this.getVideoList({ maxCount: 50 });
+    let totalViews = 0;
+    let totalLikes = 0;
+    let totalComments = 0;
+    let totalShares = 0;
+    for (const video of videoList.videos) {
+      totalViews += video.view_count || 0;
+      totalLikes += video.like_count || 0;
+      totalComments += video.comment_count || 0;
+      totalShares += video.share_count || 0;
+    }
+    const totalEngagements = totalLikes + totalComments + totalShares;
+    const averageEngagementRate = totalViews > 0 ? totalEngagements / totalViews * 100 : 0;
+    return {
+      followerCount: userInfo.follower_count || 0,
+      followingCount: userInfo.following_count || 0,
+      likesCount: userInfo.likes_count || 0,
+      videoCount: userInfo.video_count || 0,
+      totalViews,
+      totalComments,
+      totalShares,
+      averageEngagementRate: Math.round(averageEngagementRate * 100) / 100
+      // Round to 2 decimals
+    };
+  }
+  /**
+   * Get insights for a specific video
+   */
+  async getVideoInsights(videoId) {
+    const videoList = await this.getVideoList({ maxCount: 50 });
+    const video = videoList.videos.find((v) => v.id === videoId);
+    if (!video) {
+      return null;
+    }
+    const viewCount = video.view_count || 0;
+    const likeCount = video.like_count || 0;
+    const commentCount = video.comment_count || 0;
+    const shareCount = video.share_count || 0;
+    const engagementRate = viewCount > 0 ? (likeCount + commentCount + shareCount) / viewCount * 100 : 0;
+    return {
+      videoId: video.id,
+      viewCount,
+      likeCount,
+      commentCount,
+      shareCount,
+      engagementRate: Math.round(engagementRate * 100) / 100,
+      createTime: video.create_time
+    };
+  }
+  /**
+   * Get insights for multiple videos
+   */
+  async getVideosInsights(maxCount = 20) {
+    const videoList = await this.getVideoList({ maxCount });
+    return videoList.videos.map((video) => {
+      const viewCount = video.view_count || 0;
+      const likeCount = video.like_count || 0;
+      const commentCount = video.comment_count || 0;
+      const shareCount = video.share_count || 0;
+      const engagementRate = viewCount > 0 ? (likeCount + commentCount + shareCount) / viewCount * 100 : 0;
+      return {
+        videoId: video.id,
+        viewCount,
+        likeCount,
+        commentCount,
+        shareCount,
+        engagementRate: Math.round(engagementRate * 100) / 100,
+        createTime: video.create_time
+      };
+    });
+  }
+  /**
+   * Get formatted insights (unified format similar to Instagram/Facebook)
+   * This allows for easier aggregation across platforms
+   */
+  async getInsights(params) {
+    const accountInsights = await this.getAccountInsights();
+    const now = /* @__PURE__ */ new Date();
+    const endTime = now.toISOString();
+    const metricsMap = {
+      followers: accountInsights.followerCount,
+      following: accountInsights.followingCount,
+      likes: accountInsights.likesCount,
+      video_count: accountInsights.videoCount,
+      views: accountInsights.totalViews,
+      comments: accountInsights.totalComments,
+      shares: accountInsights.totalShares,
+      engagement_rate: accountInsights.averageEngagementRate
+    };
+    const data = params.metric.map((metricName) => ({
+      name: metricName,
+      period: "lifetime",
+      values: [{
+        value: metricsMap[metricName] || 0,
+        end_time: endTime
+      }],
+      title: metricName.charAt(0).toUpperCase() + metricName.slice(1).replace(/_/g, " ")
+    }));
+    return { data };
+  }
+};
+
+// providers/tiktok/auth/index.ts
+var TikTokAuth = class {
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Build authorization URL for OAuth flow
+   */
+  getAuthorizationUrl(options) {
+    const params = new URLSearchParams({
+      client_key: this.config.clientKey,
+      redirect_uri: options?.redirectUri || this.config.redirectUri || "",
+      response_type: "code",
+      scope: (options?.scopes || this.config.scopes || TIKTOK_DEFAULT_SCOPES).join(",")
+    });
+    if (options?.state) {
+      params.set("state", options.state);
+    }
+    return `${TIKTOK_OAUTH_AUTHORIZATION_URL}?${params.toString()}`;
+  }
+  /**
+   * Exchange authorization code for access token
+   * NOTE: This should be done server-side to protect client_secret
+   */
+  async exchangeCodeForToken(code, redirectUri) {
+    if (!this.config.clientSecret) {
+      throw new Error("Client secret is required for token exchange");
+    }
+    const response = await fetch(TIKTOK_OAUTH_TOKEN_URL, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: new URLSearchParams({
+        client_key: this.config.clientKey,
+        client_secret: this.config.clientSecret,
+        code,
+        grant_type: "authorization_code",
+        redirect_uri: redirectUri || this.config.redirectUri || ""
+      }).toString()
+    });
+    if (!response.ok) {
+      const error = await response.json();
+      throw new Error(error.error?.message || "Failed to exchange code for token");
+    }
+    return response.json();
+  }
+  /**
+   * Refresh access token using refresh token
+   * NOTE: This should be done server-side to protect client_secret
+   */
+  async refreshToken(refreshToken) {
+    if (!this.config.clientSecret) {
+      throw new Error("Client secret is required for token refresh");
+    }
+    const response = await fetch(TIKTOK_OAUTH_TOKEN_URL, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: new URLSearchParams({
+        client_key: this.config.clientKey,
+        client_secret: this.config.clientSecret,
+        grant_type: "refresh_token",
+        refresh_token: refreshToken
+      }).toString()
+    });
+    if (!response.ok) {
+      const error = await response.json();
+      throw new Error(error.error?.message || "Failed to refresh token");
+    }
+    return response.json();
+  }
+  /**
+   * Revoke access token
+   */
+  async revokeToken(accessToken) {
+    const response = await fetch(TIKTOK_OAUTH_REVOKE_URL, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: new URLSearchParams({
+        client_key: this.config.clientKey,
+        token: accessToken
+      }).toString()
+    });
+    if (!response.ok) {
+      const error = await response.json();
+      throw new Error(error.error?.message || "Failed to revoke token");
+    }
+  }
+};
+
+// providers/tiktok/TikTokProvider.ts
+var TikTokProvider = class {
+  constructor(config) {
+    this.name = "tiktok";
+    this.config = config;
+    this.auth = new TikTokAuth(config);
+    this.api = new TikTokAPI(config);
+  }
+  /**
+   * Create new API instance with access token
+   */
+  createAPIClient(accessToken) {
+    return new TikTokAPI(this.config, accessToken);
+  }
+  /**
+   * Update access token of existing API client
+   */
+  setAccessToken(accessToken) {
+    this.api.setAccessToken(accessToken);
+  }
+  /**
+   * Get current access token
+   */
+  getAccessToken() {
+    return this.api.getAccessToken();
+  }
+};
+
+exports.APIError = APIError;
+exports.AuthError = AuthError;
+exports.BaseError = BaseError;
+exports.FACEBOOK_GRAPH_API_BASE_URL = FACEBOOK_GRAPH_API_BASE_URL;
+exports.FACEBOOK_GRAPH_API_VERSION = FACEBOOK_GRAPH_API_VERSION;
+exports.FACEBOOK_OAUTH_AUTHORIZATION_URL = FACEBOOK_OAUTH_AUTHORIZATION_URL;
+exports.FacebookAPI = FacebookAPI;
+exports.FacebookAuth = FacebookAuth;
+exports.FacebookProvider = FacebookProvider;
+exports.FacebookScopesBusiness = FacebookScopesBusiness;
+exports.FacebookScopesUser = FacebookScopesUser;
+exports.HttpClient = HttpClient;
+exports.INSIGHTS_PERIODS = INSIGHTS_PERIODS;
+exports.INSTAGRAM_ACCOUNT_METRICS = INSTAGRAM_ACCOUNT_METRICS;
+exports.INSTAGRAM_DEMOGRAPHICS_METRICS = INSTAGRAM_DEMOGRAPHICS_METRICS;
+exports.INSTAGRAM_MEDIA_METRICS_COMMON = INSTAGRAM_MEDIA_METRICS_COMMON;
+exports.INSTAGRAM_REELS_METRICS = INSTAGRAM_REELS_METRICS;
+exports.INSTAGRAM_STORIES_METRICS = INSTAGRAM_STORIES_METRICS;
+exports.InstagramAPI = InstagramAPI;
+exports.InstagramAuth = InstagramAuth;
+exports.InstagramProvider = InstagramProvider;
+exports.InstagramScopes = InstagramScopes;
+exports.METRIC_PRESETS = METRIC_PRESETS;
+exports.PAGE_METRICS_LIFETIME = PAGE_METRICS_LIFETIME;
+exports.PAGE_METRICS_PERIODIC = PAGE_METRICS_PERIODIC;
+exports.PHOTO_METRICS = PHOTO_METRICS;
+exports.POST_METRICS = POST_METRICS;
+exports.REELS_METRICS = REELS_METRICS;
+exports.REELS_METRICS_EXTENDED = REELS_METRICS_EXTENDED;
+exports.TIKTOK_API_BASE_URL = TIKTOK_API_BASE_URL;
+exports.TIKTOK_API_VERSION = TIKTOK_API_VERSION;
+exports.TIKTOK_DEFAULT_SCOPES = TIKTOK_DEFAULT_SCOPES;
+exports.TIKTOK_OAUTH_AUTHORIZATION_URL = TIKTOK_OAUTH_AUTHORIZATION_URL;
+exports.TIKTOK_OAUTH_REVOKE_URL = TIKTOK_OAUTH_REVOKE_URL;
+exports.TIKTOK_OAUTH_TOKEN_URL = TIKTOK_OAUTH_TOKEN_URL;
+exports.TikTokAPI = TikTokAPI;
+exports.TikTokAuth = TikTokAuth;
+exports.TikTokProvider = TikTokProvider;
+exports.TikTokScopes = TikTokScopes;
+exports.VIDEO_METRICS = VIDEO_METRICS;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map