@olastudio/social-media-sdk 0.1.0

package/dist/chunk-PJ4KYVHH.js

@@ -0,0 +1,854 @@
+'use strict';
+
+var chunkER5A6TIL_js = require('./chunk-ER5A6TIL.js');
+var chunkHPLIHYLQ_js = require('./chunk-HPLIHYLQ.js');
+
+// providers/facebook/api/FacebookAPI.ts
+var FacebookAPI = class {
+  constructor(config, accessToken) {
+    this.config = config;
+    this.accessToken = accessToken;
+    this.httpClient = new chunkER5A6TIL_js.HttpClient({
+      baseURL: chunkER5A6TIL_js.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 chunkHPLIHYLQ_js.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 chunkHPLIHYLQ_js.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 chunkHPLIHYLQ_js.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 chunkHPLIHYLQ_js.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 chunkHPLIHYLQ_js.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 chunkHPLIHYLQ_js.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 chunkHPLIHYLQ_js.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 chunkHPLIHYLQ_js.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 chunkHPLIHYLQ_js.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 chunkHPLIHYLQ_js.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 || chunkER5A6TIL_js.METRIC_PRESETS.VIDEO_PERFORMANCE;
+      const response = await this.get(
+        `/${videoId}/video_insights`,
+        {
+          metric: metricsToFetch.join(",")
+        }
+      );
+      return response;
+    } catch (error) {
+      throw new chunkHPLIHYLQ_js.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, [...chunkER5A6TIL_js.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 chunkHPLIHYLQ_js.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 chunkHPLIHYLQ_js.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 || chunkER5A6TIL_js.METRIC_PRESETS.REELS_PERFORMANCE;
+      const response = await this.get(
+        `/${reelId}/video_insights`,
+        {
+          metric: metricsToFetch.join(",")
+        }
+      );
+      return response;
+    } catch (error) {
+      throw new chunkHPLIHYLQ_js.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, [...chunkER5A6TIL_js.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 chunkHPLIHYLQ_js.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 chunkHPLIHYLQ_js.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 || [...chunkER5A6TIL_js.POST_METRICS];
+      const response = await this.get(
+        `/${postId}/insights`,
+        {
+          metric: metricsToFetch.join(",")
+        }
+      );
+      return response;
+    } catch (error) {
+      throw new chunkHPLIHYLQ_js.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 chunkHPLIHYLQ_js.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 chunkHPLIHYLQ_js.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 || [...chunkER5A6TIL_js.PHOTO_METRICS];
+      const response = await this.get(
+        `/${photoId}/insights`,
+        {
+          metric: metricsToFetch.join(",")
+        }
+      );
+      return response;
+    } catch (error) {
+      throw new chunkHPLIHYLQ_js.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 chunkHPLIHYLQ_js.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 chunkHPLIHYLQ_js.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: [...chunkER5A6TIL_js.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 chunkHPLIHYLQ_js.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 chunkER5A6TIL_js.FACEBOOK_GRAPH_API_VERSION;
+  }
+};
+
+// providers/facebook/auth/FacebookAuth.ts
+var FacebookAuth = class {
+  constructor(config) {
+    this.config = config;
+    this.httpClient = new chunkER5A6TIL_js.HttpClient({
+      baseURL: chunkER5A6TIL_js.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 chunkHPLIHYLQ_js.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 chunkHPLIHYLQ_js.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 chunkHPLIHYLQ_js.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: chunkER5A6TIL_js.FACEBOOK_OAUTH_AUTHORIZATION_URL,
+      tokenEndpoint: `${chunkER5A6TIL_js.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 `${chunkER5A6TIL_js.FACEBOOK_OAUTH_AUTHORIZATION_URL}?${params.toString()}`;
+  }
+  /**
+   * Get current API version (read-only)
+   */
+  getApiVersion() {
+    return chunkER5A6TIL_js.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 || {});
+
+exports.FacebookAPI = FacebookAPI;
+exports.FacebookAuth = FacebookAuth;
+exports.FacebookProvider = FacebookProvider;
+exports.FacebookScopesBusiness = FacebookScopesBusiness;
+exports.FacebookScopesUser = FacebookScopesUser;
+//# sourceMappingURL=chunk-PJ4KYVHH.js.map
+//# sourceMappingURL=chunk-PJ4KYVHH.js.map