exlo 0.0.1

package/dist/lib/runtime/runners/node/awslambda.d.ts

@@ -0,0 +1,11 @@
+import type { StreamableHandler } from "./streamResponse";
+import type { IHttpResponseStream } from "./streamResponse";
+type HandlerMetadata = {
+    highWaterMark?: number;
+};
+export interface awslambda {
+    streamifyResponse: (handler: StreamableHandler, options?: HandlerMetadata) => Function;
+    HttpResponseStream: IHttpResponseStream;
+}
+export declare const awslambda: awslambda;
+export {};

package/dist/lib/runtime/runners/node/index.d.ts

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

package/dist/lib/runtime/runners/node/index.js

@@ -0,0 +1,19 @@
+"use strict";var Q=Object.create;var O=Object.defineProperty;var J=Object.getOwnPropertyDescriptor;var K=Object.getOwnPropertyNames;var Y=Object.getPrototypeOf,z=Object.prototype.hasOwnProperty;var X=(t,e,r,n)=>{if(e&&typeof e=="object"||typeof e=="function")for(let o of K(e))!z.call(t,o)&&o!==r&&O(t,o,{get:()=>e[o],enumerable:!(n=J(e,o))||n.enumerable});return t};var P=(t,e,r)=>(r=t!=null?Q(Y(t)):{},X(e||!t||!t.__esModule?O(r,"default",{value:t,enumerable:!0}):r,t));var L=require("node:util"),i=require("node:worker_threads");var _=require("node:stream"),x=class extends _.Writable{#e=!1;#t;#n=new TypeError('Invalid value "undefined" for header "Content-Type"');_onBeforeFirstWrite;constructor(e){super({highWaterMark:e.highWaterMark,write:e.write}),this.#t=this.write.bind(this),this.write=(n,o,l)=>{n=this.#o(n),!this.#e&&typeof this._onBeforeFirstWrite=="function"&&this._onBeforeFirstWrite(m=>this.#t(m));let a=this.#t(n,o,l);return this.#e||(this.#e=!0),a};let r=this.end.bind(this);this.end=(...n)=>{if(n.length){let[o]=n;o&&typeof o!="function"?(this.write(o),r()):r(...n)}else r(...n)}}#o=e=>(typeof e!="string"&&!Buffer.isBuffer(e)&&e?.constructor!==Uint8Array&&(e=JSON.stringify(e)),e);setContentType=e=>{if(!e)throw this.#n;this.emit("ct",e)}},v=class{static from=(e,r)=>{let n=JSON.stringify(r);return e._onBeforeFirstWrite=o=>{e.setContentType("application/vnd.awslambda.http-integration-response"),o(n),o(new Uint8Array(8))},e}};var $={streamifyResponse:function(e,r){return e.stream=!0,e.streamOpt=r,e},HttpResponseStream:v};var A=P(require("path")),M=require("util"),D=require("async_hooks"),B=process.cwd(),Z=`${B}/`,H="/dist/lambda/router.",F=B.split(A.default.sep).filter(Boolean)[0],C=new RegExp(`\\((/${F}|${F}).*(\\d+):(\\d+)`),ee=clearTimeout.bind(clearTimeout),{AWS_LAMBDA_FUNCTION_NAME:U}=process.env,te=t=>{let e=t.match(/{[\w\W]*}/);if(e)return`${t.slice(0,e.index+1)}
+  \x1B[33m  try {\x1B[0m
+      ${t.slice(e.index+1,-1).trim()}
+  \x1B[33m  } catch (error) {\x1B[0m
+    \x1B[35m  // handle the error\x1B[0m
+  \x1B[33m  }\x1B[0m
+}`},R=t=>{let e={errorType:"string",errorMessage:"",trace:[]};if(t instanceof Error)e.errorType=t.name,e.errorMessage=t.message,typeof t.stack=="string"&&(e.trace=t.stack.split(`
+`));else{e.errorType=typeof t;try{e.errorMessage=t.toString()}catch{}}return e},ne=t=>{let e="";try{let r=C.exec(t.stack.split("at")[2])?.[0];typeof r=="string"&&(e=r.slice(1))}catch{}return e},G=()=>{let t={assert:console.assert.bind(console.assert),clear:console.clear.bind(console.clear),count:console.count.bind(console.count),countReset:console.countReset.bind(console.countReset),debug:console.debug.bind(console.debug),dir:console.dir.bind(console.dir),dirxml:console.dirxml.bind(console.dirxml),error:console.error.bind(console.error),group:console.group.bind(console.group),groupCollapsed:console.groupCollapsed.bind(console.groupCollapsed),groupEnd:console.groupEnd.bind(console.groupEnd),info:console.info.bind(console.info),log:console.log.bind(console.log),table:console.table.bind(console.table),time:console.time.bind(console.time),timeEnd:console.timeEnd.bind(console.timeEnd),timeLog:console.timeLog.bind(console.timeLog),timeStamp:console.timeStamp.bind(console.timeStamp),trace:console.trace.bind(console.trace),warn:console.warn.bind(console.warn)};console=new Proxy(console,{get(e,r){return typeof e[r]=="function"?(...n)=>{let o={};Error.captureStackTrace(o);let l=ne(o);process.stdout.write(`\x1B[90m${new Date().toISOString()}	${r.toUpperCase()}	${U}	${l?.replace(Z,"")}\x1B[0m
+`),r=="log"?t.log(...n.map(a=>(0,M.inspect)(a,{colors:!0}))):t[r](...n)}:t[r]}})},V=t=>{let e="",r=0;return t.slice().reverse().filter(n=>n&&!n.includes(__dirname)&&!n.includes(H)).forEach(n=>{let o=C.exec(n)?.[0];o&&(e+=`${o}
+`.slice(1),r++,e+=" ".repeat(r))}),e},g=class t extends Map{static EMPTY_ARGS=[];static IGNORE=["PROMISE","RANDOMBYTESREQUEST","PerformanceObserver","TIMERWRAP"];onEmpty;requestId;callbackWaitsForEmptyEventLoop=!0;async=!1;hook;static context={};static parentPort;static logTimeoutPossibleCause=e=>{let r=this.context[e];if(!r.timeout)return;let n=[...r.promises.values()].reduce((o,l)=>(l.took&&(l.stack=l.stack.reverse().map(a=>{let m=C.exec(a)?.[0];if(m)return m.slice(1)}).filter(a=>a&&!a.includes(__dirname)&&!a.includes(H)),l.stack.length&&(delete l.start,o.push(l))),o),[]);if(n=n.filter((o,l)=>{if(o.took>.01)return!o.stack.every(a=>n.find((m,d)=>l!=d&&(m.took>o.took||o.stack.length<m.stack.length)&&m.stack.includes(a)))}),n.length){let o=(0,M.inspect)(n,{colors:!0});process.stdout.write(`'${U}' Timeout possible cause:
+${o}
+`)}};constructor(e){super(),this.requestId=e,t.context[e]={timers:new Map,promises:new Map}}static restoreContext=()=>{Object.values(this.context).forEach(({timers:e})=>{let r=[...e.entries()];r.length&&process.stdout.write(`\x1B[31mWarning! Restoring context from previous invokation...
+This may lead to data leak.\x1B[0m
+`),r.forEach(([n,o])=>{o.interval?setInterval(o._onTimeout,o.interval):setTimeout(o._onTimeout,o.timerValue),e.delete(n)})})};storeContextTimers=()=>{[...this.entries()].forEach(([e,r])=>{if(r.type!="Timeout")return;let{_idleTimeout:n,_idleStart:o,_onTimeout:l,_repeat:a,_destroyed:m}=r.resource,d=n-o;!m&&(d>-1||a)&&t.context[this.requestId].timers.set(e,{timerValue:d,_onTimeout:l,interval:a}),clearTimeout(r.resource)})};isEmpty=()=>!([...this.values()].filter(r=>!(typeof r.resource.hasRef=="function"&&!r.resource.hasRef())).length>0);add=(e,r,n,o)=>{let l={};Error.captureStackTrace(l);let a=l.stack.split(`
+`).slice(7);if(r=="PROMISE"&&t.context[this.requestId].promises.set(e,{stack:a,start:Date.now()}),t.IGNORE.includes(r))return this;if(r=="Timeout"){let m=o._repeat?"setInterval":"setTimeout",d=o._onTimeout.toString(),p=o._onTimeout.bind(o._onTimeout),S=o._timerArgs??t.EMPTY_ARGS;o._onTimeout=()=>{try{p(...S)}catch(T){let c=R(T),E=te(d);t.parentPort.postMessage({channel:"uncaught",type:m,data:{error:c,solution:E}})}}}return this.set(e,{resource:o,triggerAsyncId:n,type:r,stack:a})};destroy=e=>{this.delete(e)&&this.isEmpty()&&this.onEmpty&&this.onEmpty()};resolve=e=>{let r=t.context[this.requestId];if(r){let n=r.promises.get(e);n?.start&&(n.took=(Date.now()-n.start)/1e3)}};enable=()=>{t.restoreContext();let e=this,r=function(o){ee(o),e.destroy(Number(o))};global.clearTimeout=r,global.clearInterval=r,this.hook=(0,D.createHook)({init:this.add,destroy:this.destroy,promiseResolve:this.resolve}).enable()};disable=()=>{this.hook?.disable(),delete this.hook}};globalThis.awslambda=$;var b={RED:t=>{},BLUE:t=>{},PINK:t=>{}},h,oe=new Error("Unable to stringify response body");i.workerData.debug&&(b.RED=t=>{process.stdout.write(`\x1B[31m${t}\x1B[0m
+`)},b.BLUE=t=>{process.stdout.write(`\x1B[34m${t}\x1B[0m
+`)},b.PINK=t=>{process.stdout.write(`\x1B[95m${t}\x1B[0m
+`)},G());g.parentPort=i.parentPort;var y=(t,e)=>{let r=R(e);i.parentPort.postMessage({channel:"fail",data:r,awsRequestId:t})},re=t=>{let e=R(t);i.parentPort.postMessage({channel:"fatal",data:e})},q=()=>{},W=(t,e,r)=>{try{JSON.stringify(r),i.parentPort.postMessage({channel:t,data:r,awsRequestId:e})}catch{y(e,oe)}finally{q()}};process.exit=t=>{process.stdout.write(`\x1B[31musage of process.exit() will throw Runtime error in AWS Lambda\x1B[0m
+`)};process.on("unhandledRejection",t=>{process.stdout.write((0,L.inspect)(t))});process.on("uncaughtException",t=>{process.stdout.write((0,L.inspect)(t))});var se=async t=>{let{channel:e,data:r,awsRequestId:n}=t;if(e=="import"){let o;try{o=await import(`file://${i.workerData.esOutputPath}?version=${Date.now()}`),process.env.NODE_V8_COVERAGE&&(q=(await import("node:v8")).takeCoverage)}catch(l){re(l);return}if(i.workerData.handlerName=="default"&&typeof o.default=="object"&&typeof o.default.default=="function"?h=o.default.default:h=o[i.workerData.handlerName],typeof h!="function")throw new Error(`${i.workerData.name} > ${i.workerData.handlerName} is not a function`);i.parentPort.postMessage({channel:"import"})}else if(e=="complete"){let o=g.context[n];typeof t.timeout=="boolean"&&(o.timeout=!0)}else if(e=="exec"){let{event:o,clientContext:l}=r,a=!1,m=i.workerData.timeout*1e3,d,p=()=>{a=!0},S=Date.now(),T=()=>Math.max(m-(Date.now()-S),0),c=new g(n),E={functionVersion:"$LATEST",functionName:i.workerData.name,memoryLimitInMB:String(i.workerData.memorySize),logGroupName:`/aws/lambda/${i.workerData.name}`,logStreamName:`${new Date().toLocaleDateString()}[$LATEST]${n.replace(/-/g,"")}`,clientContext:l,identity:void 0,invokedFunctionArn:`arn:aws:lambda:eu-west-1:00000000000:function:${i.workerData.name}`,awsRequestId:n,getRemainingTimeInMillis:T};if(typeof h.stream=="boolean"){let w=(s,u,k)=>{i.parentPort.postMessage({channel:"stream",data:s,awsRequestId:n,type:"write",encoding:u}),k()};d=new x({highWaterMark:h.streamOpt?.highWaterMark,write:w}),d.on("close",()=>{a||(p(),i.parentPort.postMessage({channel:"stream",awsRequestId:n,type:"end"}))}),d.on("error",s=>{a||(p(),b.RED(s),y(n,s))}),d.on("ct",s=>i.parentPort.postMessage({channel:"stream",data:s,awsRequestId:n,type:"ct"}));let f={get callbackWaitsForEmptyEventLoop(){return c.callbackWaitsForEmptyEventLoop},set callbackWaitsForEmptyEventLoop(s){c.callbackWaitsForEmptyEventLoop=s},...E};typeof h(o,d,f)?.catch?.(s=>{d.destroy(),p(),b.RED(s),y(n,s)})?.then!="function"&&(p(),d.destroy(),y(n,new Error("Streaming does not support non-async handlers.")))}else{let w={get callbackWaitsForEmptyEventLoop(){return c.callbackWaitsForEmptyEventLoop},set callbackWaitsForEmptyEventLoop(s){c.callbackWaitsForEmptyEventLoop=s},...E,succeed:s=>{a||(p(),W("succeed",n,s))},fail:s=>{a||(p(),y(n,s))},done:function(s,u){a||(p(),s?y(n,s):W("done",n,u))}},f,I=(s,u)=>{f?b.RED("Invocation has already been reported as done. Cannot call complete more than once per invocation."):f={error:s,res:u}};try{c.enable();let s=h(o,w,I);if(s?.then?.(u=>{c.storeContextTimers(),g.logTimeoutPossibleCause(n),!(f||a)&&(p(),W("return",n,u),c.disable())})?.catch(u=>{p(),y(n,u),c.disable()}),c.async=typeof s?.then=="function",!c.async&&s&&b.RED("Synchronous handler 'return' value is ignored. Consider marking your handler as 'async' or use callback(error, returnValue)"),!a&&(!c.async||f)){let u=()=>{c.storeContextTimers(),c.disable(),f?w.done(f.error,f.res):(p(),W("return",n,null))};if(c.isEmpty())u();else if(!f||c.callbackWaitsForEmptyEventLoop){if(f&&c.callbackWaitsForEmptyEventLoop){b.BLUE("callbackWaitsForEmptyEventLoop...");let k=[...c.values()],j=k[k.length-1],N=V(j.stack);N&&(b.RED("Blocked by:"),b.PINK(N))}c.onEmpty=()=>{u()}}else u()}}catch(s){p(),y(n,s),c.disable()}}}};i.parentPort.on("message",se);

package/dist/lib/runtime/runners/node/runner.d.ts

@@ -0,0 +1,34 @@
+import { EventEmitter } from "node:events";
+import { Worker } from "node:worker_threads";
+import type { Runner } from "../index";
+export declare class NodeRunner extends EventEmitter implements Runner {
+    _worker?: Worker;
+    isMounted: boolean;
+    _isLoading: boolean;
+    invoke: (request: any) => Promise<any>;
+    mount: () => any;
+    unmount: () => any;
+    name: string;
+    timeout: number;
+    memorySize: number;
+    environment: {
+        [key: string]: any;
+    };
+    handlerPath: string;
+    handlerName: string;
+    esOutputPath: string;
+    private hasFatalError;
+    constructor({ name, timeout, memorySize, environment, handlerPath, handlerName, esOutputPath, }: {
+        name: string;
+        handlerPath: string;
+        handlerName: string;
+        esOutputPath: string;
+        timeout: number;
+        memorySize: number;
+        environment: {
+            [key: string]: any;
+        };
+    });
+    importHandler(): Promise<void>;
+    onComplete: (awsRequestId: string, timeout?: boolean) => void;
+}

package/dist/lib/runtime/runners/node/streamResponse.d.ts

@@ -0,0 +1,90 @@
+import { Writable } from "node:stream";
+import type { WritableOptions } from "node:stream";
+interface IResponseStream {
+    cork: Writable["cork"];
+    /**
+     * Do not use. This may lead to unexcepted result in AWS Lambda Runtime.
+     * @deprecated
+     */
+    destroy: Writable["destroy"];
+    end: Writable["end"];
+    uncork: Writable["uncork"];
+    write: Writable["write"];
+    addListener: Writable["addListener"];
+    emit: Writable["emit"];
+    eventNames: Writable["eventNames"];
+    getMaxListeners: Writable["getMaxListeners"];
+    listenerCount: Writable["listenerCount"];
+    listeners: Writable["listeners"];
+    off: Writable["off"];
+    on: Writable["on"];
+    once: Writable["once"];
+    prependListener: Writable["prependListener"];
+    prependOnceListener: Writable["prependOnceListener"];
+    rawListeners: Writable["rawListeners"];
+    removeAllListeners: Writable["removeAllListeners"];
+    removeListener: Writable["removeListener"];
+    setMaxListeners: Writable["setMaxListeners"];
+    /**
+     * @param {any} contentType must be a string or implement toString()
+     * @throws Error
+     */
+    setContentType: (contentType: any) => void;
+    writable: boolean;
+    readonly writableEnded: boolean;
+    readonly writableFinished: boolean;
+    readonly writableHighWaterMark: number;
+    readonly writableLength: number;
+    readonly writableObjectMode: boolean;
+    readonly writableNeedDrain: boolean;
+    readonly writableCorked: number;
+    destroyed: boolean;
+}
+interface IStreamableHandlerContext {
+    callbackwaitsforemptyeventloop: boolean;
+    functionVersion: string;
+    functionName: string;
+    memoryLimitInMB: string;
+    logGroupName: string;
+    logStreamName: string;
+    clientContext: any;
+    identity: any;
+    invokedFunctionArn: string;
+    awsRequestId: string;
+    getRemainingTimeInMillis: () => number;
+}
+export type StreamableHandler = (event: any, responseStream: IResponseStream, context?: IStreamableHandlerContext) => Promise<any | void>;
+interface IMetadata {
+    statusCode?: number;
+    headers?: {
+        [key: string]: string;
+    };
+    cookies?: string[];
+    body?: string | Buffer;
+    isBase64Encoded?: boolean;
+}
+export declare class ResponseStream extends Writable {
+    #private;
+    _onBeforeFirstWrite?: (write: Writable["write"]) => any;
+    constructor(opts: Partial<WritableOptions>);
+    setContentType: (contentType: any) => void;
+}
+export interface IHttpResponseStream {
+    /**
+     * @param {any} metadata http proxy integration response object.
+     *
+     * This could also be 'any' byte to be written before all write.() executions.
+     *
+     * Metadata will be wrapped into JSON.stringify().
+     *
+     *  `{statusCode: 404, cookies: ["hello=world"]}`
+     *
+     *
+     * @throws Error
+     */
+    from: (responseStream: IResponseStream, metadata: IMetadata) => IResponseStream;
+}
+export declare class HttpResponseStream {
+    static from: (responseStream: IResponseStream, metadata: IMetadata) => IResponseStream;
+}
+export {};

package/dist/lib/runtime/runners/node/utils.d.ts

@@ -0,0 +1,39 @@
+import type { AsyncHook } from "async_hooks";
+import type { MessagePort } from "worker_threads";
+interface LambdaErrorResponse {
+    errorType?: string;
+    errorMessage: string;
+    trace?: string[];
+}
+export declare const genResponsePayload: (err: any) => LambdaErrorResponse;
+export declare const patchConsole: () => void;
+export declare const formatStack: (_stack: string[]) => string;
+interface IEventQueueContext {
+    [id: string]: {
+        timers: Map<number, any>;
+        promises: Map<number, any>;
+        timeout?: boolean;
+    };
+}
+export declare class EventQueue extends Map {
+    private static readonly EMPTY_ARGS;
+    static IGNORE: string[];
+    onEmpty?: () => void;
+    requestId: string;
+    callbackWaitsForEmptyEventLoop: boolean;
+    async: boolean;
+    hook?: AsyncHook;
+    static context: IEventQueueContext;
+    static parentPort: MessagePort | null;
+    static logTimeoutPossibleCause: (requestId: string) => void;
+    constructor(requestId: string);
+    static restoreContext: () => void;
+    storeContextTimers: () => void;
+    isEmpty: () => boolean;
+    add: (asyncId: number, type: string, triggerAsyncId: number, resource: any) => this;
+    destroy: (asyncId: number) => void;
+    resolve: (asyncId: number) => void;
+    enable: () => void;
+    disable: () => void;
+}
+export {};

package/dist/lib/runtime/runners/python/runner.d.ts

@@ -0,0 +1,48 @@
+import type { ChildProcessWithoutNullStreams } from "node:child_process";
+import type { FSWatcher } from "node:fs";
+import type { Runner } from "../index";
+export declare class PythonRunner implements Runner {
+    invoke: Runner["invoke"];
+    mount: Runner["mount"];
+    unmount: Runner["unmount"];
+    name: string;
+    timeout: number;
+    memorySize: number;
+    environment: {
+        [key: string]: any;
+    };
+    handlerPath: string;
+    pyModulePath: string;
+    handlerDir: string;
+    handlerName: string;
+    handlerFileAbsolutePath: string;
+    runtime: string;
+    bin?: string;
+    python?: ChildProcessWithoutNullStreams;
+    isMounted: boolean;
+    watchers: FSWatcher[];
+    filesTime: Map<string, number>;
+    watcherListener: (event: "rename" | "change", filename: string | Buffer | null) => void;
+    emitRebuild: Function;
+    static wrapper: string;
+    static DELIMITER: string;
+    static DELIMITEREND: string;
+    static ERR_RESPONSE: string;
+    static WATCH: string;
+    static WATCHEND: string;
+    constructor({ name, timeout, memorySize, environment, handlerPath, handlerName, runtime, }: {
+        name: string;
+        handlerPath: string;
+        handlerName: string;
+        runtime: string;
+        timeout: number;
+        memorySize: number;
+        environment: {
+            [key: string]: any;
+        };
+    }, emitRebuild: Function);
+    setWatchFiles: (data: string) => Promise<void>;
+    findPython(): string;
+    load: () => void;
+    onComplete: (awsRequestId: string) => void;
+}

package/dist/lib/runtime/runners/ruby/runner.d.ts

@@ -0,0 +1,43 @@
+import type { ChildProcessWithoutNullStreams } from "node:child_process";
+import type { FSWatcher } from "node:fs";
+import type { Runner } from "../index";
+export declare class RubyRunner implements Runner {
+    invoke: Runner["invoke"];
+    mount: Runner["mount"];
+    unmount: Runner["unmount"];
+    name: string;
+    timeout: number;
+    memorySize: number;
+    environment: {
+        [key: string]: any;
+    };
+    handlerPath: string;
+    modulePath: string;
+    handlerDir: string;
+    handlerName: string;
+    runtime: string;
+    bin?: string;
+    ruby?: ChildProcessWithoutNullStreams;
+    isMounted: boolean;
+    emitRebuild: Function;
+    watcherListener: (event: "rename" | "change", filename: string | Buffer | null) => void;
+    watchers: FSWatcher[];
+    static wrapper: string;
+    static DELIMITER: string;
+    static ERR_RESPONSE: string;
+    static WATCH: string;
+    constructor({ name, timeout, memorySize, environment, handlerPath, handlerName, runtime, }: {
+        name: string;
+        handlerPath: string;
+        handlerName: string;
+        runtime: string;
+        timeout: number;
+        memorySize: number;
+        environment: {
+            [key: string]: any;
+        };
+    }, emitRebuild: Function);
+    setWatchFiles: (data: string) => Promise<void>;
+    load: () => void;
+    onComplete: (awsRequestId: string) => void;
+}

package/dist/lib/server/daemon.d.ts

@@ -0,0 +1,27 @@
+import type { Socket } from "node:net";
+import { type ILambdaMock } from "../runtime/rapidApi";
+import { Handlers } from "./handlers";
+import type { IAwsProvider, IServiceProvider } from "../../standalone_types";
+interface IDaemonConfig {
+    debug: boolean;
+}
+export declare class Daemon extends Handlers {
+    #private;
+    runtimeConfig: any;
+    sco: Socket[];
+    aws: IAwsProvider;
+    customOfflineRequests: {
+        method?: string | string[];
+        filter: RegExp | string;
+        callback: (req: any, res: any) => Promise<any> | any | undefined;
+    }[];
+    customBuildCallback?: Function;
+    onReady?: (port: number, ip: string) => any;
+    stop(cb?: (err?: any) => void): void;
+    constructor(provider: IServiceProvider, config?: IDaemonConfig);
+    setPort(p: number): void;
+    listen(port?: number, callback?: Function): void;
+    fakeRebuildEmitter: () => Promise<void>;
+    load(lambdaDefinitions: ILambdaMock[]): Promise<void>;
+}
+export {};

package/dist/lib/server/handlers.d.ts

@@ -0,0 +1,13 @@
+import type { ILambdaMock } from "../runtime/rapidApi";
+export type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD" | "OPTIONS" | "ANY";
+export declare class Handlers {
+    #private;
+    handlers: ILambdaMock[];
+    static ip: string;
+    debug: boolean;
+    port: number;
+    constructor(config: any);
+    static parseNameFromUrl(lambdaName: string): string;
+    getHandlerByName(lambdaName?: string | null): ILambdaMock | undefined;
+    addHandler(lambdaController: ILambdaMock): void;
+}

package/dist/lib/services/index.d.ts

@@ -0,0 +1,10 @@
+import type { DynamoDB } from "@aws-sdk/client-dynamodb";
+import type { S3 } from "@aws-sdk/client-s3";
+import type { SNS } from "@aws-sdk/client-sns";
+import type { SQS } from "@aws-sdk/client-sqs";
+export interface AwsServices {
+    s3?: S3;
+    sns?: SNS;
+    sqs?: SQS;
+    dynamoDb?: DynamoDB;
+}

package/dist/lib/utils/amazonifyHeaders.d.ts

@@ -0,0 +1,3 @@
+export declare const amazonifyHeaders: (_headers?: {
+    [key: string]: string | any[];
+}, cookies?: string[]) => any;

package/dist/lib/utils/colorize.d.ts

@@ -0,0 +1,12 @@
+export declare const log: {
+    GREEN: (s: string) => void;
+    YELLOW: (s: string) => void;
+    CYAN: (s: string) => void;
+    BR_BLUE: (s: string) => void;
+    RED: (s: string) => void;
+    GREY: (s: string) => void;
+    PINK: (s: string) => void;
+    setDebug: (_debug: boolean) => void;
+    getDebug: () => boolean;
+    info: (s: any) => void;
+};

package/dist/lib/utils/getPackageInstalledDir.d.ts

@@ -0,0 +1 @@
+export declare function getPackageInstalledDir(packageName: string): string;

package/dist/lib/utils/readDefineConfig.d.ts

@@ -0,0 +1,6 @@
+import { type Options } from "../../defineConfig";
+export declare const readDefineConfig: (config?: string | Options) => Promise<{
+    exportedFunc: any;
+    configObjectName: string;
+    configPath: string;
+} | undefined>;

package/dist/main.d.ts

@@ -0,0 +1,80 @@
+import type { DynamoDB } from "@aws-sdk/client-dynamodb";
+import type { S3 } from "@aws-sdk/client-s3";
+import type { SNS } from "@aws-sdk/client-sns";
+import type { SQS } from "@aws-sdk/client-sqs";
+import esbuild from "esbuild";
+import type { BuildContext, BuildResult } from "esbuild";
+import type { Config } from "./config";
+import type { IAwsProviderDefaults, Options } from "./defineConfig";
+import type { ILambdaMock } from "./lib/runtime/rapidApi";
+import { Daemon } from "./lib/server/daemon";
+import type { ILambdaFunction, IServiceProvider } from "./standalone_types";
+export declare class ExloApp extends Daemon {
+    #private;
+    options: any;
+    config?: string | Options;
+    esBuildConfig: any;
+    buildContext: BuildContext;
+    customEsBuildConfig?: Config["build"]["esbuild"];
+    optimizeBuild: boolean;
+    nodeVersion: number | boolean | string | undefined;
+    onKill: (() => Promise<void> | void)[];
+    shimRequire: boolean;
+    port: number;
+    onceServerReady: ((address: {
+        port: number;
+        url: string;
+    }) => void)[];
+    isDynamicBuild: boolean;
+    endpoints: Record<string, string>;
+    constructor(provider: IServiceProvider, options: any);
+    start(): Promise<void>;
+    setEsBuildConfig(): void;
+    buildAndWatch(): Promise<void>;
+    buildCallback: (result: BuildResult, isRebuild: boolean) => Promise<void>;
+    setEnv(lambdaName: string, key: string, value: string): void;
+    addLambda(lambdaName: string, config: ILambdaFunction): void;
+    getLambdaByName(lambdaName: string): ILambdaMock | undefined;
+    buildDefineConfigParam(): {
+        stop: (cb?: (err?: any) => void) => Promise<void>;
+        lambdas: ILambdaMock[];
+        addLambda: (lambdaName: string, config: ILambdaFunction) => void;
+        esbuild: typeof esbuild;
+        getServices(): {
+            s3: S3 | undefined;
+            sqs: SQS | undefined;
+            sns: SNS | undefined;
+            dynamoDb: DynamoDB | undefined;
+        };
+        setService<ServiceName extends "s3" | "sqs" | "sns" | "dynamoDb">(service: ServiceName, client: ServiceName extends "sqs" ? SQS : ServiceName extends "sns" ? SNS : ServiceName extends "dynamoDb" ? DynamoDB : ServiceName extends "s3" ? S3 : never): void;
+        setEndpoint: (serviceName: string, url: string, asLambdaEnvVar?: string) => void;
+        getEndpoint: (serviceName: string) => string;
+        getAwsProviderDefaults: () => {
+            accountId: string;
+            region: string;
+            runtime: `nodejs${number}${string}` | `python${number}${string}` | `ruby${number}${string}`;
+            memorySize: number;
+            timeout: number;
+            environment: {
+                [x: string]: string;
+            };
+        };
+        setAwsProviderDefaults: ({ accountId, environment, memorySize, region, runtime, timeout, }: Partial<IAwsProviderDefaults>) => void;
+        log: {
+            GREEN: (s: string) => void;
+            YELLOW: (s: string) => void;
+            CYAN: (s: string) => void;
+            BR_BLUE: (s: string) => void;
+            RED: (s: string) => void;
+            GREY: (s: string) => void;
+            PINK: (s: string) => void;
+            setDebug: (_debug: boolean) => void;
+            getDebug: () => boolean;
+            info: (s: any) => void;
+        };
+    };
+    resolveConfig(): Promise<Function | undefined>;
+    onBeforeApplyConfigCallbacks: ((configDefiner: Function) => Promise<void> | void)[];
+    onBeforeApplyConfig(cb: (configDefiner: Function) => Promise<void> | void): void;
+    kill(cb?: (err?: any) => void): Promise<void>;
+}

package/dist/plugins/lambda/events/alb.d.ts

@@ -0,0 +1,44 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { LambdaEndpoint } from "../../../lib/parseEvents/endpoints";
+import { CommonEventGenerator } from "./common";
+interface AlbPayload {
+    requestContext: {
+        elb: {
+            targetGroupArn: string;
+        };
+    };
+    multiValueHeaders?: {
+        [key: string]: string[];
+    };
+    multiValueQueryStringParameters?: {
+        [key: string]: string[];
+    };
+    queryStringParameters?: {
+        [key: string]: string;
+    };
+    headers?: {
+        [key: string]: any;
+    };
+    httpMethod: string;
+    path: string;
+    isBase64Encoded: boolean;
+    body?: string;
+}
+export declare class AlbRequestHandler extends CommonEventGenerator {
+    #private;
+    res: ServerResponse;
+    payload: AlbPayload;
+    mockEvent: LambdaEndpoint;
+    constructor({ res, req, body, mockEvent, multiValueHeaders, isBase64Encoded, lambdaName, }: {
+        res: ServerResponse;
+        req: IncomingMessage;
+        body: any;
+        mockEvent: LambdaEndpoint;
+        multiValueHeaders: any;
+        isBase64Encoded: boolean;
+        lambdaName: string;
+    });
+    returnError: () => true | ServerResponse<IncomingMessage>;
+    sendResponse: (output?: any) => void;
+}
+export {};

package/dist/plugins/lambda/events/apg.d.ts

@@ -0,0 +1,111 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { LambdaEndpoint } from "../../../lib/parseEvents/endpoints";
+import { CommonEventGenerator } from "./common";
+interface CommonApgEvent {
+    body?: string;
+    queryStringParameters: {
+        [key: string]: string;
+    };
+    isBase64Encoded: boolean;
+    headers: {
+        [key: string]: any;
+    };
+    pathParameters?: {
+        [key: string]: any;
+    };
+}
+export type ApgHttpApiEvent = {
+    version: string;
+    routeKey: string;
+    rawPath: string;
+    rawQueryString: string;
+    cookies?: string[];
+    requestContext: {
+        accountId: string;
+        apiId: string;
+        domainName: string;
+        domainPrefix: string;
+        http: {
+            method: string;
+            path: string;
+            protocol: string;
+            sourceIp: string;
+            userAgent: string;
+        };
+        requestId: string;
+        routeKey: string;
+        stage: string;
+        time: string;
+        timeEpoch: number;
+    };
+} & CommonApgEvent;
+export type ApgHttpEvent = {
+    version?: string;
+    resource: string;
+    path: string;
+    httpMethod: string;
+    multiValueHeaders: {
+        [key: string]: any;
+    };
+    multiValueQueryStringParameters: {
+        [key: string]: any;
+    };
+    requestContext: {
+        accountId: string;
+        apiId: string;
+        domainName: string;
+        domainPrefix: string;
+        extendedRequestId: string;
+        httpMethod: string;
+        path: string;
+        protocol: string;
+        requestId: string;
+        requestTime: string;
+        requestTimeEpoch: number;
+        resourcePath: string;
+        stage: string;
+    };
+} & CommonApgEvent;
+export declare class ApgRequestHandler extends CommonEventGenerator {
+    #private;
+    res: ServerResponse;
+    mockEvent: LambdaEndpoint;
+    payload: ApgHttpApiEvent | ApgHttpEvent;
+    constructor({ res, req, body, mockEvent, multiValueHeaders, isBase64Encoded, lambdaName, parsedURL, requestId, }: {
+        res: ServerResponse;
+        req: IncomingMessage;
+        body: any;
+        mockEvent: LambdaEndpoint;
+        multiValueHeaders: any;
+        isBase64Encoded: boolean;
+        lambdaName: string;
+        parsedURL: URL;
+        requestId: string;
+    });
+    static skipHeaders: string[];
+    static createApgV2Event: ({ req, mockEvent, parsedURL, requestId, isBase64Encoded, body, }: {
+        req: IncomingMessage;
+        mockEvent: LambdaEndpoint;
+        isBase64Encoded: boolean;
+        parsedURL: URL;
+        body: any;
+        requestId: string;
+    }) => ApgHttpApiEvent;
+    static createApgV1Event: ({ req, mockEvent, parsedURL, lambdaName, isBase64Encoded, requestId, body, }: {
+        req: IncomingMessage;
+        mockEvent: LambdaEndpoint;
+        parsedURL: URL;
+        lambdaName: string;
+        isBase64Encoded: boolean;
+        multiValueHeaders: {
+            [key: string]: string[];
+        };
+        requestId: string;
+        body: any;
+    }) => ApgHttpEvent;
+    returnError: (err?: any) => true | ServerResponse<IncomingMessage>;
+    sendV1Response: (output?: any) => void;
+    sendV2Response: (output?: any) => ServerResponse<IncomingMessage> | undefined;
+    sendResponse: (output?: any) => void | ServerResponse<IncomingMessage>;
+}
+export {};