@jaypie/testkit 1.1.26 → 1.1.27

package/dist/mock/mock/core.d.ts

@@ -0,0 +1,306 @@
+import { log } from "@jaypie/core";
+import * as original from "@jaypie/core";
+export declare const BadGatewayError: typeof original.BadGatewayError;
+export declare const BadRequestError: typeof original.BadRequestError;
+export declare const ConfigurationError: typeof original.ConfigurationError;
+export declare const ForbiddenError: typeof original.ForbiddenError;
+export declare const GatewayTimeoutError: typeof original.GatewayTimeoutError;
+export declare const GoneError: typeof original.GoneError;
+export declare const IllogicalError: typeof original.IllogicalError;
+export declare const InternalError: typeof original.InternalError;
+export declare const MethodNotAllowedError: typeof original.MethodNotAllowedError;
+export declare const MultiError: typeof original.ProjectMultiError;
+export declare const NotFoundError: typeof original.NotFoundError;
+export declare const NotImplementedError: typeof original.NotImplementedError;
+export declare const ProjectError: typeof original.ProjectError;
+export declare const ProjectMultiError: typeof original.ProjectMultiError;
+export declare const RejectedError: typeof original.RejectedError;
+export declare const TeapotError: typeof original.TeapotError;
+export declare const UnauthorizedError: typeof original.UnauthorizedError;
+export declare const UnavailableError: typeof original.UnavailableError;
+export declare const UnhandledError: typeof original.UnhandledError;
+export declare const UnreachableCodeError: typeof original.UnreachableCodeError;
+export declare const validate: {
+    (argument: unknown, options?: original.ValidationOptions & {
+        type?: unknown;
+    }): boolean;
+    array<T = unknown>(argument: unknown, options?: original.ValidationOptions): argument is T[];
+    boolean(argument: unknown, options?: original.ValidationOptions): argument is boolean;
+    class(argument: unknown, options?: original.ValidationOptions): boolean;
+    function(argument: unknown, options?: original.ValidationOptions): argument is (...args: unknown[]) => unknown;
+    null(argument: unknown, options?: original.ValidationOptions): argument is null;
+    number(argument: unknown, options?: original.ValidationOptions): argument is number;
+    object<T extends Record<string, unknown> = Record<string, unknown>>(argument: unknown, options?: original.ValidationOptions): argument is T;
+    string(argument: unknown, options?: original.ValidationOptions): argument is string;
+    undefined(argument: unknown, options?: original.ValidationOptions): argument is undefined;
+    optional: {
+        array<T = unknown>(argument: unknown, options?: original.ValidationOptions): argument is T[] | undefined;
+        boolean(argument: unknown, options?: original.ValidationOptions): argument is boolean | undefined;
+        class(argument: unknown, options?: original.ValidationOptions): boolean;
+        function(argument: unknown, options?: original.ValidationOptions): argument is ((...args: unknown[]) => unknown) | undefined;
+        null(argument: unknown, options?: original.ValidationOptions): argument is null | undefined;
+        number(argument: unknown, options?: original.ValidationOptions): argument is number | undefined;
+        object<T extends Record<string, unknown> = Record<string, unknown>>(argument: unknown, options?: original.ValidationOptions): argument is T | undefined;
+        string(argument: unknown, options?: original.ValidationOptions): argument is string | undefined;
+    };
+};
+export { log };
+export declare const cloneDeep: (...args: unknown[]) => unknown;
+export declare const envBoolean: (...args: unknown[]) => boolean;
+export declare const envsKey: (...args: unknown[]) => unknown;
+export declare const errorFromStatusCode: ((statusCode: number, message?: string) => Error) & {
+    mock: any;
+};
+export declare const formatError: (...args: unknown[]) => unknown;
+export declare const getHeaderFrom: (...args: unknown[]) => unknown;
+export declare const getObjectKeyCaseInsensitive: (...args: unknown[]) => unknown;
+export declare const isClass: (...args: unknown[]) => unknown;
+export declare const isJaypieError: (...args: unknown[]) => unknown;
+export declare const optional: {
+    (value: unknown, type: unknown, options?: Record<string, unknown>): boolean;
+    array<T = unknown>(value: unknown): value is T[] | undefined;
+    boolean(value: unknown): value is boolean | undefined;
+    number(value: unknown): value is number | undefined;
+    object<T extends Record<string, unknown> = Record<string, unknown>>(value: unknown): value is T | undefined;
+    positive(value: unknown): value is number | undefined;
+    string(value: unknown, defaultValue?: string): value is string | undefined;
+};
+export declare const required: {
+    (value: unknown, type: unknown, options?: Record<string, unknown>): boolean;
+    array<T = unknown>(value: unknown): value is T[];
+    boolean(value: unknown): value is boolean;
+    number(value: unknown): value is number;
+    object<T extends Record<string, unknown> = Record<string, unknown>>(value: unknown): value is T;
+    positive(value: unknown): value is number;
+    string(value: unknown, defaultValue?: string): value is string;
+};
+export declare const safeParseFloat: (...args: unknown[]) => unknown;
+export declare const placeholders: (...args: unknown[]) => unknown;
+export declare const force: {
+    (value: unknown, type: unknown, options?: string | {
+        key?: string;
+        maximum?: number;
+        minimum?: number;
+        nan?: boolean;
+    }): unknown;
+    array<T = unknown>(value: unknown): T[];
+    boolean(value: unknown): boolean;
+    number(value: unknown): number;
+    object<T extends Record<string, unknown> = Record<string, unknown>>(value: unknown, key?: string): T;
+    positive(value: unknown): number;
+    string(value: unknown, defaultValue?: string): string;
+};
+export declare const jaypieHandler: ((handler: Function, options?: {
+    setup?: Function | Function[];
+    teardown?: Function | Function[];
+    unavailable?: boolean;
+    validate?: Function | Function[];
+}) => Function) & {
+    mock: any;
+};
+export declare const sleep: (...args: unknown[]) => Promise<boolean>;
+export declare const uuid: (...args: unknown[]) => unknown;
+export declare const ERROR: {
+    MESSAGE: {
+        BAD_GATEWAY: "An unexpected error occurred on an upstream resource";
+        BAD_REQUEST: "The request was not properly formatted";
+        CONFIGURATION_ERROR: "The application responding to the request encountered a configuration error";
+        FORBIDDEN: "Access to this resource is not authorized";
+        GATEWAY_TIMEOUT: "The connection timed out waiting for an upstream resource";
+        GONE: "The requested resource is no longer available";
+        ILLOGICAL: "The application encountered an illogical condition while processing the request";
+        INTERNAL_ERROR: "An unexpected error occurred and the request was unable to complete";
+        METHOD_NOT_ALLOWED: "The requested method is not allowed";
+        NOT_FOUND: "The requested resource was not found";
+        NOT_IMPLEMENTED: "The request was understood but the resource is not implemented";
+        REJECTED: "The request was rejected prior to processing";
+        TEAPOT: "This resource is a teapot incapable of processing the request";
+        UNAUTHORIZED: "The request did not include valid authentication credentials";
+        UNAVAILABLE: "The requested resource is temporarily unavailable";
+        UNHANDLED: "An unhandled error occurred and the request was unable to complete";
+        UNREACHABLE_CODE: "The application encountered an unreachable condition while processing the request";
+    };
+    TITLE: {
+        BAD_GATEWAY: "Bad Gateway";
+        BAD_REQUEST: "Bad Request";
+        CONFIGURATION_ERROR: "Internal Configuration Error";
+        FORBIDDEN: "Forbidden";
+        GATEWAY_TIMEOUT: "Gateway Timeout";
+        GONE: "Gone";
+        INTERNAL_ERROR: "Internal Application Error";
+        METHOD_NOT_ALLOWED: "Method Not Allowed";
+        NOT_FOUND: "Not Found";
+        NOT_IMPLEMENTED: "Not Implemented";
+        REJECTED: "Request Rejected";
+        TEAPOT: "Teapot";
+        UNAUTHORIZED: "Service Unauthorized";
+        UNAVAILABLE: "Service Unavailable";
+    };
+    TYPE: {
+        BAD_GATEWAY: "BAD_GATEWAY";
+        BAD_REQUEST: "BAD_REQUEST";
+        CONFIGURATION_ERROR: "CONFIGURATION_ERROR";
+        FORBIDDEN: "FORBIDDEN";
+        GATEWAY_TIMEOUT: "GATEWAY_TIMEOUT";
+        GONE: "GONE";
+        ILLOGICAL: "ILLOGICAL";
+        INTERNAL_ERROR: "INTERNAL_ERROR";
+        METHOD_NOT_ALLOWED: "METHOD_NOT_ALLOWED";
+        MULTI_ERROR: "MULTI_ERROR";
+        NOT_FOUND: "NOT_FOUND";
+        NOT_IMPLEMENTED: "NOT_IMPLEMENTED";
+        REJECTED: "REJECTED";
+        TEAPOT: "TEAPOT";
+        UNAUTHORIZED: "UNAUTHORIZED";
+        UNAVAILABLE: "UNAVAILABLE";
+        UNHANDLED: "UNHANDLED";
+        UNKNOWN_TYPE: "UNKNOWN_TYPE";
+        UNREACHABLE_CODE: "UNREACHABLE_CODE";
+    };
+};
+export declare const HTTP: {
+    ALLOW: {
+        ANY: "*";
+    };
+    CODE: {
+        OK: 200;
+        CREATED: 201;
+        ACCEPTED: 202;
+        NO_CONTENT: 204;
+        FOUND: 302;
+        BAD_REQUEST: 400;
+        UNAUTHORIZED: 401;
+        FORBIDDEN: 403;
+        NOT_FOUND: 404;
+        METHOD_NOT_ALLOWED: 405;
+        CONFLICT: 409;
+        GONE: 410;
+        TEAPOT: 418;
+        INTERNAL_ERROR: 500;
+        BAD_GATEWAY: 502;
+        UNAVAILABLE: 503;
+        GATEWAY_TIMEOUT: 504;
+    };
+    CONTENT: {
+        ANY: "*/*";
+        HTML: "text/html";
+        JSON: "application/json";
+        TEXT: "text/plain";
+    };
+    HEADER: {
+        ACCEPT: "Accept";
+        ACCEPT_ENCODING: "Accept-Encoding";
+        ALLOW: {
+            HEADERS: "Access-Control-Allow-Headers";
+            METHODS: "Access-Control-Allow-Methods";
+            ORIGIN: "Access-Control-Allow-Origin";
+        };
+        AMAZON: {
+            CF_ID: "X-Amz-Cf-Id";
+            CLOUDFRONT_COUNTRY: "CloudFront-Viewer-Country";
+            CLOUDFRONT_DESKTOP: "CloudFront-Is-Desktop-Viewer";
+            CLOUDFRONT_MOBILE: "CloudFront-Is-Mobile-Viewer";
+            CLOUDFRONT_PROTOCOL: "CloudFront-Forwarded-Proto";
+            CLOUDFRONT_SMARTTV: "CloudFront-Is-SmartTV-Viewer";
+            CLOUDFRONT_TABLET: "CloudFront-Is-Tablet-Viewer";
+            TRACE_ID: "X-Amzn-Trace-Id";
+        };
+        AUTHORIZATION: "Authorization";
+        CACHE_CONTROL: "Cache-Control";
+        CONTENT_TYPE: "Content-Type";
+        COOKIE: {
+            REQUEST: "Cookie";
+            RESPONSE: "Set-Cookie";
+        };
+        DATADOG: {
+            SESSION_ID: "X-Session-Id";
+        };
+        FORWARDED: {
+            FOR: "X-Forwarded-For";
+            PORT: "X-Forwarded-Port";
+            PROTOCOL: "X-Forwarded-Proto";
+        };
+        HOST: "Host";
+        ORIGIN: "Origin";
+        POSTMAN: {
+            TOKEN: "Postman-Token";
+        };
+        POWERED_BY: "X-Powered-By";
+        PROJECT: {
+            ACCOUNT: "X-Project-Account";
+            CALLER: "X-Project-Caller";
+            ENVIRONMENT: "X-Project-Environment";
+            KEY: "X-Project-Key";
+            HANDLER: "X-Project-Handler";
+            INVOCATION: "X-Project-Invocation";
+            ROOT_INVOCATION: "X-Project-Root-Invocation";
+            SECRET: "X-Project-Secret";
+            SEED: "X-Project-Seed";
+            SESSION: "X-Project-Session";
+            VERSION: "X-Project-Version";
+        };
+        SIGNATURE: {
+            ED25519: "X-Signature-Ed25519";
+            TIMESTAMP: "X-Signature-Timestamp";
+        };
+        USER_AGENT: "User-Agent";
+        VIA: "Via";
+    };
+    METHOD: {
+        DELETE: "DELETE";
+        HEAD: "HEAD";
+        GET: "GET";
+        OPTIONS: "OPTIONS";
+        POST: "POST";
+        PUT: "PUT";
+    };
+    RESPONSE: Record<string, unknown>;
+};
+export declare const JAYPIE: {
+    LIB: {
+        AWS: "@jaypie/aws";
+        CDK: "@jaypie/cdk";
+        CONSTRUCTS: "@jaypie/constructs";
+        CORE: "@jaypie/core";
+        ESLINT: "@jaypie/eslint";
+        EXPRESS: "@jaypie/express";
+        ERRORS: "@jaypie/errors";
+        JAYPIE: "jaypie";
+        LAMBDA: "@jaypie/lambda";
+        LLM: "@jaypie/llm";
+        MONGOOSE: "@jaypie/mongoose";
+        TESTKIT: "@jaypie/testkit";
+        WEBKIT: "@jaypie/webkit";
+    };
+    LAYER: {
+        EXPRESS: "express";
+        HANDLER: "handler";
+        JAYPIE: "jaypie";
+        LAMBDA: "lambda";
+        MODULE: "module";
+    };
+    LOGGER: {
+        DEFAULT: "default";
+        MODULE: "module";
+    };
+    UNKNOWN: "unknown";
+};
+export declare const PROJECT: {
+    SPONSOR: {
+        FINLAYSON: "finlaysonstudio";
+        JAYPIE: "jaypie";
+        KNOWDEV: "knowdev.studio";
+    };
+};
+export declare const VALIDATE: {
+    ANY: "*";
+    ARRAY: ArrayConstructor;
+    BOOLEAN: BooleanConstructor;
+    CLASS: "_CLASS";
+    FUNCTION: FunctionConstructor;
+    NUMBER: NumberConstructor;
+    NULL: null;
+    OBJECT: ObjectConstructor;
+    STRING: StringConstructor;
+    UNDEFINED: "_UNDEFINED";
+};

