@progressive-development/pd-provider-mock 0.9.0

package/dist/MockStorageProvider.js

@@ -0,0 +1,172 @@
+class MockStorageProvider {
+  constructor(fixtures = [], config = {}) {
+    /** In-memory storage for uploaded files */
+    this.uploadedFiles = /* @__PURE__ */ new Map();
+    this.fixtures = fixtures;
+    this.config = config;
+  }
+  async uploadFile(request) {
+    this.log(`Uploading file: ${request.fileName} to ${request.storageName}/${request.referenceKey}`);
+    await this.delay();
+    const filePath = this.buildFilePath(
+      request.storageName,
+      request.referenceKey,
+      request.fileName,
+      request.subFolderName
+    );
+    const document = {
+      storageName: request.storageName,
+      refKey: request.referenceKey,
+      fileName: request.fileName,
+      filePath,
+      subFolderName: request.subFolderName,
+      description: request.description,
+      descriptionName: request.descriptionName,
+      creation: /* @__PURE__ */ new Date(),
+      readonly: request.readonly
+    };
+    this.uploadedFiles.set(filePath, {
+      document,
+      content: request.base64DataURL
+    });
+    this.log(`File uploaded: ${filePath}`);
+    return {
+      fullPath: filePath,
+      downloadURL: `mock://storage/${filePath}`
+    };
+  }
+  async downloadFile(options) {
+    this.log(`Downloading file: ${options.fileName}`);
+    await this.delay();
+    const filePath = this.buildFilePath(
+      options.storageName,
+      options.referenceKey,
+      options.fileName,
+      options.subFolderName
+    );
+    const uploaded = this.uploadedFiles.get(filePath);
+    if (uploaded?.content) {
+      return uploaded.content;
+    }
+    const file = this.findFileInFixtures(options);
+    if (file?.content) {
+      return file.content;
+    }
+    return `mock://storage/${filePath}`;
+  }
+  async deleteFile(options) {
+    this.log(`Deleting file: ${options.fileName}`);
+    await this.delay();
+    const filePath = this.buildFilePath(
+      options.storageName,
+      options.referenceKey,
+      options.fileName,
+      options.subFolderName
+    );
+    this.uploadedFiles.delete(filePath);
+    this.log(`File deleted: ${filePath}`);
+  }
+  async listFiles(options) {
+    this.log(`Listing files: ${options.storageName}/${options.referenceKey}`);
+    await this.delay();
+    const result = [];
+    const fixture = this.fixtures.find(
+      (f) => f.storageName === options.storageName && f.referenceKey === options.referenceKey
+    );
+    if (fixture) {
+      for (const file of fixture.files) {
+        if (options.subFolderName && file.document.subFolderName !== options.subFolderName) {
+          continue;
+        }
+        result.push(file.document);
+      }
+    }
+    for (const [, file] of this.uploadedFiles) {
+      if (file.document.storageName === options.storageName && file.document.refKey === options.referenceKey) {
+        if (!options.subFolderName || file.document.subFolderName === options.subFolderName) {
+          result.push(file.document);
+        }
+      }
+    }
+    this.log(`Found ${result.length} files`);
+    return result;
+  }
+  async getFile(options) {
+    this.log(`Getting file: ${options.fileName}`);
+    await this.delay();
+    const filePath = this.buildFilePath(
+      options.storageName,
+      options.referenceKey,
+      options.fileName,
+      options.subFolderName
+    );
+    const uploaded = this.uploadedFiles.get(filePath);
+    if (uploaded) {
+      return uploaded.document;
+    }
+    const file = this.findFileInFixtures(options);
+    return file?.document ?? null;
+  }
+  // -------------------------------------------------------------------------
+  // Mock-specific Methods
+  // -------------------------------------------------------------------------
+  /**
+   * Add a storage fixture at runtime
+   */
+  addFixture(fixture) {
+    this.fixtures.push(fixture);
+  }
+  /**
+   * Clear all uploaded files (in-memory)
+   */
+  clearUploads() {
+    this.uploadedFiles.clear();
+  }
+  /**
+   * Get all uploaded files
+   */
+  getUploadedFiles() {
+    return new Map(this.uploadedFiles);
+  }
+  /**
+   * Set fixtures (replace all)
+   */
+  setFixtures(fixtures) {
+    this.fixtures = fixtures;
+  }
+  // -------------------------------------------------------------------------
+  // Private Helpers
+  // -------------------------------------------------------------------------
+  buildFilePath(storageName, referenceKey, fileName, subFolderName) {
+    const parts = [storageName, referenceKey];
+    if (subFolderName) {
+      parts.push(subFolderName);
+    }
+    parts.push(fileName);
+    return parts.join("/");
+  }
+  findFileInFixtures(options) {
+    const fixture = this.fixtures.find(
+      (f) => f.storageName === options.storageName && f.referenceKey === options.referenceKey
+    );
+    if (!fixture) {
+      return void 0;
+    }
+    return fixture.files.find(
+      (f) => f.document.fileName === options.fileName && (!options.subFolderName || f.document.subFolderName === options.subFolderName)
+    );
+  }
+  async delay() {
+    const delayMs = this.config.defaultDelay ?? 200;
+    if (delayMs > 0) {
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+    }
+  }
+  log(message) {
+    if (this.config.logging) {
+      console.log(`[MockStorage] ${message}`);
+    }
+  }
+}
+
+export { MockStorageProvider };

