@jaypie/testkit 1.1.26 → 1.1.27

package/dist/mock/index.d.ts

@@ -0,0 +1,470 @@
+import * as original from '@jaypie/core';
+export { log } from '@jaypie/core';
+import * as original$1 from '@jaypie/datadog';
+import * as vitest from 'vitest';
+import * as original$2 from '@jaypie/llm';
+import * as original$3 from '@jaypie/textract';
+export { mongoose } from '@jaypie/mongoose';
+
+declare const getMessages: (...args: unknown[]) => unknown;
+declare const getSecret: (...args: unknown[]) => Promise<string>;
+declare const sendMessage: (...args: unknown[]) => Promise<{
+    MessageId: string;
+}>;
+declare const getEnvSecret: ((key: string) => Promise<string>) & {
+    mock: any;
+};
+declare const getSingletonMessage: (...args: unknown[]) => unknown;
+declare const getTextractJob: ((jobId: string) => Promise<any>) & {
+    mock: any;
+};
+declare const sendBatchMessages: (...args: unknown[]) => Promise<boolean>;
+declare const sendTextractJob: (({ bucket, key, featureTypes, }: {
+    bucket: string;
+    key: string;
+    featureTypes?: string[];
+    snsRoleArn?: string;
+    snsTopicArn?: string;
+}) => Promise<any[]>) & {
+    mock: any;
+};
+
+declare const BadGatewayError: typeof original.BadGatewayError;
+declare const BadRequestError: typeof original.BadRequestError;
+declare const ConfigurationError: typeof original.ConfigurationError;
+declare const ForbiddenError: typeof original.ForbiddenError;
+declare const GatewayTimeoutError: typeof original.GatewayTimeoutError;
+declare const GoneError: typeof original.GoneError;
+declare const IllogicalError: typeof original.IllogicalError;
+declare const InternalError: typeof original.InternalError;
+declare const MethodNotAllowedError: typeof original.MethodNotAllowedError;
+declare const MultiError: typeof original.ProjectMultiError;
+declare const NotFoundError: typeof original.NotFoundError;
+declare const NotImplementedError: typeof original.NotImplementedError;
+declare const ProjectError: typeof original.ProjectError;
+declare const ProjectMultiError: typeof original.ProjectMultiError;
+declare const RejectedError: typeof original.RejectedError;
+declare const TeapotError: typeof original.TeapotError;
+declare const UnauthorizedError: typeof original.UnauthorizedError;
+declare const UnavailableError: typeof original.UnavailableError;
+declare const UnhandledError: typeof original.UnhandledError;
+declare const UnreachableCodeError: typeof original.UnreachableCodeError;
+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;
+    };
+};
+
+declare const cloneDeep: (...args: unknown[]) => unknown;
+declare const envBoolean: (...args: unknown[]) => boolean;
+declare const envsKey: (...args: unknown[]) => unknown;
+declare const errorFromStatusCode: ((statusCode: number, message?: string) => Error) & {
+    mock: any;
+};
+declare const formatError: (...args: unknown[]) => unknown;
+declare const getHeaderFrom: (...args: unknown[]) => unknown;
+declare const getObjectKeyCaseInsensitive: (...args: unknown[]) => unknown;
+declare const isClass: (...args: unknown[]) => unknown;
+declare const isJaypieError: (...args: unknown[]) => unknown;
+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;
+};
+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;
+};
+declare const safeParseFloat: (...args: unknown[]) => unknown;
+declare const placeholders: (...args: unknown[]) => unknown;
+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;
+};
+declare const jaypieHandler: ((handler: Function, options?: {
+    setup?: Function | Function[];
+    teardown?: Function | Function[];
+    unavailable?: boolean;
+    validate?: Function | Function[];
+}) => Function) & {
+    mock: any;
+};
+declare const sleep: (...args: unknown[]) => Promise<boolean>;
+declare const uuid: (...args: unknown[]) => unknown;
+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";
+    };
+};
+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>;
+};
+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";
+};
+declare const PROJECT: {
+    SPONSOR: {
+        FINLAYSON: "finlaysonstudio";
+        JAYPIE: "jaypie";
+        KNOWDEV: "knowdev.studio";
+    };
+};
+declare const VALIDATE: {
+    ANY: "*";
+    ARRAY: ArrayConstructor;
+    BOOLEAN: BooleanConstructor;
+    CLASS: "_CLASS";
+    FUNCTION: FunctionConstructor;
+    NUMBER: NumberConstructor;
+    NULL: null;
+    OBJECT: ObjectConstructor;
+    STRING: StringConstructor;
+    UNDEFINED: "_UNDEFINED";
+};
+
+declare const DATADOG: original$1.DatadogConstants;
+declare const submitMetric: (...args: unknown[]) => Promise<boolean>;
+declare const submitMetricSet: (...args: unknown[]) => Promise<boolean>;
+
+declare const EXPRESS: {
+    PATH: {
+        ANY: "*";
+        ID: "/:id";
+        ROOT: RegExp;
+    };
+};
+declare const badRequestRoute: (...args: unknown[]) => unknown;
+declare const echoRoute: (...args: unknown[]) => unknown;
+declare const forbiddenRoute: (...args: unknown[]) => unknown;
+declare const goneRoute: (...args: unknown[]) => unknown;
+declare const methodNotAllowedRoute: (...args: unknown[]) => unknown;
+declare const noContentRoute: (...args: unknown[]) => unknown;
+declare const notFoundRoute: (...args: unknown[]) => unknown;
+declare const notImplementedRoute: (...args: unknown[]) => unknown;
+declare const expressHttpCodeHandler: (...args: unknown[]) => unknown;
+declare const cors: (...args: unknown[]) => unknown;
+interface ExpressHandlerFunction {
+    (req: any, res: any, ...extra: any[]): Promise<any> | any;
+}
+interface ExpressHandlerOptions {
+    locals?: Record<string, any>;
+    setup?: any[] | Function;
+    teardown?: any[] | Function;
+    unavailable?: boolean;
+    validate?: any[] | Function;
+}
+type ExpressHandlerParameter = ExpressHandlerFunction | ExpressHandlerOptions;
+declare const expressHandler: ((handlerOrProps: ExpressHandlerParameter, propsOrHandler?: ExpressHandlerParameter) => (req: any, res: any, ...extra: any[]) => Promise<any>) & {
+    mock: any;
+};
+
+type HandlerFunction = (...args: unknown[]) => unknown;
+type LifecycleFunction = (...args: unknown[]) => unknown | Promise<unknown>;
+interface LambdaOptions {
+    name?: string;
+    setup?: LifecycleFunction | LifecycleFunction[];
+    teardown?: LifecycleFunction | LifecycleFunction[];
+    throw?: boolean;
+    unavailable?: boolean;
+    validate?: LifecycleFunction | LifecycleFunction[];
+    [key: string]: unknown;
+}
+declare const lambdaHandler: ((handler: HandlerFunction, props?: LambdaOptions) => HandlerFunction) & {
+    mock: any;
+};
+
+declare const LLM: typeof original$2.LLM;
+declare const Llm: 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>;
+};
+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;
+        }[];
+    }>;
+};
+declare const tools: (((...args: unknown[]) => number) | ((...args: unknown[]) => string) | ((...args: unknown[]) => Promise<{
+    location: string;
+    forecast: {
+        date: string;
+        temperature: number;
+        condition: string;
+        precipitation: number;
+    }[];
+}>))[];
+
+declare const connect: (...args: unknown[]) => boolean;
+declare const connectFromSecretEnv: (...args: unknown[]) => boolean;
+declare const disconnect: (...args: unknown[]) => boolean;
+
+/**
+ * Mock for MarkdownPage class from @jaypie/textract
+ */
+declare const MarkdownPage: typeof original$3.MarkdownPage;
+/**
+ * Mock for textractJsonToMarkdown function from @jaypie/textract
+ */
+declare const textractJsonToMarkdown: (...args: unknown[]) => string;
+
+declare const _default: Record<string, unknown>;
+
+export { BadGatewayError, BadRequestError, ConfigurationError, DATADOG, ERROR, EXPRESS, ForbiddenError, GatewayTimeoutError, GoneError, HTTP, IllogicalError, InternalError, JAYPIE, LLM, Llm, MarkdownPage, MethodNotAllowedError, MultiError, NotFoundError, NotImplementedError, PROJECT, ProjectError, ProjectMultiError, RejectedError, TeapotError, UnauthorizedError, UnavailableError, UnhandledError, UnreachableCodeError, VALIDATE, badRequestRoute, cloneDeep, connect, connectFromSecretEnv, cors, _default as default, disconnect, echoRoute, envBoolean, envsKey, errorFromStatusCode, expressHandler, expressHttpCodeHandler, forbiddenRoute, force, formatError, getEnvSecret, getHeaderFrom, getMessages, getObjectKeyCaseInsensitive, getSecret, getSingletonMessage, getTextractJob, goneRoute, isClass, isJaypieError, jaypieHandler, lambdaHandler, methodNotAllowedRoute, noContentRoute, notFoundRoute, notImplementedRoute, optional, placeholders, required, safeParseFloat, sendBatchMessages, sendMessage, sendTextractJob, sleep, submitMetric, submitMetricSet, textractJsonToMarkdown, toolkit, tools, uuid, validate };
+export type { ExpressHandlerFunction, ExpressHandlerOptions, LambdaOptions };