package/dist/mock/mock/datadog.d.ts

@@ -0,0 +1,4 @@
+import * as original from "@jaypie/datadog";
+export declare const DATADOG: original.DatadogConstants;
+export declare const submitMetric: (...args: unknown[]) => Promise<boolean>;
+export declare const submitMetricSet: (...args: unknown[]) => Promise<boolean>;

package/dist/mock/mock/express.d.ts

@@ -0,0 +1,32 @@
+export declare const EXPRESS: {
+    PATH: {
+        ANY: "*";
+        ID: "/:id";
+        ROOT: RegExp;
+    };
+};
+export declare const badRequestRoute: (...args: unknown[]) => unknown;
+export declare const echoRoute: (...args: unknown[]) => unknown;
+export declare const forbiddenRoute: (...args: unknown[]) => unknown;
+export declare const goneRoute: (...args: unknown[]) => unknown;
+export declare const methodNotAllowedRoute: (...args: unknown[]) => unknown;
+export declare const noContentRoute: (...args: unknown[]) => unknown;
+export declare const notFoundRoute: (...args: unknown[]) => unknown;
+export declare const notImplementedRoute: (...args: unknown[]) => unknown;
+export declare const expressHttpCodeHandler: (...args: unknown[]) => unknown;
+export declare const cors: (...args: unknown[]) => unknown;
+export interface ExpressHandlerFunction {
+    (req: any, res: any, ...extra: any[]): Promise<any> | any;
+}
+export interface ExpressHandlerOptions {
+    locals?: Record<string, any>;
+    setup?: any[] | Function;
+    teardown?: any[] | Function;
+    unavailable?: boolean;
+    validate?: any[] | Function;
+}
+type ExpressHandlerParameter = ExpressHandlerFunction | ExpressHandlerOptions;
+export declare const expressHandler: ((handlerOrProps: ExpressHandlerParameter, propsOrHandler?: ExpressHandlerParameter) => (req: any, res: any, ...extra: any[]) => Promise<any>) & {
+    mock: any;
+};
+export {};