package/dist/createMockProvider.d.ts

@@ -0,0 +1,87 @@
+import { ServiceProvider } from '@progressive-development/pd-provider-interfaces';
+import { MockAuthProvider } from './MockAuthProvider.js';
+import { MockFunctionProvider } from './MockFunctionProvider.js';
+import { MockStorageProvider } from './MockStorageProvider.js';
+import { MockDatabaseProvider } from './MockDatabaseProvider.js';
+import { MockProviderConfig } from './fixtures.js';
+/**
+ * Extended ServiceProvider with mock-specific access
+ */
+export interface MockServiceProvider extends ServiceProvider {
+    /** Get typed auth provider */
+    readonly mockAuth: MockAuthProvider;
+    /** Get typed function provider */
+    readonly mockFunctions: MockFunctionProvider;
+    /** Get typed storage provider */
+    readonly mockStorage: MockStorageProvider;
+    /** Get typed database provider */
+    readonly mockDatabase: MockDatabaseProvider;
+    /** Switch to a different scenario */
+    switchScenario(scenarioName: string): void;
+    /** Get current scenario name */
+    getCurrentScenario(): string | undefined;
+    /** Get available scenario names */
+    getAvailableScenarios(): string[];
+}
+/**
+ * Create a mock service provider
+ *
+ * @example
+ * ```typescript
+ * // Simple usage with inline fixtures
+ * const provider = createMockProvider({
+ *   fixtures: {
+ *     users: [
+ *       { email: "test@example.com", password: "test123", user: { uid: "1", email: "test@example.com", emailVerified: true } }
+ *     ],
+ *     functions: [
+ *       { name: "getData", response: { result: { statusCode: 200, resultData: { items: [] } } } }
+ *     ]
+ *   },
+ *   defaultDelay: 500,
+ *   logging: true,
+ * });
+ *
+ * services.initialize(provider);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Usage with scenarios
+ * const provider = createMockProvider({
+ *   scenarios: [
+ *     {
+ *       name: "happy-path",
+ *       fixtures: {
+ *         users: [{ email: "user@test.com", password: "pass", user: { uid: "1", email: "user@test.com", emailVerified: true } }],
+ *         functions: [{ name: "submit", response: { result: { statusCode: 200, resultData: "ok" } } }]
+ *       }
+ *     },
+ *     {
+ *       name: "error-scenario",
+ *       fixtures: {
+ *         users: [{ email: "user@test.com", password: "pass", user: { uid: "1", email: "user@test.com", emailVerified: true } }],
+ *         functions: [{ name: "submit", response: { result: { statusCode: -1, resultData: null }, error: { message: "Server error" } } }]
+ *       }
+ *     }
+ *   ],
+ *   activeScenario: "happy-path",
+ * });
+ *
+ * // Later: switch scenario
+ * provider.switchScenario("error-scenario");
+ * ```
+ */
+export declare function createMockProvider(config?: MockProviderConfig): MockServiceProvider;
+/**
+ * Create a minimal mock provider for quick testing
+ *
+ * Provides a single test user and empty fixtures
+ */
+export declare function createQuickMockProvider(options?: {
+    email?: string;
+    password?: string;
+    delay?: number;
+    logging?: boolean;
+}): MockServiceProvider;
+//# sourceMappingURL=createMockProvider.d.ts.map

