npm - sendr-js - Versions diffs - 1.0.0 - Mend

sendr-js 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

package/LICENSE ADDED Viewed

@@ -0,0 +1,22 @@
+MIT License
+Copyright (c) 2024 Sendr
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md ADDED Viewed

@@ -0,0 +1,356 @@
+# @sendr/sendr
+Official Sendr email platform SDK for Node.js and TypeScript. Send transactional emails easily with a simple, type-safe API.
+## Installation
+```bash
+npm install @sendr/sendr
+```
+**Requirements:** Node.js 18.0.0 or higher (uses native `fetch` API)
+## Quick Start
+```typescript
+import { SendrClient } from '@sendr/sendr';
+// Initialize the client with your API key
+const client = new SendrClient({
+  apiKey: 'your-api-key-here'
+});
+// Send an email
+const response = await client.sendEmail({
+  recipients: [
+    { email: 'user1@example.com' },
+    { email: 'user2@example.com' }
+  ],
+  emailConfig: {
+    subject: 'Welcome to Sendr',
+    from: 'noreply@yourdomain.com',
+    fromName: 'Your Company',
+    body: '<html><body><h1>Hello!</h1><p>Welcome to our platform.</p></body></html>'
+  }
+});
+console.log('Email sent!', response.batchId);
+```
+## API Reference
+### SendrClient
+The main client class for interacting with the Sendr API.
+#### Constructor
+```typescript
+new SendrClient(options: SendrClientOptions)
+```
+**Options:**
+- `apiKey` (required): Your Sendr API key
+- `baseUrl` (optional): Custom API base URL (defaults to `https://sending.sendrapp.org`)
+- `statsBaseUrl` (optional): Custom stats API base URL (defaults to `https://stats.sendrapp.org`)
+- `logsBaseUrl` (optional): Custom logs API base URL (defaults to `https://logs.sendrapp.org`)
+#### Methods
+##### `sendEmail(request: SendEmailRequest): Promise<SendEmailResponse>`
+Send an email to one or more recipients.
+**Parameters:**
+- `request.recipients`: Array of recipient objects (max 100)
+  - `email`: Recipient email address (required)
+  - `name`: Recipient name (optional)
+  - `substitutions`: Template variable substitutions (optional)
+- `request.emailConfig.subject`: Email subject line (required)
+- `request.emailConfig.from`: Sender email address (must be verified domain) (required)
+- `request.emailConfig.fromName`: Sender display name (optional)
+- `request.emailConfig.body`: HTML email body (required)
+- `request.emailConfig.headers`: Custom email headers (optional)
+**Returns:** Promise resolving to `SendEmailResponse` with:
+- `status`: Processing status
+- `message`: Status message
+- `limits`: Current usage limits
+- `batchId`: Unique batch identifier
+**Throws:** `SendrError` if the request fails
+**Example:**
+```typescript
+const response = await client.sendEmail({
+  recipients: [
+    { email: 'user@example.com' }
+  ],
+  emailConfig: {
+    subject: 'Welcome!',
+    from: 'noreply@yourdomain.com',
+    fromName: 'Your Company',
+    body: '<html><body><h1>Welcome!</h1></body></html>'
+  }
+});
+```
+##### `sendEmailTo(recipientEmail: string, emailConfig: EmailConfig): Promise<SendEmailResponse>`
+Convenience method to send an email to a single recipient.
+**Example:**
+```typescript
+const response = await client.sendEmailTo('user@example.com', {
+  subject: 'Welcome!',
+  from: 'noreply@yourdomain.com',
+  fromName: 'Your Company',
+  body: '<html><body><h1>Welcome!</h1></body></html>'
+});
+```
+##### `getDomains(): Promise<DomainListResponse>`
+Get a list of all domains associated with your tenant.
+**Returns:** Promise resolving to `DomainListResponse` with:
+- `domains`: Array of domain objects
+- `count`: Total number of domains
+**Example:**
+```typescript
+const response = await client.getDomains();
+console.log(`You have ${response.count} domain(s)`);
+response.domains.forEach(domain => {
+  console.log(`${domain.name} - Verified: ${domain.isVerified}`);
+});
+```
+##### `verifyDomain(domainId: string): Promise<DomainVerifyResponse>`
+Verify a domain's DNS settings.
+**Parameters:**
+- `domainId`: Domain ID to verify (required)
+**Returns:** Promise resolving to `DomainVerifyResponse` with:
+- `isVerified`: Whether the domain is verified
+**Example:**
+```typescript
+const response = await client.verifyDomain('domain-id-here');
+if (response.isVerified) {
+  console.log('Domain is verified!');
+}
+```
+##### `createTenant(request: CreateTenantRequest): Promise<Tenant>`
+Create a new tenant/workspace in the system.
+**Parameters:**
+- `request.name`: Workspace/tenant name (required)
+- `request.domain`: Default domain name (required)
+- `request.sendingEmail`: Default sending email address (required)
+**Returns:** Promise resolving to `Tenant` object
+**Example:**
+```typescript
+const tenant = await client.createTenant({
+  name: 'mycompany',
+  domain: 'mycompany.com',
+  sendingEmail: 'noreply@mycompany.com'
+});
+console.log('Tenant created:', tenant.id);
+```
+##### `getStatistics(): Promise<TenantStatistics>`
+Get tenant statistics including email delivery metrics.
+**Returns:** Promise resolving to `TenantStatistics` with:
+- `totalSent`: Total emails sent
+- `totalDelivered`: Total emails delivered
+- `totalBounced`: Total emails bounced
+- `totalOpened`: Total emails opened
+- `totalClicked`: Total emails clicked
+**Example:**
+```typescript
+const stats = await client.getStatistics();
+console.log(`Sent: ${stats.totalSent}, Delivered: ${stats.totalDelivered}`);
+```
+##### `getLogs(options?: GetLogsOptions): Promise<EmailLogsResponse>`
+Get email delivery logs for your domain.
+**Parameters (optional):**
+- `options.limit`: Maximum number of logs to return
+- `options.offset`: Number of logs to skip
+- `options.status`: Filter by status
+- `options.startDate`: Start date for filtering
+- `options.endDate`: End date for filtering
+**Returns:** Promise resolving to `EmailLogsResponse` with:
+- `logs`: Array of email log objects
+- `count`: Total number of logs
+**Example:**
+```typescript
+// Get all logs
+const allLogs = await client.getLogs();
+// Get logs with filters
+const filteredLogs = await client.getLogs({
+  limit: 50,
+  status: 'delivered',
+  startDate: '2024-01-01',
+  endDate: '2024-01-31'
+});
+```
+## Types
+### Recipient
+```typescript
+interface Recipient {
+  email: string;
+  name?: string;
+  substitutions?: Record<string, any>;
+}
+```
+### EmailConfig
+```typescript
+interface EmailConfig {
+  subject: string;
+  from: string;
+  fromName?: string;
+  body: string;
+  headers?: Record<string, string>;
+}
+```
+### SendEmailResponse
+```typescript
+interface SendEmailResponse {
+  status: string;
+  message: string;
+  limits: {
+    limit: number;
+    used: number;
+    remaining: number;
+    requested: number;
+  };
+  batchId?: string;
+}
+```
+### Domain
+```typescript
+interface Domain {
+  id: string;
+  createdAt: string;
+  updatedAt: string;
+  name: string;
+  description?: string;
+  sendingEmail: string;
+  dnsRecords: DNSRecord[];
+  isActive: boolean;
+  isApproved: boolean;
+  isVerified: boolean;
+}
+```
+### Tenant
+```typescript
+interface Tenant {
+  id: string;
+  name: string;
+  createdAt: string;
+  updatedAt: string;
+  domain: string;
+  sendingEmail: string;
+  currentEmailCount: number;
+}
+```
+### TenantStatistics
+```typescript
+interface TenantStatistics {
+  totalSent: number;
+  totalDelivered: number;
+  totalBounced: number;
+  totalOpened: number;
+  totalClicked: number;
+  [key: string]: any;
+}
+```
+### EmailLog
+```typescript
+interface EmailLog {
+  id: string;
+  email: string;
+  subject: string;
+  status: string;
+  sentAt: string;
+  deliveredAt?: string;
+  openedAt?: string;
+  clickedAt?: string;
+  bouncedAt?: string;
+  [key: string]: any;
+}
+```
+## Error Handling
+The SDK throws `SendrError` for API errors:
+```typescript
+import { SendrError } from '@sendr/sendr';
+try {
+  await client.sendEmail({ ... });
+} catch (error) {
+  if (error instanceof SendrError) {
+    console.error('API Error:', error.message);
+    console.error('Status Code:', error.statusCode);
+    console.error('Response:', error.response);
+  } else {
+    console.error('Unexpected error:', error);
+  }
+}
+```
+## Limits
+- **Maximum recipients per API call**: 100 subscribers
+- **Maximum sending rate**: 250 emails per hour (default, custom rates available)
+- **Email content**: HTML format supported
+- **From address**: Must be a verified domain email address
+## Getting Your API Key
+1. Sign up at [https://platform.sendr.app/auth/sign-up](https://platform.sendr.app/auth/sign-up)
+2. Verify your email address
+3. Complete domain verification (you'll receive DNS settings via email)
+4. Your API key will be automatically generated and sent to your email after domain onboarding
+## Documentation
+For more information, visit the [Sendr API Documentation](https://docs.sendr.app/api-reference/introduction).
+## License
+MIT

package/dist/client.d.ts ADDED Viewed

@@ -0,0 +1,62 @@
+import { SendEmailRequest, SendEmailResponse, SendrClientOptions, DomainListResponse, DomainVerifyResponse, CreateTenantRequest, Tenant, TenantStatistics, EmailLogsResponse, GetLogsOptions } from "./types";
+/**
+ * Sendr Email API Client
+ */
+export declare class SendrClient {
+    private apiKey;
+    private baseUrl;
+    private statsBaseUrl;
+    private logsBaseUrl;
+    constructor(options: SendrClientOptions);
+    /**
+     * Make an authenticated API request
+     */
+    private request;
+    /**
+     * Send an email to one or more recipients
+     * @param request Email request with recipients and email configuration
+     * @returns Promise resolving to the send email response
+     * @throws SendrError if the request fails
+     */
+    sendEmail(request: SendEmailRequest): Promise<SendEmailResponse>;
+    /**
+     * Send an email to a single recipient (convenience method)
+     * @param recipientEmail Email address of the recipient
+     * @param emailConfig Email configuration
+     * @returns Promise resolving to the send email response
+     */
+    sendEmailTo(recipientEmail: string, emailConfig: SendEmailRequest["emailConfig"]): Promise<SendEmailResponse>;
+    /**
+     * Get a list of all domains associated with your tenant
+     * @returns Promise resolving to the domain list response
+     * @throws SendrError if the request fails
+     */
+    getDomains(): Promise<DomainListResponse>;
+    /**
+     * Verify a domain's DNS settings
+     * @param domainId Domain ID to verify
+     * @returns Promise resolving to the verification response
+     * @throws SendrError if the request fails
+     */
+    verifyDomain(domainId: string): Promise<DomainVerifyResponse>;
+    /**
+     * Create a new tenant/workspace
+     * @param request Tenant creation request
+     * @returns Promise resolving to the created tenant
+     * @throws SendrError if the request fails
+     */
+    createTenant(request: CreateTenantRequest): Promise<Tenant>;
+    /**
+     * Get tenant statistics
+     * @returns Promise resolving to tenant statistics
+     * @throws SendrError if the request fails
+     */
+    getStatistics(): Promise<TenantStatistics>;
+    /**
+     * Get email logs
+     * @param options Optional query parameters for filtering logs
+     * @returns Promise resolving to email logs response
+     * @throws SendrError if the request fails
+     */
+    getLogs(options?: GetLogsOptions): Promise<EmailLogsResponse>;
+}

package/dist/client.js ADDED Viewed

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SendrClient = void 0;
+const types_1 = require("./types");
+/**
+ * Sendr Email API Client
+ */
+class SendrClient {
+    constructor(options) {
+        if (!options.apiKey) {
+            throw new Error("API key is required");
+        }
+        this.apiKey = options.apiKey;
+        this.baseUrl = options.baseUrl || "https://sending.sendrapp.org";
+        this.statsBaseUrl = options.statsBaseUrl || "https://stats.sendrapp.org";
+        this.logsBaseUrl = options.logsBaseUrl || "https://logs.sendrapp.org";
+    }
+    /**
+     * Make an authenticated API request
+     */
+    async request(url, options = {}) {
+        try {
+            const response = await fetch(url, {
+                ...options,
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: this.apiKey,
+                    ...options.headers,
+                },
+            });
+            const data = (await response.json());
+            if (!response.ok) {
+                throw new types_1.SendrError(data.message || `HTTP ${response.status}: ${response.statusText}`, response.status, data);
+            }
+            return data;
+        }
+        catch (error) {
+            if (error instanceof types_1.SendrError) {
+                throw error;
+            }
+            if (error instanceof Error) {
+                throw new types_1.SendrError(`API request failed: ${error.message}`, undefined, error);
+            }
+            throw new types_1.SendrError("API request failed: Unknown error");
+        }
+    }
+    /**
+     * Send an email to one or more recipients
+     * @param request Email request with recipients and email configuration
+     * @returns Promise resolving to the send email response
+     * @throws SendrError if the request fails
+     */
+    async sendEmail(request) {
+        // Validate recipients
+        if (!request.recipients || request.recipients.length === 0) {
+            throw new Error("At least one recipient is required");
+        }
+        if (request.recipients.length > 100) {
+            throw new Error("Maximum 100 recipients per API call. You provided " +
+                request.recipients.length);
+        }
+        // Validate email config
+        if (!request.emailConfig) {
+            throw new Error("emailConfig is required");
+        }
+        if (!request.emailConfig.subject) {
+            throw new Error("emailConfig.subject is required");
+        }
+        if (!request.emailConfig.from) {
+            throw new Error("emailConfig.from is required");
+        }
+        if (!request.emailConfig.body) {
+            throw new Error("emailConfig.body is required");
+        }
+        const url = `${this.baseUrl}/email`;
+        return this.request(url, {
+            method: "POST",
+            body: JSON.stringify(request),
+        });
+    }
+    /**
+     * Send an email to a single recipient (convenience method)
+     * @param recipientEmail Email address of the recipient
+     * @param emailConfig Email configuration
+     * @returns Promise resolving to the send email response
+     */
+    async sendEmailTo(recipientEmail, emailConfig) {
+        return this.sendEmail({
+            recipients: [{ email: recipientEmail }],
+            emailConfig,
+        });
+    }
+    /**
+     * Get a list of all domains associated with your tenant
+     * @returns Promise resolving to the domain list response
+     * @throws SendrError if the request fails
+     */
+    async getDomains() {
+        const url = `${this.baseUrl}/v2/domain`;
+        return this.request(url, {
+            method: "GET",
+        });
+    }
+    /**
+     * Verify a domain's DNS settings
+     * @param domainId Domain ID to verify
+     * @returns Promise resolving to the verification response
+     * @throws SendrError if the request fails
+     */
+    async verifyDomain(domainId) {
+        if (!domainId) {
+            throw new Error("Domain ID is required");
+        }
+        const url = `${this.baseUrl}/v2/domain/${domainId}/verify`;
+        return this.request(url, {
+            method: "POST",
+        });
+    }
+    /**
+     * Create a new tenant/workspace
+     * @param request Tenant creation request
+     * @returns Promise resolving to the created tenant
+     * @throws SendrError if the request fails
+     */
+    async createTenant(request) {
+        if (!request.name) {
+            throw new Error("Tenant name is required");
+        }
+        if (!request.domain) {
+            throw new Error("Domain is required");
+        }
+        if (!request.sendingEmail) {
+            throw new Error("Sending email is required");
+        }
+        const url = `${this.baseUrl}/v2/tenant`;
+        return this.request(url, {
+            method: "POST",
+            body: JSON.stringify(request),
+        });
+    }
+    /**
+     * Get tenant statistics
+     * @returns Promise resolving to tenant statistics
+     * @throws SendrError if the request fails
+     */
+    async getStatistics() {
+        const url = `${this.statsBaseUrl}/stats`;
+        return this.request(url, {
+            method: "GET",
+        });
+    }
+    /**
+     * Get email logs
+     * @param options Optional query parameters for filtering logs
+     * @returns Promise resolving to email logs response
+     * @throws SendrError if the request fails
+     */
+    async getLogs(options) {
+        const params = new URLSearchParams();
+        if (options) {
+            if (options.limit)
+                params.append("limit", options.limit.toString());
+            if (options.offset)
+                params.append("offset", options.offset.toString());
+            if (options.status)
+                params.append("status", options.status);
+            if (options.startDate)
+                params.append("startDate", options.startDate);
+            if (options.endDate)
+                params.append("endDate", options.endDate);
+        }
+        const queryString = params.toString();
+        const url = `${this.logsBaseUrl}/logs${queryString ? `?${queryString}` : ""}`;
+        return this.request(url, {
+            method: "GET",
+        });
+    }
+}
+exports.SendrClient = SendrClient;

package/dist/index.d.ts ADDED Viewed

@@ -0,0 +1,24 @@
+/**
+ * Sendr Email Platform SDK
+ *
+ * Official SDK for sending emails through the Sendr platform
+ *
+ * @example
+ * ```typescript
+ * import { SendrClient } from '@sendr/sendr';
+ *
+ * const client = new SendrClient({ apiKey: 'your-api-key' });
+ *
+ * const response = await client.sendEmail({
+ *   recipients: [{ email: 'recipient@example.com' }],
+ *   emailConfig: {
+ *     subject: 'Welcome!',
+ *     from: 'noreply@yourdomain.com',
+ *     fromName: 'Your Company',
+ *     body: '<html><body><h1>Hello!</h1></body></html>'
+ *   }
+ * });
+ * ```
+ */
+export { SendrClient } from "./client";
+export * from "./types";

package/dist/index.js ADDED Viewed

@@ -0,0 +1,42 @@
+"use strict";
+/**
+ * Sendr Email Platform SDK
+ *
+ * Official SDK for sending emails through the Sendr platform
+ *
+ * @example
+ * ```typescript
+ * import { SendrClient } from '@sendr/sendr';
+ *
+ * const client = new SendrClient({ apiKey: 'your-api-key' });
+ *
+ * const response = await client.sendEmail({
+ *   recipients: [{ email: 'recipient@example.com' }],
+ *   emailConfig: {
+ *     subject: 'Welcome!',
+ *     from: 'noreply@yourdomain.com',
+ *     fromName: 'Your Company',
+ *     body: '<html><body><h1>Hello!</h1></body></html>'
+ *   }
+ * });
+ * ```
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SendrClient = void 0;
+var client_1 = require("./client");
+Object.defineProperty(exports, "SendrClient", { enumerable: true, get: function () { return client_1.SendrClient; } });
+__exportStar(require("./types"), exports);

package/dist/types.d.ts ADDED Viewed

@@ -0,0 +1,113 @@
+/**
+ * Types for Sendr Email API
+ */
+export interface Recipient {
+    email: string;
+    name?: string;
+    substitutions?: Record<string, any>;
+}
+export interface EmailConfig {
+    subject: string;
+    from: string;
+    fromName?: string;
+    body: string;
+    headers?: Record<string, string>;
+}
+export interface SendEmailRequest {
+    recipients: Recipient[];
+    emailConfig: EmailConfig;
+}
+export interface EmailLimits {
+    limit: number;
+    used: number;
+    remaining: number;
+    requested: number;
+}
+export interface SendEmailResponse {
+    status: string;
+    message: string;
+    limits: EmailLimits;
+    batchId?: string;
+}
+export interface DNSRecord {
+    type?: string;
+    name?: string;
+    value?: string;
+    ttl?: number;
+}
+export interface Domain {
+    id: string;
+    createdAt: string;
+    updatedAt: string;
+    name: string;
+    description?: string;
+    sendingEmail: string;
+    dnsRecords: DNSRecord[];
+    isActive: boolean;
+    isApproved: boolean;
+    isVerified: boolean;
+}
+export interface DomainListResponse {
+    domains: Domain[];
+    count: number;
+}
+export interface DomainVerifyResponse {
+    isVerified: boolean;
+}
+export interface CreateTenantRequest {
+    name: string;
+    domain: string;
+    sendingEmail: string;
+}
+export interface Tenant {
+    id: string;
+    name: string;
+    createdAt: string;
+    updatedAt: string;
+    domain: string;
+    sendingEmail: string;
+    currentEmailCount: number;
+}
+export interface TenantStatistics {
+    totalSent: number;
+    totalDelivered: number;
+    totalBounced: number;
+    totalOpened: number;
+    totalClicked: number;
+    [key: string]: any;
+}
+export interface EmailLog {
+    id: string;
+    email: string;
+    subject: string;
+    status: string;
+    sentAt: string;
+    deliveredAt?: string;
+    openedAt?: string;
+    clickedAt?: string;
+    bouncedAt?: string;
+    [key: string]: any;
+}
+export interface EmailLogsResponse {
+    logs: EmailLog[];
+    count: number;
+    [key: string]: any;
+}
+export interface GetLogsOptions {
+    limit?: number;
+    offset?: number;
+    status?: string;
+    startDate?: string;
+    endDate?: string;
+}
+export interface SendrClientOptions {
+    apiKey: string;
+    baseUrl?: string;
+    statsBaseUrl?: string;
+    logsBaseUrl?: string;
+}
+export declare class SendrError extends Error {
+    statusCode?: number | undefined;
+    response?: any | undefined;
+    constructor(message: string, statusCode?: number | undefined, response?: any | undefined);
+}

package/dist/types.js ADDED Viewed

@@ -0,0 +1,16 @@
+"use strict";
+/**
+ * Types for Sendr Email API
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SendrError = void 0;
+class SendrError extends Error {
+    constructor(message, statusCode, response) {
+        super(message);
+        this.statusCode = statusCode;
+        this.response = response;
+        this.name = "SendrError";
+        Object.setPrototypeOf(this, SendrError.prototype);
+    }
+}
+exports.SendrError = SendrError;

package/package.json ADDED Viewed

@@ -0,0 +1,40 @@
+{
+  "name": "sendr-js",
+  "version": "1.0.0",
+  "description": "Official Sendr email platform SDK for Node.js and TypeScript",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "test": "node test-local.js",
+    "test:link": "npm run build && npm link"
+  },
+  "keywords": [
+    "sendr",
+    "email",
+    "email-api",
+    "email-sdk",
+    "transactional-email",
+    "email-service"
+  ],
+  "author": "Sendr",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/maratgaliev/sendr.js.git"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.2.2"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}