@solytude/listmonk 1.0.0

package/dist/testing/factories/bounce.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Bounce factory functions.
+ *
+ * @module testing/factories/bounce
+ */
+import type { Bounce } from "../../resources/bounces/types";
+/**
+ * Creates a mock bounce record with realistic default values.
+ *
+ * @param overrides - Optional fields to override defaults
+ * @returns A valid Bounce object
+ *
+ * @example
+ * ```typescript
+ * // Default bounce
+ * const bounce = createMockBounce();
+ * // { id: 1, email: 'bounce1@example.com', type: 'hard', ... }
+ *
+ * // With overrides
+ * const custom = createMockBounce({
+ *   type: 'soft',
+ *   source: 'mailgun',
+ * });
+ * ```
+ */
+export declare function createMockBounce(overrides?: Partial<Bounce>): Bounce;
+/**
+ * Creates multiple unique mock bounce records.
+ *
+ * @param count - Number of bounces to create
+ * @param overrides - Optional fields to apply to all bounces
+ * @returns Array of unique Bounce objects
+ *
+ * @example
+ * ```typescript
+ * const bounces = createMockBounces(3);
+ * // 3 bounce records with unique IDs and emails
+ *
+ * const softBounces = createMockBounces(2, { type: 'soft' });
+ * // 2 soft bounces
+ * ```
+ */
+export declare function createMockBounces(count: number, overrides?: Partial<Omit<Bounce, "id" | "email">>): Bounce[];

package/dist/testing/factories/campaign.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Campaign factory functions.
+ *
+ * @module testing/factories/campaign
+ */
+import type { Campaign } from "../../resources/campaigns/types";
+/**
+ * Creates a mock campaign with realistic default values.
+ *
+ * @param overrides - Optional fields to override defaults
+ * @returns A valid Campaign object
+ *
+ * @example
+ * ```typescript
+ * // Default campaign
+ * const campaign = createMockCampaign();
+ * // { id: 1, name: 'Test Campaign 1', status: 'draft', ... }
+ *
+ * // With overrides
+ * const custom = createMockCampaign({
+ *   name: 'Weekly Newsletter',
+ *   status: 'running',
+ * });
+ * ```
+ */
+export declare function createMockCampaign(overrides?: Partial<Campaign>): Campaign;
+/**
+ * Creates multiple unique mock campaigns.
+ *
+ * @param count - Number of campaigns to create
+ * @param overrides - Optional fields to apply to all campaigns
+ * @returns Array of unique Campaign objects
+ *
+ * @example
+ * ```typescript
+ * const campaigns = createMockCampaigns(3);
+ * // 3 campaigns with unique IDs and names
+ *
+ * const drafts = createMockCampaigns(2, { status: 'draft' });
+ * // 2 draft campaigns
+ * ```
+ */
+export declare function createMockCampaigns(count: number, overrides?: Partial<Omit<Campaign, "id" | "uuid" | "name">>): Campaign[];

package/dist/testing/factories/common.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Common factory utilities.
+ *
+ * @module testing/factories/common
+ */
+/** Global counters for unique IDs */
+declare const counters: {
+    subscriber: number;
+    list: number;
+    campaign: number;
+    template: number;
+    media: number;
+    bounce: number;
+};
+/**
+ * Get next ID for a counter.
+ */
+export declare function nextId(key: keyof typeof counters): number;
+/**
+ * Reset all factory counters to 0.
+ *
+ * Call this in beforeEach/afterEach hooks for predictable test IDs.
+ *
+ * @example
+ * ```typescript
+ * beforeEach(() => {
+ *   resetFactories();
+ * });
+ *
+ * it('creates subscriber with id 1', () => {
+ *   const sub = createMockSubscriber();
+ *   expect(sub.id).toBe(1); // Always 1 after reset
+ * });
+ * ```
+ */
+export declare function resetFactories(): void;
+/**
+ * Generate a valid RFC 4122 UUID v4 for testing.
+ *
+ * The UUID is deterministic based on the entity type and id, making tests predictable.
+ * Format: xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx
+ * - 4 indicates version 4
+ * - y is one of 8, 9, a, b (variant bits)
+ *
+ * @param entityType - Entity type prefix (sub, list, camp, tmpl, med, bnce)
+ * @param id - Numeric ID to embed in the UUID
+ * @returns A valid UUID v4 string that passes Zod validation
+ */
+export declare function mockUuid(entityType: string, id: number): string;
+/**
+ * Get current ISO timestamp.
+ */
+export declare function nowISO(): string;
+export {};