package/dist/createMockProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createMockProvider.d.ts","sourceRoot":"","sources":["../src/createMockProvider.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iDAAiD,CAAC;AAEvF,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,KAAK,EACV,kBAAkB,EAGnB,MAAM,eAAe,CAAC;AAEvB;;GAEG;AACH,MAAM,WAAW,mBAAoB,SAAQ,eAAe;IAC1D,8BAA8B;IAC9B,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,CAAC;IACpC,kCAAkC;IAClC,QAAQ,CAAC,aAAa,EAAE,oBAAoB,CAAC;IAC7C,iCAAiC;IACjC,QAAQ,CAAC,WAAW,EAAE,mBAAmB,CAAC;IAC1C,kCAAkC;IAClC,QAAQ,CAAC,YAAY,EAAE,oBAAoB,CAAC;IAC5C,qCAAqC;IACrC,cAAc,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3C,gCAAgC;IAChC,kBAAkB,IAAI,MAAM,GAAG,SAAS,CAAC;IACzC,mCAAmC;IACnC,qBAAqB,IAAI,MAAM,EAAE,CAAC;CACnC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,GAAE,kBAAuB,GAC9B,mBAAmB,CAiFrB;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,GAAE;IACP,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,OAAO,CAAC;CACd,GACL,mBAAmB,CAuBrB"}

package/dist/createMockProvider.js

@@ -0,0 +1,89 @@
+import { MockAuthProvider } from './MockAuthProvider.js';
+import { MockFunctionProvider } from './MockFunctionProvider.js';
+import { MockStorageProvider } from './MockStorageProvider.js';
+import { MockDatabaseProvider } from './MockDatabaseProvider.js';
+
+function createMockProvider(config = {}) {
+  let activeFixtures = config.fixtures || {};
+  let activeScenarioName = config.activeScenario;
+  if (config.scenarios && config.scenarios.length > 0) {
+    const scenario = config.activeScenario ? config.scenarios.find((s) => s.name === config.activeScenario) : config.scenarios[0];
+    if (scenario) {
+      activeFixtures = scenario.fixtures;
+      activeScenarioName = scenario.name;
+    }
+  }
+  const auth = new MockAuthProvider(activeFixtures.users || [], config);
+  const functions = new MockFunctionProvider(activeFixtures.functions || [], config);
+  const storage = new MockStorageProvider(activeFixtures.storage || [], config);
+  const database = new MockDatabaseProvider(activeFixtures.database || [], config);
+  const provider = {
+    auth,
+    functions,
+    storage,
+    database,
+    get mockAuth() {
+      return auth;
+    },
+    get mockFunctions() {
+      return functions;
+    },
+    get mockStorage() {
+      return storage;
+    },
+    get mockDatabase() {
+      return database;
+    },
+    switchScenario(scenarioName) {
+      if (!config.scenarios) {
+        throw new Error("No scenarios configured");
+      }
+      const scenario = config.scenarios.find((s) => s.name === scenarioName);
+      if (!scenario) {
+        throw new Error(`Scenario not found: ${scenarioName}`);
+      }
+      functions.setFixtures(scenario.fixtures.functions || []);
+      storage.setFixtures(scenario.fixtures.storage || []);
+      database.clearAllCollections();
+      for (const collection of scenario.fixtures.database || []) {
+        database.addCollection(collection.path, collection.documents);
+      }
+      activeScenarioName = scenarioName;
+      if (config.logging) {
+        console.log(`[MockProvider] Switched to scenario: ${scenarioName}`);
+      }
+    },
+    getCurrentScenario() {
+      return activeScenarioName;
+    },
+    getAvailableScenarios() {
+      return (config.scenarios || []).map((s) => s.name);
+    }
+  };
+  return provider;
+}
+function createQuickMockProvider(options = {}) {
+  const email = options.email || "test@example.com";
+  const password = options.password || "test123";
+  return createMockProvider({
+    fixtures: {
+      users: [
+        {
+          email,
+          password,
+          user: {
+            uid: `mock-${Date.now()}`,
+            email,
+            emailVerified: true,
+            displayName: email.split("@")[0]
+          }
+        }
+      ]
+    },
+    defaultDelay: options.delay ?? 200,
+    logging: options.logging ?? false,
+    persistAuth: true
+  });
+}
+
+export { createMockProvider, createQuickMockProvider };