package/dist/mock/mock/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./aws";
+export * from "./core";
+export * from "./datadog";
+export * from "./express";
+export * from "./lambda";
+export * from "./llm";
+export * from "./mongoose";
+export * from "./textract";
+declare const _default: Record<string, unknown>;
+export default _default;

package/dist/mock/mock/lambda.d.ts

@@ -0,0 +1,15 @@
+type HandlerFunction = (...args: unknown[]) => unknown;
+type LifecycleFunction = (...args: unknown[]) => unknown | Promise<unknown>;
+export interface LambdaOptions {
+    name?: string;
+    setup?: LifecycleFunction | LifecycleFunction[];
+    teardown?: LifecycleFunction | LifecycleFunction[];
+    throw?: boolean;
+    unavailable?: boolean;
+    validate?: LifecycleFunction | LifecycleFunction[];
+    [key: string]: unknown;
+}
+export declare const lambdaHandler: ((handler: HandlerFunction, props?: LambdaOptions) => HandlerFunction) & {
+    mock: any;
+};
+export {};

package/dist/mock/mock/llm.d.ts

@@ -0,0 +1,66 @@
+import * as original from "@jaypie/llm";
+export declare const LLM: typeof original.LLM;
+export declare const Llm: import("vitest").Mock<(...args: any[]) => any> & {
+    operate: (...args: unknown[]) => Promise<{
+        history: ({
+            content: string;
+            role: string;
+            type: string;
+            id?: undefined;
+            status?: undefined;
+        } | {
+            id: string;
+            type: string;
+            status: string;
+            content: string;
+            role: string;
+        })[];
+        output: {
+            id: string;
+            type: string;
+            status: string;
+            content: string;
+            role: string;
+        }[];
+        responses: {
+            id: string;
+            object: string;
+            created_at: number;
+            status: string;
+            error: null;
+            output_text: string;
+        }[];
+        status: string;
+        usage: {
+            input: number;
+            output: number;
+            reasoning: number;
+            total: number;
+        };
+        content: string;
+    }>;
+    send: (...args: unknown[]) => Promise<string>;
+};
+export declare const toolkit: {
+    random: (...args: unknown[]) => number;
+    roll: (...args: unknown[]) => number;
+    time: (...args: unknown[]) => string;
+    weather: (...args: unknown[]) => Promise<{
+        location: string;
+        forecast: {
+            date: string;
+            temperature: number;
+            condition: string;
+            precipitation: number;
+        }[];
+    }>;
+};
+export declare const tools: (((...args: unknown[]) => number) | ((...args: unknown[]) => string) | ((...args: unknown[]) => Promise<{
+    location: string;
+    forecast: {
+        date: string;
+        temperature: number;
+        condition: string;
+        precipitation: number;
+    }[];
+}>))[];

