@ewyn/client 0.1.0 → 0.3.0

package/dist/__tests__/ewyn.test.js

@@ -0,0 +1,428 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { Ewyn, EwynApiError } from '../index.js';
+// Mock fetch globally
+global.fetch = vi.fn();
+describe('Ewyn SDK', () => {
+    let client;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        global.fetch.mockReset();
+        client = new Ewyn({
+            workspaceId: 'test-workspace-id',
+            apiKey: 'test-api-key',
+            maxRetries: 2, // Allow 1 retry (attempt < maxRetries)
+            timeout: 5000,
+        });
+    });
+    describe('constructor', () => {
+        it('should create client with required options', () => {
+            expect(client).toBeInstanceOf(Ewyn);
+        });
+        it('should use default base URL if not provided', () => {
+            const defaultClient = new Ewyn({
+                workspaceId: 'test-workspace-id',
+                apiKey: 'test-api-key',
+            });
+            expect(defaultClient).toBeInstanceOf(Ewyn);
+        });
+        it('should accept template config', () => {
+            const config = {
+                welcome: {
+                    id: 'version-uuid',
+                    name: 'Welcome',
+                    version: 1,
+                    vars: {
+                        firstName: { required: true },
+                    },
+                },
+            };
+            const configClient = new Ewyn({
+                workspaceId: 'test-workspace-id',
+                apiKey: 'test-api-key',
+                templates: config,
+            });
+            expect(configClient).toBeInstanceOf(Ewyn);
+        });
+    });
+    describe('send', () => {
+        it('should send email with template ID', async () => {
+            const mockResponse = {
+                messageId: 'msg-123',
+                status: 'queued',
+                queuedAt: '2024-01-01T00:00:00Z',
+            };
+            global.fetch.mockResolvedValueOnce({
+                ok: true,
+                status: 200,
+                json: async () => mockResponse,
+            });
+            const result = await client.send({
+                to: 'test@example.com',
+                templateId: 'template-uuid',
+                variables: {
+                    firstName: 'John',
+                },
+            });
+            expect(result).toEqual(mockResponse);
+            expect(global.fetch).toHaveBeenCalledWith('https://www.ewyn.ai/api/v1/workspaces/test-workspace-id/send', expect.objectContaining({
+                method: 'POST',
+                headers: expect.objectContaining({
+                    'Content-Type': 'application/json',
+                    'Authorization': 'Bearer test-api-key',
+                }),
+                body: JSON.stringify({
+                    to: 'test@example.com',
+                    templateId: 'template-uuid',
+                    variables: {
+                        firstName: 'John',
+                    },
+                }),
+            }));
+        });
+        it('should send email with template name when config provided', async () => {
+            const config = {
+                welcome: {
+                    id: 'version-uuid',
+                    name: 'Welcome',
+                    version: 1,
+                    vars: {
+                        firstName: { required: true },
+                    },
+                },
+            };
+            const configClient = new Ewyn({
+                workspaceId: 'test-workspace-id',
+                apiKey: 'test-api-key',
+                templates: config,
+            });
+            const mockResponse = {
+                messageId: 'msg-123',
+                status: 'queued',
+                queuedAt: '2024-01-01T00:00:00Z',
+            };
+            global.fetch.mockResolvedValueOnce({
+                ok: true,
+                status: 200,
+                json: async () => mockResponse,
+            });
+            const result = await configClient.send({
+                to: 'test@example.com',
+                template: 'welcome',
+                variables: {
+                    firstName: 'John',
+                },
+            });
+            expect(result).toEqual(mockResponse);
+        });
+        it('should include version parameter if specified', async () => {
+            const mockResponse = {
+                messageId: 'msg-123',
+                status: 'queued',
+                queuedAt: '2024-01-01T00:00:00Z',
+            };
+            global.fetch.mockResolvedValueOnce({
+                ok: true,
+                status: 200,
+                json: async () => mockResponse,
+            });
+            await client.send({
+                to: 'test@example.com',
+                templateId: 'template-uuid',
+                version: 2,
+                variables: {
+                    firstName: 'John',
+                },
+            });
+            expect(global.fetch).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
+                body: expect.stringContaining('"version":2'),
+            }));
+        });
+        it('should include metadata if provided', async () => {
+            const mockResponse = {
+                messageId: 'msg-123',
+                status: 'queued',
+                queuedAt: '2024-01-01T00:00:00Z',
+            };
+            global.fetch.mockResolvedValueOnce({
+                ok: true,
+                status: 200,
+                json: async () => mockResponse,
+            });
+            await client.send({
+                to: 'test@example.com',
+                templateId: 'template-uuid',
+                metadata: {
+                    userId: 'user-123',
+                },
+            });
+            expect(global.fetch).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
+                body: expect.stringContaining('"metadata"'),
+            }));
+        });
+        it('should include idempotency key if provided', async () => {
+            const mockResponse = {
+                messageId: 'msg-123',
+                status: 'queued',
+                queuedAt: '2024-01-01T00:00:00Z',
+            };
+            global.fetch.mockResolvedValueOnce({
+                ok: true,
+                status: 200,
+                json: async () => mockResponse,
+            });
+            await client.send({
+                to: 'test@example.com',
+                templateId: 'template-uuid',
+                idempotencyKey: 'idempotency-key-123',
+            });
+            expect(global.fetch).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
+                body: expect.stringContaining('"idempotencyKey":"idempotency-key-123"'),
+            }));
+        });
+        it('should throw error if neither templateId nor template provided', async () => {
+            await expect(client.send({
+                to: 'test@example.com',
+                variables: {},
+            })).rejects.toThrow('Either templateId or template must be provided');
+        });
+        it('should throw error if template name provided without config', async () => {
+            await expect(client.send({
+                to: 'test@example.com',
+                template: 'welcome',
+                variables: {},
+            })).rejects.toThrow('Template name provided but no template config was provided');
+        });
+        it('should throw error if template not found in config', async () => {
+            const config = {
+                welcome: {
+                    id: 'version-uuid',
+                    name: 'Welcome',
+                    version: 1,
+                    vars: {},
+                },
+            };
+            const configClient = new Ewyn({
+                workspaceId: 'test-workspace-id',
+                apiKey: 'test-api-key',
+                templates: config,
+            });
+            await expect(configClient.send({
+                to: 'test@example.com',
+                template: 'nonexistent',
+                variables: {},
+            })).rejects.toThrow('Template "nonexistent" not found in template config');
+        });
+    });
+    describe('variable validation', () => {
+        it('should validate required variables', async () => {
+            const config = {
+                welcome: {
+                    id: 'version-uuid',
+                    name: 'Welcome',
+                    version: 1,
+                    vars: {
+                        firstName: { required: true },
+                        lastName: { required: true },
+                    },
+                },
+            };
+            const configClient = new Ewyn({
+                workspaceId: 'test-workspace-id',
+                apiKey: 'test-api-key',
+                templates: config,
+            });
+            await expect(configClient.send({
+                to: 'test@example.com',
+                template: 'welcome',
+                variables: {
+                    firstName: 'John',
+                    // lastName missing
+                },
+            })).rejects.toThrow('Missing required variables for template "welcome": lastName');
+        });
+        it('should allow optional variables to be omitted', async () => {
+            const config = {
+                welcome: {
+                    id: 'version-uuid',
+                    name: 'Welcome',
+                    version: 1,
+                    vars: {
+                        firstName: { required: true },
+                        lastName: { required: false },
+                    },
+                },
+            };
+            const configClient = new Ewyn({
+                workspaceId: 'test-workspace-id',
+                apiKey: 'test-api-key',
+                templates: config,
+            });
+            const mockResponse = {
+                messageId: 'msg-123',
+                status: 'queued',
+                queuedAt: '2024-01-01T00:00:00Z',
+            };
+            global.fetch.mockResolvedValueOnce({
+                ok: true,
+                status: 200,
+                json: async () => mockResponse,
+            });
+            const result = await configClient.send({
+                to: 'test@example.com',
+                template: 'welcome',
+                variables: {
+                    firstName: 'John',
+                    // lastName omitted (optional)
+                },
+            });
+            expect(result).toEqual(mockResponse);
+        });
+    });
+    describe('error handling', () => {
+        it('should throw EwynApiError on 400 error', async () => {
+            const mock400Response = {
+                ok: false,
+                status: 400,
+                json: async () => ({
+                    error: 'Bad request',
+                    code: 'INVALID_REQUEST',
+                    details: { field: 'to' },
+                }),
+            };
+            global.fetch
+                .mockResolvedValueOnce(mock400Response)
+                .mockResolvedValueOnce(mock400Response);
+            await expect(client.send({
+                to: 'test@example.com',
+                templateId: 'template-uuid',
+            })).rejects.toThrow(EwynApiError);
+            try {
+                await client.send({
+                    to: 'test@example.com',
+                    templateId: 'template-uuid',
+                });
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(EwynApiError);
+                expect(error.status).toBe(400);
+                expect(error.code).toBe('INVALID_REQUEST');
+                expect(error.isClientError()).toBe(true);
+                expect(error.isServerError()).toBe(false);
+                expect(error.isRetryable()).toBe(false);
+            }
+        });
+        it('should throw EwynApiError on 429 rate limit', async () => {
+            global.fetch.mockResolvedValue({
+                ok: false,
+                status: 429,
+                json: async () => ({
+                    error: 'Too many requests',
+                    code: 'RATE_LIMITED',
+                }),
+            });
+            try {
+                await client.send({
+                    to: 'test@example.com',
+                    templateId: 'template-uuid',
+                });
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(EwynApiError);
+                expect(error.status).toBe(429);
+                expect(error.isRetryable()).toBe(true);
+            }
+            // Should have retried once (maxRetries: 1)
+            expect(global.fetch).toHaveBeenCalledTimes(2);
+        });
+        it('should throw EwynApiError on 500 server error', async () => {
+            global.fetch.mockResolvedValue({
+                ok: false,
+                status: 500,
+                json: async () => ({
+                    error: 'Internal server error',
+                }),
+            });
+            try {
+                await client.send({
+                    to: 'test@example.com',
+                    templateId: 'template-uuid',
+                });
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(EwynApiError);
+                expect(error.status).toBe(500);
+                expect(error.isServerError()).toBe(true);
+                expect(error.isRetryable()).toBe(true);
+            }
+            // Should have retried once
+            expect(global.fetch).toHaveBeenCalledTimes(2);
+        });
+        it('should handle network errors', async () => {
+            global.fetch.mockRejectedValue(new Error('Network error'));
+            await expect(client.send({
+                to: 'test@example.com',
+                templateId: 'template-uuid',
+            })).rejects.toThrow('Network error');
+            // Should have retried once
+            expect(global.fetch).toHaveBeenCalledTimes(2);
+        });
+        it('should handle timeout errors', async () => {
+            const abortError = new Error('The operation was aborted');
+            abortError.name = 'AbortError';
+            global.fetch.mockRejectedValueOnce(abortError);
+            try {
+                await client.send({
+                    to: 'test@example.com',
+                    templateId: 'template-uuid',
+                });
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(EwynApiError);
+                expect(error.status).toBe(408);
+                expect(error.code).toBe('TIMEOUT');
+            }
+        });
+    });
+    describe('retry logic', () => {
+        it('should retry on 5xx errors with exponential backoff', async () => {
+            const startTime = Date.now();
+            global.fetch
+                .mockResolvedValueOnce({
+                ok: false,
+                status: 500,
+                json: async () => ({ error: 'Server error' }),
+            })
+                .mockResolvedValueOnce({
+                ok: true,
+                status: 200,
+                json: async () => ({
+                    messageId: 'msg-123',
+                    status: 'queued',
+                    queuedAt: '2024-01-01T00:00:00Z',
+                }),
+            });
+            const result = await client.send({
+                to: 'test@example.com',
+                templateId: 'template-uuid',
+            });
+            const duration = Date.now() - startTime;
+            expect(result.messageId).toBe('msg-123');
+            expect(global.fetch).toHaveBeenCalledTimes(2);
+            // Should have waited ~1 second between attempts
+            expect(duration).toBeGreaterThanOrEqual(950);
+        });
+        it('should not retry on 4xx client errors', async () => {
+            global.fetch.mockResolvedValueOnce({
+                ok: false,
+                status: 404,
+                json: async () => ({ error: 'Not found' }),
+            });
+            await expect(client.send({
+                to: 'test@example.com',
+                templateId: 'template-uuid',
+            })).rejects.toThrow(EwynApiError);
+            // Should not retry
+            expect(global.fetch).toHaveBeenCalledTimes(1);
+        });
+    });
+});