package/dist/example-fixtures.d.ts

@@ -0,0 +1,38 @@
+import { MockFixtures, MockScenario } from './fixtures.js';
+/**
+ * Default test user
+ */
+export declare const DEFAULT_TEST_USER: import('./fixtures.js').MockUserFixture;
+/**
+ * Admin test user
+ */
+export declare const ADMIN_TEST_USER: import('./fixtures.js').MockUserFixture;
+/**
+ * Basic fixtures for simple testing
+ */
+export declare const BASIC_FIXTURES: MockFixtures;
+/**
+ * Fixtures with multiple users
+ */
+export declare const MULTI_USER_FIXTURES: MockFixtures;
+/**
+ * Happy path scenario - everything works
+ */
+export declare const HAPPY_PATH_SCENARIO: MockScenario;
+/**
+ * Auth error scenario - login failures
+ */
+export declare const AUTH_ERROR_SCENARIO: MockScenario;
+/**
+ * Network error scenario - function calls fail
+ */
+export declare const NETWORK_ERROR_SCENARIO: MockScenario;
+/**
+ * Slow network scenario - operations have long delays
+ */
+export declare const SLOW_NETWORK_SCENARIO: MockScenario;
+/**
+ * All example scenarios combined
+ */
+export declare const ALL_EXAMPLE_SCENARIOS: MockScenario[];
+//# sourceMappingURL=example-fixtures.d.ts.map

package/dist/example-fixtures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"example-fixtures.d.ts","sourceRoot":"","sources":["../src/example-fixtures.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAGhE;;GAEG;AACH,eAAO,MAAM,iBAAiB,yCAI7B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,eAAe,yCAI3B,CAAC;AAGF;;GAEG;AACH,eAAO,MAAM,cAAc,EAAE,YAK5B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,mBAAmB,EAAE,YAUjC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,mBAAmB,EAAE,YAwCjC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,mBAAmB,EAAE,YASjC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,sBAAsB,EAAE,YAYpC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,qBAAqB,EAAE,YAYnC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,qBAAqB,EAAE,YAAY,EAK/C,CAAC"}

package/dist/example-fixtures.js