package/dist/testing/factories/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Factory functions index.
+ *
+ * @module testing/factories
+ */
+export { resetFactories } from "./common";
+export { createMockSubscriber, createMockSubscribers } from "./subscriber";
+export { createMockList, createMockLists } from "./list";
+export { createMockCampaign, createMockCampaigns } from "./campaign";
+export { createMockTemplate, createMockTemplates } from "./template";
+export { createMockMedia, createMockMediaItems } from "./media";
+export { createMockBounce, createMockBounces } from "./bounce";

package/dist/testing/factories/list.d.ts

@@ -0,0 +1,43 @@
+/**
+ * List factory functions.
+ *
+ * @module testing/factories/list
+ */
+import type { List } from "../../resources/lists/types";
+/**
+ * Creates a mock list with realistic default values.
+ *
+ * @param overrides - Optional fields to override defaults
+ * @returns A valid List object
+ *
+ * @example
+ * ```typescript
+ * // Default list
+ * const list = createMockList();
+ * // { id: 1, name: 'Test List 1', type: 'public', ... }
+ *
+ * // With overrides
+ * const custom = createMockList({
+ *   name: 'Newsletter',
+ *   type: 'private',
+ * });
+ * ```
+ */
+export declare function createMockList(overrides?: Partial<List>): List;
+/**
+ * Creates multiple unique mock lists.
+ *
+ * @param count - Number of lists to create
+ * @param overrides - Optional fields to apply to all lists
+ * @returns Array of unique List objects
+ *
+ * @example
+ * ```typescript
+ * const lists = createMockLists(3);
+ * // 3 lists with unique IDs and names
+ *
+ * const privateLists = createMockLists(2, { type: 'private' });
+ * // 2 private lists
+ * ```
+ */
+export declare function createMockLists(count: number, overrides?: Partial<Omit<List, "id" | "uuid" | "name">>): List[];

package/dist/testing/factories/media.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Media factory functions.
+ *
+ * @module testing/factories/media
+ */
+import type { Media } from "../../resources/media/types";
+/**
+ * Creates a mock media item with realistic default values.
+ *
+ * @param overrides - Optional fields to override defaults
+ * @returns A valid Media object
+ *
+ * @example
+ * ```typescript
+ * // Default media
+ * const media = createMockMedia();
+ * // { id: 1, filename: 'image1.jpg', content_type: 'image/jpeg', ... }
+ *
+ * // With overrides
+ * const custom = createMockMedia({
+ *   filename: 'logo.png',
+ *   content_type: 'image/png',
+ * });
+ * ```
+ */
+export declare function createMockMedia(overrides?: Partial<Media>): Media;
+/**
+ * Creates multiple unique mock media items.
+ *
+ * @param count - Number of media items to create
+ * @param overrides - Optional fields to apply to all media items
+ * @returns Array of unique Media objects
+ *
+ * @example
+ * ```typescript
+ * const media = createMockMediaItems(5);
+ * // 5 media items with unique IDs and filenames
+ * ```
+ */
+export declare function createMockMediaItems(count: number, overrides?: Partial<Omit<Media, "id" | "uuid" | "filename">>): Media[];

