synup-js 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1405 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  SynupAPIError: () => SynupAPIError,
+  SynupClient: () => SynupClient,
+  encodeLocationId: () => encodeLocationId
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var SynupAPIError = class extends Error {
+  statusCode;
+  responseBody;
+  constructor(message, statusCode, responseBody) {
+    const fullMessage = responseBody ? `${message} \u2014 ${responseBody}` : message;
+    super(fullMessage);
+    this.name = "SynupAPIError";
+    this.statusCode = statusCode ?? null;
+    this.responseBody = responseBody ?? null;
+  }
+};
+
+// src/resources/locations.ts
+function createLocationMethods(http) {
+  function parsePaginatedLocations(container) {
+    const edges = container?.edges ?? [];
+    const rawPageInfo = container?.pageInfo ?? {};
+    const locations = edges.map((e) => e.node);
+    const startCursor = edges.length > 0 ? edges[0].cursor : null;
+    const endCursor = edges.length > 0 ? edges[edges.length - 1].cursor : null;
+    return {
+      locations,
+      pageInfo: {
+        hasNextPage: rawPageInfo.hasNextPage ?? false,
+        hasPreviousPage: rawPageInfo.hasPreviousPage ?? false,
+        startCursor,
+        endCursor,
+        ...rawPageInfo.total !== void 0 ? { total: rawPageInfo.total } : {}
+      }
+    };
+  }
+  function paginationParams(options) {
+    const params = {};
+    if (!options) return params;
+    if (options.first !== void 0) params.first = options.first;
+    if (options.after !== void 0) params.after = options.after;
+    if (options.before !== void 0) params.before = options.before;
+    if (options.last !== void 0) params.last = options.last;
+    return params;
+  }
+  async function fetchLocationsPage(options) {
+    const params = paginationParams(options);
+    const data = await http.apiGet("locations", params);
+    const allLocations = data?.data?.allLocations ?? {};
+    const { locations, pageInfo } = parsePaginatedLocations(allLocations);
+    return {
+      success: true,
+      locations,
+      pageInfo,
+      raw: data
+    };
+  }
+  async function fetchAllLocationsPaginated(pageSize = 100) {
+    const allNodes = [];
+    let after;
+    while (true) {
+      const page = await fetchLocationsPage({ first: pageSize, after });
+      allNodes.push(...page.locations);
+      if (!page.pageInfo.hasNextPage) break;
+      after = page.pageInfo.endCursor ?? void 0;
+      if (!after) break;
+    }
+    return allNodes;
+  }
+  return {
+    /**
+     * Get locations for the account, with optional pagination or fetch-all.
+     *
+     * When fetchAll is true, returns a flat array of all locations.
+     * Otherwise returns a paginated response with locations, pageInfo, and raw data.
+     */
+    async fetchAllLocations(options) {
+      if (options?.fetchAll) {
+        return fetchAllLocationsPaginated(options.pageSize ?? 100);
+      }
+      return fetchLocationsPage(options);
+    },
+    /**
+     * Get locations by a list of IDs. Accepts numeric or base64-encoded IDs.
+     */
+    async fetchLocationsByIds(locationIds) {
+      if (!locationIds || locationIds.length === 0) return [];
+      const encodedIds = locationIds.map((id) => http.encodeLocationId(id));
+      const data = await http.apiGet("locations-by-ids", {
+        ids: JSON.stringify(encodedIds)
+      });
+      return data?.data?.getLocationsByIds ?? [];
+    },
+    /**
+     * Get locations that match the given store codes.
+     */
+    async fetchLocationsByStoreCodes(storeCodes) {
+      if (!storeCodes || storeCodes.length === 0) return [];
+      const data = await http.apiGet("locations-by-store-codes", {
+        storeCodes: JSON.stringify(storeCodes)
+      });
+      return data?.data?.getLocationsByStoreCodes ?? [];
+    },
+    /**
+     * Search locations by keyword (name, address, or store ID).
+     */
+    async searchLocations(query, options) {
+      if (options?.fetchAll) {
+        const allNodes = [];
+        let after;
+        const pageSize = options.pageSize ?? 100;
+        while (true) {
+          const params2 = {
+            query,
+            first: pageSize,
+            ...paginationParams({ after })
+          };
+          if (options.fields) {
+            params2.fields = JSON.stringify(options.fields);
+          }
+          const data2 = await http.apiGet("locations/search", params2);
+          const searchResult2 = data2?.data?.searchLocations ?? {};
+          const { locations: locations2, pageInfo: pageInfo2 } = parsePaginatedLocations(searchResult2);
+          allNodes.push(...locations2);
+          if (!pageInfo2.hasNextPage) break;
+          after = pageInfo2.endCursor ?? void 0;
+          if (!after) break;
+        }
+        return allNodes;
+      }
+      const params = {
+        query,
+        ...paginationParams(options)
+      };
+      if (options?.fields) {
+        params.fields = JSON.stringify(options.fields);
+      }
+      const data = await http.apiGet("locations/search", params);
+      const searchResult = data?.data?.searchLocations ?? {};
+      const { locations, pageInfo } = parsePaginatedLocations(searchResult);
+      return {
+        success: true,
+        locations,
+        pageInfo,
+        raw: data
+      };
+    },
+    /**
+     * Get all locations in a folder (including subfolders). Use folderId or folderName.
+     */
+    async fetchLocationsByFolder(options) {
+      if (!options.folderId && !options.folderName) {
+        throw new Error("Provide either folderId or folderName");
+      }
+      const params = {};
+      if (options.folderId) params.folderId = options.folderId;
+      if (options.folderName) params.folderName = options.folderName;
+      const data = await http.apiGet("folder-locations", params);
+      return data?.data?.getLocationsForFolder ?? [];
+    },
+    /**
+     * Get locations that have any of the given tags.
+     */
+    async fetchLocationsByTags(tags, options) {
+      if (!tags || tags.length === 0) {
+        if (options?.fetchAll) return [];
+        return {
+          success: true,
+          locations: [],
+          pageInfo: {
+            hasNextPage: false,
+            hasPreviousPage: false,
+            startCursor: null,
+            endCursor: null
+          },
+          raw: {}
+        };
+      }
+      if (options?.fetchAll) {
+        const allNodes = [];
+        let after;
+        const pageSize = options.pageSize ?? 100;
+        while (true) {
+          const params2 = {
+            tags: JSON.stringify(tags),
+            first: pageSize,
+            ...paginationParams({ after })
+          };
+          if (options.archived !== void 0) {
+            params2.archived = JSON.stringify(options.archived);
+          }
+          const data2 = await http.apiGet("tags/locations", params2);
+          const tagResult2 = data2?.data?.searchLocationsByTag ?? {};
+          const { locations: locations2, pageInfo: pageInfo2 } = parsePaginatedLocations(tagResult2);
+          allNodes.push(...locations2);
+          if (!pageInfo2.hasNextPage) break;
+          after = pageInfo2.endCursor ?? void 0;
+          if (!after) break;
+        }
+        return allNodes;
+      }
+      const params = {
+        tags: JSON.stringify(tags),
+        ...paginationParams(options)
+      };
+      if (options?.archived !== void 0) {
+        params.archived = JSON.stringify(options.archived);
+      }
+      const data = await http.apiGet("tags/locations", params);
+      const tagResult = data?.data?.searchLocationsByTag ?? {};
+      const { locations, pageInfo } = parsePaginatedLocations(tagResult);
+      return {
+        success: true,
+        locations,
+        pageInfo,
+        raw: data
+      };
+    },
+    /**
+     * Create a new location.
+     */
+    async createLocation(input) {
+      const data = await http.apiPost("locations", { input });
+      return data?.data?.createLocation ?? {};
+    },
+    /**
+     * Update a location. Pass id plus any fields to change.
+     */
+    async updateLocation(input) {
+      const encoded = {
+        ...input,
+        id: http.encodeLocationId(input.id)
+      };
+      const data = await http.apiPost("locations/update", { input: encoded });
+      return data?.data?.updateLocation ?? {};
+    },
+    /**
+     * Archive one or more locations.
+     */
+    async archiveLocations(locationIds) {
+      const encodedIds = locationIds.map((id) => http.encodeLocationId(id));
+      const data = await http.apiPost("locations/archive", {
+        input: { locationIds: encodedIds }
+      });
+      return data?.data?.archiveLocations ?? {};
+    },
+    /**
+     * Reactivate previously archived locations.
+     */
+    async activateLocations(locationIds) {
+      const encodedIds = locationIds.map((id) => http.encodeLocationId(id));
+      const data = await http.apiPost("locations/activate", {
+        input: { locationIds: encodedIds }
+      });
+      return data?.data?.activateLocations ?? {};
+    },
+    /**
+     * Cancel scheduled archival for the given locations.
+     */
+    async cancelArchiveLocations(locationIds, selectionType, changedBy) {
+      const encodedIds = locationIds.map((id) => http.encodeLocationId(id));
+      const data = await http.apiPost("locations/cancel_archive", {
+        input: {
+          locationIds: encodedIds,
+          selectionType,
+          changedBy
+        }
+      });
+      return data?.data?.cancelLocationsArchive ?? {};
+    }
+  };
+}
+
+// src/resources/listings.ts
+function createListingMethods(http) {
+  return {
+    /**
+     * Get premium (directory) listings for a location (Google, Yelp, etc.).
+     */
+    async fetchPremiumListings(locationId) {
+      const data = await http.listingsGet(locationId, "listings/premium");
+      return data?.data?.listingsForLocation ?? [];
+    },
+    /**
+     * Get voice assistant listings for a location (Google, Alexa, Siri, etc.).
+     */
+    async fetchVoiceListings(locationId) {
+      const data = await http.listingsGet(locationId, "voice-assistants");
+      return data?.data?.voiceAssistantsForLocation ?? [];
+    },
+    /**
+     * Get additional (non-premium) listings for a location.
+     */
+    async fetchAdditionalListings(locationId) {
+      const data = await http.listingsGet(locationId, "listings/additional");
+      return data?.data?.listingsForLocation ?? [];
+    },
+    /**
+     * Get duplicate listings detected for a location.
+     */
+    async fetchDuplicateListings(locationId) {
+      const data = await http.listingsGet(locationId, "listings/duplicates");
+      return data?.data?.duplicateListingsForLocation ?? [];
+    },
+    /**
+     * Get a rollup of duplicate listings across all locations,
+     * with optional tag filter and pagination.
+     */
+    async fetchAllDuplicateListings(options) {
+      const params = {};
+      if (options?.tag !== void 0) params.tag = options.tag;
+      if (options?.page !== void 0) params.page = options.page;
+      const data = await http.apiGet("locations/listings/duplicates", params);
+      return data?.data?.duplicateListingsRollup ?? {};
+    },
+    /**
+     * Get AI-generated listing suggestions for a location.
+     */
+    async fetchAiListings(locationId) {
+      const data = await http.listingsGet(locationId, "ai-listings");
+      return data?.data?.fetchAiListings ?? {};
+    },
+    /**
+     * Mark one or more listing items as duplicate for a location.
+     */
+    async markListingsAsDuplicate(locationId, listingItemIds) {
+      const data = await http.apiPost("locations/listings/mark-as-duplicate", {
+        input: {
+          locationId: http.encodeLocationId(locationId),
+          listingItemIds
+        }
+      });
+      return data?.data?.markAsDuplicate ?? {};
+    },
+    /**
+     * Clear duplicate status for listing items.
+     */
+    async markListingsAsNotDuplicate(locationId, listingItemIds) {
+      const data = await http.apiPost(
+        "locations/listings/mark-as-not-duplicate",
+        {
+          input: {
+            locationId: http.encodeLocationId(locationId),
+            listingItemIds
+          }
+        }
+      );
+      return data?.data?.markAsNotDuplicate ?? {};
+    }
+  };
+}
+
+// src/resources/reviews.ts
+function createReviewMethods(http) {
+  async function fetchInteractionsPage(locationId, options = {}) {
+    const params = {};
+    if (options.first !== void 0) params.first = options.first;
+    if (options.after !== void 0) params.after = options.after;
+    if (options.before !== void 0) params.before = options.before;
+    if (options.last !== void 0) params.last = options.last;
+    if (options.startDate !== void 0) params.startDate = options.startDate;
+    if (options.endDate !== void 0) params.endDate = options.endDate;
+    if (options.category !== void 0) params.category = options.category;
+    if (options.siteUrls !== void 0) params.siteUrls = JSON.stringify(options.siteUrls);
+    if (options.ratingFilters !== void 0) params.ratingFilters = JSON.stringify(options.ratingFilters);
+    const data = await http.listingsGet(locationId, "reviews", params);
+    const interactionsData = data?.data?.interactions ?? {};
+    const edges = interactionsData.edges ?? [];
+    const pageInfo = interactionsData.pageInfo ?? {};
+    const interactions = edges.map((e) => e.node);
+    const startCursor = edges.length > 0 ? edges[0].cursor : null;
+    const endCursor = edges.length > 0 ? edges[edges.length - 1].cursor : null;
+    return {
+      success: true,
+      interactions,
+      pageInfo: {
+        hasNextPage: pageInfo.hasNextPage ?? false,
+        hasPreviousPage: pageInfo.hasPreviousPage ?? false,
+        startCursor,
+        endCursor
+      },
+      totalCount: interactionsData.totalCount,
+      raw: data
+    };
+  }
+  async function fetchAllInteractions(locationId, options = {}) {
+    const allNodes = [];
+    let afterCursor;
+    const pageSize = options.pageSize ?? 100;
+    while (true) {
+      const page = await fetchInteractionsPage(locationId, {
+        ...options,
+        first: pageSize,
+        after: afterCursor
+      });
+      allNodes.push(...page.interactions);
+      if (!page.pageInfo.hasNextPage || page.interactions.length === 0) break;
+      afterCursor = page.pageInfo.endCursor ?? void 0;
+      if (!afterCursor) break;
+    }
+    return allNodes;
+  }
+  return {
+    /**
+     * Get reviews/interactions for a location with pagination and filters.
+     * When fetchAll is true, returns a flat array of all interactions.
+     * Otherwise returns a paginated response object.
+     */
+    async fetchInteractions(locationId, options = {}) {
+      if (options.fetchAll) {
+        return fetchAllInteractions(locationId, {
+          ...options,
+          pageSize: options.pageSize
+        });
+      }
+      return fetchInteractionsPage(locationId, options);
+    },
+    /**
+     * Get review source settings for a location.
+     */
+    async fetchReviewSettings(locationId) {
+      const data = await http.listingsGet(locationId, "reviews/settings");
+      return data?.data?.interactionsSetting ?? {};
+    },
+    /**
+     * Get overall review analytics for a location.
+     */
+    async fetchReviewAnalyticsOverview(locationId, options = {}) {
+      const params = {};
+      if (options.startDate !== void 0) params.startDate = options.startDate;
+      if (options.endDate !== void 0) params.endDate = options.endDate;
+      const data = await http.listingsGet(locationId, "review-analytics-overview", params);
+      return data?.data?.interactionsAnalyticsStats ?? {};
+    },
+    /**
+     * Get review analytics over time for a location.
+     */
+    async fetchReviewAnalyticsTimeline(locationId, options = {}) {
+      const params = {};
+      if (options.startDate !== void 0) params.startDate = options.startDate;
+      if (options.endDate !== void 0) params.endDate = options.endDate;
+      const data = await http.listingsGet(locationId, "review-analytics-timeline", params);
+      return data?.data?.interactionsChartData ?? {};
+    },
+    /**
+     * Get review analytics broken down by site for a location.
+     */
+    async fetchReviewAnalyticsSitesStats(locationId, options = {}) {
+      const params = {};
+      if (options.startDate !== void 0) params.startDate = options.startDate;
+      if (options.endDate !== void 0) params.endDate = options.endDate;
+      const data = await http.listingsGet(locationId, "review-analytics-sites-stats", params);
+      return data?.data?.interactionsSitesStats ?? {};
+    },
+    /**
+     * Get eligible review sources and site config for the account.
+     */
+    async fetchReviewSiteConfig() {
+      const data = await http.apiGet("reviews/site-config");
+      return data?.data?.interactionSiteConfig ?? [];
+    },
+    /**
+     * Get detailed information for specific reviews by interaction IDs.
+     */
+    async fetchReviewDetails(interactionIds) {
+      if (interactionIds.length === 0) return {};
+      const params = { interactionIds: JSON.stringify(interactionIds) };
+      const data = await http.apiGet("reviewDetails", params);
+      return data?.data?.interactionDetails ?? {};
+    },
+    /**
+     * Get review phrase analysis for given locations.
+     */
+    async fetchReviewPhrases(options) {
+      if (options.locationIds.length === 0) return [];
+      const params = {
+        locationIds: JSON.stringify(options.locationIds)
+      };
+      if (options.siteUrls !== void 0) params.siteUrls = JSON.stringify(options.siteUrls);
+      if (options.startDate !== void 0) params.startDate = options.startDate;
+      if (options.endDate !== void 0) params.endDate = options.endDate;
+      const data = await http.apiGet("review-phrases", params);
+      return data?.data?.newReviewPhrases ?? [];
+    },
+    /**
+     * Post a reply to a review/interaction.
+     */
+    async respondToReview(interactionId, responseContent) {
+      const data = await http.apiPost("locations/reviews/respond", {
+        interactionId,
+        responseContent
+      });
+      return data?.data?.respondToInteraction ?? {};
+    },
+    /**
+     * Edit an existing reply to a review.
+     */
+    async editReviewResponse(reviewId, responseId, responseContent) {
+      const data = await http.apiPost("locations/reviews/respond/edit", {
+        reviewId,
+        responseId,
+        responseContent
+      });
+      return data?.data?.editResponse ?? {};
+    },
+    /**
+     * Archive (hide) a reply to a review.
+     */
+    async archiveReviewResponse(responseId) {
+      const data = await http.apiPost("locations/reviews/respond/archive", {
+        responseId
+      });
+      return data?.data?.archiveResponse ?? {};
+    },
+    /**
+     * Set or update review source URLs for a location.
+     */
+    async editReviewSettings(locationId, siteUrls) {
+      const data = await http.apiPost("locations/reviews/settings/edit", {
+        locationId: http.encodeLocationId(locationId),
+        siteUrls
+      });
+      return data?.data?.editInteractionsSetting ?? {};
+    }
+  };
+}
+
+// src/resources/keywords.ts
+function createKeywordMethods(http) {
+  return {
+    /**
+     * Get all keywords tracked for a location.
+     */
+    async fetchKeywords(locationId) {
+      const data = await http.listingsGet(locationId, "keywords");
+      return data?.data?.keywordsByLocationId ?? [];
+    },
+    /**
+     * Get ranking performance for a location's keywords over an optional date range.
+     */
+    async fetchKeywordsPerformance(locationId, options = {}) {
+      const params = {};
+      if (options.fromDate !== void 0) params.fromDate = options.fromDate;
+      if (options.toDate !== void 0) params.toDate = options.toDate;
+      const data = await http.listingsGet(locationId, "keywords-performance", params);
+      return data?.data?.keywordsByLocationId ?? [];
+    },
+    /**
+     * Add keywords to a location for ranking tracking.
+     */
+    async addKeywords(locationId, keywords) {
+      const data = await http.apiPost("locations/keywords", {
+        locationId: http.encodeLocationId(locationId),
+        inputKeywords: keywords
+      });
+      const addResult = data?.data?.addKeywords ?? {};
+      return addResult.keywords ?? [];
+    },
+    /**
+     * Archive a keyword so it is no longer tracked.
+     */
+    async archiveKeyword(keywordId) {
+      const data = await http.apiPost("locations/keywords/archive", {
+        id: keywordId
+      });
+      const archiveResult = data?.data?.archiveKeyword ?? {};
+      return archiveResult.keyword ?? {};
+    },
+    /**
+     * Get ranking analytics timeline (positions over time) for locations and a source.
+     */
+    async fetchRankingAnalyticsTimeline(input) {
+      const encodedIds = input.locationIds.map((id) => http.encodeLocationId(id));
+      const data = await http.apiPost("locations/ranking-analytics-timeline", {
+        fromDate: input.fromDate,
+        toDate: input.toDate,
+        locationIds: encodedIds,
+        source: input.source
+      });
+      return data?.data?.rankingsRollupByDate ?? [];
+    },
+    /**
+     * Get ranking histogram by keyword count for locations and a source.
+     */
+    async fetchRankingSitewiseHistogram(input) {
+      const encodedIds = input.locationIds.map((id) => http.encodeLocationId(id));
+      const data = await http.apiPost("locations/ranking-sitewise-histogram", {
+        fromDate: input.fromDate,
+        toDate: input.toDate,
+        locationIds: encodedIds,
+        source: input.source
+      });
+      return data?.data?.rankingsRollupByKeywordCount ?? [];
+    }
+  };
+}
+
+// src/resources/campaigns.ts
+function createCampaignMethods(http) {
+  return {
+    /**
+     * Get review campaigns for a location, optionally filtered by date range.
+     */
+    async fetchReviewCampaigns(locationId, options = {}) {
+      const params = {};
+      if (options.startDate !== void 0) params.startDate = options.startDate;
+      if (options.endDate !== void 0) params.endDate = options.endDate;
+      const data = await http.listingsGet(locationId, "review-campaigns", params);
+      const listData = data?.data?.listReviewCampaigns ?? {};
+      return listData.reviewCampaigns ?? [];
+    },
+    /**
+     * Get customer details for a specific review campaign.
+     */
+    async fetchReviewCampaignCustomers(reviewCampaignId) {
+      const data = await http.apiGet(
+        `locations/review-campaigns/${reviewCampaignId}/customers`
+      );
+      return data?.data?.reviewCampaignInfo ?? {};
+    },
+    /**
+     * Create a review campaign for a location with customers and optional templates.
+     */
+    async createReviewCampaign(input) {
+      const payload = {
+        locationId: http.encodeLocationId(input.locationId),
+        name: input.name,
+        locationCustomers: input.locationCustomers
+      };
+      if (input.screening !== void 0) payload.screening = input.screening;
+      if (input.landingPageTemplate !== void 0) payload.landingPageTemplate = input.landingPageTemplate;
+      if (input.openingEmailTemplate !== void 0) payload.openingEmailTemplate = input.openingEmailTemplate;
+      if (input.smsTemplate !== void 0) payload.smsTemplate = input.smsTemplate;
+      if (input.emailDetails !== void 0) payload.emailDetails = input.emailDetails;
+      if (input.smsDetails !== void 0) payload.smsDetails = input.smsDetails;
+      const data = await http.apiPost("locations/review-campaigns", { input: payload });
+      return data?.data?.createReviewCampaign ?? {};
+    },
+    /**
+     * Add customers to an existing review campaign.
+     */
+    async addReviewCampaignCustomers(reviewCampaignId, locationCustomers) {
+      const data = await http.apiPost("locations/review-campaigns/customers", {
+        input: {
+          reviewCampaignId,
+          locationCustomers
+        }
+      });
+      return data?.data?.addCustomersToReviewCampaign ?? {};
+    }
+  };
+}
+
+// src/resources/analytics.ts
+function createAnalyticsMethods(http) {
+  return {
+    /**
+     * Get Google (GMB) profile analytics for a location.
+     */
+    async fetchGoogleAnalytics(locationId, options) {
+      const params = {};
+      if (options?.fromDate) params.fromDate = options.fromDate;
+      if (options?.toDate) params.toDate = options.toDate;
+      const data = await http.listingsGet(locationId, "google-analytics", params);
+      return data?.data?.googleInsights ?? {};
+    },
+    /**
+     * Get Bing profile analytics for a location.
+     */
+    async fetchBingAnalytics(locationId, options) {
+      const params = {};
+      if (options?.fromDate) params.fromDate = options.fromDate;
+      if (options?.toDate) params.toDate = options.toDate;
+      const data = await http.listingsGet(locationId, "bing-analytics", params);
+      return data?.data?.bingInsights ?? {};
+    },
+    /**
+     * Get Facebook page analytics for a location.
+     */
+    async fetchFacebookAnalytics(locationId, options) {
+      const params = {};
+      if (options?.fromDate) params.fromDate = options.fromDate;
+      if (options?.toDate) params.toDate = options.toDate;
+      const data = await http.listingsGet(locationId, "facebook-analytics", params);
+      return data?.data?.facebookInsights ?? {};
+    }
+  };
+}
+
+// src/resources/photos.ts
+function createPhotoMethods(http) {
+  return {
+    /**
+     * Get photos and media attached to a location.
+     */
+    async fetchLocationPhotos(locationId) {
+      const data = await http.listingsGet(locationId, "photos");
+      return data?.data?.mediaFilesOfLocation ?? [];
+    },
+    /**
+     * Add one or more photos to a location.
+     */
+    async addLocationPhotos(locationId, photos) {
+      const data = await http.apiPost("locations/photos", {
+        input: {
+          locationId: http.encodeLocationId(locationId),
+          photos
+        }
+      });
+      return data?.data?.addLocationPhotos ?? {};
+    },
+    /**
+     * Remove photos from a location by photo IDs.
+     */
+    async removeLocationPhotos(locationId, photoIds) {
+      const data = await http.apiPost("locations/photos/remove", {
+        input: {
+          locationId: http.encodeLocationId(locationId),
+          photoIds
+        }
+      });
+      return data?.data?.removeLocationPhotos ?? {};
+    },
+    /**
+     * Star or unstar location photos.
+     */
+    async starLocationPhotos(locationId, mediaIds, starred) {
+      const data = await http.apiPost("locations/photos/star", {
+        input: {
+          locationId: http.encodeLocationId(locationId),
+          mediaIds,
+          starred
+        }
+      });
+      return data?.data?.starUnstarLocationPhotos ?? {};
+    },
+    /**
+     * Get the processing status for a bulk photo upload request.
+     */
+    async fetchPhotoUploadStatus(requestId) {
+      const data = await http.apiGet(`locations/photos/requests/${requestId}`);
+      return data?.data?.bulkImageProcessingStatus ?? {};
+    }
+  };
+}
+
+// src/resources/folders.ts
+function createFolderMethods(http) {
+  return {
+    /**
+     * Get all folders as a flat list.
+     */
+    async fetchFoldersFlat() {
+      const data = await http.apiGet("folders/flat");
+      return data?.data?.getUserFolders ?? [];
+    },
+    /**
+     * Get all folders as a nested tree structure.
+     */
+    async fetchFoldersTree() {
+      const data = await http.apiGet("folders/tree");
+      return data?.data?.getFolderTree ?? [];
+    },
+    /**
+     * Get details for a specific folder by ID or name.
+     */
+    async fetchFolderDetails(options) {
+      const params = {};
+      if (options.folderId) params.folderId = options.folderId;
+      if (options.folderName) params.folderName = options.folderName;
+      const data = await http.apiGet("folder-details", params);
+      return data?.data?.getFolderDetails ?? {};
+    },
+    /**
+     * Create a folder to organize locations.
+     */
+    async createFolder(name, options) {
+      const payload = { name };
+      if (options?.parentFolder) payload.parentFolder = options.parentFolder;
+      if (options?.parentFolderName) payload.parentFolderName = options.parentFolderName;
+      const data = await http.apiPost("folders/create", { input: payload });
+      return data?.data?.createFolder ?? {};
+    },
+    /**
+     * Rename an existing folder.
+     */
+    async renameFolder(oldName, newName) {
+      const data = await http.apiPost("locations/folders/rename", {
+        input: { oldName, name: newName }
+      });
+      return data?.data?.renameFolder ?? {};
+    },
+    /**
+     * Delete a folder by name. Locations in the folder are not deleted.
+     */
+    async deleteFolder(name) {
+      const data = await http.apiPost("folders/delete", { input: { name } });
+      return data?.data?.deleteFolder ?? {};
+    },
+    /**
+     * Add locations to a folder. Folder is created if it does not exist.
+     */
+    async addLocationsToFolder(folderName, locationIds) {
+      const encodedIds = locationIds.map((id) => http.encodeLocationId(id));
+      const data = await http.apiPost("locations/folders", {
+        input: { name: folderName, locationIds: encodedIds }
+      });
+      return data?.data?.addLocationsToFolder ?? {};
+    },
+    /**
+     * Remove locations from their current folder.
+     */
+    async removeLocationsFromFolder(locationIds) {
+      const encodedIds = locationIds.map((id) => http.encodeLocationId(id));
+      const data = await http.apiPost("locations/folders/remove", {
+        input: { locationIds: encodedIds }
+      });
+      return data?.data?.deleteLocationsFromFolder ?? {};
+    }
+  };
+}
+
+// src/resources/tags.ts
+function createTagMethods(http) {
+  return {
+    /**
+     * Get all tags defined in the account.
+     */
+    async fetchTags() {
+      const data = await http.apiGet("tags");
+      return data?.data?.listAllTags ?? [];
+    },
+    /**
+     * Add a tag to a location. Tag is created if it does not exist.
+     */
+    async addLocationTag(locationId, tag) {
+      const data = await http.apiPost("locations/tags", {
+        input: {
+          locationId: http.encodeLocationId(locationId),
+          tag
+        }
+      });
+      return data?.data?.addTag ?? {};
+    },
+    /**
+     * Remove a tag from a location.
+     */
+    async removeLocationTag(locationId, tag) {
+      const data = await http.apiPost("locations/tags/remove", {
+        input: {
+          locationId: http.encodeLocationId(locationId),
+          tag
+        }
+      });
+      return data?.data?.removeTag ?? {};
+    }
+  };
+}
+
+// src/resources/users.ts
+function createUserMethods(http) {
+  return {
+    /**
+     * Get all users in the account.
+     */
+    async fetchUsers() {
+      const data = await http.apiGet("users");
+      return data?.data?.users ?? [];
+    },
+    /**
+     * Get users by a list of user IDs.
+     */
+    async fetchUsersByIds(userIds) {
+      if (!userIds.length) return [];
+      const data = await http.apiGet("users-by-ids", {
+        userIds: JSON.stringify(userIds)
+      });
+      return data?.data?.usersByIds ?? [];
+    },
+    /**
+     * Get resources (locations, folders, etc.) assigned to a specific user.
+     */
+    async fetchUserResources(userId) {
+      const data = await http.apiGet(`users/${userId}/resources`);
+      return data?.data?.listUserResources ?? [];
+    },
+    /**
+     * Get all roles defined in the account.
+     */
+    async fetchRoles() {
+      const data = await http.apiGet("roles");
+      return data?.data?.fetchAccountRoles ?? [];
+    },
+    /**
+     * Create a user in the account with the given role.
+     */
+    async createUser(input) {
+      const { email, roleId, firstName, lastName, directCustomer, ...extra } = input;
+      const payload = { email, roleId, firstName };
+      if (lastName !== void 0) payload.lastName = lastName;
+      if (directCustomer !== void 0) payload.directCustomer = directCustomer;
+      Object.assign(payload, extra);
+      const data = await http.apiPost("users/create", { input: payload });
+      return data?.data?.addUser ?? {};
+    },
+    /**
+     * Update a user. Pass userId and any fields to change.
+     */
+    async updateUser(input) {
+      const { userId, email, roleId, firstName, lastName, phone, archived, directCustomer, ...extra } = input;
+      const payload = { id: userId };
+      if (email !== void 0) payload.email = email;
+      if (roleId !== void 0) payload.roleId = roleId;
+      if (firstName !== void 0) payload.firstName = firstName;
+      if (lastName !== void 0) payload.lastName = lastName;
+      if (phone !== void 0) payload.phone = phone;
+      if (archived !== void 0) payload.archived = archived;
+      if (directCustomer !== void 0) payload.directCustomer = directCustomer;
+      Object.assign(payload, extra);
+      const data = await http.apiPost("users/update", { input: payload });
+      return data?.data?.updateUser ?? {};
+    },
+    /**
+     * Assign locations to a user.
+     */
+    async addUserLocations(userId, locationIds) {
+      const encodedIds = locationIds.map((id) => http.encodeLocationId(id));
+      const data = await http.apiPost("users/locations/add", {
+        input: { userId, locationIds: encodedIds }
+      });
+      return data?.data?.addLocationsForUser ?? {};
+    },
+    /**
+     * Remove location assignments from a user.
+     */
+    async removeUserLocations(userId, locationIds) {
+      const encodedIds = locationIds.map((id) => http.encodeLocationId(id));
+      const data = await http.apiPost("users/locations/remove", {
+        input: { userId, locationIds: encodedIds }
+      });
+      return data?.data?.removeLocationsForUser ?? {};
+    },
+    /**
+     * Assign folders to a user.
+     */
+    async addUserFolders(userId, folderIds) {
+      const data = await http.apiPost("users/folders/add", {
+        input: { userId, folderIds }
+      });
+      return data?.data?.addFoldersForUser ?? {};
+    },
+    /**
+     * Remove folder assignments from a user.
+     */
+    async removeUserFolders(userId, folderIds) {
+      const data = await http.apiPost("users/folders/remove", {
+        input: { userId, folderIds }
+      });
+      return data?.data?.removeFoldersForUser ?? {};
+    },
+    /**
+     * Create a user and a folder, then assign the folder to the user in one call.
+     */
+    async addUserAndFolder(input) {
+      const data = await http.apiPost("users/add_user_and_folder", { input });
+      return data?.data?.addUserAndFolder ?? {};
+    }
+  };
+}
+
+// src/resources/connections.ts
+function createConnectionMethods(http) {
+  return {
+    /**
+     * Get a URL to connect a Google or Facebook profile to a location.
+     */
+    async getOauthConnectUrl(locationId, site, successUrl, errorUrl) {
+      const data = await http.apiPost("locations/oauth_connect_url", {
+        input: {
+          locationId: http.encodeLocationId(locationId),
+          site: site.toUpperCase(),
+          successUrl,
+          errorUrl
+        }
+      });
+      return data?.data?.connectUrl ?? {};
+    },
+    /**
+     * Disconnect a Google or Facebook profile from a location.
+     */
+    async oauthDisconnect(locationId, site) {
+      const data = await http.apiPost("locations/oauth-disconnect", {
+        input: {
+          locationId: http.encodeLocationId(locationId),
+          site: site.toUpperCase()
+        }
+      });
+      return data?.data?.disconnectConnectedAccountsLocations ?? {};
+    },
+    /**
+     * Get a URL to connect a Google account for bulk use across locations.
+     */
+    async connectGoogleAccount(successUrl, errorUrl) {
+      const data = await http.apiPost("connected-accounts/connect-google", {
+        input: { successUrl, errorUrl }
+      });
+      return data?.data?.bulkConnectLinkForGoogle ?? {};
+    },
+    /**
+     * Get a URL to connect a Facebook account for bulk use across locations.
+     */
+    async connectFacebookAccount(successUrl, errorUrl) {
+      const data = await http.apiPost("connected-accounts/connect-facebook", {
+        input: { successUrl, errorUrl }
+      });
+      return data?.data?.bulkConnectLinkForFacebook ?? {};
+    },
+    /**
+     * Disconnect a Google connected account (bulk).
+     */
+    async disconnectGoogleAccount(connectedAccountId) {
+      const data = await http.apiPost("connected-accounts/disconnect-google", {
+        input: { connectedAccountId }
+      });
+      return data?.data?.gmbBulkDisconnect ?? {};
+    },
+    /**
+     * Disconnect a Facebook connected account (bulk).
+     */
+    async disconnectFacebookAccount(connectedAccountId) {
+      const data = await http.apiPost("connected-accounts/disconnect-facebook", {
+        input: { connectedAccountId }
+      });
+      return data?.data?.fbBulkDisconnect ?? {};
+    },
+    /**
+     * Get connected third-party accounts with optional filters.
+     */
+    async fetchConnectedAccounts(options) {
+      const params = {};
+      if (options?.publisher !== void 0) params.publisher = options.publisher;
+      if (options?.status !== void 0) params.status = options.status;
+      if (options?.page !== void 0) params.page = options.page;
+      if (options?.perPage !== void 0) params.perPage = options.perPage;
+      const data = await http.apiGet("connected-accounts", params);
+      return data?.data?.connectedAccountsInfo ?? {};
+    },
+    /**
+     * Get detailed information about a specific connected account.
+     */
+    async fetchConnectedAccountDetails(connectedAccountId) {
+      const data = await http.apiGet(
+        `connected-accounts/${connectedAccountId}/details`
+      );
+      return data?.data?.connectedAccountDetails ?? {};
+    },
+    /**
+     * Get folders (business groups) under a connected Google account.
+     */
+    async fetchConnectedAccountFolders(connectedAccountId, options) {
+      const params = {};
+      if (options?.folderName) params.folderName = options.folderName;
+      const data = await http.apiGet(
+        `connected-accounts/${connectedAccountId}/folders`,
+        params
+      );
+      return data?.data?.getFoldersUnderGoogleAccount ?? [];
+    },
+    /**
+     * Get listings the connected Google/Facebook account has access to.
+     */
+    async fetchConnectedAccountListings(connectedAccountId, options) {
+      const payload = { connectedAccountId };
+      if (options?.locationInfo !== void 0) payload.locationInfo = options.locationInfo;
+      if (options?.page !== void 0) payload.page = options.page;
+      if (options?.perPage !== void 0) payload.perPage = options.perPage;
+      const data = await http.apiPost(
+        "connected-accounts/connected-account-listings",
+        payload
+      );
+      return data?.data?.connectedAccountListings ?? {};
+    },
+    /**
+     * Get suggested matches between a connected account's listings and Synup locations.
+     */
+    async fetchConnectionSuggestions(connectedAccountId, options) {
+      const params = {};
+      if (options?.page !== void 0) params.page = options.page;
+      if (options?.perPage !== void 0) params.perPage = options.perPage;
+      const data = await http.apiGet(
+        `connected-accounts/${connectedAccountId}/connection-suggestions`,
+        params
+      );
+      return data?.data?.connectionSuggestionsForAccount ?? {};
+    },
+    /**
+     * Trigger matching of Google/Facebook profile locations to Synup locations.
+     */
+    async triggerConnectedAccountMatches(connectedAccountIds) {
+      const data = await http.apiPost("connected-accounts/trigger-matches", {
+        input: { connectedAccountIds }
+      });
+      return data?.data?.connectedAccountsTriggerMatches ?? {};
+    },
+    /**
+     * Confirm suggested matches between connected account listings and Synup locations.
+     */
+    async confirmConnectedAccountMatches(matchRecordIds) {
+      const data = await http.apiPost("connected-accounts/confirm-matches", {
+        input: { matchRecordIds }
+      });
+      return data?.data?.confirmConnectMatches ?? {};
+    },
+    /**
+     * Link a Synup location to a listing from a connected Google/Facebook account.
+     */
+    async connectListing(locationId, connectedAccountListingId, connectedAccountId) {
+      const data = await http.apiPost("connected-accounts/connect-listing", {
+        input: {
+          locationId: http.encodeLocationId(locationId),
+          connectedAccountListingId,
+          connectedAccountId
+        }
+      });
+      return data?.data?.connectListing ?? {};
+    },
+    /**
+     * Unlink a location from its Google or Facebook listing.
+     */
+    async disconnectListing(locationId, site) {
+      const data = await http.apiPost("connected-accounts/disconnect-listing", {
+        input: {
+          locationId: http.encodeLocationId(locationId),
+          site: site.toUpperCase()
+        }
+      });
+      return data?.data?.disconnectConnectedAccountsLocations ?? {};
+    },
+    /**
+     * Create a Google Business Profile listing for an existing Synup location.
+     */
+    async createGmbListing(locationId, connectedAccountId, options) {
+      const payload = {
+        locationId: http.encodeLocationId(locationId),
+        connectedAccountId
+      };
+      if (options?.folderId) payload.folderId = options.folderId;
+      const data = await http.apiPost("locations/create/gmb-listing", {
+        input: payload
+      });
+      return data?.data?.createGmbListingForLocation ?? {};
+    }
+  };
+}
+
+// src/resources/grid-rank.ts
+function createGridRankMethods(http) {
+  return {
+    /**
+     * Create a Local Rank Grid report.
+     */
+    async createGridReport(input) {
+      const body = {
+        locationId: http.encodeLocationId(input.locationId),
+        keywords: input.keywords,
+        businessName: input.businessName,
+        businessStreet: input.businessStreet,
+        businessCity: input.businessCity,
+        businessState: input.businessState,
+        businessCountry: input.businessCountry,
+        latitude: input.latitude,
+        longitude: input.longitude,
+        distance: input.distance,
+        distanceUnit: input.distanceUnit,
+        gridSize: input.gridSize
+      };
+      const data = await http.apiPost("create-grid-report", body);
+      return data?.data?.createGridrankReport ?? {};
+    },
+    /**
+     * Get a Local Rank Grid report by its ID.
+     */
+    async fetchGridReport(reportId) {
+      const data = await http.apiGet(`grid-report/${reportId}`);
+      return data?.data?.gridrankReportById ?? {};
+    },
+    /**
+     * Get all Local Rank Grid reports for a location with optional filters.
+     */
+    async fetchLocationGridReports(locationId, options) {
+      const params = {};
+      if (options?.searchString !== void 0) params.searchString = options.searchString;
+      if (options?.gridSize !== void 0) params.gridSize = options.gridSize;
+      if (options?.fromDate !== void 0) params.fromDate = options.fromDate;
+      if (options?.toDate !== void 0) params.toDate = options.toDate;
+      if (options?.sortField !== void 0) params.sortField = options.sortField;
+      if (options?.sortOrder !== void 0) params.sortOrder = options.sortOrder;
+      if (options?.pageSize !== void 0) params.pageSize = options.pageSize;
+      if (options?.page !== void 0) params.page = options.page;
+      const data = await http.listingsGet(locationId, "grid-reports", params);
+      const listData = data?.data?.allGridrankReports ?? {};
+      return {
+        reports: listData.reports ?? [],
+        total: listData.total
+      };
+    }
+  };
+}
+
+// src/resources/account.ts
+function createAccountMethods(http) {
+  return {
+    /**
+     * Get supported directories and site details for your plan.
+     */
+    async fetchPlanSites() {
+      const data = await http.apiGet("plan-sites");
+      return data?.data?.planSites ?? [];
+    },
+    /**
+     * Get supported countries and states.
+     */
+    async fetchCountries() {
+      const data = await http.apiGet("countries");
+      return data?.data?.supportedCountries ?? [];
+    },
+    /**
+     * Get active subscriptions for the account.
+     */
+    async fetchSubscriptions() {
+      const data = await http.apiGet("subscriptions");
+      return data?.data?.activeSubscriptions ?? [];
+    },
+    /**
+     * Get OAuth connection status for a location.
+     */
+    async fetchConnectionInfo(locationId) {
+      const data = await http.listingsGet(locationId, "connection_info");
+      return data?.data?.locationConnectionInfo ?? {};
+    },
+    /**
+     * Create an automation that temporarily closes a location and reopens on a set date.
+     */
+    async createTemporaryCloseAutomation(input) {
+      const data = await http.apiPost(
+        "automations/temporary-close-location-with-reopening-date",
+        {
+          input: {
+            name: input.name,
+            startDate: input.startDate,
+            startTime: input.startTime,
+            endDate: input.endDate,
+            locationId: http.encodeLocationId(input.locationId)
+          }
+        }
+      );
+      return data?.data?.createFlowFromRecipe ?? {};
+    }
+  };
+}
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://api.synup.com";
+function encodeLocationId(idValue) {
+  if (typeof idValue === "number") {
+    return btoa(`Location:${idValue}`);
+  }
+  const s = String(idValue).trim();
+  if (/^\d+$/.test(s)) {
+    return btoa(`Location:${s}`);
+  }
+  return s;
+}
+function buildQueryString(params) {
+  const entries = Object.entries(params).filter(
+    ([, v]) => v !== void 0 && v !== null
+  );
+  if (entries.length === 0) return "";
+  const searchParams = new URLSearchParams();
+  for (const [key, value] of entries) {
+    searchParams.set(key, String(value));
+  }
+  return `?${searchParams.toString()}`;
+}
+var SynupClient = class {
+  baseUrl;
+  headers;
+  constructor(options) {
+    this.baseUrl = (options.baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, "");
+    this.headers = {
+      Authorization: `API ${options.apiKey}`,
+      "Content-Type": "application/json"
+    };
+    const http = {
+      apiGet: this.apiGet.bind(this),
+      apiPost: this.apiPost.bind(this),
+      listingsGet: this.listingsGet.bind(this),
+      encodeLocationId
+    };
+    Object.assign(this, createLocationMethods(http));
+    Object.assign(this, createListingMethods(http));
+    Object.assign(this, createReviewMethods(http));
+    Object.assign(this, createKeywordMethods(http));
+    Object.assign(this, createCampaignMethods(http));
+    Object.assign(this, createAnalyticsMethods(http));
+    Object.assign(this, createPhotoMethods(http));
+    Object.assign(this, createFolderMethods(http));
+    Object.assign(this, createTagMethods(http));
+    Object.assign(this, createUserMethods(http));
+    Object.assign(this, createConnectionMethods(http));
+    Object.assign(this, createGridRankMethods(http));
+    Object.assign(this, createAccountMethods(http));
+  }
+  /**
+   * GET request to an account-level API endpoint.
+   */
+  async apiGet(path, params) {
+    const qs = params ? buildQueryString(params) : "";
+    const url = `${this.baseUrl}/api/v4/${path}${qs}`;
+    const response = await fetch(url, {
+      method: "GET",
+      headers: this.headers
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new SynupAPIError(
+        `API request failed: ${response.status}`,
+        response.status,
+        body
+      );
+    }
+    return response.json();
+  }
+  /**
+   * POST request to an account-level API endpoint.
+   */
+  async apiPost(path, body) {
+    const url = `${this.baseUrl}/api/v4/${path}`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: this.headers,
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const bodyText = await response.text();
+      throw new SynupAPIError(
+        `API request failed: ${response.status}`,
+        response.status,
+        bodyText
+      );
+    }
+    return response.json();
+  }
+  /**
+   * GET request to a location-scoped API endpoint.
+   */
+  async listingsGet(locationId, path, params) {
+    const encodedId = encodeLocationId(locationId);
+    const qs = params ? buildQueryString(params) : "";
+    const url = `${this.baseUrl}/api/v4/locations/${encodedId}/${path}${qs}`;
+    const response = await fetch(url, {
+      method: "GET",
+      headers: this.headers
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new SynupAPIError(
+        `API request failed: ${response.status}`,
+        response.status,
+        body
+      );
+    }
+    return response.json();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SynupAPIError,
+  SynupClient,
+  encodeLocationId
+});