@olastudio/social-media-sdk 0.1.0 → 0.1.1

package/dist/providers/instagram/index.mjs

@@ -1,5 +1,865 @@
-export { InstagramAPI, InstagramAuth, InstagramProvider, InstagramScopes } from '../../chunk-QZHJXRRW.mjs';
-import '../../chunk-H5GAC4UG.mjs';
-import '../../chunk-36RADUUO.mjs';
+// 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/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 };
+  }
+};
+
+// 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;
+  }
+};
+
+// core/insights.constants.ts
+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 METRIC_PRESETS = {
+  // Instagram account overview
+  INSTAGRAM_OVERVIEW: ["views", "reach", "accounts_engaged", "total_interactions"],
+  // Instagram content engagement
+  INSTAGRAM_ENGAGEMENT: ["likes", "comments", "shares", "saves"]
+};
+
+// 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 || {});
+
+export { InstagramAPI, InstagramAuth, InstagramProvider, InstagramScopes };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map