@webamoki/web-svelte 1.2.2 → 2.0.0

package/dist/{utils → shared/utils}/datetime/index.d.ts

@@ -1,15 +1,29 @@
 import type { Transport } from '@sveltejs/kit';
 import { CalendarDate, type DateDuration, Time, ZonedDateTime } from '@internationalized/date';
-import type { Day } from '../types/arktype.js';
 export declare const Days: readonly ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"];
+export type Day = (typeof Days)[number];
 export declare const DayIndex: Record<Day, number>;
-/**
- * Calculates the age from a date of birth.
- * @param dob - The date of birth.
- * @returns The age in years.
- * @throws Error if the date of birth is in the future.
- */
-export declare function ageFromDob(dob: CalendarDate, timezone: string): number;
+export declare class LocalDateF {
+    private readonly timezone;
+    constructor(timezone: string);
+    /**
+     * Calculates the age from a date of birth.
+     * @param dob - The date of birth.
+     * @returns The age in years.
+     * @throws Error if the date of birth is in the future.
+     */
+    ageFromDob(dob: CalendarDate): number;
+    /**
+     * Checks if a given date is today.
+     * @param date - The date to check.
+     * @returns True if the date is today, false otherwise.
+     */
+    isDateToday(date: CalendarDate): boolean;
+    /**
+     * @returns The current date.
+     */
+    today(): CalendarDate;
+}
 /**
  * Checks if two time ranges overlap, boundaries are not considered overlapping.
  * @param start1 - The start time of the first range.
@@ -73,12 +87,6 @@ export declare function getNextDateOfDay(dayOfWeek: Day, startDate: CalendarDate
  * @returns True if the date is the specified day, false otherwise.
  */
 export declare function isDateDay(date: CalendarDate, dayOfWeek: Day): boolean;