package/dist/testing/factories/subscriber.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Subscriber factory functions.
+ *
+ * @module testing/factories/subscriber
+ */
+import type { Subscriber } from "../../resources/subscribers/types";
+/**
+ * Creates a mock subscriber with realistic default values.
+ *
+ * @param overrides - Optional fields to override defaults
+ * @returns A valid Subscriber object
+ *
+ * @example
+ * ```typescript
+ * // Default subscriber
+ * const sub = createMockSubscriber();
+ * // { id: 1, email: 'user1@example.com', name: 'Test User 1', ... }
+ *
+ * // With overrides
+ * const custom = createMockSubscriber({
+ *   email: 'custom@mycompany.com',
+ *   status: 'disabled',
+ * });
+ * ```
+ */
+export declare function createMockSubscriber(overrides?: Partial<Subscriber>): Subscriber;
+/**
+ * Creates multiple unique mock subscribers.
+ *
+ * @param count - Number of subscribers to create
+ * @param overrides - Optional fields to apply to all subscribers
+ * @returns Array of unique Subscriber objects
+ *
+ * @example
+ * ```typescript
+ * const subs = createMockSubscribers(5);
+ * // 5 subscribers with unique IDs and emails
+ *
+ * const blocklisted = createMockSubscribers(3, { status: 'blocklisted' });
+ * // 3 blocklisted subscribers
+ * ```
+ */
+export declare function createMockSubscribers(count: number, overrides?: Partial<Omit<Subscriber, "id" | "uuid" | "email">>): Subscriber[];

package/dist/testing/factories/template.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Template factory functions.
+ *
+ * @module testing/factories/template
+ */
+import type { Template } from "../../resources/templates/types";
+/**
+ * Creates a mock template with realistic default values.
+ *
+ * @param overrides - Optional fields to override defaults
+ * @returns A valid Template object
+ *
+ * @example
+ * ```typescript
+ * // Default template
+ * const template = createMockTemplate();
+ * // { id: 1, name: 'Test Template 1', type: 'campaign', ... }
+ *
+ * // With overrides
+ * const custom = createMockTemplate({
+ *   name: 'Welcome Email',
+ *   is_default: true,
+ * });
+ * ```
+ */
+export declare function createMockTemplate(overrides?: Partial<Template>): Template;
+/**
+ * Creates multiple unique mock templates.
+ *
+ * @param count - Number of templates to create
+ * @param overrides - Optional fields to apply to all templates
+ * @returns Array of unique Template objects
+ *
+ * @example
+ * ```typescript
+ * const templates = createMockTemplates(3);
+ * // 3 templates with unique IDs and names
+ * ```
+ */
+export declare function createMockTemplates(count: number, overrides?: Partial<Omit<Template, "id" | "name">>): Template[];

package/dist/testing/index.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Testing utilities for the Listmonk SDK.
+ *
+ * Provides MockListmonkClient and factory functions for testing
+ * application code that uses the SDK without making real API calls.
+ *
+ * @module testing
+ *
+ * @example
+ * ```typescript
+ * import { MockListmonkClient, createMockSubscriber } from '@solytude/listmonk/testing';
+ *
+ * describe('MyApp', () => {
+ *   let mockClient: MockListmonkClient;
+ *
+ *   beforeEach(() => {
+ *     mockClient = new MockListmonkClient();
+ *   });
+ *
+ *   afterEach(() => {
+ *     mockClient.reset();
+ *   });
+ *
+ *   it('works', async () => {
+ *     mockClient.subscribers.retrieve.mockResolvedValue(
+ *       createMockSubscriber({ email: 'test@example.com' })
+ *     );
+ *
+ *     // Test your application code...
+ *   });
+ * });
+ * ```
+ */
+export { MockListmonkClient } from "./mock-client";
+export { createMockFunction } from "./mock-function";
+export { MockNotConfiguredError } from "./errors";
+export { resetFactories, createMockSubscriber, createMockSubscribers, createMockList, createMockLists, createMockCampaign, createMockCampaigns, createMockTemplate, createMockTemplates, createMockMedia, createMockMediaItems, createMockBounce, createMockBounces, } from "./factories";
+export type { MockFunction, MockState, MockResult, MockArgs, MockReturn, Mocked, MockedObject, } from "./types";
+export type { MockSubscribersResource, MockListsResource, MockCampaignsResource, MockTemplatesResource, MockTransactionalResource, MockMediaResource, MockImportResource, MockBouncesResource, MockSettingsResource, MockDashboardResource, MockAdminResource, MockMaintenanceResource, MockPublicResource, } from "./resources";