@@ -0,0 +1,116 @@
+import { createUserFixture, createFunctionSuccess, createFunctionError } from './fixtures.js';
+
+const DEFAULT_TEST_USER = createUserFixture(
+  "test@example.com",
+  "test123",
+  { displayName: "Test User" }
+);
+const ADMIN_TEST_USER = createUserFixture(
+  "admin@example.com",
+  "admin123",
+  { displayName: "Admin User" }
+);
+ADMIN_TEST_USER.claims = { admin: true, role: "admin" };
+const BASIC_FIXTURES = {
+  users: [DEFAULT_TEST_USER],
+  functions: [],
+  storage: [],
+  database: []
+};
+const MULTI_USER_FIXTURES = {
+  users: [
+    DEFAULT_TEST_USER,
+    ADMIN_TEST_USER,
+    createUserFixture("user2@example.com", "pass2"),
+    createUserFixture("user3@example.com", "pass3")
+  ],
+  functions: [],
+  storage: [],
+  database: []
+};
+const HAPPY_PATH_SCENARIO = {
+  name: "happy-path",
+  description: "All operations succeed with realistic data",
+  fixtures: {
+    users: [DEFAULT_TEST_USER, ADMIN_TEST_USER],
+    functions: [
+      createFunctionSuccess("getData", { items: [], total: 0 }, 200, 300),
+      createFunctionSuccess("saveData", { success: true }, 200, 500),
+      createFunctionSuccess("deleteData", { deleted: true }, 200, 300)
+    ],
+    storage: [
+      {
+        storageName: "documents",
+        referenceKey: "uploads",
+        files: [
+          {
+            document: {
+              storageName: "documents",
+              refKey: "uploads",
+              fileName: "example.pdf",
+              filePath: "documents/uploads/example.pdf",
+              documentType: "application/pdf",
+              description: "Example document",
+              creation: /* @__PURE__ */ new Date("2024-01-15"),
+              size: 1024
+            }
+          }
+        ]
+      }
+    ],
+    database: [
+      {
+        path: "users",
+        documents: [
+          { id: "user1", data: { name: "John", email: "john@example.com" } },
+          { id: "user2", data: { name: "Jane", email: "jane@example.com" } }
+        ]
+      }
+    ]
+  }
+};
+const AUTH_ERROR_SCENARIO = {
+  name: "auth-error",
+  description: "Authentication fails",
+  fixtures: {
+    users: [],
+    // No valid users - all logins will fail
+    functions: [],
+    storage: [],
+    database: []
+  }
+};
+const NETWORK_ERROR_SCENARIO = {
+  name: "network-error",
+  description: "Network/API calls fail",
+  fixtures: {
+    users: [DEFAULT_TEST_USER],
+    functions: [
+      createFunctionError("getData", "Network error", "network/unavailable", 1e3),
+      createFunctionError("saveData", "Server unavailable", "server/unavailable", 1e3)
+    ],
+    storage: [],
+    database: []
+  }
+};
+const SLOW_NETWORK_SCENARIO = {
+  name: "slow-network",
+  description: "Operations succeed but with significant delays",
+  fixtures: {
+    users: [DEFAULT_TEST_USER],
+    functions: [
+      createFunctionSuccess("getData", { items: [], total: 0 }, 200, 3e3),
+      createFunctionSuccess("saveData", { success: true }, 200, 5e3)
+    ],
+    storage: [],
+    database: []
+  }
+};
+const ALL_EXAMPLE_SCENARIOS = [
+  HAPPY_PATH_SCENARIO,
+  AUTH_ERROR_SCENARIO,
+  NETWORK_ERROR_SCENARIO,
+  SLOW_NETWORK_SCENARIO
+];
+
+export { ADMIN_TEST_USER, ALL_EXAMPLE_SCENARIOS, AUTH_ERROR_SCENARIO, BASIC_FIXTURES, DEFAULT_TEST_USER, HAPPY_PATH_SCENARIO, MULTI_USER_FIXTURES, NETWORK_ERROR_SCENARIO, SLOW_NETWORK_SCENARIO };

package/dist/fixtures.d.ts

