@simmit/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,718 @@
+// src/error.ts
+var SimmitError = class extends Error {
+};
+var APIError = class _APIError extends SimmitError {
+  /** HTTP status of the response that caused the error. */
+  status;
+  /** HTTP headers of the response that caused the error. */
+  headers;
+  /** Machine-readable `code` from the error envelope. */
+  code;
+  /** Typed `meta` from the error envelope. */
+  meta;
+  /** Raw parsed JSON error body — escape hatch for unmapped fields. */
+  error;
+  constructor(status, body, message, headers) {
+    super(_APIError.makeMessage(status, body, message));
+    this.status = status;
+    this.headers = headers;
+    this.error = body;
+    const envelope = body;
+    this.code = typeof envelope?.code === "string" ? envelope.code : void 0;
+    this.meta = body ? envelope?.meta ?? null : void 0;
+  }
+  static makeMessage(status, body, message) {
+    const bodyMessage = body?.error;
+    const msg = typeof bodyMessage === "string" ? bodyMessage : body ? JSON.stringify(body) : message;
+    if (status && msg) return `${status} ${msg}`;
+    if (status) return `${status} status code (no body)`;
+    if (msg) return msg;
+    return "(no status code or body)";
+  }
+  /**
+   * Maps a response to the most specific error class: status selects the base
+   * class; an enumerated `code` with structured `meta` selects the subclass;
+   * anything unrecognized falls back to the status class so new server codes
+   * degrade gracefully without breaking `instanceof` handling.
+   */
+  static generate(status, body, message, headers) {
+    if (!status || !headers) {
+      return new APIConnectionError({
+        message,
+        cause: body instanceof Error ? body : void 0
+      });
+    }
+    const code = body?.code;
+    if (status === 400) return new BadRequestError(400, body, message, headers);
+    if (status === 401) {
+      return new AuthenticationError(401, body, message, headers);
+    }
+    if (status === 402) {
+      if (code === "insufficient_credits") {
+        return new InsufficientCreditsError(402, body, message, headers);
+      }
+      if (code === "insufficient_credits_liability") {
+        return new InsufficientCreditsLiabilityError(
+          402,
+          body,
+          message,
+          headers
+        );
+      }
+      return new BillingError(402, body, message, headers);
+    }
+    if (status === 404) return new NotFoundError(404, body, message, headers);
+    if (status === 409) {
+      if (code === "idempotency_key_reuse") {
+        return new IdempotencyKeyReuseError(409, body, message, headers);
+      }
+      if (code === "result_not_ready") {
+        return new ResultNotReadyError(409, body, message, headers);
+      }
+      if (code === "job_not_cancellable") {
+        return new JobNotCancellableError(409, body, message, headers);
+      }
+      return new ConflictError(409, body, message, headers);
+    }
+    if (status === 413) {
+      return new RequestTooLargeError(413, body, message, headers);
+    }
+    if (status === 422) {
+      if (code === "input_sanitized_rejected") {
+        return new InvalidProfileError(422, body, message, headers);
+      }
+      if (code === "result_unavailable") {
+        return new ResultUnavailableError(422, body, message, headers);
+      }
+      return new UnprocessableEntityError(422, body, message, headers);
+    }
+    if (status === 429) {
+      if (code === "max_active_jobs_exceeded") {
+        return new MaxActiveJobsError(429, body, message, headers);
+      }
+      return new RateLimitError(429, body, message, headers);
+    }
+    if (status === 503 && isServiceUnavailableBody(body)) {
+      return new ServiceUnavailableError(503, body, message, headers);
+    }
+    if (status >= 500) {
+      return new InternalServerError(status, body, message, headers);
+    }
+    return new _APIError(status, body, message, headers);
+  }
+};
+var BadRequestError = class extends APIError {
+};
+var AuthenticationError = class extends APIError {
+};
+var BillingError = class extends APIError {
+};
+var InsufficientCreditsError = class extends BillingError {
+};
+var InsufficientCreditsLiabilityError = class extends BillingError {
+};
+var NotFoundError = class extends APIError {
+};
+var ConflictError = class extends APIError {
+};
+var IdempotencyKeyReuseError = class extends ConflictError {
+};
+var ResultNotReadyError = class extends ConflictError {
+};
+var JobNotCancellableError = class extends ConflictError {
+};
+var RequestTooLargeError = class extends APIError {
+};
+var UnprocessableEntityError = class extends APIError {
+};
+var InvalidProfileError = class extends UnprocessableEntityError {
+};
+var ResultUnavailableError = class extends UnprocessableEntityError {
+};
+var RateLimitError = class extends APIError {
+};
+var MaxActiveJobsError = class extends RateLimitError {
+};
+var InternalServerError = class extends APIError {
+};
+var SERVICE_UNAVAILABLE_CODES = /* @__PURE__ */ new Set([
+  "queue_unavailable",
+  "queue_health_unknown",
+  "secret_store_unavailable",
+  "api_maintenance"
+]);
+function isServiceUnavailableBody(body) {
+  const code = body?.code;
+  return typeof code === "string" && SERVICE_UNAVAILABLE_CODES.has(code);
+}
+var ServiceUnavailableError = class extends InternalServerError {
+  /** The discriminated 503 envelope: `if (e.body.code === 'api_maintenance') e.body.meta.retryAfterSeconds`. */
+  get body() {
+    return this.error;
+  }
+};
+var APIConnectionError = class extends APIError {
+  constructor({
+    message,
+    cause
+  } = {}) {
+    super(void 0, void 0, message ?? "Connection error.", void 0);
+    if (cause) this.cause = cause;
+  }
+};
+var APIConnectionTimeoutError = class extends APIConnectionError {
+  constructor({ message } = {}) {
+    super({ message: message ?? "Request timed out." });
+  }
+};
+var APIUserAbortError = class extends APIError {
+  constructor({ message } = {}) {
+    super(void 0, void 0, message ?? "Request was aborted.", void 0);
+  }
+};
+var JobUnsuccessfulError = class extends SimmitError {
+  job;
+  constructor(job, message) {
+    super(
+      message ?? `Job ${job.id} ${job.status}` + (job.statusReason ? `: ${job.statusReason}` : "") + (job.errorCode ? ` (${job.errorCode})` : "")
+    );
+    this.job = job;
+  }
+};
+var JobFailedError = class extends JobUnsuccessfulError {
+};
+var JobCancelledError = class extends JobUnsuccessfulError {
+};
+var JobTimedOutError = class extends JobUnsuccessfulError {
+};
+var JobWaitTimeoutError = class extends SimmitError {
+  jobId;
+  lastStatus;
+  constructor(args) {
+    super(
+      args.message ?? `Timed out waiting for job ${args.jobId} (last status: ${args.lastStatus}). The job is still running server-side and continues to bill.`
+    );
+    this.jobId = args.jobId;
+    this.lastStatus = args.lastStatus;
+  }
+};
+var WebhookVerificationError = class extends SimmitError {
+};
+
+// src/api-promise.ts
+var APIPromise = class extends Promise {
+  // Chained promises (.then/.catch) must be plain Promises: this class's
+  // constructor signature is incompatible with the executor the runtime
+  // would otherwise pass via the species constructor.
+  static get [Symbol.species]() {
+    return Promise;
+  }
+  #parsed;
+  constructor(parsed) {
+    super((resolve) => resolve(void 0));
+    this.#parsed = parsed;
+  }
+  then(onfulfilled, onrejected) {
+    return this.#parsed.then((result) => result.data).then(onfulfilled, onrejected);
+  }
+  withResponse() {
+    return this.#parsed;
+  }
+  asResponse() {
+    return this.#parsed.then((result) => result.response);
+  }
+};
+
+// src/internal/abort.ts
+function throwIfUserAborted(signal) {
+  if (signal?.aborted) throw new APIUserAbortError();
+}
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    throwIfUserAborted(signal);
+    const timeoutId = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timeoutId);
+      reject(new APIUserAbortError());
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
+// src/internal/request.ts
+var INITIAL_BACKOFF_MS = 500;
+var MAX_BACKOFF_MS = 8e3;
+var MAX_RETRY_AFTER_MS = 6e4;
+function makeRequest(config, spec, options = {}) {
+  return new APIPromise(run(config, spec, options));
+}
+async function run(config, spec, options) {
+  const maxRetries = options.maxRetries ?? config.maxRetries;
+  const timeout = options.timeout ?? config.timeout;
+  const headers = buildHeaders(config, spec, options);
+  const url = `${config.baseURL.replace(/\/+$/, "")}${spec.path}`;
+  const body = spec.body === void 0 ? void 0 : JSON.stringify(spec.body);
+  for (let attempt = 0; ; attempt++) {
+    throwIfUserAborted(options.signal);
+    let result;
+    try {
+      result = await fetchAttempt(config, spec, options, {
+        url,
+        headers,
+        body,
+        timeout
+      });
+    } catch (err) {
+      if (err instanceof APIUserAbortError) throw err;
+      if (attempt < maxRetries) {
+        await backoff(attempt, void 0, options.signal);
+        continue;
+      }
+      throw err;
+    }
+    const { response, json } = result;
+    if (response.ok) {
+      return { data: json, response };
+    }
+    if (shouldRetryStatus(response.status) && attempt < maxRetries) {
+      await backoff(
+        attempt,
+        response.headers.get("retry-after"),
+        options.signal
+      );
+      continue;
+    }
+    throw APIError.generate(
+      response.status,
+      typeof json === "object" && json !== null ? json : void 0,
+      response.statusText,
+      response.headers
+    );
+  }
+}
+async function fetchAttempt(config, spec, options, attempt) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), attempt.timeout);
+  const onUserAbort = () => controller.abort();
+  options.signal?.addEventListener("abort", onUserAbort, { once: true });
+  try {
+    const response = await config.fetch(attempt.url, {
+      ...config.fetchOptions,
+      method: spec.method,
+      headers: attempt.headers,
+      ...attempt.body !== void 0 ? { body: attempt.body } : {},
+      signal: controller.signal
+    });
+    let json;
+    if (response.ok) {
+      json = await response.json();
+    } else {
+      try {
+        json = await response.json();
+      } catch (err) {
+        if (controller.signal.aborted) throw err;
+        json = void 0;
+      }
+    }
+    return { response, json };
+  } catch (err) {
+    if (options.signal?.aborted) throw new APIUserAbortError();
+    if (controller.signal.aborted) {
+      throw new APIConnectionTimeoutError();
+    }
+    throw new APIConnectionError({
+      cause: err instanceof Error ? err : void 0
+    });
+  } finally {
+    clearTimeout(timeoutId);
+    options.signal?.removeEventListener("abort", onUserAbort);
+  }
+}
+function buildHeaders(config, spec, options) {
+  const idempotent = spec.idempotent && spec.method === "POST";
+  const merged = {
+    authorization: `Bearer ${config.secretKey}`,
+    ...spec.body !== void 0 ? { "content-type": "application/json" } : {},
+    ...idempotent && !options.idempotencyKey ? {
+      // Generated once per call and reused across retry attempts — that
+      // is what makes POST retries safe by default. The auto
+      // key is an SDK built-in default (lowest tier), so defaultHeaders
+      // may override it.
+      "idempotency-key": `simmit-node-retry-${crypto.randomUUID()}`
+    } : {},
+    ...lowercaseKeys(config.defaultHeaders),
+    ...idempotent && options.idempotencyKey ? {
+      // An explicit key is a per-request option: it must beat constructor
+      // defaultHeaders. Raw options.headers still wins last.
+      "idempotency-key": options.idempotencyKey
+    } : {},
+    ...lowercaseKeys(options.headers)
+  };
+  const headers = {};
+  for (const [key, value] of Object.entries(merged)) {
+    if (typeof value === "string") headers[key] = value;
+  }
+  return headers;
+}
+function lowercaseKeys(record) {
+  if (!record) return {};
+  return Object.fromEntries(
+    Object.entries(record).map(([key, value]) => [key.toLowerCase(), value])
+  );
+}
+function shouldRetryStatus(status) {
+  return status === 408 || status === 429 || status >= 500;
+}
+async function backoff(attempt, retryAfterHeader, signal) {
+  const retryAfterMs = parseRetryAfter(retryAfterHeader);
+  const delay = retryAfterMs !== void 0 ? retryAfterMs : Math.min(INITIAL_BACKOFF_MS * 2 ** attempt, MAX_BACKOFF_MS) * (1 - 0.25 * Math.random());
+  await sleep(delay, signal);
+}
+function parseRetryAfter(header) {
+  if (!header) return void 0;
+  let ms;
+  if (/^\d+$/.test(header.trim())) {
+    ms = Number(header.trim()) * 1e3;
+  } else {
+    ms = new Date(header).getTime() - Date.now();
+  }
+  return Number.isFinite(ms) && ms > 0 && ms <= MAX_RETRY_AFTER_MS ? ms : void 0;
+}
+
+// src/resources/artifacts.ts
+var Artifacts = class {
+  #client;
+  constructor(client) {
+    this.#client = client;
+  }
+  /**
+   * Fetch a stable public download URL for an artifact, valid for the
+   * artifact's full retention window — the same URL `jobs.getResult` returns,
+   * fetched on demand (e.g. browser flows that control the final fetch). The
+   * artifact is gone (410) once its retention window passes.
+   */
+  getUrl(artifactId, options) {
+    return this.#client._request(
+      {
+        method: "GET",
+        path: `/v1/simc/artifacts/${encodeURIComponent(artifactId)}/url`
+      },
+      options
+    );
+  }
+};
+
+// src/resources/credits.ts
+var Credits = class {
+  #client;
+  constructor(client) {
+    this.#client = client;
+  }
+  /** Fetch the account's current credit balance and per-grant breakdown. */
+  get(options) {
+    return this.#client._request(
+      { method: "GET", path: "/v1/simc/credits" },
+      options
+    );
+  }
+};
+
+// src/internal/poll.ts
+var MIN_POLL_INTERVAL_MS = 100;
+var DEFAULT_POLL_INTERVAL_MS = 1e3;
+var MAX_POLL_INTERVAL_MS = 1e4;
+var POLL_BACKOFF_FACTOR = 1.5;
+var DEADLINE_GRACE_MS = 6e4;
+var FALLBACK_WAIT_TIMEOUT_MS = 45 * 60 * 1e3;
+var TERMINAL_STATUSES = /* @__PURE__ */ new Set([
+  "completed",
+  "failed",
+  "cancelled",
+  "timed_out"
+]);
+function isTerminal(status) {
+  return TERMINAL_STATUSES.has(status);
+}
+function deriveWaitTimeoutMs(created) {
+  const { runtimeSeconds, queueSeconds } = created.runtime.ceiling;
+  if (runtimeSeconds != null && queueSeconds != null) {
+    return (runtimeSeconds + queueSeconds) * 1e3 + DEADLINE_GRACE_MS;
+  }
+  return FALLBACK_WAIT_TIMEOUT_MS;
+}
+function nextPollInterval(interval) {
+  return Math.min(interval * POLL_BACKOFF_FACTOR, MAX_POLL_INTERVAL_MS);
+}
+
+// src/resources/jobs.ts
+var Jobs = class {
+  #client;
+  constructor(client) {
+    this.#client = client;
+  }
+  /**
+   * Submit a new SimC sim. Returns immediately with the job handle; the sim
+   * runs asynchronously. `idempotent: true` makes the request layer attach an
+   * auto-generated idempotency key so the POST is safe to retry; pass
+   * `options.idempotencyKey` to supply your own.
+   */
+  create(params, options) {
+    return this.#client._request(
+      { method: "POST", path: "/v1/simc/jobs", body: params, idempotent: true },
+      options
+    );
+  }
+  /** Fetch the full record for a job. */
+  get(jobId, options) {
+    return this.#client._request(
+      { method: "GET", path: `/v1/simc/jobs/${encodeURIComponent(jobId)}` },
+      options
+    );
+  }
+  /**
+   * Fetch the live status of a job in any state — `status`, `errorCode`,
+   * `progress`, and `queue` estimate. Unlike `getResult`, it never throws for a
+   * non-terminal job, so it is the supported way to drive a custom poll loop.
+   */
+  getStatus(jobId, options) {
+    return this.#client._request(
+      {
+        method: "GET",
+        path: `/v1/simc/jobs/${encodeURIComponent(jobId)}/status`
+      },
+      options
+    );
+  }
+  /**
+   * Fetch the result summary of a terminal job. Throws `ResultNotReadyError`
+   * (409) while the job is still running — poll `/status` or use
+   * `createAndWait` rather than `/result` for a job in flight.
+   */
+  getResult(jobId, options) {
+    return this.#client._request(
+      {
+        method: "GET",
+        path: `/v1/simc/jobs/${encodeURIComponent(jobId)}/result`
+      },
+      options
+    );
+  }
+  /**
+   * Submit a job and resolve once it reaches a terminal state. Polls
+   * `GET /v1/simc/jobs/{id}/status` (first after `pollIntervalMs`, then ×1.5 to
+   * a 10s cap), then fetches the full record. Resolves with the `CompletedJob`
+   * on success; throws `JobFailedError` / `JobCancelledError` /
+   * `JobTimedOutError` for the other terminal states, or `JobWaitTimeoutError`
+   * if the deadline passes first — the job keeps running and is **not**
+   * cancelled (call `cancel(jobId)` to stop the spend). `signal` aborts the wait
+   * with `APIUserAbortError`, also without cancelling.
+   */
+  async createAndWait(params, options = {}) {
+    const {
+      pollIntervalMs,
+      waitTimeoutMs,
+      onCreated,
+      onPoll,
+      ...requestOptions
+    } = options;
+    const created = await this.create(params, requestOptions);
+    onCreated?.(created);
+    const deadline = Date.now() + (waitTimeoutMs ?? deriveWaitTimeoutMs(created));
+    let interval = Math.max(
+      pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS,
+      MIN_POLL_INTERVAL_MS
+    );
+    let lastStatus = "pending";
+    for (; ; ) {
+      const remaining = deadline - Date.now();
+      if (remaining <= 0) {
+        throw new JobWaitTimeoutError({ jobId: created.id, lastStatus });
+      }
+      await sleep(Math.min(interval, remaining), requestOptions.signal);
+      const status = await this.getStatus(created.id, requestOptions);
+      onPoll?.(status);
+      lastStatus = status.status;
+      if (isTerminal(status.status)) {
+        const job = await this.get(created.id, requestOptions);
+        switch (job.status) {
+          case "completed":
+            return job;
+          case "failed":
+            throw new JobFailedError(job);
+          case "cancelled":
+            throw new JobCancelledError(job);
+          case "timed_out":
+            throw new JobTimedOutError(job);
+        }
+        lastStatus = job.status;
+      }
+      interval = nextPollInterval(interval);
+    }
+  }
+  /**
+   * Request cancellation. Returns `status: 'cancelled'` when the job ended
+   * before it ran, or `status: 'cancel_requested'` when an in-flight job was
+   * signaled to stop. Repeat calls are naturally idempotent, so no key is sent.
+   */
+  cancel(jobId, options) {
+    return this.#client._request(
+      {
+        method: "POST",
+        path: `/v1/simc/jobs/${encodeURIComponent(jobId)}/cancel`
+      },
+      options
+    );
+  }
+};
+
+// src/client.ts
+var Simmit = class {
+  jobs;
+  credits;
+  artifacts;
+  baseURL;
+  #config;
+  constructor(options = {}) {
+    const secretKey = options.secretKey ?? readEnv("SIMMIT_SECRET_KEY");
+    if (!secretKey) {
+      throw new SimmitError(
+        "Missing secret key. Pass secretKey or set SIMMIT_SECRET_KEY."
+      );
+    }
+    this.baseURL = options.baseURL ?? readEnv("SIMMIT_BASE_URL") ?? "https://api.simmit.com";
+    this.#config = {
+      secretKey,
+      baseURL: this.baseURL,
+      timeout: options.timeout ?? 6e4,
+      maxRetries: options.maxRetries ?? 2,
+      defaultHeaders: options.defaultHeaders,
+      // Resolved lazily so a fetch patched onto globalThis after the client
+      // is constructed (msw, APM instrumentation) is still honored.
+      fetch: options.fetch ?? ((...args) => globalThis.fetch(...args)),
+      fetchOptions: options.fetchOptions
+    };
+    this.jobs = new Jobs(this);
+    this.credits = new Credits(this);
+    this.artifacts = new Artifacts(this);
+  }
+  /** @internal Resource classes route through here; not public surface. */
+  _request(spec, options) {
+    return makeRequest(this.#config, spec, options);
+  }
+};
+function readEnv(name) {
+  if (typeof process === "undefined") return void 0;
+  const value = process.env?.[name]?.trim();
+  return value || void 0;
+}
+
+// src/webhook.ts
+var DEFAULT_TOLERANCE_SECONDS = 300;
+async function unwrapWebhook(rawBody, signatureHeader, secret, options) {
+  if (!secret) {
+    throw new WebhookVerificationError("Webhook signing secret is empty.");
+  }
+  const tolerance = options?.toleranceSeconds ?? DEFAULT_TOLERANCE_SECONDS;
+  if (!Number.isFinite(tolerance) || tolerance < 0) {
+    throw new WebhookVerificationError(
+      "toleranceSeconds must be a non-negative number."
+    );
+  }
+  const { timestampRaw, timestamp, signature } = parseSignatureHeader(signatureHeader);
+  const expected = await hmacSha256Hex(secret, `${timestampRaw}.${rawBody}`);
+  if (!timingSafeEqual(expected, signature)) {
+    throw new WebhookVerificationError("Webhook signature does not match.");
+  }
+  if (Math.abs(Math.floor(Date.now() / 1e3) - timestamp) > tolerance) {
+    throw new WebhookVerificationError(
+      "Webhook timestamp is outside the tolerance window."
+    );
+  }
+  try {
+    return JSON.parse(rawBody);
+  } catch {
+    throw new WebhookVerificationError("Webhook body is not valid JSON.");
+  }
+}
+function parseSignatureHeader(header) {
+  let timestampRaw;
+  let signature;
+  for (const part of header.split(",")) {
+    const eq = part.indexOf("=");
+    if (eq === -1) continue;
+    const key = part.slice(0, eq).trim();
+    const value = part.slice(eq + 1).trim();
+    if (key === "t") timestampRaw = value;
+    else if (key === "v1") signature = value;
+  }
+  if (!timestampRaw || !signature || !/^\d+$/.test(timestampRaw)) {
+    throw new WebhookVerificationError(
+      'Malformed signature header; expected "t=<unix>,v1=<hex>".'
+    );
+  }
+  return { timestampRaw, timestamp: Number(timestampRaw), signature };
+}
+async function hmacSha256Hex(secret, payload) {
+  const encoder = new TextEncoder();
+  const key = await crypto.subtle.importKey(
+    "raw",
+    encoder.encode(secret),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const mac = await crypto.subtle.sign("HMAC", key, encoder.encode(payload));
+  return toHex(new Uint8Array(mac));
+}
+function toHex(bytes) {
+  let hex = "";
+  for (const byte of bytes) hex += byte.toString(16).padStart(2, "0");
+  return hex;
+}
+function timingSafeEqual(a, b) {
+  if (a.length !== b.length) return false;
+  let mismatch = 0;
+  for (let i = 0; i < a.length; i++) {
+    mismatch |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  }
+  return mismatch === 0;
+}
+export {
+  APIConnectionError,
+  APIConnectionTimeoutError,
+  APIError,
+  APIPromise,
+  APIUserAbortError,
+  AuthenticationError,
+  BadRequestError,
+  BillingError,
+  ConflictError,
+  IdempotencyKeyReuseError,
+  InsufficientCreditsError,
+  InsufficientCreditsLiabilityError,
+  InternalServerError,
+  InvalidProfileError,
+  JobCancelledError,
+  JobFailedError,
+  JobNotCancellableError,
+  JobTimedOutError,
+  JobUnsuccessfulError,
+  JobWaitTimeoutError,
+  MaxActiveJobsError,
+  NotFoundError,
+  RateLimitError,
+  RequestTooLargeError,
+  ResultNotReadyError,
+  ResultUnavailableError,
+  ServiceUnavailableError,
+  Simmit,
+  SimmitError,
+  UnprocessableEntityError,
+  WebhookVerificationError,
+  Simmit as default,
+  unwrapWebhook
+};
+//# sourceMappingURL=index.js.map