@gpc-cli/api 1.0.0

package/dist/index.js

@@ -0,0 +1,972 @@
+// src/http.ts
+import { readFile } from "fs/promises";
+import { resolve, isAbsolute } from "path";
+
+// src/errors.ts
+var ApiError = class extends Error {
+  constructor(message, code, statusCode, suggestion) {
+    super(message);
+    this.code = code;
+    this.statusCode = statusCode;
+    this.suggestion = suggestion;
+    this.name = "ApiError";
+  }
+  exitCode = 4;
+  toJSON() {
+    return {
+      success: false,
+      error: {
+        code: this.code,
+        message: this.message,
+        suggestion: this.suggestion
+      }
+    };
+  }
+};
+
+// src/http.ts
+function sanitizeErrorBody(body) {
+  try {
+    const parsed = JSON.parse(body);
+    if (parsed?.error?.message) {
+      return `${parsed.error.code ?? "?"} ${parsed.error.status ?? ""}: ${parsed.error.message}`.trim();
+    }
+  } catch {
+  }
+  return body.length > 200 ? body.slice(0, 200) + "..." : body;
+}
+function validateFilePath(filePath) {
+  const resolved = resolve(filePath);
+  if (!isAbsolute(resolved)) {
+    throw new ApiError("Invalid file path", "API_INVALID_PATH", void 0, "File path must resolve to an absolute path.");
+  }
+  if (filePath.includes("\0")) {
+    throw new ApiError("Invalid file path: null bytes not allowed", "API_INVALID_PATH");
+  }
+  return resolved;
+}
+var BASE_URL = "https://androidpublisher.googleapis.com/androidpublisher/v3/applications";
+var UPLOAD_BASE_URL = "https://androidpublisher.googleapis.com/upload/androidpublisher/v3/applications";
+function envInt(name) {
+  const val = process.env[name];
+  if (val === void 0) return void 0;
+  const n = Number(val);
+  return Number.isFinite(n) ? n : void 0;
+}
+function resolveOption(explicit, envName, fallback) {
+  return explicit ?? envInt(envName) ?? fallback;
+}
+function mapStatusToError(status, body) {
+  switch (status) {
+    case 401:
+      return {
+        code: "API_UNAUTHORIZED",
+        suggestion: "Check that your access token is valid and not expired."
+      };
+    case 403:
+      return {
+        code: "API_FORBIDDEN",
+        suggestion: "Ensure the service account has the required permissions for this operation."
+      };
+    case 404:
+      return {
+        code: "API_NOT_FOUND",
+        suggestion: "Verify the package name and resource IDs are correct."
+      };
+    case 409:
+      return {
+        code: "API_EDIT_CONFLICT",
+        suggestion: "Another edit may be in progress. Delete the existing edit and retry."
+      };
+    case 429:
+      return {
+        code: "API_RATE_LIMITED",
+        suggestion: "Too many requests. The client will retry automatically."
+      };
+    default:
+      if (status >= 500) {
+        return {
+          code: "API_SERVER_ERROR",
+          suggestion: "Google Play API server error. The client will retry automatically."
+        };
+      }
+      return { code: `API_HTTP_${status}` };
+  }
+}
+function isRetryable(status) {
+  return status === 429 || status >= 500;
+}
+function jitteredDelay(base, attempt, max) {
+  const exponential = base * 2 ** attempt;
+  const capped = Math.min(exponential, max);
+  return capped * (0.5 + Math.random() * 0.5);
+}
+function createHttpClient(options) {
+  const maxRetries = resolveOption(options.maxRetries, "GPC_MAX_RETRIES", 3);
+  const timeout = resolveOption(options.timeout, "GPC_TIMEOUT", 3e4);
+  const baseDelay = resolveOption(options.baseDelay, "GPC_BASE_DELAY", 1e3);
+  const maxDelay = resolveOption(options.maxDelay, "GPC_MAX_DELAY", 6e4);
+  const onRetry = options.onRetry;
+  async function request(method, path, body, params) {
+    let url = `${options.baseUrl ?? BASE_URL}${path}`;
+    if (params) {
+      const search = new URLSearchParams(params);
+      url += `?${search.toString()}`;
+    }
+    let lastError;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      if (attempt > 0) {
+        const delay = jitteredDelay(baseDelay, attempt - 1, maxDelay);
+        await new Promise((r) => setTimeout(r, delay));
+      }
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), timeout);
+      try {
+        const token = await options.auth.getAccessToken();
+        const headers = {
+          Authorization: `Bearer ${token}`,
+          "Content-Type": "application/json"
+        };
+        const init = {
+          method,
+          headers,
+          signal: controller.signal
+        };
+        if (body !== void 0) {
+          init.body = JSON.stringify(body);
+        }
+        const response = await fetch(url, init);
+        if (response.ok) {
+          const text = await response.text();
+          const data = text ? JSON.parse(text) : {};
+          return { data, status: response.status };
+        }
+        const errorBody = await response.text();
+        const { code, suggestion } = mapStatusToError(response.status, errorBody);
+        const err = new ApiError(
+          `${method} ${path} failed with status ${response.status}: ${sanitizeErrorBody(errorBody)}`,
+          code,
+          response.status,
+          suggestion
+        );
+        if (isRetryable(response.status) && attempt < maxRetries) {
+          lastError = err;
+          const delay = jitteredDelay(baseDelay, attempt, maxDelay);
+          onRetry?.({
+            attempt: attempt + 1,
+            method,
+            path,
+            status: response.status,
+            error: err.message,
+            delayMs: Math.round(delay),
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          continue;
+        }
+        throw err;
+      } catch (error) {
+        if (error instanceof ApiError) {
+          throw error;
+        }
+        if (error instanceof DOMException && error.name === "AbortError") {
+          const timeoutErr = new ApiError(
+            `${method} ${path} timed out after ${timeout}ms`,
+            "API_TIMEOUT",
+            void 0,
+            "The request exceeded the configured timeout. Consider increasing the timeout value."
+          );
+          if (attempt < maxRetries) {
+            lastError = timeoutErr;
+            onRetry?.({
+              attempt: attempt + 1,
+              method,
+              path,
+              error: timeoutErr.message,
+              delayMs: Math.round(jitteredDelay(baseDelay, attempt, maxDelay)),
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            });
+            continue;
+          }
+          throw timeoutErr;
+        }
+        const networkErr = new ApiError(
+          `${method} ${path} failed: ${error instanceof Error ? error.message : String(error)}`,
+          "API_NETWORK_ERROR",
+          void 0,
+          "A network error occurred. Check your internet connection."
+        );
+        if (attempt < maxRetries) {
+          lastError = networkErr;
+          onRetry?.({
+            attempt: attempt + 1,
+            method,
+            path,
+            error: networkErr.message,
+            delayMs: Math.round(jitteredDelay(baseDelay, attempt, maxDelay)),
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          continue;
+        }
+        throw networkErr;
+      } finally {
+        clearTimeout(timer);
+      }
+    }
+    throw lastError ?? new ApiError("Request failed", "API_NETWORK_ERROR");
+  }
+  async function uploadRequest(path, filePath, contentType) {
+    const url = `${UPLOAD_BASE_URL}${path}`;
+    const safeFilePath = validateFilePath(filePath);
+    const fileBuffer = await readFile(safeFilePath);
+    let lastError;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      if (attempt > 0) {
+        const delay = jitteredDelay(baseDelay, attempt - 1, maxDelay);
+        await new Promise((r) => setTimeout(r, delay));
+      }
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), timeout);
+      try {
+        const token = await options.auth.getAccessToken();
+        const headers = {
+          Authorization: `Bearer ${token}`,
+          "Content-Type": contentType
+        };
+        const response = await fetch(url, {
+          method: "POST",
+          headers,
+          body: fileBuffer,
+          signal: controller.signal
+        });
+        if (response.ok) {
+          const text = await response.text();
+          const data = text ? JSON.parse(text) : {};
+          return { data, status: response.status };
+        }
+        const errorBody = await response.text();
+        const { code, suggestion } = mapStatusToError(response.status, errorBody);
+        const err = new ApiError(
+          `POST upload ${path} failed with status ${response.status}: ${sanitizeErrorBody(errorBody)}`,
+          code,
+          response.status,
+          suggestion
+        );
+        if (isRetryable(response.status) && attempt < maxRetries) {
+          lastError = err;
+          const delay = jitteredDelay(baseDelay, attempt, maxDelay);
+          onRetry?.({
+            attempt: attempt + 1,
+            method: "POST",
+            path: `upload ${path}`,
+            status: response.status,
+            error: err.message,
+            delayMs: Math.round(delay),
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          continue;
+        }
+        throw err;
+      } catch (error) {
+        if (error instanceof ApiError) {
+          throw error;
+        }
+        if (error instanceof DOMException && error.name === "AbortError") {
+          const timeoutErr = new ApiError(
+            `POST upload ${path} timed out after ${timeout}ms`,
+            "API_TIMEOUT",
+            void 0,
+            "The request exceeded the configured timeout. Consider increasing the timeout value."
+          );
+          if (attempt < maxRetries) {
+            lastError = timeoutErr;
+            onRetry?.({
+              attempt: attempt + 1,
+              method: "POST",
+              path: `upload ${path}`,
+              error: timeoutErr.message,
+              delayMs: Math.round(jitteredDelay(baseDelay, attempt, maxDelay)),
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            });
+            continue;
+          }
+          throw timeoutErr;
+        }
+        const networkErr = new ApiError(
+          `POST upload ${path} failed: ${error instanceof Error ? error.message : String(error)}`,
+          "API_NETWORK_ERROR",
+          void 0,
+          "A network error occurred. Check your internet connection."
+        );
+        if (attempt < maxRetries) {
+          lastError = networkErr;
+          onRetry?.({
+            attempt: attempt + 1,
+            method: "POST",
+            path: `upload ${path}`,
+            error: networkErr.message,
+            delayMs: Math.round(jitteredDelay(baseDelay, attempt, maxDelay)),
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          continue;
+        }
+        throw networkErr;
+      } finally {
+        clearTimeout(timer);
+      }
+    }
+    throw lastError ?? new ApiError("Upload request failed", "API_NETWORK_ERROR");
+  }
+  return {
+    get(path, params) {
+      return request("GET", path, void 0, params);
+    },
+    post(path, body) {
+      return request("POST", path, body);
+    },
+    put(path, body) {
+      return request("PUT", path, body);
+    },
+    patch(path, body) {
+      return request("PATCH", path, body);
+    },
+    delete(path) {
+      return request("DELETE", path);
+    },
+    upload(path, filePath, contentType) {
+      return uploadRequest(path, filePath, contentType);
+    }
+  };
+}
+
+// src/client.ts
+async function rateLimit(limiter, bucket) {
+  if (limiter) await limiter.acquire(bucket);
+}
+function createApiClient(options) {
+  const http = createHttpClient(options);
+  const limiter = options.rateLimiter || void 0;
+  return {
+    edits: {
+      async insert(packageName) {
+        const { data } = await http.post(`/${packageName}/edits`);
+        return data;
+      },
+      async get(packageName, editId) {
+        const { data } = await http.get(
+          `/${packageName}/edits/${editId}`
+        );
+        return data;
+      },
+      async validate(packageName, editId) {
+        const { data } = await http.post(
+          `/${packageName}/edits/${editId}:validate`
+        );
+        return data;
+      },
+      async commit(packageName, editId) {
+        const { data } = await http.post(
+          `/${packageName}/edits/${editId}:commit`
+        );
+        return data;
+      },
+      async delete(packageName, editId) {
+        await http.delete(`/${packageName}/edits/${editId}`);
+      }
+    },
+    details: {
+      async get(packageName, editId) {
+        const { data } = await http.get(
+          `/${packageName}/edits/${editId}/details`
+        );
+        return data;
+      },
+      async update(packageName, editId, details) {
+        const { data } = await http.put(
+          `/${packageName}/edits/${editId}/details`,
+          details
+        );
+        return data;
+      },
+      async patch(packageName, editId, partial) {
+        const { data } = await http.patch(
+          `/${packageName}/edits/${editId}/details`,
+          partial
+        );
+        return data;
+      }
+    },
+    bundles: {
+      async list(packageName, editId) {
+        const { data } = await http.get(
+          `/${packageName}/edits/${editId}/bundles`
+        );
+        return data.bundles;
+      },
+      async upload(packageName, editId, filePath) {
+        const { data } = await http.upload(
+          `/${packageName}/edits/${editId}/bundles`,
+          filePath,
+          "application/octet-stream"
+        );
+        return data.bundle;
+      }
+    },
+    tracks: {
+      async list(packageName, editId) {
+        const { data } = await http.get(
+          `/${packageName}/edits/${editId}/tracks`
+        );
+        return data.tracks;
+      },
+      async get(packageName, editId, track) {
+        const { data } = await http.get(
+          `/${packageName}/edits/${editId}/tracks/${track}`
+        );
+        return data;
+      },
+      async update(packageName, editId, track, release) {
+        const { data } = await http.put(
+          `/${packageName}/edits/${editId}/tracks/${track}`,
+          { track, releases: [release] }
+        );
+        return data;
+      }
+    },
+    listings: {
+      async list(packageName, editId) {
+        const { data } = await http.get(
+          `/${packageName}/edits/${editId}/listings`
+        );
+        return data.listings || [];
+      },
+      async get(packageName, editId, language) {
+        const { data } = await http.get(
+          `/${packageName}/edits/${editId}/listings/${language}`
+        );
+        return data;
+      },
+      async update(packageName, editId, language, listing) {
+        const { data } = await http.put(
+          `/${packageName}/edits/${editId}/listings/${language}`,
+          listing
+        );
+        return data;
+      },
+      async patch(packageName, editId, language, partial) {
+        const { data } = await http.patch(
+          `/${packageName}/edits/${editId}/listings/${language}`,
+          partial
+        );
+        return data;
+      },
+      async delete(packageName, editId, language) {
+        await http.delete(`/${packageName}/edits/${editId}/listings/${language}`);
+      },
+      async deleteAll(packageName, editId) {
+        await http.delete(`/${packageName}/edits/${editId}/listings`);
+      }
+    },
+    images: {
+      async list(packageName, editId, language, imageType) {
+        const { data } = await http.get(
+          `/${packageName}/edits/${editId}/listings/${language}/${imageType}`
+        );
+        return data.images || [];
+      },
+      async upload(packageName, editId, language, imageType, filePath) {
+        const { data } = await http.upload(
+          `/${packageName}/edits/${editId}/listings/${language}/${imageType}`,
+          filePath,
+          filePath.endsWith(".png") ? "image/png" : "image/jpeg"
+        );
+        return data.image;
+      },
+      async delete(packageName, editId, language, imageType, imageId) {
+        await http.delete(
+          `/${packageName}/edits/${editId}/listings/${language}/${imageType}/${imageId}`
+        );
+      },
+      async deleteAll(packageName, editId, language, imageType) {
+        const { data } = await http.delete(
+          `/${packageName}/edits/${editId}/listings/${language}/${imageType}`
+        );
+        return data.deleted || [];
+      }
+    },
+    countryAvailability: {
+      async get(packageName, editId, track) {
+        const { data } = await http.get(
+          `/${packageName}/edits/${editId}/countryAvailability/${track}`
+        );
+        return data;
+      }
+    },
+    reviews: {
+      async list(packageName, options2) {
+        await rateLimit(limiter, "reviewsGet");
+        const params = {};
+        if (options2?.token) params["token"] = options2.token;
+        if (options2?.maxResults) params["maxResults"] = String(options2.maxResults);
+        if (options2?.translationLanguage) params["translationLanguage"] = options2.translationLanguage;
+        const hasParams = Object.keys(params).length > 0;
+        const { data } = await http.get(
+          `/${packageName}/reviews`,
+          hasParams ? params : void 0
+        );
+        return data;
+      },
+      async get(packageName, reviewId, translationLanguage) {
+        await rateLimit(limiter, "reviewsGet");
+        const params = {};
+        if (translationLanguage) params["translationLanguage"] = translationLanguage;
+        const hasParams = Object.keys(params).length > 0;
+        const { data } = await http.get(
+          `/${packageName}/reviews/${reviewId}`,
+          hasParams ? params : void 0
+        );
+        return data;
+      },
+      async reply(packageName, reviewId, replyText) {
+        await rateLimit(limiter, "reviewsPost");
+        const body = { replyText };
+        const { data } = await http.post(
+          `/${packageName}/reviews/${reviewId}:reply`,
+          body
+        );
+        return data;
+      }
+    },
+    subscriptions: {
+      async list(packageName, options2) {
+        const params = {};
+        if (options2?.pageToken) params["pageToken"] = options2.pageToken;
+        if (options2?.pageSize) params["pageSize"] = String(options2.pageSize);
+        const hasParams = Object.keys(params).length > 0;
+        const { data } = await http.get(
+          `/${packageName}/monetization/subscriptions`,
+          hasParams ? params : void 0
+        );
+        return data;
+      },
+      async get(packageName, productId) {
+        const { data } = await http.get(
+          `/${packageName}/monetization/subscriptions/${productId}`
+        );
+        return data;
+      },
+      async create(packageName, body) {
+        const { data } = await http.post(
+          `/${packageName}/monetization/subscriptions`,
+          body
+        );
+        return data;
+      },
+      async update(packageName, productId, body, updateMask) {
+        let path = `/${packageName}/monetization/subscriptions/${productId}`;
+        if (updateMask) {
+          path += `?updateMask=${encodeURIComponent(updateMask).replace(/%2C/gi, ",")}`;
+        }
+        const { data } = await http.patch(path, body);
+        return data;
+      },
+      async delete(packageName, productId) {
+        await http.delete(`/${packageName}/monetization/subscriptions/${productId}`);
+      },
+      async activateBasePlan(packageName, productId, basePlanId) {
+        const { data } = await http.post(
+          `/${packageName}/monetization/subscriptions/${productId}/basePlans/${basePlanId}:activate`
+        );
+        return data;
+      },
+      async deactivateBasePlan(packageName, productId, basePlanId) {
+        const { data } = await http.post(
+          `/${packageName}/monetization/subscriptions/${productId}/basePlans/${basePlanId}:deactivate`
+        );
+        return data;
+      },
+      async deleteBasePlan(packageName, productId, basePlanId) {
+        await http.delete(
+          `/${packageName}/monetization/subscriptions/${productId}/basePlans/${basePlanId}`
+        );
+      },
+      async migratePrices(packageName, productId, basePlanId, body) {
+        const { data } = await http.post(
+          `/${packageName}/monetization/subscriptions/${productId}/basePlans/${basePlanId}:migratePrices`,
+          body
+        );
+        return data;
+      },
+      async listOffers(packageName, productId, basePlanId) {
+        const { data } = await http.get(
+          `/${packageName}/monetization/subscriptions/${productId}/basePlans/${basePlanId}/offers`
+        );
+        return data;
+      },
+      async getOffer(packageName, productId, basePlanId, offerId) {
+        const { data } = await http.get(
+          `/${packageName}/monetization/subscriptions/${productId}/basePlans/${basePlanId}/offers/${offerId}`
+        );
+        return data;
+      },
+      async createOffer(packageName, productId, basePlanId, body) {
+        const { data } = await http.post(
+          `/${packageName}/monetization/subscriptions/${productId}/basePlans/${basePlanId}/offers`,
+          body
+        );
+        return data;
+      },
+      async updateOffer(packageName, productId, basePlanId, offerId, body, updateMask) {
+        let path = `/${packageName}/monetization/subscriptions/${productId}/basePlans/${basePlanId}/offers/${offerId}`;
+        if (updateMask) {
+          path += `?updateMask=${encodeURIComponent(updateMask).replace(/%2C/gi, ",")}`;
+        }
+        const { data } = await http.patch(path, body);
+        return data;
+      },
+      async deleteOffer(packageName, productId, basePlanId, offerId) {
+        await http.delete(
+          `/${packageName}/monetization/subscriptions/${productId}/basePlans/${basePlanId}/offers/${offerId}`
+        );
+      },
+      async activateOffer(packageName, productId, basePlanId, offerId) {
+        const { data } = await http.post(
+          `/${packageName}/monetization/subscriptions/${productId}/basePlans/${basePlanId}/offers/${offerId}:activate`
+        );
+        return data;
+      },
+      async deactivateOffer(packageName, productId, basePlanId, offerId) {
+        const { data } = await http.post(
+          `/${packageName}/monetization/subscriptions/${productId}/basePlans/${basePlanId}/offers/${offerId}:deactivate`
+        );
+        return data;
+      }
+    },
+    inappproducts: {
+      async list(packageName, options2) {
+        const params = {};
+        if (options2?.token) params["token"] = options2.token;
+        if (options2?.maxResults) params["maxResults"] = String(options2.maxResults);
+        const hasParams = Object.keys(params).length > 0;
+        const { data } = await http.get(
+          `/${packageName}/inappproducts`,
+          hasParams ? params : void 0
+        );
+        return data;
+      },
+      async get(packageName, sku) {
+        const { data } = await http.get(
+          `/${packageName}/inappproducts/${sku}`
+        );
+        return data;
+      },
+      async create(packageName, body) {
+        const { data } = await http.post(
+          `/${packageName}/inappproducts`,
+          body
+        );
+        return data;
+      },
+      async update(packageName, sku, body) {
+        const { data } = await http.put(
+          `/${packageName}/inappproducts/${sku}`,
+          body
+        );
+        return data;
+      },
+      async delete(packageName, sku) {
+        await http.delete(`/${packageName}/inappproducts/${sku}`);
+      }
+    },
+    purchases: {
+      async getProduct(packageName, productId, token) {
+        const { data } = await http.get(
+          `/${packageName}/purchases/products/${productId}/tokens/${token}`
+        );
+        return data;
+      },
+      async acknowledgeProduct(packageName, productId, token, body) {
+        await http.post(
+          `/${packageName}/purchases/products/${productId}/tokens/${token}:acknowledge`,
+          body
+        );
+      },
+      async consumeProduct(packageName, productId, token) {
+        await http.post(
+          `/${packageName}/purchases/products/${productId}/tokens/${token}:consume`
+        );
+      },
+      async getSubscriptionV2(packageName, token) {
+        const { data } = await http.get(
+          `/${packageName}/purchases/subscriptionsv2/tokens/${token}`
+        );
+        return data;
+      },
+      async getSubscriptionV1(packageName, subscriptionId, token) {
+        const { data } = await http.get(
+          `/${packageName}/purchases/subscriptions/${subscriptionId}/tokens/${token}`
+        );
+        return data;
+      },
+      async cancelSubscription(packageName, subscriptionId, token) {
+        await http.post(
+          `/${packageName}/purchases/subscriptions/${subscriptionId}/tokens/${token}:cancel`
+        );
+      },
+      async deferSubscription(packageName, subscriptionId, token, body) {
+        const { data } = await http.post(
+          `/${packageName}/purchases/subscriptions/${subscriptionId}/tokens/${token}:defer`,
+          body
+        );
+        return data;
+      },
+      async revokeSubscriptionV2(packageName, token) {
+        await http.post(
+          `/${packageName}/purchases/subscriptionsv2/tokens/${token}:revoke`
+        );
+      },
+      async listVoided(packageName, options2) {
+        await rateLimit(limiter, "voidedBurst");
+        await rateLimit(limiter, "voidedDaily");
+        const params = {};
+        if (options2?.startTime) params["startTime"] = options2.startTime;
+        if (options2?.endTime) params["endTime"] = options2.endTime;
+        if (options2?.maxResults) params["maxResults"] = String(options2.maxResults);
+        if (options2?.token) params["token"] = options2.token;
+        const hasParams = Object.keys(params).length > 0;
+        const { data } = await http.get(
+          `/${packageName}/purchases/voidedpurchases`,
+          hasParams ? params : void 0
+        );
+        return data;
+      }
+    },
+    orders: {
+      async refund(packageName, orderId, body) {
+        await http.post(
+          `/${packageName}/orders/${orderId}:refund`,
+          body
+        );
+      }
+    },
+    monetization: {
+      async convertRegionPrices(packageName, price) {
+        const { data } = await http.post(
+          `/${packageName}/monetization/convertRegionPrices`,
+          price
+        );
+        return data;
+      }
+    },
+    reports: {
+      async list(packageName, reportType, year, month) {
+        const monthStr = String(month).padStart(2, "0");
+        const { data } = await http.get(
+          `/${packageName}/reports/${reportType}/${year}/${monthStr}`
+        );
+        return data;
+      }
+    },
+    testers: {
+      async get(packageName, editId, track) {
+        const { data } = await http.get(
+          `/${packageName}/edits/${editId}/testers/${track}`
+        );
+        return data;
+      },
+      async update(packageName, editId, track, testersData) {
+        const { data } = await http.put(
+          `/${packageName}/edits/${editId}/testers/${track}`,
+          testersData
+        );
+        return data;
+      }
+    },
+    deobfuscation: {
+      async upload(packageName, editId, versionCode, filePath) {
+        const { data } = await http.upload(
+          `/${packageName}/edits/${editId}/apks/${versionCode}/deobfuscationFiles/proguard`,
+          filePath,
+          "application/octet-stream"
+        );
+        return data.deobfuscationFile;
+      }
+    }
+  };
+}
+
+// src/reporting-client.ts
+var REPORTING_BASE_URL = "https://playdeveloperreporting.googleapis.com/v1beta1";
+function createReportingClient(options) {
+  const http = createHttpClient({ ...options, baseUrl: REPORTING_BASE_URL });
+  return {
+    async queryMetricSet(packageName, metricSet, query) {
+      const { data } = await http.post(
+        `/apps/${packageName}/${metricSet}:query`,
+        query
+      );
+      return data;
+    },
+    async getAnomalies(packageName) {
+      const { data } = await http.get(
+        `/apps/${packageName}/anomalies`
+      );
+      return data;
+    },
+    async searchErrorIssues(packageName, filter, pageSize, pageToken) {
+      const params = {};
+      if (filter) params["filter"] = filter;
+      if (pageSize) params["pageSize"] = String(pageSize);
+      if (pageToken) params["pageToken"] = pageToken;
+      const { data } = await http.get(
+        `/apps/${packageName}/errorIssues:search`,
+        params
+      );
+      return data;
+    },
+    async searchErrorReports(packageName, issueName, pageSize, pageToken) {
+      const params = {};
+      if (pageSize) params["pageSize"] = String(pageSize);
+      if (pageToken) params["pageToken"] = pageToken;
+      const { data } = await http.get(
+        `/apps/${packageName}/errorIssues/${issueName}/reports`,
+        params
+      );
+      return data;
+    }
+  };
+}
+
+// src/users-client.ts
+var USERS_BASE_URL = "https://androidpublisher.googleapis.com/androidpublisher/v3/developers";
+function createUsersClient(options) {
+  const http = createHttpClient({ ...options, baseUrl: USERS_BASE_URL });
+  return {
+    async list(developerId, listOptions) {
+      const params = {};
+      if (listOptions?.pageToken) params["pageToken"] = listOptions.pageToken;
+      if (listOptions?.pageSize) params["pageSize"] = String(listOptions.pageSize);
+      const hasParams = Object.keys(params).length > 0;
+      const { data } = await http.get(
+        `/${developerId}/users`,
+        hasParams ? params : void 0
+      );
+      return data;
+    },
+    async get(developerId, userId) {
+      const { data } = await http.get(
+        `/${developerId}/users/${userId}`
+      );
+      return data;
+    },
+    async create(developerId, user) {
+      const { data } = await http.post(
+        `/${developerId}/users`,
+        user
+      );
+      return data;
+    },
+    async update(developerId, userId, user, updateMask) {
+      let path = `/${developerId}/users/${userId}`;
+      if (updateMask) {
+        path += `?updateMask=${encodeURIComponent(updateMask).replace(/%2C/gi, ",")}`;
+      }
+      const { data } = await http.patch(path, user);
+      return data;
+    },
+    async delete(developerId, userId) {
+      await http.delete(`/${developerId}/users/${userId}`);
+    }
+  };
+}
+
+// src/rate-limiter.ts
+var RATE_LIMIT_BUCKETS = {
+  default: { name: "default", maxTokens: 200, refillRate: 200, refillIntervalMs: 1e3 },
+  reviewsGet: { name: "reviewsGet", maxTokens: 200, refillRate: 200, refillIntervalMs: 36e5 },
+  reviewsPost: { name: "reviewsPost", maxTokens: 2e3, refillRate: 2e3, refillIntervalMs: 864e5 },
+  voidedBurst: { name: "voidedBurst", maxTokens: 30, refillRate: 30, refillIntervalMs: 3e4 },
+  voidedDaily: { name: "voidedDaily", maxTokens: 6e3, refillRate: 6e3, refillIntervalMs: 864e5 }
+};
+function createRateLimiter(buckets) {
+  const states = /* @__PURE__ */ new Map();
+  if (buckets) {
+    for (const bucket of buckets) {
+      states.set(bucket.name, {
+        tokens: bucket.maxTokens,
+        lastRefillTime: Date.now(),
+        config: bucket
+      });
+    }
+  }
+  return {
+    async acquire(bucket) {
+      const state = states.get(bucket);
+      if (!state) return;
+      const now = Date.now();
+      const elapsed = now - state.lastRefillTime;
+      const refill = Math.floor(elapsed / state.config.refillIntervalMs * state.config.refillRate);
+      if (refill > 0) {
+        state.tokens = Math.min(state.config.maxTokens, state.tokens + refill);
+        state.lastRefillTime = now;
+      }
+      if (state.tokens > 0) {
+        state.tokens--;
+        return;
+      }
+      const tokensNeeded = 1;
+      const waitMs = Math.ceil(tokensNeeded / state.config.refillRate * state.config.refillIntervalMs);
+      await new Promise((r) => setTimeout(r, waitMs));
+      state.tokens = state.config.refillRate - 1;
+      state.lastRefillTime = Date.now();
+    }
+  };
+}
+
+// src/paginate.ts
+async function* paginate(fetchPage, options) {
+  let pageToken = options?.startPageToken;
+  let collected = 0;
+  const limit = options?.limit;
+  for (; ; ) {
+    if (limit !== void 0 && collected >= limit) break;
+    const page = await fetchPage(pageToken);
+    const items = page.items;
+    if (items.length === 0) break;
+    if (limit !== void 0) {
+      const remaining = limit - collected;
+      if (items.length > remaining) {
+        yield items.slice(0, remaining);
+        return;
+      }
+    }
+    yield items;
+    collected += items.length;
+    pageToken = page.nextPageToken;
+    if (!pageToken) break;
+  }
+}
+async function paginateAll(fetchPage, options) {
+  const allItems = [];
+  let lastPageToken;
+  const limit = options?.limit;
+  for await (const items of paginate(fetchPage, options)) {
+    allItems.push(...items);
+    if (limit !== void 0 && allItems.length >= limit) break;
+  }
+  if (limit !== void 0 && allItems.length >= limit) {
+    lastPageToken = void 0;
+  }
+  return { items: allItems, nextPageToken: lastPageToken };
+}
+export {
+  ApiError,
+  RATE_LIMIT_BUCKETS,
+  createApiClient,
+  createHttpClient,
+  createRateLimiter,
+  createReportingClient,
+  createUsersClient,
+  paginate,
+  paginateAll
+};
+//# sourceMappingURL=index.js.map