package/dist/mock/mock/mongoose.d.ts

@@ -0,0 +1,4 @@
+export declare const connect: (...args: unknown[]) => boolean;
+export declare const connectFromSecretEnv: (...args: unknown[]) => boolean;
+export declare const disconnect: (...args: unknown[]) => boolean;
+export { mongoose } from "@jaypie/mongoose";

package/dist/mock/mock/original.d.ts

@@ -0,0 +1,19 @@
+import * as aws from "@jaypie/aws";
+import * as core from "@jaypie/core";
+import * as datadog from "@jaypie/datadog";
+import * as express from "@jaypie/express";
+import * as lambda from "@jaypie/lambda";
+import * as llm from "@jaypie/llm";
+import * as mongoose from "@jaypie/mongoose";
+import * as textract from "@jaypie/textract";
+export declare const original: {
+    aws: typeof aws;
+    core: typeof core;
+    datadog: typeof datadog;
+    express: typeof express;
+    lambda: typeof lambda;
+    llm: typeof llm;
+    mongoose: typeof mongoose;
+    textract: typeof textract;
+};
+export default original;

package/dist/mock/mock/textract.d.ts

@@ -0,0 +1,14 @@
+import * as original from "@jaypie/textract";
+/**
+ * Mock for MarkdownPage class from @jaypie/textract
+ */
+export declare const MarkdownPage: typeof original.MarkdownPage;
+/**
+ * Mock for textractJsonToMarkdown function from @jaypie/textract
+ */
+export declare const textractJsonToMarkdown: (...args: unknown[]) => string;
+declare const _default: {
+    MarkdownPage: typeof original.MarkdownPage;
+    textractJsonToMarkdown: (...args: unknown[]) => string;
+};
+export default _default;