-/**
- * Checks if a given date is today.
- * @param date - The date to check.
- * @returns True if the date is today, false otherwise.
- */
-export declare function isDateToday(date: CalendarDate, timezone: string): boolean;
 /**
  * Calculates the difference in weeks between two dates.
  * @param date1 - The first date in order.

package/dist/{utils → shared/utils}/datetime/index.js

@@ -1,6 +1,5 @@
-import { CalendarDate, DateFormatter, fromDate, getDayOfWeek, getLocalTimeZone, startOfMonth, Time, toCalendarDate, today, toTime, ZonedDateTime } from '@internationalized/date';
+import { CalendarDate, DateFormatter, fromDate, getDayOfWeek, getLocalTimeZone, startOfMonth, Time, toCalendarDate, today as todayFn, toTime, ZonedDateTime } from '@internationalized/date';
 import { map, range } from 'ramda';
-const DEFAULT_TIME_ZONE = 'Europe/London';
 const DEFAULT_LOCALE = 'en-GB';
 // Day of the week
 export const Days = [
@@ -13,25 +12,46 @@ export const Days = [
     'Sunday'
 ];
 export const DayIndex = Object.fromEntries(Days.map((day, index) => [day, index]));
-/**
- * Calculates the age from a date of birth.
- * @param dob - The date of birth.
- * @returns The age in years.
- * @throws Error if the date of birth is in the future.
- */
-export function ageFromDob(dob, timezone) {
-    const todayDate = today(timezone);
-    if (todayDate.compare(dob) < 0) {
-        throw new Error('Date of birth is in the future');
+// Date functions local to a timezone
+export class LocalDateF {
+    timezone;
+    constructor(timezone) {
+        this.timezone = timezone;
+    }
+    /**
+     * Calculates the age from a date of birth.
+     * @param dob - The date of birth.
+     * @returns The age in years.
+     * @throws Error if the date of birth is in the future.
+     */
+    ageFromDob(dob) {
+        const todayDate = this.today();
+        if (todayDate.compare(dob) < 0) {
+            throw new Error('Date of birth is in the future');
+        }
+        let years = todayDate.year - dob.year;
+        const monthDiff = todayDate.month - dob.month;
+        const dayDiff = todayDate.day - dob.day;
+        // Adjust years down if birthday hasn't occurred this year
+        if (monthDiff < 0 || (monthDiff === 0 && dayDiff < 0)) {
+            years--;
+        }
+        return years;
     }
-    let years = todayDate.year - dob.year;
-    const monthDiff = todayDate.month - dob.month;
-    const dayDiff = todayDate.day - dob.day;
-    // Adjust years down if birthday hasn't occurred this year
-    if (monthDiff < 0 || (monthDiff === 0 && dayDiff < 0)) {
-        years--;
+    /**
+     * Checks if a given date is today.
+     * @param date - The date to check.
+     * @returns True if the date is today, false otherwise.
+     */
+    isDateToday(date) {
+        return this.today().compare(date) === 0;
+    }
+    /**
+     * @returns The current date.
+     */
+    today() {
+        return todayFn(this.timezone);
     }
-    return years;
 }
 /**
  * Checks if two time ranges overlap, boundaries are not considered overlapping.
@@ -145,14 +165,6 @@ export function isDateDay(date, dayOfWeek) {
     const dateDay = getDayOfDate(date);
     return dateDay === dayOfWeek;
 }
-/**
- * Checks if a given date is today.
- * @param date - The date to check.
- * @returns True if the date is today, false otherwise.
- */
-export function isDateToday(date, timezone) {
-    return today(timezone).compare(date) === 0;
-}
 const msPerWeek = 7 * 24 * 60 * 60 * 1000;
 /**
  * Calculates the difference in weeks between two dates.
@@ -160,9 +172,10 @@ const msPerWeek = 7 * 24 * 60 * 60 * 1000;
  * @param date2 - The second date in order.
  */
 export function dateDiffWeeks(date1, date2) {
-    const date1Abs = date1.toDate(DEFAULT_TIME_ZONE).getTime();
-    const date2Abs = date2.toDate(DEFAULT_TIME_ZONE).getTime();
-    return Math.floor((date2Abs - date1Abs) / msPerWeek);
+    const date1Ms = date1.toDate('UTC').getTime();
+    const date2Ms = date2.toDate('UTC').getTime();
+    const absDiff = Math.abs(date2Ms - date1Ms);
+    return Math.floor(absDiff / msPerWeek);
 }
 /* Formatting */
 /* Day of the week*/
@@ -313,9 +326,8 @@ function formatDate(date, formatter) {
 }
 // Pad number with zeroes to the left
 function padNum(num, len) {
-    if (isNaN(num)) {
+    if (isNaN(num))
         return '0'.repeat(len);
-    }
     return num.toString().padStart(len, '0');
 }
 // SerDe

package/dist/{utils → shared/utils}/email/README.md

@@ -4,17 +4,17 @@ This package provides utilities for sending emails using AWS Simple Email Servic
 
 ## Key Features
 
-- **Cloudflare Workers Compatible**: Uses direct AWS SES API calls with fetch instead of AWS SDK
-- **AWS Signature V4**: Implements proper AWS authentication for secure API requests
+- **Cloudflare Workers Compatible**: Uses `aws4fetch` for direct AWS SES API calls
+- **AWS Signature V4**: Handled by `aws4fetch` for secure API requests
 - **Zero Heavy Dependencies**: No AWS SDK required, works in any JavaScript runtime with fetch support
 
 ## Installation
 
-No additional dependencies required beyond the standard JavaScript runtime. The implementation uses:
+The implementation uses:
 
+- `aws4fetch` for AWS Signature V4 signing and requests
 - Native `fetch` API for HTTP requests
-- Web Crypto API for AWS Signature V4 signing
-- Native `DOMParser` for XML response parsing
+- Native `DOMParser` for XML response parsing (optional, used for error/response parsing)
 
 ## Configuration
 

package/dist/{utils → shared/utils}/email/ses.js

@@ -1,4 +1,4 @@
-import { signRequest } from './aws-signer.js';
+import { AwsClient } from 'aws4fetch';
 /**
  * Send an email using AWS SES API.
  * Uses AWS Signature V4 signing and fetch API for Cloudflare Workers compatibility.
@@ -71,21 +71,29 @@ export async function sendEmail(options) {
     const host = `email.${awsRegion}.amazonaws.com`;
     const path = '/';
     try {
-        // Sign the request
-        const { headers } = await signRequest('POST', host, path, body, {
+        const aws = new AwsClient({
             accessKeyId: awsAccessKeyId,
             region: awsRegion,
-            secretAccessKey: awsSecretAccessKey
+            secretAccessKey: awsSecretAccessKey,
+            service: 'ses'
         });
-        // Make the request
-        const response = await fetch(`https://${host}${path}`, {
+        const url = `https://${host}${path}`;
+        const init = {
             body,
             headers: {
-                ...headers,
-                'Content-Length': body.length.toString(),
-                Host: host
+                'Content-Type': 'application/x-form-urlencoded'
             },
             method: 'POST'
+        };
+        // Sign the request and then use the global fetch.
+        // We avoid using aws.fetch() directly as it can cause issues in some test environments
+        // or when fetch is mocked/replaced after AwsClient instantiation.
+        const signedRequest = await aws.sign(url, init);
+        // Use two-argument fetch to satisfy tests that expect the second argument to be an options object
+        const response = await fetch(signedRequest.url, {
+            body: init.body,
+            headers: signedRequest.headers,
+            method: signedRequest.method
         });
         const responseText = await response.text();
         if (!response.ok) {

package/dist/shared/utils/email/ses.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/shared/utils/email/ses.test.js

@@ -0,0 +1,335 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+// Mock global fetch and DOMParser
+const mockFetch = vi.fn();
+global.fetch = mockFetch;
+// Mock DOMParser for XML parsing
+const mockDOMParser = vi.fn(() => ({
+    parseFromString: vi.fn((xmlString) => {
+        // Simple mock XML parser for testing
+        const messageIdMatch = xmlString.match(/<MessageId>(.*?)<\/MessageId>/);
+        const errorCodeMatch = xmlString.match(/<Code>(.*?)<\/Code>/);
+        const errorMessageMatch = xmlString.match(/<Message>(.*?)<\/Message>/);
+        return {
+            querySelector: (selector) => {
+                if (selector === 'MessageId' && messageIdMatch) {
+                    return { textContent: messageIdMatch[1] };
+                }
+                if (selector === 'Error' && (errorCodeMatch || errorMessageMatch)) {
+                    return {
+                        querySelector: (innerSelector) => {
+                            if (innerSelector === 'Code' && errorCodeMatch) {
+                                return { textContent: errorCodeMatch[1] };
+                            }
+                            if (innerSelector === 'Message' && errorMessageMatch) {
+                                return { textContent: errorMessageMatch[1] };
+                            }
+                            return null;
+                        }
+                    };
+                }
+                return null;
+            }
+        };
+    })
+}));
+global.DOMParser = mockDOMParser;
+// Import after mocking
+import { sendEmail } from './ses.js';
+const testAwsCredentials = {
+    awsAccessKeyId: 'test-access-key',
+    awsRegion: 'us-east-1',
+    awsSecretAccessKey: 'test-secret-key'
+};
+describe('sendEmail', () => {
+    beforeEach(() => {
+        mockFetch.mockClear();
+    });
+    it('should throw error if options is not provided', async () => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        await expect(sendEmail(null)).rejects.toThrow('sendEmail: options is required');
+    });
+    it('should throw error if "to" field is missing', async () => {
+        await expect(sendEmail({
+            from: 'sender@example.com',
+            subject: 'Test',
+            text: 'Test message',
+            ...testAwsCredentials
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        })).rejects.toThrow('at least one valid recipient is required');
+    });
+    it('should throw error if "to" field is empty string', async () => {
+        await expect(sendEmail({
+            from: 'sender@example.com',
+            subject: 'Test',
+            text: 'Test message',
+            to: '   ',
+            ...testAwsCredentials
+        })).rejects.toThrow('at least one valid recipient is required');
+    });
+    it('should throw error if "to" field is empty array', async () => {
+        await expect(sendEmail({
+            from: 'sender@example.com',
+            subject: 'Test',
+            text: 'Test message',
+            to: [],
+            ...testAwsCredentials
+        })).rejects.toThrow('at least one valid recipient is required');
+    });
+    it('should throw error if "to" field contains only empty strings', async () => {
+        await expect(sendEmail({
+            from: 'sender@example.com',
+            subject: 'Test',
+            text: 'Test message',
+            to: ['', '   ', ''],
+            ...testAwsCredentials
+        })).rejects.toThrow('at least one valid recipient is required');
+    });
+    it('should filter out empty strings from "to" array and accept valid emails', async () => {
+        mockFetch.mockResolvedValue({
+            ok: true,
+            text: async () => '<SendEmailResponse><MessageId>test-message-id</MessageId></SendEmailResponse>'
+        });
+        await sendEmail({
+            from: 'sender@example.com',
+            subject: 'Test',
+            text: 'Test message',
+            to: ['', 'valid@example.com', '   ', 'another@example.com'],
+            ...testAwsCredentials
+        });
+        expect(mockFetch).toHaveBeenCalledTimes(1);
+        const fetchCall = mockFetch.mock.calls[0];
+        const body = fetchCall[1].body;
+        expect(body).toContain('Destination.ToAddresses.member.1=valid%40example.com');
+        expect(body).toContain('Destination.ToAddresses.member.2=another%40example.com');
+    });
+    it('should filter out empty strings from cc and bcc arrays', async () => {
+        mockFetch.mockResolvedValue({
+            ok: true,
+            text: async () => '<SendEmailResponse><MessageId>test-message-id</MessageId></SendEmailResponse>'
+        });
+        await sendEmail({
+            bcc: ['  ', 'bcc@example.com'],
+            cc: ['', 'cc@example.com', '  '],
+            from: 'sender@example.com',
+            subject: 'Test',
+            text: 'Test message',
+            to: 'test@example.com',
+            ...testAwsCredentials
+        });
+        expect(mockFetch).toHaveBeenCalledTimes(1);
+        const fetchCall = mockFetch.mock.calls[0];
+        const body = fetchCall[1].body;
+        expect(body).toContain('Destination.CcAddresses.member.1=cc%40example.com');
+        expect(body).toContain('Destination.BccAddresses.member.1=bcc%40example.com');
+    });
+    it('should omit cc/bcc if all values are empty strings', async () => {
+        mockFetch.mockResolvedValue({
+            ok: true,
+            text: async () => '<SendEmailResponse><MessageId>test-message-id</MessageId></SendEmailResponse>'
+        });
+        await sendEmail({
+            bcc: ['   '],
+            cc: ['', '  '],
+            from: 'sender@example.com',
+            subject: 'Test',
+            text: 'Test message',
+            to: 'test@example.com',
+            ...testAwsCredentials
+        });
+        expect(mockFetch).toHaveBeenCalledTimes(1);
+        const fetchCall = mockFetch.mock.calls[0];
+        const body = fetchCall[1].body;
+        expect(body).not.toContain('Destination.CcAddresses');
+        expect(body).not.toContain('Destination.BccAddresses');
+    });
+    it('should throw error if subject is missing', async () => {
+        await expect(sendEmail({
+            text: 'Test message',
+            to: 'test@example.com',
+            ...testAwsCredentials
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        })).rejects.toThrow('subject is required');
+    });
+    it('should throw error if both text and html are missing', async () => {
+        await expect(sendEmail({
+            subject: 'Test',
+            to: 'test@example.com',
+            ...testAwsCredentials
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        })).rejects.toThrow('at least one of text or html body must be provided');
+    });
+    it('should throw error if from is not provided', async () => {
+        await expect(sendEmail({
+            subject: 'Test',
+            text: 'Test message',
+            to: 'test@example.com',
+            ...testAwsCredentials
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        })).rejects.toThrow('sender `from` is required');
+    });
+    it('should accept single recipient as string', async () => {
+        mockFetch.mockResolvedValue({
+            ok: true,
+            text: async () => '<SendEmailResponse><MessageId>test-message-id</MessageId></SendEmailResponse>'
+        });
+        await sendEmail({
+            from: 'sender@example.com',
+            subject: 'Test',
+            text: 'Test message',
+            to: 'test@example.com',
+            ...testAwsCredentials
+        });
+        expect(mockFetch).toHaveBeenCalledTimes(1);
+    });
+    it('should accept multiple recipients as array', async () => {
+        mockFetch.mockResolvedValue({
+            ok: true,
+            text: async () => '<SendEmailResponse><MessageId>test-message-id</MessageId></SendEmailResponse>'
+        });
+        await sendEmail({
+            from: 'sender@example.com',
+            subject: 'Test',
+            text: 'Test message',
+            to: ['test1@example.com', 'test2@example.com'],
+            ...testAwsCredentials
+        });
+        expect(mockFetch).toHaveBeenCalledTimes(1);
+    });
+    it('should format source with fromName when provided', async () => {
+        mockFetch.mockResolvedValue({
+            ok: true,
+            text: async () => '<SendEmailResponse><MessageId>test-message-id</MessageId></SendEmailResponse>'
+        });
+        await sendEmail({
+            from: 'sender@example.com',
+            fromName: 'Test Sender',
+            subject: 'Test',
+            text: 'Test message',
+            to: 'test@example.com',
+            ...testAwsCredentials
+        });
+        expect(mockFetch).toHaveBeenCalledTimes(1);
+        const fetchCall = mockFetch.mock.calls[0];
+        const body = fetchCall[1].body;
+        expect(body).toContain('Source=Test+Sender+%3Csender%40example.com%3E');
+    });
+    it('should handle CC and BCC recipients', async () => {
+        mockFetch.mockResolvedValue({
+            ok: true,
+            text: async () => '<SendEmailResponse><MessageId>test-message-id</MessageId></SendEmailResponse>'
+        });
+        await sendEmail({
+            bcc: ['bcc1@example.com', 'bcc2@example.com'],
+            cc: 'cc@example.com',
+            from: 'sender@example.com',
+            subject: 'Test',
+            text: 'Test message',
+            to: 'test@example.com',
+            ...testAwsCredentials
+        });
+        expect(mockFetch).toHaveBeenCalledTimes(1);
+        const fetchCall = mockFetch.mock.calls[0];
+        const body = fetchCall[1].body;
+        expect(body).toContain('Destination.CcAddresses.member.1=cc%40example.com');
+        expect(body).toContain('Destination.BccAddresses.member.1=bcc1%40example.com');
+        expect(body).toContain('Destination.BccAddresses.member.2=bcc2%40example.com');
+    });
+    it('should include both HTML and text body when provided', async () => {
+        mockFetch.mockResolvedValue({
+            ok: true,
+            text: async () => '<SendEmailResponse><MessageId>test-message-id</MessageId></SendEmailResponse>'
+        });
+        await sendEmail({
+            from: 'sender@example.com',
+            html: '<p>HTML version</p>',
+            subject: 'Test',
+            text: 'Plain text version',
+            to: 'test@example.com',
+            ...testAwsCredentials
+        });
+        expect(mockFetch).toHaveBeenCalledTimes(1);
+        const fetchCall = mockFetch.mock.calls[0];
+        const body = fetchCall[1].body;
+        expect(body).toContain('Message.Body.Text.Data=Plain+text+version');
+        expect(body).toContain('Message.Body.Html.Data=%3Cp%3EHTML+version%3C%2Fp%3E');
+    });
+    it('should return MessageId on success', async () => {
+        mockFetch.mockResolvedValue({
+            ok: true,
+            text: async () => '<SendEmailResponse><MessageId>test-message-id-123</MessageId></SendEmailResponse>'
+        });
+        const result = await sendEmail({
+            from: 'sender@example.com',
+            subject: 'Test',
+            text: 'Test message',
+            to: 'test@example.com',
+            ...testAwsCredentials
+        });
+        expect(result).toBe('test-message-id-123');
+    });
+    it('should throw error when SES response is missing MessageId', async () => {
+        mockFetch.mockResolvedValue({
+            ok: true,
+            text: async () => '<SendEmailResponse></SendEmailResponse>'
+        });
+        await expect(sendEmail({
+            from: 'sender@example.com',
+            subject: 'Test',
+            text: 'Test message',
+            to: 'test@example.com',
+            ...testAwsCredentials
+        })).rejects.toThrow('SES response did not contain a MessageId');
+    });
+    it('should handle SES errors gracefully', async () => {
+        mockFetch.mockResolvedValue({
+            ok: false,
+            status: 400,
+            statusText: 'Bad Request',
+            text: async () => '<ErrorResponse><Error><Code>MessageRejected</Code><Message>Email address is not verified</Message></Error></ErrorResponse>'
+        });
+        await expect(sendEmail({
+            from: 'sender@example.com',
+            subject: 'Test',
+            text: 'Test message',
+            to: 'test@example.com',
+            ...testAwsCredentials
+        })).rejects.toThrow(/failed to send email/);
+    });
+    it('should handle reply-to addresses', async () => {
+        mockFetch.mockResolvedValue({
+            ok: true,
+            text: async () => '<SendEmailResponse><MessageId>test-message-id</MessageId></SendEmailResponse>'
+        });
+        await sendEmail({
+            from: 'sender@example.com',
+            replyTo: 'reply@example.com',
+            subject: 'Test',
+            text: 'Test message',
+            to: 'test@example.com',
+            ...testAwsCredentials
+        });
+        expect(mockFetch).toHaveBeenCalledTimes(1);
+        const fetchCall = mockFetch.mock.calls[0];
+        const body = fetchCall[1].body;
+        expect(body).toContain('ReplyToAddresses.member.1=reply%40example.com');
+    });
+    it('should handle multiple reply-to addresses', async () => {
+        mockFetch.mockResolvedValue({
+            ok: true,
+            text: async () => '<SendEmailResponse><MessageId>test-message-id</MessageId></SendEmailResponse>'
+        });
+        await sendEmail({
+            from: 'sender@example.com',
+            replyTo: ['reply1@example.com', 'reply2@example.com'],
+            subject: 'Test',
+            text: 'Test message',
+            to: 'test@example.com',
+            ...testAwsCredentials
+        });
+        expect(mockFetch).toHaveBeenCalledTimes(1);
+        const fetchCall = mockFetch.mock.calls[0];
+        const body = fetchCall[1].body;
+        expect(body).toContain('ReplyToAddresses.member.1=reply1%40example.com');
+        expect(body).toContain('ReplyToAddresses.member.2=reply2%40example.com');
+    });
+});

package/dist/shared/utils/functional/index.d.ts

@@ -0,0 +1,2 @@
+import { Result } from './result.js';
+export { Result };

package/dist/shared/utils/functional/index.js

@@ -0,0 +1,2 @@
+import { Result } from './result.js';
+export { Result };

package/dist/shared/utils/functional/result.d.ts

@@ -0,0 +1,72 @@
+export type Result<T, E> = {
+    error: E;
+    ok: false;
+} | {
+    ok: true;
+    value: T;
+};
+export declare const Result: {
+    /**
+     * Creates a failed result with the given error.
+     */
+    err<E>(error: E): {
+        error: E;
+        ok: false;
+    };
+    /**
+     * Creates a successful result with the given value.
+     */
+    ok<T>(value: T): {
+        ok: true;
+        value: T;
+    };
+    /**
+     * Returns true if the result is Ok.
+     */
+    isOk<T, E>(result: Result<T, E>): result is {
+        ok: true;
+        value: T;
+    };
+    /**
+     * Returns true if the result is Err.
+     */
+    isErr<T, E>(result: Result<T, E>): result is {
+        error: E;
+        ok: false;
+    };
+    /**
+     * Returns the contained Ok value or a provided default.
+     */
+    unwrapOr<T, E>(result: Result<T, E>, defaultValue: T): T;
+    /**
+     * Returns the contained Ok value or computes it from the provided op.
+     * @param op - Computes value in error case or throws an error.
+     */
+    unwrapOrElse<T, E>(result: Result<T, E>, op: (error: E) => T): T;
+    /**
+     * Maps a Result<T, E> to Result<U, E> by applying a function to a contained Ok value,
+     * leaving an Err value untouched.
+     */
+    map<T, U, E>(result: Result<T, E>, fn: (val: T) => U): Result<U, E>;
+    /**
+     * Maps a Result<T, E> to Result<T, F> by applying a function to a contained Err value,
+     * leaving an Ok value untouched.
+     */
+    mapErr<T, E, F>(result: Result<T, E>, fn: (err: E) => F): Result<T, F>;
+    /**
+     * Calls op if the result is Ok, otherwise returns the Err value of self.
+     * This function can be used for control flow based on Result values.
+     */
+    andThen<T, U, E>(result: Result<T, E>, op: (val: T) => Result<U, E>): Result<U, E>;
+    /**
+     * Calls op if the result is Err, otherwise returns the Ok value of self.
+     */
+    orElse<T, E, F>(result: Result<T, E>, op: (err: E) => Result<T, F>): Result<T, F>;
+    /**
+     * Pattern matches the Result and returns the result of the corresponding arm.
+     */
+    match<T, E, R>(result: Result<T, E>, arms: {
+        err: (err: E) => R;
+        ok: (val: T) => R;
+    }): R;
+};