@rewritetoday/sdk 1.0.1

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Rewrite
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,107 @@
+<div align="center">
+
+# Rewrite Node SDK
+
+[`@rewritetoday/sdk`](https://docs.rewritetoday.com/en/sdks/node), the official Node.js/TypeScript SDK for the Rewrite API.
+
+It wraps authentication, typed REST calls, and resource helpers on top of [`@rewritetoday/rest`](https://www.npmjs.com/package/@rewritetoday/rest) and [`@rewritetoday/types`](https://www.npmjs.com/package/@rewritetoday/types).
+
+<img src="https://cdn.rewritetoday.com/assets/banners/node-sdk.png" width="100%" alt="Rewrite Banner"/>
+
+## Installation
+
+Use your preferred package manager:
+
+</div>
+
+```bash
+bun add @rewritetoday/sdk
+# Or
+npm install @rewritetoday/sdk
+# Or
+pnpm add @rewritetoday/sdk
+```
+
+<div align="center">
+
+## Setup
+
+First, you need to create an API key in the [Rewrite Dashboard](https://dash.rewritetoday.com/api-keys) and use it in the constructor.
+
+</div>
+
+```ts
+import { Rewrite } from '@rewritetoday/sdk';
+
+const rewrite = new Rewrite(process.env.REWRITE_API_KEY);
+```
+
+<div align="center">
+
+## Create the client
+
+You can pass the API key directly or use the full options object.
+
+</div>
+
+```ts
+import { Rewrite } from '@rewritetoday/sdk';
+
+const rewrite = new Rewrite({
+	secret: 'rw_...',
+	rest: {
+		timeout: 10_000,
+		headers: {
+			'User-Agent': 'StatusPage One (1.0.0)',
+		},
+		retry: {
+			max: 3,
+			delay(attempt) {
+				return attempt * 250;
+			},
+		},
+	},
+});
+```
+
+<div align="center">
+
+## Send your first message
+
+</div>
+
+```ts
+const { data, error } = await rewrite.messages.send({
+	to: '+551234567890',
+	content: 'Hey, Rewrite is here!',
+});
+```
+
+<div align="center">
+
+You can view in our [documentation](https://docs.rewritetoday.com/api-reference/messages/send-a-message) everything in you can use when sending a message.
+
+## Error Handling
+
+Requests run through `@rewritetoday/rest`. HTTP failures can throw `HTTPError`.
+
+</div>
+
+```ts
+import { HTTPError } from '@rewritetoday/rest';
+
+try {
+	await rewrite.projects.get('invalid_id');
+} catch (error) {
+	if (error instanceof HTTPError) {
+		console.error('HTTP Error:', error.status, error.method, error.url);
+	}
+}
+```
+
+<div align="center">
+
+Made with 🤍 by the Rewrite team. <br/>
+SMS the way it should be.
+
+</div>

package/dist/client.d.ts

@@ -0,0 +1,33 @@
+import { REST } from '@rewritetoday/rest';
+import { APIKeyManager } from './resources/api-key';
+import { LogManager } from './resources/logs';
+import { MessageManager } from './resources/message';
+import { OTPManager } from './resources/otp';
+import { TemplateManager } from './resources/template';
+import { WebhookManager } from './resources/webhook';
+import type { RewriteOptions } from './types';
+/**
+ * Main SDK client for the Rewrite API.
+ */
+export declare class Rewrite {
+    /** Low-level REST client instance. */
+    readonly rest: REST;
+    /** Resolved API secret used for authentication. */
+    private readonly secret;
+    /** OTP resource client. */
+    readonly otp: OTPManager;
+    /** Webhook logs resource client. */
+    readonly logs: LogManager;
+    /** API key resource client. */
+    readonly apiKeys: APIKeyManager;
+    /** Messages resource client. */
+    readonly messages: MessageManager;
+    /** Webhook resource client. */
+    readonly webhooks: WebhookManager;
+    /** Template resource client. */
+    readonly templates: TemplateManager;
+    /**
+     * Creates a new Rewrite client instance.
+     */
+    constructor(options: RewriteOptions | string);
+}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export * from '@rewritetoday/types';
+export { Rewrite } from './client';
+export { APIKeyManager } from './resources/api-key';
+export { LogManager } from './resources/logs';
+export { MessageManager } from './resources/message';
+export { OTPManager } from './resources/otp';
+export { TemplateManager } from './resources/template';
+export { WebhookManager } from './resources/webhook';
+export * from './types';
+export { version } from './version';

package/dist/index.js

@@ -0,0 +1,483 @@
+// node_modules/@rewritetoday/types/dist/v1/resources/apiKeys.js
+var APIKeyScope;
+(function(APIKeyScope2) {
+  APIKeyScope2["Wildcard"] = "*";
+  APIKeyScope2["ReadProject"] = "project:read";
+  APIKeyScope2["ReadAPIKeys"] = "project:api_keys:read";
+  APIKeyScope2["WriteProject"] = "project:write";
+  APIKeyScope2["ReadWebhooks"] = "project:webhooks:read";
+  APIKeyScope2["WriteTemplate"] = "project:templates:write";
+  APIKeyScope2["ReadTemplates"] = "project:templates:read";
+  APIKeyScope2["WriteWebhooks"] = "project:webhooks:write";
+  APIKeyScope2["WriteMessages"] = "message:write";
+  APIKeyScope2["ReadMessages"] = "message:read";
+  APIKeyScope2["ReadLogs"] = "project:logs:read";
+})(APIKeyScope || (APIKeyScope = {}));
+// node_modules/@rewritetoday/types/dist/v1/resources/logs.js
+var WebhookDeliveryStatus;
+(function(WebhookDeliveryStatus2) {
+  WebhookDeliveryStatus2["Success"] = "SUCCESS";
+  WebhookDeliveryStatus2["Failed"] = "FAILED";
+})(WebhookDeliveryStatus || (WebhookDeliveryStatus = {}));
+// node_modules/@rewritetoday/types/dist/v1/resources/message.js
+var MessageEncoding;
+(function(MessageEncoding2) {
+  MessageEncoding2["GMS7"] = "GMS7";
+  MessageEncoding2["UCS2"] = "UCS2";
+})(MessageEncoding || (MessageEncoding = {}));
+var MessageStatus;
+(function(MessageStatus2) {
+  MessageStatus2["Sent"] = "SENT";
+  MessageStatus2["Queued"] = "QUEUED";
+  MessageStatus2["Failed"] = "FAILED";
+  MessageStatus2["Canceled"] = "CANCELED";
+  MessageStatus2["Scheduled"] = "SCHEDULED";
+  MessageStatus2["Delivered"] = "DELIVERED";
+})(MessageStatus || (MessageStatus = {}));
+var MessageType;
+(function(MessageType2) {
+  MessageType2["SMS"] = "SMS";
+  MessageType2["OTP"] = "OTP";
+})(MessageType || (MessageType = {}));
+var MessageAnalysisReason;
+(function(MessageAnalysisReason2) {
+  MessageAnalysisReason2["FitsSingleSegment"] = "fits";
+  MessageAnalysisReason2["SmartEncodingApplied"] = "smart";
+  MessageAnalysisReason2["ExceedsSingleSegmentLimit"] = "singleLimit";
+  MessageAnalysisReason2["ContainsNonGsm7Characters"] = "nonGsm7";
+})(MessageAnalysisReason || (MessageAnalysisReason = {}));
+var MessageAnalysisEncoding;
+(function(MessageAnalysisEncoding2) {
+  MessageAnalysisEncoding2["GSM7"] = "gsm7";
+  MessageAnalysisEncoding2["UCS2"] = "ucs2";
+})(MessageAnalysisEncoding || (MessageAnalysisEncoding = {}));
+// node_modules/@rewritetoday/types/dist/v1/resources/webhooks.js
+var WebhookEventType;
+(function(WebhookEventType2) {
+  WebhookEventType2["SMSOTP"] = "sms.otp";
+  WebhookEventType2["MessageSent"] = "message.sent";
+  WebhookEventType2["MessageBatch"] = "message.batch";
+  WebhookEventType2["MessageQueued"] = "message.queued";
+  WebhookEventType2["MessageDelivered"] = "message.delivered";
+  WebhookEventType2["MessageScheduled"] = "message.scheduled";
+  WebhookEventType2["MessageFailed"] = "message.failed";
+  WebhookEventType2["MessageCanceled"] = "message.canceled";
+})(WebhookEventType || (WebhookEventType = {}));
+var WebhookStatus;
+(function(WebhookStatus2) {
+  WebhookStatus2["Active"] = "ACTIVE";
+  WebhookStatus2["Inactive"] = "INACTIVE";
+})(WebhookStatus || (WebhookStatus = {}));
+// node_modules/@rewritetoday/types/dist/v1/utils.js
+var createCursorQuery = ({ limit = 15, ...options } = {}) => {
+  return new URLSearchParams({ limit: limit.toString(), ...options });
+};
+
+// node_modules/@rewritetoday/types/dist/v1/routes.js
+var API_BASE_URL = "https://api.rewritetoday.com";
+var Routes = {
+  otp: {
+    send() {
+      return "/otp";
+    },
+    verify(id) {
+      return `/otp/${id}/verify`;
+    }
+  },
+  messages: {
+    send() {
+      return "/messages";
+    },
+    batch() {
+      return "/messages/batch";
+    },
+    list(options) {
+      return `/messages?${createCursorQuery(options)}`;
+    },
+    get(id) {
+      return `/messages/:${id}`;
+    },
+    cancel(id) {
+      return `/messages/${id}/cancel`;
+    }
+  },
+  webhooks: {
+    list(options) {
+      return `/webhooks?${createCursorQuery(options)}`;
+    },
+    create() {
+      return "/webhooks";
+    },
+    update(id) {
+      return `/webhooks/${id}`;
+    },
+    delete(id) {
+      return `/webhooks/${id}`;
+    },
+    get(id) {
+      return `/webhooks/${id}`;
+    },
+    logs(id, options) {
+      return `/webhooks/${id}/logs?${createCursorQuery(options)}`;
+    }
+  },
+  templates: {
+    list(options) {
+      return `/templates?${createCursorQuery(options)}`;
+    },
+    create() {
+      return "/templates";
+    },
+    update(id) {
+      return `/templates/${id}`;
+    },
+    delete(id) {
+      return `/templates/${id}`;
+    },
+    get(id) {
+      return `/templates/${id}`;
+    }
+  },
+  apiKeys: {
+    delete(id) {
+      return `/api-keys/${id}`;
+    }
+  },
+  logs: {
+    get(id) {
+      return `/logs/${id}`;
+    }
+  }
+};
+// node_modules/@rewritetoday/rest/dist/errors.js
+class HTTPError extends Error {
+  message;
+  status;
+  url;
+  method;
+  constructor(message2, status, url, method) {
+    super(message2);
+    this.message = message2;
+    this.status = status;
+    this.url = url;
+    this.method = method;
+    this.name = `HTTPError(${status})`;
+  }
+}
+
+class RateLimitError extends HTTPError {
+  limit;
+  global;
+  retryAfter;
+  constructor(message2, url, method, context) {
+    super(message2, 429, url, method);
+    this.limit = context.limit;
+    this.global = context.isGlobal;
+    this.retryAfter = context.retryAfter;
+    this.name = "RateLimitError";
+  }
+}
+
+// node_modules/@rewritetoday/rest/dist/version.js
+var version = "1.0.1";
+var API_VERSION = "1";
+
+// node_modules/@rewritetoday/rest/dist/utils.js
+var DEFAULT_BASE_URL = "https://api.rewritetoday.com";
+var API_PATH = `/v${API_VERSION}`;
+var normalizeBaseURL = (baseURL) => {
+  let normalized = baseURL.endsWith("/") ? baseURL.slice(0, -1) : baseURL;
+  if (normalized.endsWith(API_PATH))
+    normalized = normalized.slice(0, -API_PATH.length);
+  return normalized;
+};
+var createURL = (route, query, baseURL = DEFAULT_BASE_URL) => {
+  const normalizedRoute = route.startsWith("/") ? route : `/${route}`;
+  const url = new URL(`${normalizeBaseURL(baseURL)}${API_PATH}${normalizedRoute}`);
+  if (query)
+    url.search = new URLSearchParams(query).toString();
+  return url.toString();
+};
+var FIVE_SECONDS_IN_MS = 5000;
+var RETRYABLE_STATUS = [408, 425, 429, 500, 502, 503, 504];
+var isRetryableStatus = (status) => RETRYABLE_STATUS.includes(status);
+var BASE_DELAY_MS = 300;
+var MAX_DELAY_MS = 1e4;
+var backoff = (attempt) => {
+  const exp = Math.min(MAX_DELAY_MS, BASE_DELAY_MS * 2 ** attempt);
+  const jitter = Math.random() * exp * 0.3;
+  return Math.floor(exp + jitter);
+};
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var RATE_LIMIT_STATUS = 429;
+
+// node_modules/@rewritetoday/rest/dist/client.js
+var DEFAULT_RETRY_MAX = 3;
+
+class REST {
+  options;
+  headers;
+  constructor(options) {
+    this.options = typeof options === "string" ? { auth: options } : { ...options };
+    this.headers = {
+      "Content-Type": "application/json",
+      "User-Agent": `@rewritetoday/rest (${version})`,
+      ...this.options.headers
+    };
+    this.setAuth(this.options.auth);
+  }
+  setAuth(authorization) {
+    if (typeof authorization !== "string" || !authorization.startsWith("rw_"))
+      throw new Error("Unknown or invalid API key.");
+    this.options.auth = authorization;
+    this.headers.Authorization = `Bearer ${authorization}`;
+    return this;
+  }
+  get(route, options) {
+    return this.request(route, { ...options, method: "GET" });
+  }
+  post(route, data, options) {
+    return this.request(route, { data, ...options, method: "POST" });
+  }
+  delete(route, options) {
+    return this.request(route, { ...options, method: "DELETE" });
+  }
+  put(route, data, options) {
+    return this.request(route, { data, ...options, method: "PUT" });
+  }
+  patch(route, data, options) {
+    return this.request(route, { data, ...options, method: "PATCH" });
+  }
+  async request(route, options, attempt = 0) {
+    const timeout = options.timeout ?? this.options.timeout ?? FIVE_SECONDS_IN_MS;
+    const response = await fetch(createURL(route, options.query, this.options.baseURL), {
+      method: options.method,
+      headers: { ...this.headers, ...options.headers },
+      signal: AbortSignal.timeout(timeout),
+      body: "data" in options ? JSON.stringify(options.data) : null
+    });
+    if (!response.ok)
+      return this.handleError({
+        route,
+        attempt,
+        options,
+        response,
+        method: options.method
+      });
+    return await response.json();
+  }
+  async handleError({ route, method, options, attempt, response }) {
+    if (!isRetryableStatus(response.status))
+      return await response.json();
+    const { onRateLimit, retry } = this.options;
+    const rateLimitContext = response.status === RATE_LIMIT_STATUS ? this.parseRateLimitContext(response) : null;
+    if (attempt >= (retry?.max ?? DEFAULT_RETRY_MAX))
+      throw this.buildRetryExceededError(response, method, rateLimitContext);
+    if (rateLimitContext)
+      await onRateLimit?.(rateLimitContext);
+    await retry?.onRetry?.({ route, attempt, options, response, method });
+    await sleep(rateLimitContext && rateLimitContext.retryAfter > 0 ? rateLimitContext.retryAfter : (retry?.delay ?? backoff)(attempt));
+    return this.request(route, options, attempt + 1);
+  }
+  buildRetryExceededError(response, method, rateLimitContext) {
+    if (rateLimitContext)
+      return new RateLimitError("Rate limit has not been reset yet", response.url, method, rateLimitContext);
+    return new HTTPError("Max retries reached", response.status, response.url, method);
+  }
+  parseRateLimitContext(response) {
+    const { headers } = response;
+    const xRateLimitRetryAfter = this.readNumberHeader(headers, "X-RateLimit-Retry-After");
+    const retryAfter = xRateLimitRetryAfter > 0 ? xRateLimitRetryAfter : this.parseRetryAfterHeader(headers.get("X-RateLimit-Retry-After"));
+    return {
+      retryAfter,
+      limit: this.readNumberHeader(headers, "X-RateLimit-Limit"),
+      isGlobal: headers.get("X-RateLimit-Global")?.toLowerCase() === "true"
+    };
+  }
+  readNumberHeader(headers, key) {
+    const value = headers.get(key);
+    if (!value)
+      return 0;
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : 0;
+  }
+  parseRetryAfterHeader(header) {
+    if (!header)
+      return 0;
+    const seconds = Number(header);
+    if (Number.isFinite(seconds))
+      return Math.max(0, Math.ceil(seconds * 1000));
+    const date = Date.parse(header);
+    return Number.isNaN(date) ? 0 : Math.max(0, date - Date.now());
+  }
+}
+// src/resources/base.ts
+class BaseManager {
+  rest;
+  constructor(rest2) {
+    this.rest = rest2;
+  }
+}
+
+// src/resources/api-key.ts
+class APIKeyManager extends BaseManager {
+  async delete(id) {
+    return await this.rest.delete(Routes.apiKeys.delete(id));
+  }
+}
+
+// src/resources/logs.ts
+class LogManager extends BaseManager {
+  async list(id, options) {
+    return await this.rest.get(Routes.webhooks.logs(id, options));
+  }
+  async get(id) {
+    return await this.rest.get(Routes.logs.get(id));
+  }
+}
+
+// src/resources/message.ts
+class MessageManager extends BaseManager {
+  async send({ idempotencyKey, ...body }) {
+    return await this.rest.post(Routes.messages.send(), body, {
+      headers: {
+        "Idempotency-Key": idempotencyKey ?? ""
+      }
+    });
+  }
+  async list(options) {
+    return await this.rest.get(Routes.messages.list(options));
+  }
+  async batch(body, { idempotencyKey }) {
+    return await this.rest.post(Routes.messages.batch(), body, {
+      headers: {
+        "Idempotency-Key": idempotencyKey ?? ""
+      }
+    });
+  }
+  async cancel(id) {
+    return await this.rest.post(Routes.messages.cancel(id));
+  }
+  async get(id) {
+    return await this.rest.get(Routes.messages.get(id));
+  }
+}
+
+// src/resources/otp.ts
+class OTPManager extends BaseManager {
+  async send({ idempotencyKey, ...body }) {
+    return await this.rest.post(Routes.otp.send(), body, {
+      headers: {
+        "Idempotency-Key": idempotencyKey ?? ""
+      }
+    });
+  }
+  async verify({ id, ...body }) {
+    return await this.rest.post(Routes.otp.verify(id), body);
+  }
+}
+
+// src/resources/template.ts
+class TemplateManager extends BaseManager {
+  async create(options) {
+    return await this.rest.post(Routes.templates.create(), options);
+  }
+  async update(id, options) {
+    return await this.rest.patch(Routes.templates.update(id), options);
+  }
+  async delete(id) {
+    return await this.rest.delete(Routes.templates.delete(id));
+  }
+  async list(options) {
+    return await this.rest.get(Routes.templates.list(options));
+  }
+  async get(id) {
+    return await this.rest.get(Routes.templates.get(id));
+  }
+}
+
+// src/resources/webhook.ts
+import { createHmac, timingSafeEqual } from "node:crypto";
+class WebhookManager extends BaseManager {
+  verify({
+    headers,
+    payload,
+    secret = process.env.REWRITE_WEBHOOK_SECRET
+  }) {
+    if (!secret)
+      throw new Error("Rewrite could not find a webhook secret to verify.");
+    const value = secret.startsWith("whsec_") ? secret.slice("whsec_".length) : secret;
+    const key = secret.startsWith("rw_whsec_") ? Buffer.from(secret) : /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}(?:==)?|[A-Za-z0-9+/]{3}=?)?$/.test(value) ? Buffer.from(value, "base64") : null;
+    const signature = headers["svix-signature"]?.split(",")[1];
+    if (!key || !headers["svix-id"] || !headers["svix-timestamp"] || !signature)
+      return false;
+    const expected = createHmac("sha256", key).update(`${headers["svix-id"]}.${headers["svix-timestamp"]}.${payload}`).digest("base64");
+    return signature.length === expected.length && timingSafeEqual(Buffer.from(signature), Buffer.from(expected));
+  }
+  async create(options) {
+    return await this.rest.post(Routes.webhooks.create(), options);
+  }
+  async update(id, options) {
+    return await this.rest.patch(Routes.webhooks.update(id), options);
+  }
+  async delete(id) {
+    return await this.rest.delete(Routes.webhooks.delete(id));
+  }
+  async list(options) {
+    return await this.rest.get(Routes.webhooks.list(options));
+  }
+  async get(id) {
+    return await this.rest.get(Routes.webhooks.get(id));
+  }
+}
+
+// src/client.ts
+class Rewrite {
+  rest;
+  secret;
+  otp;
+  logs;
+  apiKeys;
+  messages;
+  webhooks;
+  templates;
+  constructor(options) {
+    const resolved = typeof options === "string" ? { secret: options } : options;
+    if (typeof resolved.secret !== "string")
+      throw new Error("Expected a string for the secret");
+    this.secret = resolved.secret;
+    this.rest = new REST({
+      ...resolved.rest,
+      auth: this.secret
+    });
+    this.otp = new OTPManager(this.rest);
+    this.logs = new LogManager(this.rest);
+    this.apiKeys = new APIKeyManager(this.rest);
+    this.webhooks = new WebhookManager(this.rest);
+    this.messages = new MessageManager(this.rest);
+    this.templates = new TemplateManager(this.rest);
+  }
+}
+// src/version.ts
+var version3 = "1.0.1";
+export {
+  version3 as version,
+  WebhookStatus,
+  WebhookManager,
+  WebhookEventType,
+  WebhookDeliveryStatus,
+  TemplateManager,
+  Routes,
+  Rewrite,
+  OTPManager,
+  MessageType,
+  MessageStatus,
+  MessageManager,
+  MessageEncoding,
+  MessageAnalysisReason,
+  MessageAnalysisEncoding,
+  LogManager,
+  API_BASE_URL,
+  APIKeyScope,
+  APIKeyManager
+};

package/dist/resources/api-key.d.ts

@@ -0,0 +1,11 @@
+import { type RESTDeleteAPIKeyData } from '@rewritetoday/types';
+import { BaseManager } from './base';
+/**
+ * API key resource operations.
+ */
+export declare class APIKeyManager extends BaseManager {
+    /**
+     * Deletes an API key by id.
+     */
+    delete(id: string): Promise<RESTDeleteAPIKeyData>;
+}

package/dist/resources/base.d.ts

@@ -0,0 +1,12 @@
+import type { REST } from '@rewritetoday/rest';
+/**
+ * Shared base resource with access to the REST client.
+ */
+export declare abstract class BaseManager {
+    /** REST client used by resource operations. */
+    readonly rest: REST;
+    /**
+     * Creates a base resource wrapper.
+     */
+    constructor(rest: REST);
+}

package/dist/resources/logs.d.ts

@@ -0,0 +1,15 @@
+import { type RESTGetListWebhookLogsData, type RESTGetListWebhookLogsQueryParams, type RESTGetWebhookLogData, type Snowflake } from '@rewritetoday/types';
+import { BaseManager } from './base';
+/**
+ * Webhook logs resource operations.
+ */
+export declare class LogManager extends BaseManager {
+    /**
+     * Deletes an API key by id.
+     */
+    list(id: Snowflake, options?: RESTGetListWebhookLogsQueryParams): Promise<RESTGetListWebhookLogsData>;
+    /**
+     * Fetch for a single webhook log.
+     */
+    get(id: Snowflake): Promise<RESTGetWebhookLogData>;
+}

package/dist/resources/message.d.ts

@@ -0,0 +1,10 @@
+import { type RESTGetListMessagesData, type RESTGetListMessagesQueryParams, type RESTGetMessageData, type RESTPostCancelMessageData, type RESTPostSendBatchMessagesBody, type RESTPostSendBatchMessagesData, type RESTPostSendMessageData } from '@rewritetoday/types';
+import type { SendBatchMessageOptions, SendMessageOptions } from '../types/message';
+import { BaseManager } from './base';
+export declare class MessageManager extends BaseManager {
+    send({ idempotencyKey, ...body }: SendMessageOptions): Promise<RESTPostSendMessageData>;
+    list(options?: RESTGetListMessagesQueryParams): Promise<RESTGetListMessagesData>;
+    batch(body: RESTPostSendBatchMessagesBody, { idempotencyKey }: SendBatchMessageOptions): Promise<RESTPostSendBatchMessagesData>;
+    cancel(id: string): Promise<RESTPostCancelMessageData>;
+    get(id: string): Promise<RESTGetMessageData>;
+}

package/dist/resources/otp.d.ts

@@ -0,0 +1,7 @@
+import { type RESTPostSendOTPMessageData, type RESTPostVerifyOTPCodeData } from '@rewritetoday/types';
+import type { SendOTPMessageOptions, VerifyOTPOptions } from '../types/otp';
+import { BaseManager } from './base';
+export declare class OTPManager extends BaseManager {
+    send({ idempotencyKey, ...body }: SendOTPMessageOptions): Promise<RESTPostSendOTPMessageData>;
+    verify({ id, ...body }: VerifyOTPOptions): Promise<RESTPostVerifyOTPCodeData>;
+}

package/dist/resources/template.d.ts

@@ -0,0 +1,27 @@
+import { type RESTDeleteTemplateData, type RESTGetListTemplatesData, type RESTGetListTemplatesQueryParams, type RESTGetTemplateData, type RESTPostCreateTemplateBody, type RESTPostCreateTemplateData, type Snowflake } from '@rewritetoday/types';
+import { BaseManager } from './base';
+/**
+ * Template resource operations.
+ */
+export declare class TemplateManager extends BaseManager {
+    /**
+     * Creates a template for a project.
+     */
+    create(options: RESTPostCreateTemplateBody): Promise<RESTPostCreateTemplateData>;
+    /**
+     * Updates a template by id.
+     */
+    update(id: Snowflake, options: RESTPostCreateTemplateBody): Promise<RESTPostCreateTemplateData>;
+    /**
+     * Deletes a template by id.
+     */
+    delete(id: Snowflake): Promise<RESTDeleteTemplateData>;
+    /**
+     * Lists templates for a project.
+     */
+    list(options?: RESTGetListTemplatesQueryParams): Promise<RESTGetListTemplatesData>;
+    /**
+     * Fetches a template by id.
+     */
+    get(id: Snowflake): Promise<RESTGetTemplateData>;
+}

package/dist/resources/webhook.d.ts

@@ -0,0 +1,29 @@
+import { type RESTDeleteWebhookData, type RESTGetListWebhooksData, type RESTGetListWebhooksQueryParams, type RESTGetWebhookData, type RESTPatchUpdateWebhookBody, type RESTPatchUpdateWebhookData, type RESTPostCreateWebhookBody, type RESTPostCreateWebhookData, type Snowflake } from '@rewritetoday/types';
+import type { VerifyWebhookOptions } from '../types/webhook';
+import { BaseManager } from './base';
+/**
+ * Webhook resource operations.
+ */
+export declare class WebhookManager extends BaseManager {
+    verify({ headers, payload, secret, }: VerifyWebhookOptions): boolean;
+    /**
+     * Creates a webhook for a project.
+     */
+    create(options: RESTPostCreateWebhookBody): Promise<RESTPostCreateWebhookData>;
+    /**
+     * Updates a webhook by id.
+     */
+    update(id: Snowflake, options: RESTPatchUpdateWebhookBody): Promise<RESTPatchUpdateWebhookData>;
+    /**
+     * Deletes a webhook by id.
+     */
+    delete(id: Snowflake): Promise<RESTDeleteWebhookData>;
+    /**
+     * Lists webhooks for a project.
+     */
+    list(options?: RESTGetListWebhooksQueryParams): Promise<RESTGetListWebhooksData>;
+    /**
+     * Fetches a webhook by id.
+     */
+    get(id: Snowflake): Promise<RESTGetWebhookData>;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,13 @@
+import type { RESTOptions } from '@rewritetoday/rest';
+/**
+ * Options used to initialize the Rewrite client.
+ */
+export interface RewriteOptions {
+    /** API secret used for authentication. */
+    secret: string;
+    /** Extra REST client options, excluding auth. */
+    rest?: Omit<RESTOptions, 'auth'>;
+}
+export * from './message';
+export * from './otp';
+export * from './webhook';

package/dist/types/message.d.ts

@@ -0,0 +1,10 @@
+import type { RESTPostSendMessageBody } from '@rewritetoday/types';
+/** Options to send when creating a new message. */
+export type SendMessageOptions = RESTPostSendMessageBody & {
+    /** Idempotency key to use in "Idempotency-Key" header. */
+    idempotencyKey?: string;
+};
+export interface SendBatchMessageOptions {
+    /** Idempotency key to use in "Idempotency-Key" header. */
+    idempotencyKey?: string;
+}

package/dist/types/otp.d.ts

@@ -0,0 +1,11 @@
+import type { RESTPostSendOTPMessageBody, RESTPostVerifyOTPCodeBody, Snowflake } from '@rewritetoday/types';
+/** Options to send when creating a new OTP message. */
+export interface SendOTPMessageOptions extends RESTPostSendOTPMessageBody {
+    /** Idempotency key to use in "Idempotency-Key" header. */
+    idempotencyKey?: string;
+}
+/** Options to send when verifing an OTP message. */
+export interface VerifyOTPOptions extends RESTPostVerifyOTPCodeBody {
+    /** ID of the message. See {@link Snowflake}. */
+    id: Snowflake;
+}

package/dist/types/webhook.d.ts

@@ -0,0 +1,9 @@
+/** Options used the verify if a webhook came from Rewrite or not. */
+export interface VerifyWebhookOptions {
+    /** Signing secret of the webhook. @default process.env.REWRITE_WEBHOOK_SECRET */
+    secret?: string;
+    /** Raw payload in string of the request. */
+    payload: string;
+    /** Headers of the request. */
+    headers: Record<string, string>;
+}

package/dist/version.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Current version of [@rewritetoday/sdk](https://www.npmjs.com/package/@rewritetoday/sdk).
+ */
+export declare const version: "1.0.1";

package/package.json

@@ -0,0 +1,48 @@
+{
+	"name": "@rewritetoday/sdk",
+	"version": "1.0.1",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/rewritetoday/node.git"
+	},
+	"main": "./dist/index.js",
+	"module": "src/index.ts",
+	"devDependencies": {
+		"@biomejs/biome": "^2.4.8",
+		"@types/bun": "latest"
+	},
+	"peerDependencies": {
+		"typescript": "^5.9.3"
+	},
+	"description": "An ergonomic SDK to integrate with Rewrite in your workflow",
+	"engines": {
+		"node": ">=18",
+		"bun": ">=1.0.0"
+	},
+	"files": [
+		"dist"
+	],
+	"maintainers": [
+		{
+			"name": "Almeida",
+			"url": "https://github.com/almeidazs"
+		}
+	],
+	"private": false,
+	"publishConfig": {
+		"access": "public"
+	},
+	"scripts": {
+		"test": "bun test",
+		"biome:check": "biome check --write .",
+		"build": "rm -rf dist && bun run scripts/version.ts && bun biome:check && bun build src/index.ts --outdir dist --target node && bun run types",
+		"types": "bunx tsc --emitDeclarationOnly",
+		"prepublishOnly": "bun run build"
+	},
+	"type": "module",
+	"types": "./dist/index.d.ts",
+	"dependencies": {
+		"@rewritetoday/rest": "^1.0.1",
+		"@rewritetoday/types": "^1.0.1"
+	}
+}