package/dist/mock/mock/utils.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Creates function mocks with proper typing
+ * Internal utility to create properly typed mocks
+ */
+declare function createMockFunction<T extends (...args: any[]) => any>(implementation?: (...args: Parameters<T>) => ReturnType<T>): T & {
+    mock: any;
+};
+/**
+ * Creates a mock function that resolves to a value when awaited
+ * Internal utility to create async mock functions
+ */
+declare function createMockResolvedFunction<T>(value: T): (...args: unknown[]) => Promise<T>;
+/**
+ * Creates a mock function that returns a value
+ * Internal utility to create mock functions that return a value
+ */
+declare function createMockReturnedFunction<T>(value: T): (...args: unknown[]) => T;
+/**
+ * Creates a mock function that wraps another function
+ * Internal utility to create mock functions that wrap another function
+ */
+declare function createMockWrappedFunction<T>(fn: (...args: unknown[]) => unknown, fallbackOrOptions?: any | {
+    fallback?: any;
+    throws?: boolean;
+    class?: boolean;
+}): (...args: unknown[]) => T;
+declare function createMockWrappedObject<T extends Record<string, any>>(object: T, fallbackOrOptions?: any | {
+    fallback?: any;
+    throws?: boolean;
+    class?: boolean;
+}): T;
+/**
+ * Utility to create a mock error constructor from an error class
+ */
+declare function createMockError<T extends new (...args: any[]) => Error>(ErrorClass: T): T;
+declare class MockValidationError extends Error {
+    constructor(message: string);
+}
+declare class MockNotFoundError extends Error {
+    constructor(message: string);
+}
+export { createMockFunction, createMockResolvedFunction, createMockReturnedFunction, createMockWrappedFunction, createMockWrappedObject, MockValidationError, MockNotFoundError, createMockError, };