@@ -0,0 +1,142 @@
+import { AuthUser, FunctionResult, StorageDocument } from '@progressive-development/pd-provider-interfaces';
+/**
+ * Mock user definition with credentials
+ */
+export interface MockUserFixture {
+    /** User credentials */
+    email: string;
+    password: string;
+    /** User profile data */
+    user: AuthUser;
+    /** Custom claims for the user */
+    claims?: Record<string, unknown>;
+}
+/**
+ * Mock function response definition
+ */
+export interface MockFunctionResponse {
+    /** Response data */
+    result: FunctionResult;
+    /** Optional delay in ms before responding */
+    delay?: number;
+    /** Optional error to throw instead of returning result */
+    error?: {
+        message: string;
+        code?: string;
+    };
+}
+/**
+ * Function fixture - maps function calls to responses
+ */
+export interface MockFunctionFixture {
+    /** Function name */
+    name: string;
+    /** Input matcher - if provided, only match when input matches */
+    inputMatcher?: Record<string, unknown>;
+    /** Response to return */
+    response: MockFunctionResponse;
+}
+/**
+ * Mock file in storage
+ */
+export interface MockStorageFile {
+    /** File metadata */
+    document: StorageDocument;
+    /** Base64 content (optional - for download simulation) */
+    content?: string;
+}
+/**
+ * Storage fixture - predefined files
+ */
+export interface MockStorageFixture {
+    /** Storage bucket name */
+    storageName: string;
+    /** Reference key */
+    referenceKey: string;
+    /** Files in this location */
+    files: MockStorageFile[];
+}
+/**
+ * Mock document in database
+ */
+export interface MockDatabaseDocument<T = unknown> {
+    /** Document ID */
+    id: string;
+    /** Document data */
+    data: T;
+}
+/**
+ * Database collection fixture
+ */
+export interface MockDatabaseCollection<T = unknown> {
+    /** Collection path */
+    path: string;
+    /** Documents in the collection */
+    documents: MockDatabaseDocument<T>[];
+}
+/**
+ * Complete mock fixture configuration
+ *
+ * Can be loaded from JSON files or defined programmatically
+ */
+export interface MockFixtures {
+    /** Available mock users */
+    users?: MockUserFixture[];
+    /** Function responses */
+    functions?: MockFunctionFixture[];
+    /** Storage files */
+    storage?: MockStorageFixture[];
+    /** Database collections */
+    database?: MockDatabaseCollection[];
+}
+/**
+ * Mock scenario - a named configuration for specific test cases
+ */
+export interface MockScenario {
+    /** Scenario name (e.g., "happy-path", "auth-error", "network-error") */
+    name: string;
+    /** Scenario description */
+    description?: string;
+    /** Fixtures for this scenario */
+    fixtures: MockFixtures;
+}
+/**
+ * Mock provider configuration
+ */
+export interface MockProviderConfig {
+    /** Fixtures to use */
+    fixtures?: MockFixtures;
+    /** Named scenarios (can switch between them) */
+    scenarios?: MockScenario[];
+    /** Active scenario name */
+    activeScenario?: string;
+    /** Default delay for all operations (ms) */
+    defaultDelay?: number;
+    /** Use localStorage for auth persistence */
+    persistAuth?: boolean;
+    /** LocalStorage key for auth persistence */
+    persistAuthKey?: string;
+    /** Enable console logging */
+    logging?: boolean;
+}
+/**
+ * Merge multiple fixture configurations
+ */
+export declare function mergeFixtures(...fixtures: MockFixtures[]): MockFixtures;
+/**
+ * Create a simple user fixture
+ * @param email - User's email address
+ * @param password - User's password
+ * @param overrides - Optional overrides for AuthUser properties
+ * @param claims - Optional custom claims (for role-based access)
+ */
+export declare function createUserFixture(email: string, password: string, overrides?: Partial<AuthUser>, claims?: Record<string, unknown>): MockUserFixture;
+/**
+ * Create a function fixture with success response
+ */
+export declare function createFunctionSuccess(name: string, resultData: unknown, statusCode?: number, delay?: number): MockFunctionFixture;
+/**
+ * Create a function fixture with error response
+ */
+export declare function createFunctionError(name: string, errorMessage: string, errorCode?: string, delay?: number): MockFunctionFixture;
+//# sourceMappingURL=fixtures.d.ts.map

package/dist/fixtures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixtures.d.ts","sourceRoot":"","sources":["../src/fixtures.ts"],"names":[],"mappings":"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"}