package/dist/cli.d.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+/** Exported for testing. */
+export declare function runFetchConfig(cwd: string): Promise<void>;
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AA+GA,4BAA4B;AAC5B,wBAAsB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAqB/D"}

package/dist/cli.js

@@ -0,0 +1,140 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+const EWYN_API_BASE_URL = 'https://www.ewyn.ai/api/v1';
+const CONFIG_NAMES = ['ewyn.config.ts', 'ewyn.config.mjs', 'ewyn.config.js'];
+const DEFAULT_OUTPUT_FILE = 'ewynTemplates.ts';
+function printUsage() {
+    console.error(`
+Usage: ewyn <command>
+
+Commands:
+  fetch-config   Fetch template config from the API and write ewynTemplates.ts (or configurationPath from ewyn.config)
+
+Config file (in current working directory):
+  Look for ewyn.config.ts, ewyn.config.mjs, or ewyn.config.js with default export:
+  { workspaceId: string, apiKey: string, configurationPath?: string }
+
+Example ewyn.config.ts:
+  export default {
+    workspaceId: process.env.EWYN_WORKSPACE_ID!,
+    apiKey: process.env.EWYN_API_KEY!,
+    configurationPath: './src/ewynTemplates.ts',  // optional
+  };
+`);
+}
+function findConfigPath(cwd) {
+    for (const name of CONFIG_NAMES) {
+        const p = path.join(cwd, name);
+        if (fs.existsSync(p))
+            return p;
+    }
+    return null;
+}
+async function loadConfig(configPath) {
+    const ext = path.extname(configPath);
+    if (ext === '.ts') {
+        const require = createRequire(import.meta.url);
+        const { register } = require('tsx/cjs');
+        register();
+        const mod = require(configPath);
+        const config = mod?.default;
+        if (!config || typeof config !== 'object') {
+            throw new Error(`${configPath}: expected default export to be a config object`);
+        }
+        return config;
+    }
+    const mod = await import(pathToFileURL(configPath).href);
+    const config = mod?.default;
+    if (!config || typeof config !== 'object') {
+        throw new Error(`${configPath}: expected default export to be a config object`);
+    }
+    return config;
+}
+function validateConfig(config, configPath) {
+    if (!config.workspaceId || typeof config.workspaceId !== 'string') {
+        console.error(`Error: workspaceId is missing or invalid in ${configPath}. You can use process.env.EWYN_WORKSPACE_ID.`);
+        process.exit(1);
+    }
+    if (!config.apiKey || typeof config.apiKey !== 'string') {
+        console.error(`Error: apiKey is missing or invalid in ${configPath}. You can use process.env.EWYN_API_KEY.`);
+        process.exit(1);
+    }
+}
+async function fetchTemplates(workspaceId, apiKey) {
+    const url = `${EWYN_API_BASE_URL}/workspaces/${workspaceId}/templates/config`;
+    const response = await fetch(url, {
+        method: 'GET',
+        headers: {
+            Authorization: `Bearer ${apiKey}`,
+        },
+    });
+    if (!response.ok) {
+        const body = await response.text();
+        let details = body;
+        try {
+            const json = JSON.parse(body);
+            details = json.error ?? json.message ?? body;
+        }
+        catch {
+            // use raw body
+        }
+        console.error(`Error: API request failed (${response.status}): ${details}`);
+        process.exit(1);
+    }
+    const data = (await response.json());
+    const templates = data.templates ?? {};
+    return templates;
+}
+function serializeTemplates(templates) {
+    const lines = ['// Generated by @ewyn/client fetch-config. Do not edit by hand.', '', 'export const ewynTemplates = '];
+    const json = JSON.stringify(templates, null, 2);
+    // Ensure valid TS: escape any stray characters and add "as const"
+    lines.push(json + ' as const;');
+    return lines.join('\n');
+}
+/** Exported for testing. */
+export async function runFetchConfig(cwd) {
+    const configPath = findConfigPath(cwd);
+    if (!configPath) {
+        console.error('Error: ewyn.config.ts (or ewyn.config.mjs / ewyn.config.js) not found in current directory.');
+        process.exit(1);
+    }
+    const config = await loadConfig(configPath);
+    validateConfig(config, configPath);
+    const outputPath = config.configurationPath
+        ? path.resolve(cwd, config.configurationPath)
+        : path.join(cwd, DEFAULT_OUTPUT_FILE);
+    const templates = await fetchTemplates(config.workspaceId, config.apiKey);
+    const dir = path.dirname(outputPath);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(outputPath, serializeTemplates(templates), 'utf-8');
+    console.log(`Wrote ${outputPath}`);
+}
+async function main() {
+    const args = process.argv.slice(2);
+    const command = args[0];
+    if (!command || command === '--help' || command === '-h') {
+        printUsage();
+        process.exit(0);
+    }
+    if (command === 'fetch-config') {
+        const cwd = process.cwd();
+        await runFetchConfig(cwd);
+        return;
+    }
+    console.error(`Error: unknown command "${command}".`);
+    printUsage();
+    process.exit(1);
+}
+const isMain = typeof process !== 'undefined' &&
+    process.argv[1] &&
+    pathToFileURL(process.argv[1]).href === import.meta.url;
+if (isMain) {
+    main().catch((err) => {
+        console.error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    });
+}