package/dist/mock/mockLog.module.d.ts

@@ -0,0 +1,5 @@
+import { log } from "@jaypie/core";
+import { LogMock } from "./types/jaypie-testkit";
+export declare function mockLogFactory(): LogMock;
+export declare function spyLog(logInstance: typeof log): void;
+export declare function restoreLog(logInstance: typeof log): void;

package/dist/mock/mongoose.d.ts

@@ -0,0 +1,4 @@
+export declare const connect: (...args: unknown[]) => boolean;
+export declare const connectFromSecretEnv: (...args: unknown[]) => boolean;
+export declare const disconnect: (...args: unknown[]) => boolean;
+export { mongoose } from "@jaypie/mongoose";

package/dist/mock/original.d.ts

@@ -0,0 +1,19 @@
+import * as aws from "@jaypie/aws";
+import * as core from "@jaypie/core";
+import * as datadog from "@jaypie/datadog";
+import * as express from "@jaypie/express";
+import * as lambda from "@jaypie/lambda";
+import * as llm from "@jaypie/llm";
+import * as mongoose from "@jaypie/mongoose";
+import * as textract from "@jaypie/textract";
+export declare const original: {
+    aws: typeof aws;
+    core: typeof core;
+    datadog: typeof datadog;
+    express: typeof express;
+    lambda: typeof lambda;
+    llm: typeof llm;
+    mongoose: typeof mongoose;
+    textract: typeof textract;
+};
+export default original;

