instagram-graph-api-sdk 1.0.0

package/dist/index.js

@@ -0,0 +1,1745 @@
+'use strict';
+
+var axios = require('axios');
+var crypto = require('crypto');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var axios__default = /*#__PURE__*/_interopDefault(axios);
+var crypto__default = /*#__PURE__*/_interopDefault(crypto);
+
+// src/http.ts
+
+// src/endpoints.ts
+var INSTAGRAM_BASE_URL = "https://graph.instagram.com";
+function buildUrl(version, path) {
+  return `${INSTAGRAM_BASE_URL}/${version}${path}`;
+}
+var USER_ENDPOINTS = {
+  /** Get user profile: GET /{user-id} */
+  PROFILE: (userId) => `/${userId}`,
+  /** Get user media: GET /{user-id}/media */
+  MEDIA: (userId) => `/${userId}/media`,
+  /** Get user stories: GET /{user-id}/stories */
+  STORIES: (userId) => `/${userId}/stories`,
+  /** Get user insights: GET /{user-id}/insights */
+  INSIGHTS: (userId) => `/${userId}/insights`,
+  /** Get live media: GET /{user-id}/live_media */
+  LIVE_MEDIA: (userId) => `/${userId}/live_media`,
+  /** Get content publishing limit: GET /{user-id}/content_publishing_limit */
+  CONTENT_PUBLISHING_LIMIT: (userId) => `/${userId}/content_publishing_limit`,
+  /** Get business discovery: GET /{user-id}?fields=business_discovery.username(...) */
+  BUSINESS_DISCOVERY: (userId) => `/${userId}`,
+  /** Get mentioned media: GET /{user-id}/mentioned_media */
+  MENTIONED_MEDIA: (userId) => `/${userId}/mentioned_media`,
+  /** Get mentioned comment: GET /{user-id}/mentioned_comment */
+  MENTIONED_COMMENT: (userId) => `/${userId}/mentioned_comment`,
+  /** Get tags: GET /{user-id}/tags */
+  TAGS: (userId) => `/${userId}/tags`,
+  /** Get recently searched hashtags: GET /{user-id}/recently_searched_hashtags */
+  RECENTLY_SEARCHED_HASHTAGS: (userId) => `/${userId}/recently_searched_hashtags`,
+  /** Get available catalogs: GET /{user-id}/available_catalogs */
+  AVAILABLE_CATALOGS: (userId) => `/${userId}/available_catalogs`,
+  /** Search catalog products: GET /{user-id}/catalog_product_search */
+  CATALOG_PRODUCT_SEARCH: (userId) => `/${userId}/catalog_product_search`
+};
+var MEDIA_ENDPOINTS = {
+  /** Get media by ID: GET /{media-id} */
+  GET: (mediaId) => `/${mediaId}`,
+  /** Get media children (carousel): GET /{media-id}/children */
+  CHILDREN: (mediaId) => `/${mediaId}/children`,
+  /** Get media comments: GET /{media-id}/comments */
+  COMMENTS: (mediaId) => `/${mediaId}/comments`,
+  /** Get media insights: GET /{media-id}/insights */
+  INSIGHTS: (mediaId) => `/${mediaId}/insights`,
+  /** Get media collaborators: GET /{media-id}/collaborators */
+  COLLABORATORS: (mediaId) => `/${mediaId}/collaborators`,
+  /** Get product tags: GET /{media-id}/product_tags */
+  PRODUCT_TAGS: (mediaId) => `/${mediaId}/product_tags`
+};
+var PUBLISHING_ENDPOINTS = {
+  /** Create media container: POST /{user-id}/media */
+  CREATE_CONTAINER: (userId) => `/${userId}/media`,
+  /** Publish media: POST /{user-id}/media_publish */
+  PUBLISH: (userId) => `/${userId}/media_publish`,
+  /** Get container status: GET /{container-id} */
+  CONTAINER_STATUS: (containerId) => `/${containerId}`
+};
+var MESSAGING_ENDPOINTS = {
+  /** Send message: POST /{user-id}/messages */
+  SEND: (userId) => `/${userId}/messages`,
+  /** Get conversations: GET /{user-id}/conversations */
+  CONVERSATIONS: (userId) => `/${userId}/conversations`,
+  /** Get conversation by ID: GET /{conversation-id} */
+  CONVERSATION: (conversationId) => `/${conversationId}`,
+  /** Get message by ID: GET /{message-id} */
+  MESSAGE: (messageId) => `/${messageId}`
+};
+var WELCOME_FLOW_ENDPOINTS = {
+  /** Get/Create/Update flows: /{user-id}/welcome_message_flows */
+  FLOWS: (userId) => `/${userId}/welcome_message_flows`
+};
+var MESSENGER_PROFILE_ENDPOINTS = {
+  /** Get/Set/Delete profile: /{user-id}/messenger_profile */
+  PROFILE: (userId) => `/${userId}/messenger_profile`
+};
+var COMMENT_ENDPOINTS = {
+  /** Get comment: GET /{comment-id} */
+  GET: (commentId) => `/${commentId}`,
+  /** Get replies: GET /{comment-id}/replies */
+  REPLIES: (commentId) => `/${commentId}/replies`,
+  /** Reply to comment: POST /{comment-id}/replies */
+  REPLY: (commentId) => `/${commentId}/replies`,
+  /** Hide/Unhide comment: POST /{comment-id} */
+  UPDATE: (commentId) => `/${commentId}`,
+  /** Delete comment: DELETE /{comment-id} */
+  DELETE: (commentId) => `/${commentId}`
+};
+var HASHTAG_ENDPOINTS = {
+  /** Search hashtag: GET /ig_hashtag_search */
+  SEARCH: "/ig_hashtag_search",
+  /** Get hashtag: GET /{hashtag-id} */
+  GET: (hashtagId) => `/${hashtagId}`,
+  /** Get recent media: GET /{hashtag-id}/recent_media */
+  RECENT_MEDIA: (hashtagId) => `/${hashtagId}/recent_media`,
+  /** Get top media: GET /{hashtag-id}/top_media */
+  TOP_MEDIA: (hashtagId) => `/${hashtagId}/top_media`
+};
+var AUTH_ENDPOINTS = {
+  /** Get current user: GET /me */
+  ME: "/me",
+  /** Refresh token: GET /refresh_access_token */
+  REFRESH_TOKEN: "/refresh_access_token",
+  /** Exchange token: GET /access_token */
+  ACCESS_TOKEN: "/access_token"
+};
+var OAUTH_ENDPOINTS = {
+  /** Authorization URL - redirect users here to start OAuth flow */
+  AUTHORIZE: "https://www.instagram.com/oauth/authorize",
+  /** Short-lived token exchange: POST with form data */
+  TOKEN: "https://api.instagram.com/oauth/access_token",
+  /** Long-lived token exchange: GET with query params */
+  LONG_LIVED_TOKEN: "https://graph.instagram.com/access_token"
+};
+var OEMBED_ENDPOINTS = {
+  /** Get oEmbed: GET /instagram_oembed */
+  GET: "/instagram_oembed"
+};
+
+// src/errors.ts
+var InstagramAPIError = class _InstagramAPIError extends Error {
+  constructor(message, code, type, subcode, fbTraceId) {
+    super(message);
+    this.name = "InstagramAPIError";
+    this.code = code;
+    this.type = type;
+    this.subcode = subcode;
+    this.fbTraceId = fbTraceId;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _InstagramAPIError);
+    }
+  }
+  /**
+   * Create an InstagramAPIError from an API response
+   */
+  static fromResponse(response) {
+    const { error } = response;
+    if (error.code === 190) {
+      return new AuthenticationError(error.message, error.code, error.fbtrace_id);
+    }
+    if (error.code === 4 || error.code === 17 || error.code === 32) {
+      return new RateLimitError(error.message, error.code, error.fbtrace_id);
+    }
+    if (error.code === 100) {
+      return new ValidationError(error.message, error.code, error.error_subcode, error.fbtrace_id);
+    }
+    return new _InstagramAPIError(
+      error.message,
+      error.code,
+      error.type,
+      error.error_subcode,
+      error.fbtrace_id
+    );
+  }
+};
+var AuthenticationError = class extends InstagramAPIError {
+  constructor(message, code = 190, fbTraceId) {
+    super(message, code, "OAuthException", void 0, fbTraceId);
+    this.name = "AuthenticationError";
+  }
+};
+var RateLimitError = class extends InstagramAPIError {
+  constructor(message, code = 4, fbTraceId, retryAfter) {
+    super(message, code, "RateLimitException", void 0, fbTraceId);
+    this.name = "RateLimitError";
+    this.retryAfter = retryAfter;
+  }
+};
+var ValidationError = class extends InstagramAPIError {
+  constructor(message, code = 100, subcode, fbTraceId) {
+    super(message, code, "ValidationException", subcode, fbTraceId);
+    this.name = "ValidationError";
+  }
+};
+var NetworkError = class _NetworkError extends Error {
+  constructor(message, originalError) {
+    super(message);
+    this.name = "NetworkError";
+    this.originalError = originalError;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _NetworkError);
+    }
+  }
+};
+function isInstagramAPIError(error) {
+  return error instanceof InstagramAPIError;
+}
+function isAuthenticationError(error) {
+  return error instanceof AuthenticationError;
+}
+function isRateLimitError(error) {
+  return error instanceof RateLimitError;
+}
+function isValidationError(error) {
+  return error instanceof ValidationError;
+}
+
+// src/http.ts
+var HttpClient = class {
+  constructor(config) {
+    this.config = config;
+    this.client = axios__default.default.create({
+      baseURL: `${INSTAGRAM_BASE_URL}/${config.apiVersion}`,
+      timeout: config.timeout ?? 3e4,
+      headers: {
+        "Content-Type": "application/json",
+        ...config.headers
+      }
+    });
+    this.setupInterceptors();
+  }
+  /**
+   * Set up request and response interceptors
+   */
+  setupInterceptors() {
+    this.client.interceptors.request.use(
+      (config) => {
+        if (config.params) {
+          config.params.access_token = this.config.accessToken;
+        } else {
+          config.params = { access_token: this.config.accessToken };
+        }
+        return config;
+      },
+      (error) => Promise.reject(error)
+    );
+    this.client.interceptors.response.use(
+      (response) => response,
+      (error) => {
+        if (!error.response) {
+          throw new NetworkError(
+            error.message || "Network error occurred",
+            error
+          );
+        }
+        const response = error.response;
+        if (response.data?.error) {
+          throw InstagramAPIError.fromResponse(response.data);
+        }
+        if (response.status === 429) {
+          const retryAfter = parseInt(response.headers["retry-after"] || "60", 10);
+          throw new RateLimitError(
+            "Rate limit exceeded",
+            4,
+            response.headers["x-fb-trace-id"],
+            retryAfter
+          );
+        }
+        throw new InstagramAPIError(
+          response.data?.message || "Unknown error occurred",
+          response.status,
+          "UnknownError"
+        );
+      }
+    );
+  }
+  /**
+   * Update access token
+   */
+  setAccessToken(accessToken) {
+    this.config.accessToken = accessToken;
+  }
+  /**
+   * GET request
+   */
+  async get(path, params, config) {
+    const response = await this.client.get(path, {
+      ...config,
+      params: { ...params }
+    });
+    return response.data;
+  }
+  /**
+   * POST request
+   */
+  async post(path, data, params, config) {
+    const response = await this.client.post(path, data, {
+      ...config,
+      params: { ...params }
+    });
+    return response.data;
+  }
+  /**
+   * DELETE request
+   */
+  async delete(path, params, config) {
+    const response = await this.client.delete(path, {
+      ...config,
+      params: { ...params }
+    });
+    return response.data;
+  }
+  /**
+   * POST with form data (for file uploads)
+   */
+  async postForm(path, data, config) {
+    const formData = new URLSearchParams();
+    Object.entries(data).forEach(([key, value]) => {
+      if (value !== void 0 && value !== null) {
+        formData.append(key, String(value));
+      }
+    });
+    const response = await this.client.post(path, formData, {
+      ...config,
+      headers: {
+        ...config?.headers,
+        "Content-Type": "application/x-www-form-urlencoded"
+      }
+    });
+    return response.data;
+  }
+};
+
+// src/api/auth.ts
+var AuthApi = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Get current user information
+   * @param fields - Fields to retrieve
+   */
+  async me(fields = "id,username") {
+    return this.http.get(AUTH_ENDPOINTS.ME, { fields });
+  }
+  /**
+   * Refresh a long-lived token (Instagram Login)
+   * Returns a new long-lived token with 60 days expiry
+   */
+  async refreshToken() {
+    return this.http.get(
+      AUTH_ENDPOINTS.REFRESH_TOKEN,
+      { grant_type: "ig_refresh_token" }
+    );
+  }
+  /**
+   * Exchange short-lived token for long-lived token (Instagram Login)
+   * @param shortLivedToken - Short-lived access token (1 hour expiry)
+   * @param appSecret - Instagram App Secret
+   */
+  async exchangeToken(shortLivedToken, appSecret) {
+    return this.http.get(
+      AUTH_ENDPOINTS.ACCESS_TOKEN,
+      {
+        grant_type: "ig_exchange_token",
+        client_secret: appSecret,
+        access_token: shortLivedToken
+      }
+    );
+  }
+};
+
+// src/api/oauth.ts
+var InstagramOAuth = class {
+  /**
+   * Build the Instagram authorization URL
+   * 
+   * Direct users to this URL to start the OAuth flow.
+   * They will be asked to grant permissions to your app.
+   * 
+   * @param params - Authorization URL parameters
+   * @returns Full authorization URL to redirect user to
+   * 
+   * @example
+   * ```typescript
+   * const url = InstagramOAuth.buildAuthorizationUrl({
+   *   clientId: process.env.INSTAGRAM_APP_ID,
+   *   redirectUri: `${process.env.APP_URL}/api/instagram/callback`,
+   *   scopes: [
+   *     'instagram_business_basic',
+   *     'instagram_business_manage_messages',
+   *   ],
+   *   state: crypto.randomUUID(), // CSRF protection
+   * });
+   * 
+   * // Redirect user to url
+   * ```
+   */
+  static buildAuthorizationUrl(params) {
+    const {
+      clientId,
+      redirectUri,
+      scopes,
+      state,
+      responseType = "code",
+      forceReauth
+    } = params;
+    const queryParams = new URLSearchParams({
+      client_id: clientId,
+      redirect_uri: redirectUri,
+      scope: scopes.join(","),
+      response_type: responseType
+    });
+    if (state) {
+      queryParams.set("state", state);
+    }
+    if (forceReauth) {
+      queryParams.set("force_reauth", "true");
+    }
+    return `${OAUTH_ENDPOINTS.AUTHORIZE}?${queryParams.toString()}`;
+  }
+  /**
+   * Parse OAuth callback parameters from URL
+   * 
+   * Use this to extract code, state, and error info from the callback URL.
+   * 
+   * @param url - The callback URL (or just the search params)
+   * @returns Parsed callback parameters
+   * 
+   * @example
+   * ```typescript
+   * const params = InstagramOAuth.parseCallback(request.url);
+   * 
+   * if (params.error) {
+   *   // User denied access
+   *   console.log(params.error_description);
+   * } else {
+   *   // Exchange code for token
+   *   const tokens = await InstagramOAuth.exchangeCodeForToken({
+   *     code: params.code!,
+   *     ...
+   *   });
+   * }
+   * ```
+   */
+  static parseCallback(url) {
+    const urlObj = new URL(url, "https://placeholder.com");
+    const params = urlObj.searchParams;
+    let code = params.get("code") || void 0;
+    if (code) {
+      code = code.replace(/#_$/, "");
+    }
+    return {
+      code,
+      state: params.get("state") || void 0,
+      error: params.get("error") || void 0,
+      error_reason: params.get("error_reason") || void 0,
+      error_description: params.get("error_description") || void 0
+    };
+  }
+  /**
+   * Exchange authorization code for tokens
+   * 
+   * This is the recommended method - it handles the full flow:
+   * 1. Exchange code for short-lived token (1 hour)
+   * 2. Exchange short-lived for long-lived token (60 days)
+   * 
+   * @param params - Exchange parameters
+   * @returns Long-lived token response with user ID
+   * @throws Error if exchange fails
+   * 
+   * @example
+   * ```typescript
+   * const tokens = await InstagramOAuth.exchangeCodeForToken({
+   *   clientId: process.env.INSTAGRAM_APP_ID!,
+   *   clientSecret: process.env.INSTAGRAM_APP_SECRET!,
+   *   code: codeFromCallback,
+   *   redirectUri: `${process.env.APP_URL}/api/instagram/callback`,
+   * });
+   * 
+   * // Store tokens.access_token and tokens.user_id in your database
+   * // Token expires in tokens.expires_in seconds (~60 days)
+   * ```
+   */
+  static async exchangeCodeForToken(params) {
+    const shortLived = await this.getShortLivedToken(params);
+    const longLived = await this.getLongLivedToken({
+      clientSecret: params.clientSecret,
+      accessToken: shortLived.access_token
+    });
+    return {
+      access_token: longLived.access_token,
+      token_type: longLived.token_type,
+      expires_in: longLived.expires_in,
+      user_id: shortLived.user_id
+    };
+  }
+  /**
+   * Get short-lived token from authorization code
+   * 
+   * Use this if you need more control over the token exchange process.
+   * The short-lived token is valid for 1 hour.
+   * 
+   * @param params - Exchange parameters
+   * @returns Short-lived token response
+   * @throws Error if exchange fails
+   */
+  static async getShortLivedToken(params) {
+    const { clientId, clientSecret, code, redirectUri } = params;
+    const cleanCode = code.replace(/#_$/, "");
+    const formData = new FormData();
+    formData.append("client_id", clientId);
+    formData.append("client_secret", clientSecret);
+    formData.append("grant_type", "authorization_code");
+    formData.append("redirect_uri", redirectUri);
+    formData.append("code", cleanCode);
+    const response = await fetch(OAUTH_ENDPOINTS.TOKEN, {
+      method: "POST",
+      body: formData
+    });
+    const responseText = await response.text();
+    if (!response.ok) {
+      let error;
+      try {
+        error = JSON.parse(responseText);
+      } catch {
+        error = { error_message: responseText };
+      }
+      throw new Error(
+        error.error_message || error.error?.message || "Failed to exchange authorization code for token"
+      );
+    }
+    const data = JSON.parse(responseText);
+    if (data.data && Array.isArray(data.data) && data.data.length > 0) {
+      return {
+        access_token: data.data[0].access_token,
+        user_id: data.data[0].user_id,
+        permissions: data.data[0].permissions || ""
+      };
+    } else if (data.access_token) {
+      return {
+        access_token: data.access_token,
+        user_id: data.user_id,
+        permissions: data.permissions || ""
+      };
+    }
+    throw new Error("Unexpected token response format");
+  }
+  /**
+   * Exchange short-lived token for long-lived token
+   * 
+   * Long-lived tokens are valid for 60 days and can be refreshed.
+   * 
+   * @param params - Exchange parameters
+   * @returns Long-lived token response
+   * @throws Error if exchange fails
+   */
+  static async getLongLivedToken(params) {
+    const { clientSecret, accessToken } = params;
+    const queryParams = new URLSearchParams({
+      grant_type: "ig_exchange_token",
+      client_secret: clientSecret,
+      access_token: accessToken
+    });
+    const response = await fetch(
+      `${OAUTH_ENDPOINTS.LONG_LIVED_TOKEN}?${queryParams.toString()}`
+    );
+    const responseText = await response.text();
+    if (!response.ok) {
+      let error;
+      try {
+        error = JSON.parse(responseText);
+      } catch {
+        error = { error: { message: responseText } };
+      }
+      throw new Error(
+        error.error?.message || "Failed to exchange for long-lived token"
+      );
+    }
+    return JSON.parse(responseText);
+  }
+  /**
+   * Get the default scopes for Instagram Business Login
+   * 
+   * @returns Array of commonly used scopes
+   */
+  static getDefaultScopes() {
+    return [
+      "instagram_business_basic",
+      "instagram_business_manage_messages",
+      "instagram_business_manage_comments",
+      "instagram_business_content_publish"
+    ];
+  }
+  /**
+   * Get all available Instagram Business Login scopes
+   * 
+   * @returns Array of all available scopes
+   */
+  static getAllScopes() {
+    return [
+      "instagram_business_basic",
+      "instagram_business_manage_messages",
+      "instagram_business_manage_comments",
+      "instagram_business_content_publish",
+      "instagram_business_manage_insights"
+    ];
+  }
+};
+
+// src/types/common.ts
+function formatFields(fields) {
+  if (!fields) return void 0;
+  if (Array.isArray(fields)) return fields.join(",");
+  return fields;
+}
+
+// src/api/users.ts
+var UsersApi = class {
+  constructor(http, userId) {
+    this.http = http;
+    this.userId = userId;
+  }
+  /**
+   * Get user profile information
+   * @param options - Fields to retrieve
+   */
+  async getProfile(options) {
+    const fields = options?.fields?.join(",") || "id,username,account_type";
+    return this.http.get(USER_ENDPOINTS.PROFILE(this.userId), { fields });
+  }
+  /**
+   * Get user's media
+   * @param options - Pagination and fields options
+   */
+  async getMedia(options) {
+    return this.http.get(
+      USER_ENDPOINTS.MEDIA(this.userId),
+      {
+        fields: formatFields(options?.fields) || "id,caption,media_type,media_url,permalink,timestamp",
+        limit: options?.limit,
+        after: options?.after,
+        before: options?.before
+      }
+    );
+  }
+  /**
+   * Get user's stories
+   */
+  async getStories() {
+    return this.http.get(
+      USER_ENDPOINTS.STORIES(this.userId),
+      { fields: "id,media_type,media_url,timestamp" }
+    );
+  }
+  /**
+   * Get user's live media
+   */
+  async getLiveMedia() {
+    return this.http.get(
+      USER_ENDPOINTS.LIVE_MEDIA(this.userId),
+      { fields: "id,media_type,timestamp" }
+    );
+  }
+  /**
+   * Get content publishing limit (quota usage)
+   */
+  async getContentPublishingLimit() {
+    return this.http.get(
+      USER_ENDPOINTS.CONTENT_PUBLISHING_LIMIT(this.userId),
+      { fields: "quota_usage,config" }
+    );
+  }
+  /**
+   * Discover another business account by username
+   * @param options - Username and fields to retrieve
+   */
+  async getBusinessDiscovery(options) {
+    const fields = options.fields?.join(",") || "id,username,followers_count,media_count";
+    return this.http.get(
+      USER_ENDPOINTS.BUSINESS_DISCOVERY(this.userId),
+      {
+        fields: `business_discovery.username(${options.username}){${fields}}`
+      }
+    );
+  }
+  /**
+   * Get media where user is mentioned
+   */
+  async getMentionedMedia() {
+    return this.http.get(
+      USER_ENDPOINTS.MENTIONED_MEDIA(this.userId),
+      { fields: "id,caption,media_type,timestamp" }
+    );
+  }
+  /**
+   * Get comments where user is mentioned
+   */
+  async getMentionedComment() {
+    return this.http.get(
+      USER_ENDPOINTS.MENTIONED_COMMENT(this.userId),
+      { fields: "id,text,timestamp" }
+    );
+  }
+  /**
+   * Get media user is tagged in
+   */
+  async getTags() {
+    return this.http.get(
+      USER_ENDPOINTS.TAGS(this.userId),
+      { fields: "id,media_type,timestamp" }
+    );
+  }
+  /**
+   * Get recently searched hashtags
+   */
+  async getRecentlySearchedHashtags() {
+    return this.http.get(
+      USER_ENDPOINTS.RECENTLY_SEARCHED_HASHTAGS(this.userId)
+    );
+  }
+  /**
+   * Get available product catalogs
+   */
+  async getAvailableCatalogs() {
+    return this.http.get(
+      USER_ENDPOINTS.AVAILABLE_CATALOGS(this.userId)
+    );
+  }
+  /**
+   * Search products in a catalog
+   * @param catalogId - Catalog ID to search in
+   * @param query - Search query
+   */
+  async searchCatalogProducts(catalogId, query) {
+    return this.http.get(
+      USER_ENDPOINTS.CATALOG_PRODUCT_SEARCH(this.userId),
+      { catalog_id: catalogId, q: query }
+    );
+  }
+};
+
+// src/api/media.ts
+var MediaApi = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Get media by ID
+   * @param mediaId - Media ID
+   * @param options - Fields to retrieve
+   */
+  async get(mediaId, options) {
+    const fields = options?.fields?.join(",") || "id,caption,media_type,media_url,permalink,timestamp";
+    return this.http.get(MEDIA_ENDPOINTS.GET(mediaId), { fields });
+  }
+  /**
+   * Get carousel children
+   * @param mediaId - Carousel media ID
+   * @param options - Fields to retrieve
+   */
+  async getChildren(mediaId, options) {
+    const fields = formatFields(options?.fields) || "id,media_type,media_url";
+    return this.http.get(
+      MEDIA_ENDPOINTS.CHILDREN(mediaId),
+      { fields }
+    );
+  }
+  /**
+   * Get comments on media
+   * @param mediaId - Media ID
+   * @param options - Pagination and fields options
+   */
+  async getComments(mediaId, options) {
+    return this.http.get(
+      MEDIA_ENDPOINTS.COMMENTS(mediaId),
+      {
+        fields: formatFields(options?.fields) || "id,text,username,timestamp",
+        limit: options?.limit,
+        after: options?.after
+      }
+    );
+  }
+  /**
+   * Get media insights
+   * @param mediaId - Media ID
+   * @param options - Metrics to retrieve
+   */
+  async getInsights(mediaId, options) {
+    return this.http.get(
+      MEDIA_ENDPOINTS.INSIGHTS(mediaId),
+      { metric: options.metric.join(",") }
+    );
+  }
+  /**
+   * Get media collaborators
+   * @param mediaId - Media ID
+   */
+  async getCollaborators(mediaId) {
+    return this.http.get(
+      MEDIA_ENDPOINTS.COLLABORATORS(mediaId),
+      { fields: "id,username" }
+    );
+  }
+  /**
+   * Get product tags on media
+   * @param mediaId - Media ID
+   */
+  async getProductTags(mediaId) {
+    return this.http.get(
+      MEDIA_ENDPOINTS.PRODUCT_TAGS(mediaId)
+    );
+  }
+};
+
+// src/api/publishing.ts
+var PublishingApi = class {
+  constructor(http, userId) {
+    this.http = http;
+    this.userId = userId;
+  }
+  /**
+   * Create an image container
+   * @param options - Image URL and optional caption, location, tags
+   */
+  async createImageContainer(options) {
+    return this.http.post(
+      PUBLISHING_ENDPOINTS.CREATE_CONTAINER(this.userId),
+      {
+        image_url: options.image_url,
+        caption: options.caption,
+        location_id: options.location_id,
+        user_tags: options.user_tags ? JSON.stringify(options.user_tags) : void 0,
+        collaborators: options.collaborators?.join(","),
+        alt_text: options.alt_text,
+        is_carousel_item: options.is_carousel_item
+      }
+    );
+  }
+  /**
+   * Create a video/reel/story container
+   * @param options - Video URL, media type, and optional settings
+   */
+  async createVideoContainer(options) {
+    return this.http.post(
+      PUBLISHING_ENDPOINTS.CREATE_CONTAINER(this.userId),
+      {
+        video_url: options.video_url,
+        media_type: options.media_type,
+        caption: options.caption,
+        location_id: options.location_id,
+        user_tags: options.user_tags ? JSON.stringify(options.user_tags) : void 0,
+        collaborators: options.collaborators?.join(","),
+        share_to_feed: options.share_to_feed,
+        is_carousel_item: options.is_carousel_item,
+        cover_url: options.cover_url,
+        thumb_offset: options.thumb_offset,
+        audio_name: options.audio_name
+      }
+    );
+  }
+  /**
+   * Create a carousel container
+   * @param options - Child container IDs and optional caption
+   */
+  async createCarouselContainer(options) {
+    return this.http.post(
+      PUBLISHING_ENDPOINTS.CREATE_CONTAINER(this.userId),
+      {
+        media_type: "CAROUSEL",
+        children: options.children.join(","),
+        caption: options.caption,
+        location_id: options.location_id,
+        collaborators: options.collaborators?.join(",")
+      }
+    );
+  }
+  /**
+   * Create a resumable upload session
+   * @param options - Media type and settings
+   */
+  async createResumableUpload(options) {
+    return this.http.post(
+      PUBLISHING_ENDPOINTS.CREATE_CONTAINER(this.userId),
+      {
+        media_type: options.media_type,
+        upload_type: "resumable",
+        caption: options.caption,
+        location_id: options.location_id,
+        collaborators: options.collaborators?.join(",")
+      }
+    );
+  }
+  /**
+   * Get container status
+   * @param containerId - Container ID
+   */
+  async getContainerStatus(containerId) {
+    return this.http.get(
+      PUBLISHING_ENDPOINTS.CONTAINER_STATUS(containerId),
+      { fields: "id,status_code,status" }
+    );
+  }
+  /**
+   * Publish a container
+   * @param containerId - Container ID to publish
+   */
+  async publishContainer(containerId) {
+    return this.http.post(
+      PUBLISHING_ENDPOINTS.PUBLISH(this.userId),
+      { creation_id: containerId }
+    );
+  }
+  /**
+   * Wait for container to be ready, then publish
+   * @param containerId - Container ID
+   * @param maxAttempts - Maximum number of status checks (default: 30)
+   * @param intervalMs - Interval between checks in ms (default: 2000)
+   */
+  async waitAndPublish(containerId, maxAttempts = 30, intervalMs = 2e3) {
+    for (let i = 0; i < maxAttempts; i++) {
+      const status = await this.getContainerStatus(containerId);
+      if (status.status_code === "FINISHED") {
+        return this.publishContainer(containerId);
+      }
+      if (status.status_code === "ERROR" || status.status_code === "EXPIRED") {
+        throw new Error(`Container failed with status: ${status.status_code}`);
+      }
+      await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
+    throw new Error("Container did not become ready in time");
+  }
+};
+
+// src/api/messaging.ts
+var MessagingApi = class {
+  constructor(http, userId) {
+    this.http = http;
+    this.userId = userId;
+  }
+  /**
+   * Send a text message
+   * @param recipientId - Instagram-scoped user ID (IGSID)
+   * @param text - Message text
+   * @param options - Optional settings (humanAgent for 7-day window)
+   */
+  async sendText(recipientId, text, options) {
+    const payload = {
+      recipient: { id: recipientId },
+      message: { text }
+    };
+    if (options?.humanAgent) {
+      payload.messaging_type = "MESSAGE_TAG";
+      payload.tag = "HUMAN_AGENT";
+    }
+    return this.http.post(
+      MESSAGING_ENDPOINTS.SEND(this.userId),
+      payload
+    );
+  }
+  /**
+   * Send a media message (image, video, audio)
+   * @param recipientId - Instagram-scoped user ID
+   * @param options - Media type and URL
+   */
+  async sendMedia(recipientId, options) {
+    return this.http.post(
+      MESSAGING_ENDPOINTS.SEND(this.userId),
+      {
+        recipient: { id: recipientId },
+        message: {
+          attachment: {
+            type: options.type,
+            payload: { url: options.url }
+          }
+        }
+      }
+    );
+  }
+  /**
+   * Send a sticker (like_heart)
+   * @param recipientId - Instagram-scoped user ID
+   */
+  async sendLikeHeart(recipientId) {
+    return this.http.post(
+      MESSAGING_ENDPOINTS.SEND(this.userId),
+      {
+        recipient: { id: recipientId },
+        message: {
+          attachment: {
+            type: "like_heart"
+          }
+        }
+      }
+    );
+  }
+  /**
+   * Send a generic template
+   * @param recipientId - Instagram-scoped user ID
+   * @param options - Template elements
+   */
+  async sendGenericTemplate(recipientId, options) {
+    return this.http.post(
+      MESSAGING_ENDPOINTS.SEND(this.userId),
+      {
+        recipient: { id: recipientId },
+        message: {
+          attachment: {
+            type: "template",
+            payload: {
+              template_type: "generic",
+              elements: options.elements
+            }
+          }
+        }
+      }
+    );
+  }
+  /**
+   * Send a button template
+   * @param recipientId - Instagram-scoped user ID
+   * @param options - Text and buttons
+   */
+  async sendButtonTemplate(recipientId, options) {
+    return this.http.post(
+      MESSAGING_ENDPOINTS.SEND(this.userId),
+      {
+        recipient: { id: recipientId },
+        message: {
+          attachment: {
+            type: "template",
+            payload: {
+              template_type: "button",
+              text: options.text,
+              buttons: options.buttons
+            }
+          }
+        }
+      }
+    );
+  }
+  /**
+   * Send quick replies
+   * @param recipientId - Instagram-scoped user ID
+   * @param options - Text and quick reply options
+   */
+  async sendQuickReplies(recipientId, options) {
+    return this.http.post(
+      MESSAGING_ENDPOINTS.SEND(this.userId),
+      {
+        recipient: { id: recipientId },
+        message: {
+          text: options.text,
+          quick_replies: options.replies
+        }
+      }
+    );
+  }
+  /**
+   * Send a private reply to a comment
+   * @param commentId - Comment ID to reply to
+   * @param message - Message text
+   */
+  async sendPrivateReply(commentId, message) {
+    return this.http.post(
+      MESSAGING_ENDPOINTS.SEND(this.userId),
+      {
+        recipient: { comment_id: commentId },
+        message: { text: message }
+      }
+    );
+  }
+  /**
+   * Share a published post via message
+   * @param recipientId - Instagram-scoped user ID
+   * @param mediaId - Media ID of the post to share
+   */
+  async sendMediaShare(recipientId, mediaId) {
+    return this.http.post(
+      MESSAGING_ENDPOINTS.SEND(this.userId),
+      {
+        recipient: { id: recipientId },
+        message: {
+          attachment: {
+            type: "MEDIA_SHARE",
+            payload: { id: mediaId }
+          }
+        }
+      }
+    );
+  }
+  /**
+   * React to a message
+   * @param recipientId - Instagram-scoped user ID
+   * @param messageId - Message ID to react to
+   * @param reaction - Reaction type
+   */
+  async reactToMessage(recipientId, messageId, reaction) {
+    return this.http.post(
+      MESSAGING_ENDPOINTS.SEND(this.userId),
+      {
+        recipient: { id: recipientId },
+        sender_action: "react",
+        payload: {
+          message_id: messageId,
+          reaction
+        }
+      }
+    );
+  }
+  /**
+   * Remove reaction from a message
+   * @param recipientId - Instagram-scoped user ID
+   * @param messageId - Message ID to unreact from
+   */
+  async unreactToMessage(recipientId, messageId) {
+    return this.http.post(
+      MESSAGING_ENDPOINTS.SEND(this.userId),
+      {
+        recipient: { id: recipientId },
+        sender_action: "unreact",
+        payload: {
+          message_id: messageId
+        }
+      }
+    );
+  }
+  /**
+   * Send typing indicator
+   * @param recipientId - Instagram-scoped user ID
+   * @param typing - Whether to show typing (true) or stop (false)
+   */
+  async sendTypingIndicator(recipientId, typing = true) {
+    return this.http.post(
+      MESSAGING_ENDPOINTS.SEND(this.userId),
+      {
+        recipient: { id: recipientId },
+        sender_action: typing ? "typing_on" : "typing_off"
+      }
+    );
+  }
+};
+
+// src/api/conversations.ts
+var ConversationsApi = class {
+  constructor(http, userId) {
+    this.http = http;
+    this.userId = userId;
+  }
+  /**
+   * Get list of conversations
+   * @param options - Pagination and filter options
+   */
+  async list(options) {
+    return this.http.get(
+      MESSAGING_ENDPOINTS.CONVERSATIONS(this.userId),
+      {
+        platform: options?.platform || "instagram",
+        user_id: options?.user_id,
+        limit: options?.limit,
+        after: options?.after,
+        fields: "id,updated_time"
+      }
+    );
+  }
+  /**
+   * Find conversation with a specific user
+   * @param igsid - Instagram-scoped user ID
+   */
+  async findByUser(igsid) {
+    return this.http.get(
+      MESSAGING_ENDPOINTS.CONVERSATIONS(this.userId),
+      {
+        platform: "instagram",
+        user_id: igsid,
+        fields: "id,updated_time"
+      }
+    );
+  }
+  /**
+   * Get messages in a conversation
+   * @param conversationId - Conversation ID
+   * @param fields - Fields to retrieve (default: from,to)
+   */
+  async getMessages(conversationId, fields = "messages{id,created_time,from,to,message}") {
+    return this.http.get(
+      MESSAGING_ENDPOINTS.CONVERSATION(conversationId),
+      { fields }
+    );
+  }
+  /**
+   * Get a specific message
+   * @param messageId - Message ID
+   * @param fields - Fields to retrieve
+   */
+  async getMessage(messageId, fields = "id,created_time,from,to,message") {
+    return this.http.get(
+      MESSAGING_ENDPOINTS.MESSAGE(messageId),
+      { fields }
+    );
+  }
+};
+
+// src/api/comments.ts
+var CommentsApi = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Get comment by ID
+   * @param commentId - Comment ID
+   * @param fields - Fields to retrieve
+   */
+  async get(commentId, fields = ["id", "text", "username", "timestamp"]) {
+    return this.http.get(
+      COMMENT_ENDPOINTS.GET(commentId),
+      { fields: fields.join(",") }
+    );
+  }
+  /**
+   * Get replies to a comment
+   * @param commentId - Comment ID
+   * @param options - Pagination and fields options
+   */
+  async getReplies(commentId, options) {
+    return this.http.get(
+      COMMENT_ENDPOINTS.REPLIES(commentId),
+      {
+        fields: options?.fields?.join(",") || "id,text,username,timestamp",
+        limit: options?.limit,
+        after: options?.after
+      }
+    );
+  }
+  /**
+   * Reply to a comment
+   * @param commentId - Comment ID to reply to
+   * @param options - Reply message
+   */
+  async reply(commentId, options) {
+    return this.http.post(
+      COMMENT_ENDPOINTS.REPLY(commentId),
+      { message: options.message }
+    );
+  }
+  /**
+   * Hide a comment
+   * @param commentId - Comment ID
+   */
+  async hide(commentId) {
+    return this.http.post(
+      COMMENT_ENDPOINTS.UPDATE(commentId),
+      { hide: true }
+    );
+  }
+  /**
+   * Unhide a comment
+   * @param commentId - Comment ID
+   */
+  async unhide(commentId) {
+    return this.http.post(
+      COMMENT_ENDPOINTS.UPDATE(commentId),
+      { hide: false }
+    );
+  }
+  /**
+   * Delete a comment
+   * @param commentId - Comment ID
+   */
+  async delete(commentId) {
+    return this.http.delete(COMMENT_ENDPOINTS.DELETE(commentId));
+  }
+};
+
+// src/api/hashtags.ts
+var HashtagsApi = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Search for a hashtag
+   * @param options - User ID and search query
+   */
+  async search(options) {
+    return this.http.get(
+      HASHTAG_ENDPOINTS.SEARCH,
+      {
+        user_id: options.user_id,
+        q: options.q
+      }
+    );
+  }
+  /**
+   * Get hashtag information
+   * @param hashtagId - Hashtag ID
+   */
+  async get(hashtagId) {
+    return this.http.get(
+      HASHTAG_ENDPOINTS.GET(hashtagId),
+      { fields: "id,name" }
+    );
+  }
+  /**
+   * Get recent media with hashtag
+   * @param hashtagId - Hashtag ID
+   * @param options - User ID and pagination options
+   */
+  async getRecentMedia(hashtagId, options) {
+    return this.http.get(
+      HASHTAG_ENDPOINTS.RECENT_MEDIA(hashtagId),
+      {
+        user_id: options.user_id,
+        fields: options.fields?.join(",") || "id,caption,media_type,permalink",
+        limit: options.limit,
+        after: options.after
+      }
+    );
+  }
+  /**
+   * Get top media with hashtag
+   * @param hashtagId - Hashtag ID
+   * @param options - User ID and pagination options
+   */
+  async getTopMedia(hashtagId, options) {
+    return this.http.get(
+      HASHTAG_ENDPOINTS.TOP_MEDIA(hashtagId),
+      {
+        user_id: options.user_id,
+        fields: options.fields?.join(",") || "id,caption,media_type,permalink",
+        limit: options.limit,
+        after: options.after
+      }
+    );
+  }
+};
+
+// src/api/insights.ts
+var InsightsApi = class {
+  constructor(http, userId) {
+    this.http = http;
+    this.userId = userId;
+  }
+  /**
+   * Get account insights
+   * @param options - Metrics, period, and breakdown options
+   */
+  async getAccountInsights(options) {
+    return this.http.get(
+      USER_ENDPOINTS.INSIGHTS(this.userId),
+      {
+        metric: options.metric.join(","),
+        period: options.period || "day",
+        since: options.since,
+        until: options.until,
+        metric_type: options.metric_type,
+        breakdown: options.breakdown
+      }
+    );
+  }
+  /**
+   * Get media insights
+   * @param mediaId - Media ID
+   * @param options - Metrics to retrieve
+   */
+  async getMediaInsights(mediaId, options) {
+    return this.http.get(
+      MEDIA_ENDPOINTS.INSIGHTS(mediaId),
+      { metric: options.metric.join(",") }
+    );
+  }
+};
+
+// src/api/welcomeFlows.ts
+var WelcomeFlowsApi = class {
+  constructor(http, userId) {
+    this.http = http;
+    this.userId = userId;
+  }
+  /**
+   * Get all welcome message flows
+   */
+  async list() {
+    return this.http.get(
+      WELCOME_FLOW_ENDPOINTS.FLOWS(this.userId)
+    );
+  }
+  /**
+   * Get a specific welcome message flow
+   * @param flowId - Flow ID
+   */
+  async get(flowId) {
+    return this.http.get(
+      WELCOME_FLOW_ENDPOINTS.FLOWS(this.userId),
+      { flow_id: flowId }
+    );
+  }
+  /**
+   * Create a new welcome message flow
+   * @param options - Flow name and screens
+   */
+  async create(options) {
+    return this.http.post(
+      WELCOME_FLOW_ENDPOINTS.FLOWS(this.userId),
+      {
+        name: options.name,
+        screens: options.screens
+      }
+    );
+  }
+  /**
+   * Update an existing welcome message flow
+   * @param flowId - Flow ID
+   * @param options - Updated flow name and screens
+   */
+  async update(flowId, options) {
+    return this.http.post(
+      WELCOME_FLOW_ENDPOINTS.FLOWS(this.userId),
+      {
+        flow_id: flowId,
+        name: options.name,
+        screens: options.screens
+      }
+    );
+  }
+  /**
+   * Delete a welcome message flow
+   * @param flowId - Flow ID
+   */
+  async delete(flowId) {
+    return this.http.delete(
+      WELCOME_FLOW_ENDPOINTS.FLOWS(this.userId),
+      { flow_id: flowId }
+    );
+  }
+};
+
+// src/api/messengerProfile.ts
+var MessengerProfileApi = class {
+  constructor(http, userId) {
+    this.http = http;
+    this.userId = userId;
+  }
+  /**
+   * Get current ice breakers
+   */
+  async getIceBreakers() {
+    return this.http.get(
+      MESSENGER_PROFILE_ENDPOINTS.PROFILE(this.userId),
+      { fields: "ice_breakers" }
+    );
+  }
+  /**
+   * Set ice breakers (FAQ questions)
+   * @param iceBreakers - Ice breaker configurations (max 4 questions per locale)
+   */
+  async setIceBreakers(iceBreakers) {
+    return this.http.post(
+      MESSENGER_PROFILE_ENDPOINTS.PROFILE(this.userId),
+      {
+        platform: "instagram",
+        ice_breakers: iceBreakers
+      }
+    );
+  }
+  /**
+   * Delete ice breakers
+   */
+  async deleteIceBreakers() {
+    return this.http.delete(
+      MESSENGER_PROFILE_ENDPOINTS.PROFILE(this.userId),
+      { fields: ["ice_breakers"] }
+    );
+  }
+  /**
+   * Get persistent menu
+   */
+  async getPersistentMenu() {
+    return this.http.get(
+      MESSENGER_PROFILE_ENDPOINTS.PROFILE(this.userId),
+      { fields: "persistent_menu" }
+    );
+  }
+  /**
+   * Set persistent menu
+   * @param menus - Persistent menu configurations
+   */
+  async setPersistentMenu(menus) {
+    return this.http.post(
+      MESSENGER_PROFILE_ENDPOINTS.PROFILE(this.userId),
+      {
+        platform: "instagram",
+        persistent_menu: menus
+      }
+    );
+  }
+  /**
+   * Delete persistent menu
+   */
+  async deletePersistentMenu() {
+    return this.http.delete(
+      MESSENGER_PROFILE_ENDPOINTS.PROFILE(this.userId),
+      { fields: ["persistent_menu"] }
+    );
+  }
+};
+
+// src/api/oembed.ts
+var OEmbedApi = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Get oEmbed data for an Instagram URL
+   * @param options - URL and optional formatting options
+   */
+  async get(options) {
+    return this.http.get(
+      OEMBED_ENDPOINTS.GET,
+      {
+        url: options.url,
+        maxwidth: options.maxwidth,
+        hidecaption: options.hidecaption,
+        omitscript: options.omitscript
+      }
+    );
+  }
+};
+
+// src/api/webhooks.ts
+var WebhooksApi = class {
+  constructor(http, userId) {
+    this.http = http;
+    this.userId = userId;
+  }
+  /**
+   * Subscribe your app to specific fields for this user/page.
+   * 
+   * @param fields List of fields to subscribe to (e.g., ['messages', 'comments'])
+   */
+  async subscribe(fields) {
+    return this.http.post(`/${this.userId}/subscribed_apps`, {
+      subscribed_fields: fields.join(",")
+    });
+  }
+  /**
+   * Unsubscribe from specific fields or all fields.
+   * 
+   * @param fields Optional list of fields to unsubscribe from. If empty, unsubscribes from all.
+   */
+  async unsubscribe(fields) {
+    if (fields && fields.length > 0) {
+      throw new Error("Partial unsubscribe not directly supported by API. Use subscribe() with the fields you want to keep.");
+    }
+    return this.http.delete(`/${this.userId}/subscribed_apps`);
+  }
+  /**
+   * Get the list of fields your app is currently subscribed to.
+   */
+  async getSubscribedFields() {
+    return this.http.get(`/${this.userId}/subscribed_apps`);
+  }
+};
+
+// src/client.ts
+var DEFAULT_API_VERSION = "v22.0";
+var InstagramClient = class {
+  /**
+   * Create a new Instagram client
+   * @param config - Client configuration
+   */
+  constructor(config) {
+    this.cachedUserId = null;
+    this.config = {
+      accessToken: config.accessToken,
+      apiVersion: config.apiVersion || DEFAULT_API_VERSION,
+      timeout: config.timeout || 3e4
+    };
+    this.http = new HttpClient({
+      accessToken: this.config.accessToken,
+      apiVersion: this.config.apiVersion,
+      timeout: this.config.timeout
+    });
+    const userId = "me";
+    this.auth = new AuthApi(this.http);
+    this.users = new UsersApi(this.http, userId);
+    this.media = new MediaApi(this.http);
+    this.publishing = new PublishingApi(this.http, userId);
+    this.messaging = new MessagingApi(this.http, userId);
+    this.conversations = new ConversationsApi(this.http, userId);
+    this.comments = new CommentsApi(this.http);
+    this.hashtags = new HashtagsApi(this.http);
+    this.insights = new InsightsApi(this.http, userId);
+    this.welcomeFlows = new WelcomeFlowsApi(this.http, userId);
+    this.messengerProfile = new MessengerProfileApi(this.http, userId);
+    this.oembed = new OEmbedApi(this.http);
+    this.webhooks = new WebhooksApi(this.http, userId);
+  }
+  /**
+   * Get the current user ID
+   * Fetches from API if not cached
+   */
+  async getUserId() {
+    if (this.cachedUserId) {
+      return this.cachedUserId;
+    }
+    const user = await this.auth.me("id");
+    this.cachedUserId = user.id;
+    return user.id;
+  }
+  /**
+   * Update the access token
+   * @param accessToken - New access token
+   */
+  setAccessToken(accessToken) {
+    this.http.setAccessToken(accessToken);
+  }
+  /**
+   * Get the current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Get the API version
+   */
+  getApiVersion() {
+    return this.config.apiVersion;
+  }
+};
+var InstagramWebhooks = class {
+  /**
+   * Verify that the webhook request came from Meta.
+   * Calculates SHA256 HMAC of the raw body using the App Secret.
+   * 
+   * @param body Raw request body as string
+   * @param signature Signature from X-Hub-Signature-256 header (e.g., "sha256=...")
+   * @param appSecret Your Instagram App Secret
+   * @returns true if signature is valid
+   */
+  static verifySignature(body, signature, appSecret) {
+    if (!signature || !signature.startsWith("sha256=")) {
+      return false;
+    }
+    const expectedSignature = "sha256=" + crypto__default.default.createHmac("sha256", appSecret).update(body).digest("hex");
+    return crypto__default.default.timingSafeEqual(
+      Buffer.from(signature),
+      Buffer.from(expectedSignature)
+    );
+  }
+  /**
+   * Type guard and parser for webhook payloads.
+   * 
+   * @param body Parsed JSON body
+   * @returns Typed WebhookPayload or throws error
+   */
+  static parsePayload(body) {
+    if (body?.object !== "instagram" || !Array.isArray(body?.entry)) {
+      throw new Error("Invalid Instagram webhook payload");
+    }
+    return body;
+  }
+};
+
+// src/types/user.ts
+var IG_USER_FIELDS = [
+  "id",
+  "account_type",
+  "biography",
+  "followers_count",
+  "follows_count",
+  "media_count",
+  "username",
+  "name",
+  "profile_picture_url",
+  "website",
+  "ig_id"
+];
+
+// src/types/media.ts
+var IG_MEDIA_FIELDS = [
+  "id",
+  "caption",
+  "media_type",
+  "media_product_type",
+  "media_url",
+  "permalink",
+  "thumbnail_url",
+  "timestamp",
+  "username",
+  "like_count",
+  "comments_count",
+  "is_comment_enabled",
+  "is_shared_to_feed",
+  "owner",
+  "shortcode"
+];
+
+// src/types/comment.ts
+var IG_COMMENT_FIELDS = [
+  "id",
+  "text",
+  "username",
+  "timestamp",
+  "like_count",
+  "hidden",
+  "from",
+  "media",
+  "parent_id",
+  "replies"
+];
+
+exports.AUTH_ENDPOINTS = AUTH_ENDPOINTS;
+exports.AuthApi = AuthApi;
+exports.AuthenticationError = AuthenticationError;
+exports.COMMENT_ENDPOINTS = COMMENT_ENDPOINTS;
+exports.CommentsApi = CommentsApi;
+exports.ConversationsApi = ConversationsApi;
+exports.HASHTAG_ENDPOINTS = HASHTAG_ENDPOINTS;
+exports.HashtagsApi = HashtagsApi;
+exports.HttpClient = HttpClient;
+exports.IG_COMMENT_FIELDS = IG_COMMENT_FIELDS;
+exports.IG_MEDIA_FIELDS = IG_MEDIA_FIELDS;
+exports.IG_USER_FIELDS = IG_USER_FIELDS;
+exports.INSTAGRAM_BASE_URL = INSTAGRAM_BASE_URL;
+exports.InsightsApi = InsightsApi;
+exports.InstagramAPIError = InstagramAPIError;
+exports.InstagramClient = InstagramClient;
+exports.InstagramOAuth = InstagramOAuth;
+exports.InstagramWebhooks = InstagramWebhooks;
+exports.MEDIA_ENDPOINTS = MEDIA_ENDPOINTS;
+exports.MESSAGING_ENDPOINTS = MESSAGING_ENDPOINTS;
+exports.MESSENGER_PROFILE_ENDPOINTS = MESSENGER_PROFILE_ENDPOINTS;
+exports.MediaApi = MediaApi;
+exports.MessagingApi = MessagingApi;
+exports.MessengerProfileApi = MessengerProfileApi;
+exports.NetworkError = NetworkError;
+exports.OAUTH_ENDPOINTS = OAUTH_ENDPOINTS;
+exports.OEMBED_ENDPOINTS = OEMBED_ENDPOINTS;
+exports.OEmbedApi = OEmbedApi;
+exports.PUBLISHING_ENDPOINTS = PUBLISHING_ENDPOINTS;
+exports.PublishingApi = PublishingApi;
+exports.RateLimitError = RateLimitError;
+exports.USER_ENDPOINTS = USER_ENDPOINTS;
+exports.UsersApi = UsersApi;
+exports.ValidationError = ValidationError;
+exports.WELCOME_FLOW_ENDPOINTS = WELCOME_FLOW_ENDPOINTS;
+exports.WebhooksApi = WebhooksApi;
+exports.WelcomeFlowsApi = WelcomeFlowsApi;
+exports.buildUrl = buildUrl;
+exports.formatFields = formatFields;
+exports.isAuthenticationError = isAuthenticationError;
+exports.isInstagramAPIError = isInstagramAPIError;
+exports.isRateLimitError = isRateLimitError;
+exports.isValidationError = isValidationError;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map