package/dist/errors.d.ts

@@ -1,7 +1,7 @@
 /**
- * API Error class for handling HTTP errors from the Mailer API
+ * API Error class for handling HTTP errors from the Ewyn API
  */
-export declare class MailerApiError extends Error {
+export declare class EwynApiError extends Error {
     status: number;
     code?: string | undefined;
     details?: unknown | undefined;

package/dist/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,qBAAa,cAAe,SAAQ,KAAK;IAE9B,MAAM,EAAE,MAAM;IACd,IAAI,CAAC,EAAE,MAAM;IACb,OAAO,CAAC,EAAE,OAAO;gBAFjB,MAAM,EAAE,MAAM,EACd,IAAI,CAAC,EAAE,MAAM,YAAA,EACb,OAAO,CAAC,EAAE,OAAO,YAAA,EACxB,OAAO,CAAC,EAAE,MAAM;IAOlB;;OAEG;IACH,aAAa,IAAI,OAAO;IAIxB;;OAEG;IACH,aAAa,IAAI,OAAO;IAIxB;;OAEG;IACH,WAAW,IAAI,OAAO;CAGvB"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,qBAAa,YAAa,SAAQ,KAAK;IAE5B,MAAM,EAAE,MAAM;IACd,IAAI,CAAC,EAAE,MAAM;IACb,OAAO,CAAC,EAAE,OAAO;gBAFjB,MAAM,EAAE,MAAM,EACd,IAAI,CAAC,EAAE,MAAM,YAAA,EACb,OAAO,CAAC,EAAE,OAAO,YAAA,EACxB,OAAO,CAAC,EAAE,MAAM;IAOlB;;OAEG;IACH,aAAa,IAAI,OAAO;IAIxB;;OAEG;IACH,aAAa,IAAI,OAAO;IAIxB;;OAEG;IACH,WAAW,IAAI,OAAO;CAGvB"}

package/dist/errors.js

@@ -1,7 +1,7 @@
 /**
- * API Error class for handling HTTP errors from the Mailer API
+ * API Error class for handling HTTP errors from the Ewyn API
  */
-export class MailerApiError extends Error {
+export class EwynApiError extends Error {
     status;
     code;
     details;
@@ -10,8 +10,8 @@ export class MailerApiError extends Error {
         this.status = status;
         this.code = code;
         this.details = details;
-        this.name = 'MailerApiError';
-        Object.setPrototypeOf(this, MailerApiError.prototype);
+        this.name = 'EwynApiError';
+        Object.setPrototypeOf(this, EwynApiError.prototype);
     }
     /**
      * Check if the error is a client error (4xx)

package/dist/index.d.ts

@@ -1,65 +1,17 @@
-import type { MailerOptions, MailerOptionsTyped, SendEmailOptions, SendEmailOptionsTyped, SendEmailResponse, TemplateConfig } from './types.js';
-/**
- * Mailer SDK Client
- *
- * @example Basic usage without template config
- * ```ts
- * const client = new Mailer({
- *   workspaceId: 'your-workspace-id',
- *   apiKey: 'your-api-key',
- * });
- *
- * await client.send({
- *   to: 'user@example.com',
- *   templateId: 'version-uuid',
- *   variables: { firstName: 'John' }
- * });
- * ```
- *
- * @example Type-safe usage with template config
- * ```ts
- * const config = {
- *   welcome: {
- *     id: 'version-uuid',
- *     name: 'Welcome Email',
- *     version: 1,
- *     vars: {
- *       firstName: { required: true },
- *       plan: { required: false }
- *     }
- *   }
- * } as const;
- *
- * const client = new Mailer({
- *   workspaceId: 'your-workspace-id',
- *   apiKey: 'your-api-key',
- *   templates: config
- * });
- *
- * // Type-safe sending
- * await client.send({
- *   to: 'user@example.com',
- *   template: 'welcome',  // Autocomplete available
- *   variables: {
- *     firstName: 'John'    // TypeScript enforces required vars
- *   }
- * });
- * ```
- */
-export declare class Mailer<TConfig extends TemplateConfig = TemplateConfig> {
+import type { EwynOptions, EwynOptionsTyped, SendEmailOptions, SendEmailOptionsTyped, SendEmailResponse, TemplateConfig } from './types.js';
+export declare class Ewyn<TConfig extends TemplateConfig = TemplateConfig> {
     private readonly workspaceId;
     private readonly apiKey;
-    private readonly baseUrl;
     private readonly templates?;
     private readonly maxRetries;
     private readonly timeout;
-    constructor(options: MailerOptions | MailerOptionsTyped<TConfig>);
+    constructor(options: EwynOptions | EwynOptionsTyped<TConfig>);
     /**
      * Send an email using a template
      *
      * @param options - Email sending options
      * @returns Promise resolving to the send response
-     * @throws {MailerApiError} If the API request fails
+     * @throws {EwynApiError} If the API request fails
      *
      * @example With template ID
      * ```ts
@@ -94,6 +46,6 @@ export declare class Mailer<TConfig extends TemplateConfig = TemplateConfig> {
      */
     private requestWithRetry;
 }
-export { MailerApiError } from './errors.js';
-export type { MailerOptions, MailerOptionsTyped, SendEmailOptions, SendEmailOptionsBase, SendEmailOptionsTyped, SendEmailResponse, TemplateConfig, TemplateConfigEntry, TemplateVariable } from './types.js';
+export { EwynApiError } from './errors.js';
+export type { EwynFetchConfig, EwynOptions, EwynOptionsTyped, SendEmailOptions, SendEmailOptionsBase, SendEmailOptionsTyped, SendEmailResponse, TemplateConfig, TemplateConfigEntry, TemplateVariable } from './types.js';
 //# sourceMappingURL=index.d.ts.map