package/dist/mock/placeholders.d.ts

@@ -0,0 +1,9 @@
+/*!
+ * Replaces placeholders with real content
+ * Requires get() - https://vanillajstoolkit.com/helpers/get/
+ * (c) 2019 Chris Ferdinandi, MIT License, https://gomakethings.com
+ * @param {String} template The template string
+ * @param {String} local    A local placeholder to use, if any
+ */
+declare function placeholders(template: string | (() => string), data?: Record<string, unknown>): string;
+export default placeholders;

package/dist/mock/sqsTestRecords.function.d.ts

@@ -0,0 +1,14 @@
+interface SQSEvent {
+    Records: Array<{
+        body: string;
+        messageId?: string | number;
+        [key: string]: unknown;
+    }>;
+}
+/**
+ * Creates a mock SQS event with the given records
+ * @param records - Array of records or individual records to include in the event
+ * @returns SQS event object with Records array
+ */
+declare const sqsTestRecords: (...records: Array<unknown>) => SQSEvent;
+export default sqsTestRecords;

package/dist/mock/textract.d.ts

@@ -0,0 +1,14 @@
+import * as original from "@jaypie/textract";
+/**
+ * Mock for MarkdownPage class from @jaypie/textract
+ */
+export declare const MarkdownPage: typeof original.MarkdownPage;
+/**
+ * Mock for textractJsonToMarkdown function from @jaypie/textract
+ */
+export declare const textractJsonToMarkdown: (...args: unknown[]) => string;
+declare const _default: {
+    MarkdownPage: typeof original.MarkdownPage;
+    textractJsonToMarkdown: (...args: unknown[]) => string;
+};
+export default _default;

package/dist/mock/utils.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Creates function mocks with proper typing
+ * Internal utility to create properly typed mocks
+ */
+declare function createMockFunction<T extends (...args: any[]) => any>(implementation?: (...args: Parameters<T>) => ReturnType<T>): T & {
+    mock: any;
+};
+/**
+ * Creates a mock function that resolves to a value when awaited
+ * Internal utility to create async mock functions
+ */
+declare function createMockResolvedFunction<T>(value: T): (...args: unknown[]) => Promise<T>;
+/**
+ * Creates a mock function that returns a value
+ * Internal utility to create mock functions that return a value
+ */
+declare function createMockReturnedFunction<T>(value: T): (...args: unknown[]) => T;
+/**
+ * Creates a mock function that wraps another function
+ * Internal utility to create mock functions that wrap another function
+ */
+declare function createMockWrappedFunction<T>(fn: (...args: unknown[]) => unknown, fallbackOrOptions?: any | {
+    fallback?: any;
+    throws?: boolean;
+    class?: boolean;
+}): (...args: unknown[]) => T;
+declare function createMockWrappedObject<T extends Record<string, any>>(object: T, fallbackOrOptions?: any | {
+    fallback?: any;
+    throws?: boolean;
+    class?: boolean;
+}): T;
+/**
+ * Utility to create a mock error constructor from an error class
+ */
+declare function createMockError<T extends new (...args: any[]) => Error>(ErrorClass: T): T;
+declare class MockValidationError extends Error {
+    constructor(message: string);
+}
+declare class MockNotFoundError extends Error {
+    constructor(message: string);
+}
+export { createMockFunction, createMockResolvedFunction, createMockReturnedFunction, createMockWrappedFunction, createMockWrappedObject, MockValidationError, MockNotFoundError, createMockError, };

package/dist/mockLog.module.d.ts

@@ -1,5 +1,5 @@
-import { Log } from "@jaypie/core";
+import { log } from "@jaypie/core";
 import { LogMock } from "./types/jaypie-testkit";
 export declare function mockLogFactory(): LogMock;
-export declare function spyLog(log: Log): void;
-export declare function restoreLog(log: Log): void;
+export declare function spyLog(logInstance: typeof log): void;
+export declare function restoreLog(logInstance: typeof log): void;