@sinnu-dev/sdk 0.0.0-stage → 0.2.1

package/dist/index.js

@@ -0,0 +1,850 @@
+// node_modules/openapi-fetch/dist/index.js
+var PATH_PARAM_RE = /\{[^{}]+\}/g;
+var supportsRequestInitExt = () => {
+  return typeof process === "object" && Number.parseInt(process?.versions?.node?.substring(0, 2)) >= 18 && process.versions.undici;
+};
+function randomID() {
+  return Math.random().toString(36).slice(2, 11);
+}
+function createClient(clientOptions) {
+  let {
+    baseUrl = "",
+    Request: CustomRequest = globalThis.Request,
+    fetch: baseFetch = globalThis.fetch,
+    querySerializer: globalQuerySerializer,
+    bodySerializer: globalBodySerializer,
+    headers: baseHeaders,
+    requestInitExt = void 0,
+    ...baseOptions
+  } = { ...clientOptions };
+  requestInitExt = supportsRequestInitExt() ? requestInitExt : void 0;
+  baseUrl = removeTrailingSlash(baseUrl);
+  const middlewares = [];
+  async function coreFetch(schemaPath, fetchOptions) {
+    const {
+      baseUrl: localBaseUrl,
+      fetch: fetch2 = baseFetch,
+      Request = CustomRequest,
+      headers,
+      params = {},
+      parseAs = "json",
+      querySerializer: requestQuerySerializer,
+      bodySerializer = globalBodySerializer ?? defaultBodySerializer,
+      body,
+      ...init
+    } = fetchOptions || {};
+    let finalBaseUrl = baseUrl;
+    if (localBaseUrl) {
+      finalBaseUrl = removeTrailingSlash(localBaseUrl) ?? baseUrl;
+    }
+    let querySerializer = typeof globalQuerySerializer === "function" ? globalQuerySerializer : createQuerySerializer(globalQuerySerializer);
+    if (requestQuerySerializer) {
+      querySerializer = typeof requestQuerySerializer === "function" ? requestQuerySerializer : createQuerySerializer({
+        ...typeof globalQuerySerializer === "object" ? globalQuerySerializer : {},
+        ...requestQuerySerializer
+      });
+    }
+    const serializedBody = body === void 0 ? void 0 : bodySerializer(
+      body,
+      // Note: we declare mergeHeaders() both here and below because it’s a bit of a chicken-or-egg situation:
+      // bodySerializer() needs all headers so we aren’t dropping ones set by the user, however,
+      // the result of this ALSO sets the lowest-priority content-type header. So we re-merge below,
+      // setting the content-type at the very beginning to be overwritten.
+      // Lastly, based on the way headers work, it’s not a simple “present-or-not” check becauase null intentionally un-sets headers.
+      mergeHeaders(baseHeaders, headers, params.header)
+    );
+    const finalHeaders = mergeHeaders(
+      // with no body, we should not to set Content-Type
+      serializedBody === void 0 || // if serialized body is FormData; browser will correctly set Content-Type & boundary expression
+      serializedBody instanceof FormData ? {} : {
+        "Content-Type": "application/json"
+      },
+      baseHeaders,
+      headers,
+      params.header
+    );
+    const requestInit = {
+      redirect: "follow",
+      ...baseOptions,
+      ...init,
+      body: serializedBody,
+      headers: finalHeaders
+    };
+    let id;
+    let options;
+    let request = new CustomRequest(
+      createFinalURL(schemaPath, { baseUrl: finalBaseUrl, params, querySerializer }),
+      requestInit
+    );
+    let response;
+    for (const key in init) {
+      if (!(key in request)) {
+        request[key] = init[key];
+      }
+    }
+    if (middlewares.length) {
+      id = randomID();
+      options = Object.freeze({
+        baseUrl: finalBaseUrl,
+        fetch: fetch2,
+        parseAs,
+        querySerializer,
+        bodySerializer
+      });
+      for (const m of middlewares) {
+        if (m && typeof m === "object" && typeof m.onRequest === "function") {
+          const result = await m.onRequest({
+            request,
+            schemaPath,
+            params,
+            options,
+            id
+          });
+          if (result) {
+            if (result instanceof CustomRequest) {
+              request = result;
+            } else if (result instanceof Response) {
+              response = result;
+              break;
+            } else {
+              throw new Error("onRequest: must return new Request() or Response() when modifying the request");
+            }
+          }
+        }
+      }
+    }
+    if (!response) {
+      try {
+        response = await fetch2(request, requestInitExt);
+      } catch (error2) {
+        let errorAfterMiddleware = error2;
+        if (middlewares.length) {
+          for (let i = middlewares.length - 1; i >= 0; i--) {
+            const m = middlewares[i];
+            if (m && typeof m === "object" && typeof m.onError === "function") {
+              const result = await m.onError({
+                request,
+                error: errorAfterMiddleware,
+                schemaPath,
+                params,
+                options,
+                id
+              });
+              if (result) {
+                if (result instanceof Response) {
+                  errorAfterMiddleware = void 0;
+                  response = result;
+                  break;
+                }
+                if (result instanceof Error) {
+                  errorAfterMiddleware = result;
+                  continue;
+                }
+                throw new Error("onError: must return new Response() or instance of Error");
+              }
+            }
+          }
+        }
+        if (errorAfterMiddleware) {
+          throw errorAfterMiddleware;
+        }
+      }
+      if (middlewares.length) {
+        for (let i = middlewares.length - 1; i >= 0; i--) {
+          const m = middlewares[i];
+          if (m && typeof m === "object" && typeof m.onResponse === "function") {
+            const result = await m.onResponse({
+              request,
+              response,
+              schemaPath,
+              params,
+              options,
+              id
+            });
+            if (result) {
+              if (!(result instanceof Response)) {
+                throw new Error("onResponse: must return new Response() when modifying the response");
+              }
+              response = result;
+            }
+          }
+        }
+      }
+    }
+    if (response.status === 204 || request.method === "HEAD" || response.headers.get("Content-Length") === "0") {
+      return response.ok ? { data: void 0, response } : { error: void 0, response };
+    }
+    if (response.ok) {
+      if (parseAs === "stream") {
+        return { data: response.body, response };
+      }
+      return { data: await response[parseAs](), response };
+    }
+    let error = await response.text();
+    try {
+      error = JSON.parse(error);
+    } catch {
+    }
+    return { error, response };
+  }
+  return {
+    request(method, url, init) {
+      return coreFetch(url, { ...init, method: method.toUpperCase() });
+    },
+    /** Call a GET endpoint */
+    GET(url, init) {
+      return coreFetch(url, { ...init, method: "GET" });
+    },
+    /** Call a PUT endpoint */
+    PUT(url, init) {
+      return coreFetch(url, { ...init, method: "PUT" });
+    },
+    /** Call a POST endpoint */
+    POST(url, init) {
+      return coreFetch(url, { ...init, method: "POST" });
+    },
+    /** Call a DELETE endpoint */
+    DELETE(url, init) {
+      return coreFetch(url, { ...init, method: "DELETE" });
+    },
+    /** Call a OPTIONS endpoint */
+    OPTIONS(url, init) {
+      return coreFetch(url, { ...init, method: "OPTIONS" });
+    },
+    /** Call a HEAD endpoint */
+    HEAD(url, init) {
+      return coreFetch(url, { ...init, method: "HEAD" });
+    },
+    /** Call a PATCH endpoint */
+    PATCH(url, init) {
+      return coreFetch(url, { ...init, method: "PATCH" });
+    },
+    /** Call a TRACE endpoint */
+    TRACE(url, init) {
+      return coreFetch(url, { ...init, method: "TRACE" });
+    },
+    /** Register middleware */
+    use(...middleware) {
+      for (const m of middleware) {
+        if (!m) {
+          continue;
+        }
+        if (typeof m !== "object" || !("onRequest" in m || "onResponse" in m || "onError" in m)) {
+          throw new Error("Middleware must be an object with one of `onRequest()`, `onResponse() or `onError()`");
+        }
+        middlewares.push(m);
+      }
+    },
+    /** Unregister middleware */
+    eject(...middleware) {
+      for (const m of middleware) {
+        const i = middlewares.indexOf(m);
+        if (i !== -1) {
+          middlewares.splice(i, 1);
+        }
+      }
+    }
+  };
+}
+function serializePrimitiveParam(name, value, options) {
+  if (value === void 0 || value === null) {
+    return "";
+  }
+  if (typeof value === "object") {
+    throw new Error(
+      "Deeply-nested arrays/objects aren\u2019t supported. Provide your own `querySerializer()` to handle these."
+    );
+  }
+  return `${name}=${options?.allowReserved === true ? value : encodeURIComponent(value)}`;
+}
+function serializeObjectParam(name, value, options) {
+  if (!value || typeof value !== "object") {
+    return "";
+  }
+  const values = [];
+  const joiner = {
+    simple: ",",
+    label: ".",
+    matrix: ";"
+  }[options.style] || "&";
+  if (options.style !== "deepObject" && options.explode === false) {
+    for (const k in value) {
+      values.push(k, options.allowReserved === true ? value[k] : encodeURIComponent(value[k]));
+    }
+    const final2 = values.join(",");
+    switch (options.style) {
+      case "form": {
+        return `${name}=${final2}`;
+      }
+      case "label": {
+        return `.${final2}`;
+      }
+      case "matrix": {
+        return `;${name}=${final2}`;
+      }
+      default: {
+        return final2;
+      }
+    }
+  }
+  for (const k in value) {
+    const finalName = options.style === "deepObject" ? `${name}[${k}]` : k;
+    values.push(serializePrimitiveParam(finalName, value[k], options));
+  }
+  const final = values.join(joiner);
+  return options.style === "label" || options.style === "matrix" ? `${joiner}${final}` : final;
+}
+function serializeArrayParam(name, value, options) {
+  if (!Array.isArray(value)) {
+    return "";
+  }
+  if (options.explode === false) {
+    const joiner2 = { form: ",", spaceDelimited: "%20", pipeDelimited: "|" }[options.style] || ",";
+    const final = (options.allowReserved === true ? value : value.map((v) => encodeURIComponent(v))).join(joiner2);
+    switch (options.style) {
+      case "simple": {
+        return final;
+      }
+      case "label": {
+        return `.${final}`;
+      }
+      case "matrix": {
+        return `;${name}=${final}`;
+      }
+      // case "spaceDelimited":
+      // case "pipeDelimited":
+      default: {
+        return `${name}=${final}`;
+      }
+    }
+  }
+  const joiner = { simple: ",", label: ".", matrix: ";" }[options.style] || "&";
+  const values = [];
+  for (const v of value) {
+    if (options.style === "simple" || options.style === "label") {
+      values.push(options.allowReserved === true ? v : encodeURIComponent(v));
+    } else {
+      values.push(serializePrimitiveParam(name, v, options));
+    }
+  }
+  return options.style === "label" || options.style === "matrix" ? `${joiner}${values.join(joiner)}` : values.join(joiner);
+}
+function createQuerySerializer(options) {
+  return function querySerializer(queryParams) {
+    const search = [];
+    if (queryParams && typeof queryParams === "object") {
+      for (const name in queryParams) {
+        const value = queryParams[name];
+        if (value === void 0 || value === null) {
+          continue;
+        }
+        if (Array.isArray(value)) {
+          if (value.length === 0) {
+            continue;
+          }
+          search.push(
+            serializeArrayParam(name, value, {
+              style: "form",
+              explode: true,
+              ...options?.array,
+              allowReserved: options?.allowReserved || false
+            })
+          );
+          continue;
+        }
+        if (typeof value === "object") {
+          search.push(
+            serializeObjectParam(name, value, {
+              style: "deepObject",
+              explode: true,
+              ...options?.object,
+              allowReserved: options?.allowReserved || false
+            })
+          );
+          continue;
+        }
+        search.push(serializePrimitiveParam(name, value, options));
+      }
+    }
+    return search.join("&");
+  };
+}
+function defaultPathSerializer(pathname, pathParams) {
+  let nextURL = pathname;
+  for (const match of pathname.match(PATH_PARAM_RE) ?? []) {
+    let name = match.substring(1, match.length - 1);
+    let explode = false;
+    let style = "simple";
+    if (name.endsWith("*")) {
+      explode = true;
+      name = name.substring(0, name.length - 1);
+    }
+    if (name.startsWith(".")) {
+      style = "label";
+      name = name.substring(1);
+    } else if (name.startsWith(";")) {
+      style = "matrix";
+      name = name.substring(1);
+    }
+    if (!pathParams || pathParams[name] === void 0 || pathParams[name] === null) {
+      continue;
+    }
+    const value = pathParams[name];
+    if (Array.isArray(value)) {
+      nextURL = nextURL.replace(match, serializeArrayParam(name, value, { style, explode }));
+      continue;
+    }
+    if (typeof value === "object") {
+      nextURL = nextURL.replace(match, serializeObjectParam(name, value, { style, explode }));
+      continue;
+    }
+    if (style === "matrix") {
+      nextURL = nextURL.replace(match, `;${serializePrimitiveParam(name, value)}`);
+      continue;
+    }
+    nextURL = nextURL.replace(match, style === "label" ? `.${encodeURIComponent(value)}` : encodeURIComponent(value));
+  }
+  return nextURL;
+}
+function defaultBodySerializer(body, headers) {
+  if (body instanceof FormData) {
+    return body;
+  }
+  if (headers) {
+    const contentType = headers.get instanceof Function ? headers.get("Content-Type") ?? headers.get("content-type") : headers["Content-Type"] ?? headers["content-type"];
+    if (contentType === "application/x-www-form-urlencoded") {
+      return new URLSearchParams(body).toString();
+    }
+  }
+  return JSON.stringify(body);
+}
+function createFinalURL(pathname, options) {
+  let finalURL = `${options.baseUrl}${pathname}`;
+  if (options.params?.path) {
+    finalURL = defaultPathSerializer(finalURL, options.params.path);
+  }
+  let search = options.querySerializer(options.params.query ?? {});
+  if (search.startsWith("?")) {
+    search = search.substring(1);
+  }
+  if (search) {
+    finalURL += `?${search}`;
+  }
+  return finalURL;
+}
+function mergeHeaders(...allHeaders) {
+  const finalHeaders = new Headers();
+  for (const h of allHeaders) {
+    if (!h || typeof h !== "object") {
+      continue;
+    }
+    const iterator = h instanceof Headers ? h.entries() : Object.entries(h);
+    for (const [k, v] of iterator) {
+      if (v === null) {
+        finalHeaders.delete(k);
+      } else if (Array.isArray(v)) {
+        for (const v2 of v) {
+          finalHeaders.append(k, v2);
+        }
+      } else if (v !== void 0) {
+        finalHeaders.set(k, v);
+      }
+    }
+  }
+  return finalHeaders;
+}
+function removeTrailingSlash(url) {
+  if (url.endsWith("/")) {
+    return url.substring(0, url.length - 1);
+  }
+  return url;
+}
+
+// src/errors.ts
+var SinnuError = class extends Error {
+  constructor(message, statusCode, body, response) {
+    super(message);
+    this.name = "SinnuError";
+    this.statusCode = statusCode;
+    this.body = body;
+    this.response = response;
+  }
+};
+var SinnuAuthError = class extends SinnuError {
+  constructor(message, statusCode = 401, body, response) {
+    super(message, statusCode, body, response);
+    this.name = "SinnuAuthError";
+  }
+};
+var SinnuNotFoundError = class extends SinnuError {
+  constructor(message, body, response) {
+    super(message, 404, body, response);
+    this.name = "SinnuNotFoundError";
+  }
+};
+var SinnuValidationError = class extends SinnuError {
+  constructor(message, statusCode, body, response) {
+    super(message, statusCode, body, response);
+    this.name = "SinnuValidationError";
+  }
+};
+var SinnuRateLimitError = class extends SinnuError {
+  constructor(message, body, response) {
+    super(message, 429, body, response);
+    this.name = "SinnuRateLimitError";
+  }
+};
+function toSinnuError(statusCode, body, response) {
+  const message = body?.message ?? `Requisi\xE7\xE3o falhou com status ${statusCode}`;
+  switch (statusCode) {
+    case 401:
+    case 403:
+      return new SinnuAuthError(message, statusCode, body, response);
+    case 404:
+      return new SinnuNotFoundError(message, body, response);
+    case 400:
+    case 422:
+      return new SinnuValidationError(message, statusCode, body, response);
+    case 429:
+      return new SinnuRateLimitError(message, body, response);
+    default:
+      return new SinnuError(message, statusCode, body, response);
+  }
+}
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://api.sinnu.com.br";
+var API_KEY_PREFIXES = ["sk_live_"];
+function assertApiKey(apiKey) {
+  if (!apiKey || typeof apiKey !== "string") {
+    throw new Error(
+      "[@sinnu-dev/sdk] apiKey \xE9 obrigat\xF3ria. Gere uma chave secreta no painel sinnu (Integra\xE7\xF5es)."
+    );
+  }
+  if (!API_KEY_PREFIXES.some((p) => apiKey.startsWith(p))) {
+    console.warn(
+      "[@sinnu-dev/sdk] apiKey n\xE3o come\xE7a com 'sk_live_'. Use a chave secreta no backend, nunca uma chave no cliente."
+    );
+  }
+}
+function createTypedClient(options) {
+  assertApiKey(options.apiKey);
+  return createClient({
+    baseUrl: options.baseUrl ?? DEFAULT_BASE_URL,
+    fetch: options.fetch,
+    headers: {
+      Authorization: `Bearer ${options.apiKey}`,
+      "Content-Type": "application/json",
+      ...options.headers
+    }
+  });
+}
+async function unwrap(p) {
+  const { data, error, response } = await p;
+  if (error || !response.ok) {
+    throw toSinnuError(
+      response.status,
+      error ?? void 0,
+      response
+    );
+  }
+  if (data === void 0 || data === null) {
+    throw toSinnuError(response.status, { message: "Resposta sem corpo" }, response);
+  }
+  return data;
+}
+var RawHttp = class {
+  constructor(baseUrl, apiKey, extraHeaders, fetchImpl) {
+    this.baseUrl = baseUrl;
+    this.apiKey = apiKey;
+    this.extraHeaders = extraHeaders;
+    this.fetchImpl = fetchImpl;
+  }
+  async request(path, options = {}) {
+    const url = new URL(path.replace(/^\//, ""), ensureTrailingSlash(this.baseUrl));
+    if (options.query) {
+      for (const [key, value] of Object.entries(options.query)) {
+        if (value !== void 0) {
+          url.searchParams.set(key, String(value));
+        }
+      }
+    }
+    const response = await this.fetchImpl(url.toString(), {
+      method: options.method ?? "GET",
+      headers: {
+        Authorization: `Bearer ${this.apiKey}`,
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        ...this.extraHeaders
+      },
+      body: options.body !== void 0 ? JSON.stringify(options.body) : void 0
+    });
+    const text = await response.text();
+    const parsed = text ? safeJsonParse(text) : void 0;
+    if (!response.ok) {
+      throw toSinnuError(response.status, parsed, response);
+    }
+    return parsed;
+  }
+};
+function ensureTrailingSlash(url) {
+  return url.endsWith("/") ? url : `${url}/`;
+}
+function safeJsonParse(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+
+// src/resources/checkout.ts
+var DEFAULT_CHECKOUT_BASE_URL = "https://pay.sinnu.com.br";
+var Checkout = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  /**
+   * Monta a URL pública do checkout hosted para um `slug` (8 chars) gerado
+   * ao criar um link (`sinnu.links.create(...).url` já vem pronto; este
+   * helper é útil quando você só tem o slug).
+   *
+   * @example
+   * const url = sinnu.checkout.url("abcd1234", { reference: "pedido-123" });
+   * // => "https://pay.sinnu.com.br/abcd1234?ref=pedido-123"
+   */
+  url(slug, options = {}) {
+    if (!slug || typeof slug !== "string") {
+      throw new Error("[@sinnu-dev/sdk] slug do checkout \xE9 obrigat\xF3rio.");
+    }
+    const base = options.checkoutBaseUrl ?? this.options.checkoutBaseUrl ?? DEFAULT_CHECKOUT_BASE_URL;
+    const url = new URL(encodeURIComponent(slug), ensureTrailingSlash2(base));
+    const query = { ...this.options.query, ...options.query };
+    for (const [key, value] of Object.entries(query)) {
+      if (value !== void 0) {
+        url.searchParams.set(key, String(value));
+      }
+    }
+    if (options.reference !== void 0) {
+      if (options.reference.length > 255) {
+        throw new Error("[@sinnu-dev/sdk] reference tem no m\xE1ximo 255 caracteres.");
+      }
+      url.searchParams.set("ref", options.reference);
+    }
+    return url.toString();
+  }
+};
+function ensureTrailingSlash2(url) {
+  return url.endsWith("/") ? url : `${url}/`;
+}
+
+// src/pagination.ts
+async function* paginate(fetchPage) {
+  let page = 1;
+  let seen = 0;
+  while (true) {
+    const result = await fetchPage(page);
+    for (const item of result.data) {
+      yield item;
+    }
+    seen += result.data.length;
+    const pageSize = result.pageSize || result.data.length;
+    if (result.data.length === 0 || seen >= result.total || pageSize === 0) {
+      return;
+    }
+    page += 1;
+  }
+}
+async function collectAll(fetchPage) {
+  const out = [];
+  for await (const item of paginate(fetchPage)) {
+    out.push(item);
+  }
+  return out;
+}
+
+// src/resources/links.ts
+var Links = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /** Cria um link de pagamento (valor em centavos). */
+  async create(body) {
+    return this.http.request("/api/payment-links", {
+      method: "POST",
+      body
+    });
+  }
+  /** Busca um link de pagamento pelo id. */
+  async get(id) {
+    return this.http.request(`/api/payment-links/${encodeURIComponent(id)}`);
+  }
+  /** Atualiza parcialmente um link de pagamento. */
+  async update(id, body) {
+    return this.http.request(`/api/payment-links/${encodeURIComponent(id)}`, {
+      method: "PATCH",
+      body
+    });
+  }
+  /** Arquiva um link de pagamento. */
+  async archive(id) {
+    await this.http.request(`/api/payment-links/${encodeURIComponent(id)}`, {
+      method: "DELETE"
+    });
+  }
+  /** Lista links de pagamento (paginado). */
+  async list(params = {}) {
+    return this.http.request("/api/payment-links", {
+      query: { page: params.page, pageSize: params.pageSize }
+    });
+  }
+  /** Lista transações de um link de pagamento (paginado). */
+  async transactions(id, params = {}) {
+    return this.http.request(
+      `/api/payment-links/${encodeURIComponent(id)}/transactions`,
+      { query: { page: params.page, pageSize: params.pageSize } }
+    );
+  }
+  /** Itera todos os links de pagamento, página a página. */
+  listAll(params = {}) {
+    return paginate((page) => this.list({ ...params, page }));
+  }
+};
+
+// src/resources/transactions.ts
+var Transactions = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /** Lista transações (paginado, com filtro opcional por status). */
+  async list(params = {}) {
+    return this.http.request("/api/transactions/", {
+      query: {
+        status: params.status,
+        search: params.search,
+        customer: params.customer,
+        page: params.page,
+        pageSize: params.pageSize
+      }
+    });
+  }
+  /** Busca uma transação pelo id. */
+  async get(id) {
+    return this.http.request(`/api/transactions/${encodeURIComponent(id)}/`);
+  }
+  /** Estorna (refund) uma transação, sempre pelo valor total. Exige o escopo `transactions:refund` na chave. */
+  async refund(id, body = {}) {
+    return this.http.request(
+      `/api/transactions/${encodeURIComponent(id)}/refund/`,
+      { method: "POST", body }
+    );
+  }
+  /** Itera todas as transações, página a página. */
+  listAll(params = {}) {
+    return paginate((page) => this.list({ ...params, page }));
+  }
+};
+
+// src/webhooks.ts
+import { createHmac, timingSafeEqual } from "crypto";
+var SINNU_SIGNATURE_HEADER = "x-sinnu-signature";
+var SinnuWebhookSignatureError = class extends SinnuError {
+  constructor(message) {
+    super(message, 0);
+    this.name = "SinnuWebhookSignatureError";
+  }
+};
+function normalizeSignature(signature) {
+  if (signature === void 0) {
+    throw new SinnuWebhookSignatureError(
+      "[@sinnu-dev/sdk] header de assinatura ausente. Esperado 'X-Sinnu-Signature'."
+    );
+  }
+  const value = Array.isArray(signature) ? signature[0] : signature;
+  if (!value) {
+    throw new SinnuWebhookSignatureError("[@sinnu-dev/sdk] header de assinatura vazio.");
+  }
+  return value.startsWith("sha256=") ? value.slice("sha256=".length) : value;
+}
+function toBuffer(payload) {
+  return typeof payload === "string" ? Buffer.from(payload, "utf8") : payload;
+}
+function computeSignature(payload, secret) {
+  return createHmac("sha256", secret).update(toBuffer(payload)).digest("hex");
+}
+function verifySignature(options) {
+  const { payload, signature, secret } = options;
+  if (!secret) {
+    throw new SinnuWebhookSignatureError(
+      "[@sinnu-dev/sdk] webhook secret \xE9 obrigat\xF3rio para verificar a assinatura."
+    );
+  }
+  const provided = normalizeSignature(signature);
+  const expected = computeSignature(payload, secret);
+  const providedBuf = Buffer.from(provided, "hex");
+  const expectedBuf = Buffer.from(expected, "hex");
+  if (providedBuf.length !== expectedBuf.length) {
+    return false;
+  }
+  return timingSafeEqual(providedBuf, expectedBuf);
+}
+function constructEvent(options) {
+  if (!verifySignature(options)) {
+    throw new SinnuWebhookSignatureError(
+      "[@sinnu-dev/sdk] assinatura de webhook inv\xE1lida. Requisi\xE7\xE3o rejeitada."
+    );
+  }
+  const text = typeof options.payload === "string" ? options.payload : options.payload.toString("utf8");
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new SinnuWebhookSignatureError("[@sinnu-dev/sdk] corpo do webhook n\xE3o \xE9 um JSON v\xE1lido.");
+  }
+}
+var webhooks = {
+  signatureHeader: SINNU_SIGNATURE_HEADER,
+  computeSignature,
+  verifySignature,
+  constructEvent
+};
+
+// src/index.ts
+var Sinnu = class {
+  constructor(options) {
+    /** Verificação de webhooks (HMAC SHA-256): não faz requisições. */
+    this.webhooks = webhooks;
+    this.http = createTypedClient(options);
+    const raw = new RawHttp(
+      options.baseUrl ?? DEFAULT_BASE_URL,
+      options.apiKey,
+      options.headers ?? {},
+      options.fetch ?? fetch
+    );
+    this.links = new Links(raw);
+    this.transactions = new Transactions(raw);
+    this.checkout = new Checkout({ checkoutBaseUrl: options.checkoutBaseUrl });
+  }
+};
+var index_default = Sinnu;
+export {
+  Checkout,
+  DEFAULT_BASE_URL,
+  DEFAULT_CHECKOUT_BASE_URL,
+  SINNU_SIGNATURE_HEADER,
+  Sinnu,
+  SinnuAuthError,
+  SinnuError,
+  SinnuNotFoundError,
+  SinnuRateLimitError,
+  SinnuValidationError,
+  SinnuWebhookSignatureError,
+  collectAll,
+  computeSignature,
+  constructEvent,
+  createTypedClient,
+  index_default as default,
+  paginate,
+  unwrap,
+  verifySignature,
+  webhooks
+};