codehooks-js 1.3.7 → 1.3.9

package/types/index.d.ts

@@ -1,138 +1,1385 @@
-export const Datastore: any;
-export const datastore: any;
+/**
+ * Built-in persistent datastore.
+ * - Datastore is capable of serving NoSQL object data and Key-Value data.
+ */
+export type Datastore = {
+  /**
+   * - Connect to Datastore
+   */
+  open: () => Promise<DatastoreAPI>;
+};
+
+/**
+ * @type {Datastore}
+ */
+export const Datastore: Datastore;
+/**
+ * @type {Datastore}
+ */
+export const datastore: Datastore;
 export const aggregation: typeof agg;
 export const crudlify: typeof crud;
+
+/**
+ * Express style API
+ * @type {Codehooks}
+ */
 export const coho: Codehooks;
 export const app: Codehooks;
-export const workflowconfig: {
-    setCollectionName: any;
-    setQueuePrefix: any;
-};
-export namespace realtime {
-    function createChannel(path: any, ...hook: any[]): void;
-    function publishEvent(channel: any, data: any, query?: {}): Promise<any>;
-    function createListener(channel: any, data: any): Promise<any>;
-    function getListeners(channel: any): Promise<any>;
-    function getListener(channel: any, listenerID: any): Promise<any>;
-    function removeListener(channel: any, listenerID: any): Promise<any>;
-}
+export const coderunner: any;
+
+/**
+ * Scheduled background worker functions
+ */
 export namespace schedule {
-    function runAt(date: any, payload: any, worker: any): Promise<any>;
-    function run(payload: any, worker: any): Promise<any>;
-    function cron(cronExpression: any, ...hook: any[]): Promise<void>;
+  function runAt(date: any, payload: any, worker: string): Promise<any>;
+  function run(payload: any, worker: string): Promise<any>;
+  function cron(
+    cronExpression: string,
+    ...hook: ((
+      request: httpRequest,
+      response: httpResponse,
+      next: nextFunction
+    ) => any)[]
+  ): void;
+}
+/**
+ * Real time publish subscribe events
+ */
+export namespace realtime {
+  type SSEListener = {
+    _id: string;
+    [key: string]: any;
+  };
+  /**
+   * Create a real time channel for clients for listen to and server to publish to
+   * @param path string - e.g. '/goals'
+   * @example
+   * realtime.createChannel('/goals')
+   */
+  function createChannel(path: string, ...hook: any): void;
+  /**
+   *
+   * @param channel string - e.g. '/goals'
+   * @param data object - Event object to publish
+   * @param query object - optional matching criteria for listeners to get the event
+   * @example
+   * realtime.publishEvent('/goals', {player: "Rod", score: 2})
+   */
+  function publishEvent(
+    channel: string,
+    data: object,
+    query?: object
+  ): Promise<object>;
+
+  /**
+   * Create a listener to use to connect to an EventSource later
+   * @param path string - Channel
+   * @param data object - Listener topics of interest
+   * @returns Promise with SSEListener
+   */
+  function createListener(path: string, data: object): Promise<SSEListener>;
+
+  /**
+   * Get a listener topics
+   * @param path string - Channel
+   * @param listenerID - A valid _id for a listener
+   */
+  function getListener(path: string, listenerID: string): Promise<SSEListener>;
+
+  /**
+   * Get all listeners on channel
+   * @param path string - Channel
+   */
+  function getListeners(path: string): Promise<SSEListener[]>;
+
+  /**
+   * Delete a listenerID
+   * @param path string - Channel
+   * @param listenerID - A valid listenerID
+   */
+  function removeListener(
+    path: string,
+    listenerID: string
+  ): Promise<SSEListener>;
 }
+/**
+ * Virtual filesystem
+ */
 export namespace filestore {
-    function getReadStream(path: any, options?: {}): any;
-    function readFile(path: any, options?: {}): any;
-    function saveFile(path: any, buffer: any, options?: {}): any;
-    function deleteFile(path: any, options?: {}): any;
-    function list(path: any, options?: {}): any;
-    function readFileAsBuffer(path: any): Promise<any>;
+  /**
+   * Raad file content as stream
+   * @see {@link https://codehooks.io/docs/fileapi#filestoregetreadstreampath API docs}
+   * @param path Absolute path to file
+   * @param options Not in use
+   * @returns Promise EventEmitter with chunks on data
+   * @example
+   * app.get('/image', async (req: httpRequest, res: httpResponse) => {
+   *   const bufStream = await filestore.getReadStream('/img/logo.png');
+   *   res.set('content-type', 'image/png')
+   *   bufStream.on('data', (buf) => {
+   *     res.write(buf, 'buffer')
+   *   })
+   *   .on('end', () => {
+   *     res.end()
+   *   })
+   * })
+   */
+  function getReadStream(path: string, options?: any): Promise<any>;
+  /**
+   * Read file content as string
+   * @see {@link https://codehooks.io/docs/fileapi#filestorereadfilepath API docs}
+   * @param path Absolute path to file
+   * @param options
+   * @returns Promise File content as string
+   */
+  function readFile(path: string, options?: any): Promise<String>;
+  /**
+   * Save file binary buffer
+   * @see {@link https://codehooks.io/docs/fileapi#filestoresavefilepath-filestream API docs}
+   * @param path Abolute path to file, e.g. /static/home.html
+   * @param buffer Stream data
+   * @param options Not in use
+   * @returns Promise with save result
+   * @example
+   * import {PassThrough} from 'stream';
+   * app.post('/file', async (req, res) => {
+   *   try {
+   *     const stream = new PassThrough();
+   *     req.pipe(stream);
+   *     const result = await filestore.saveFile('/static.html', stream);
+   *     res.end(result)
+   *   } catch (error) {
+   *     console.error(error)
+   *     res.status(404).end('Bad upload')
+   *   }
+   * })
+   */
+  function saveFile(path: string, buffer: any, options?: any): Promise<any>;
+  /**
+   * Delete file
+   * @see {@link https://codehooks.io/docs/fileapi#filestoredeletefilepath API docs}
+   * @param path
+   * @param options
+   */
+  function deleteFile(path: string, options?: any): Promise<any>;
+  /**
+   * List file directories and files
+   * @see {@link https://codehooks.io/docs/fileapi#filestorelistpath API docs}
+   * @param path
+   * @param options
+   */
+  function list(path: string, options?: any): Promise<Array<Object>>;
+  /**
+   * Read binary buffer from file
+   * @param path Path to file
+   * @returns Promise with Buffer
+   * @example
+   * const myBuf = await filestore.getFileAsBuffer('/images/logo.png');
+   */
+  function readFileAsBuffer(path: any): Promise<any>;
 }
 export default _coho;
+/**
+ * keyvalOptions
+ */
+export type keyvalOptions = {
+  /**
+   * - Time to live in milliseconds
+   */
+  ttl: number;
+  /**
+   * - Name of isolated keyspace
+   */
+  keyspace: string;
+};
+/**
+ * NoSQL API
+ */
+export type NoSQLAPI = {
+  /**
+   * - Get object by ID, returns a Promise with the object
+   */
+  getOne: (query: string | object) => Promise<object>;
+  /**
+   * - Get object by ID, returns a Promise with the object - alias for getOne
+   */
+  findOne: (query: string | object) => Promise<object>;
+  /**
+   * - Get stream of objects by query
+   * https://codehooks.io/docs/nosql-database-api#getmanycollection-query-options
+   */
+  getMany: (query: object, options?: object) => DataStream;
+  /**
+   * - Get stream of objects by query, alias for getMany
+   */
+  find: (query: object, options?: object) => DataStream;
+  /**
+   * - Insert a new data object into a collection in the current Datastore
+   */
+  insertOne: (document: object) => Promise<object>;
+  /**
+   * - Update one data object by ID in a datastore collection.
+   * - Input document is patched with the matched database object
+   * @param query string | object
+   * @param document object
+   * @param updateoperators object
+   * @param options object - {upsert: true}
+   * @returns Promise<object>
+   */
+  updateOne: (
+    query: string | object,
+    document: object,
+    updateoperators?: object,
+    options?: object
+  ) => Promise<object>;
+  /**
+   * - Update multiple data objects in a datastore collection.
+   * - Input document is patched with the matched database objects
+   */
+  updateMany: (
+    query: object,
+    document: object,
+    options?: object
+  ) => Promise<object>;
+  /**
+   * - Replace one data object by ID in a datastore collection.
+   * - Input document overwrites the matched database object, the _id value is not overwritten.
+   */
+  replaceOne: (
+    query: string | object,
+    document: object,
+    options?: object
+  ) => Promise<object>;
+  /**
+   * - Replace multiple data objects in a datastore collection.
+   * - Input document overwrites the matched database objects. The _id value is not overwritten
+   */
+  replaceMany: (
+    query: object,
+    document: object,
+    options?: object
+  ) => Promise<object>;
+  /**
+   * - Remove one data object by ID in a collection in the current Datastore
+   */
+  removeOne: (query: string | object) => Promise<object>;
+  /**
+   * - Remove multiple data objects in a collection in the current Datastore
+   */
+  removeMany: (query: object) => Promise<object>;
+  /**
+   * Validate database colletion data agains JSON-Schema
+   * @param schema JSON-schema
+   * @returns Promise with result
+   */
+  createSchema: (schema: object) => Promise<object>;
+  /**
+   * Validate database colletion data agains JSON-Schema
+   * @param schema JSON-schema
+   * @returns Promise with result
+   */
+  setSchema: (schema: object) => Promise<object>;
+  /**
+   * Remove JSON-schema for database collection
+   * @param collection string
+   * @returns Promise with result
+   */
+  removeSchema: () => Promise<object>;
+  /**
+   * Get JSON-schema for database collection
+   * @returns Promise with result
+   */
+  getSchema: () => Promise<object>;
+  /**
+   * Count database collection items
+   * @returns Promise result
+   */
+  count: () => Promise<object>;
+};
+/**
+ * Database API
+ */
+export type DatastoreAPI = {
+  /**
+   * - Get database collection by string name, returns an NoSQL API object
+   */
+  collection: (collection: string) => NoSQLAPI;
+  /**
+   * - Get object by ID, returns a Promise with the object
+   */
+  getOne: (collection: string, query: string | object) => Promise<any>;
+  /**
+   * - Get stream of objects by query
+   * * https://codehooks.io/docs/nosql-database-api#getmanycollection-query-options
+   */
+  getMany: (collection: string, query?: object, options?: object) => DataStream;
+  /**
+   * - Get object by ID, returns a Promise with the object (alias for getOne)
+   */
+  findOne: (collection: string, query: string | object) => Promise<any>;
+  /**
+   * - Alias for getMany
+   * https://codehooks.io/docs/nosql-database-api#getmanycollection-query-options
+   */
+  find: (collection: string, query?: object, options?: object) => DataStream;
+  /**
+   * - Insert a new data object into a collection in the current Datastore
+   */
+  insertOne: (collection: string, document: object) => Promise<object>;
+  /**
+   * - Update one data object by ID in a datastore collection.
+   * - Input document is patched with the matched database object
+   * @param collection string
+   * @param query string | object
+   * @param updateoperators object
+   * @param options object - {upsert: true}
+   * @returns Promise<any>
+   */
+  updateOne: (
+    collection: string,
+    query: string | object,
+    updateoperators?: object,
+    options?: object
+  ) => Promise<any>;
+  /**
+   * - Update multiple data objects in a datastore collection.
+   * - Input document is patched with the matched database objects
+   */
+  updateMany: (
+    collection: string,
+    query: object,
+    document: object,
+    updateoperators?: object
+  ) => Promise<any>;
+  /**
+   * - Replace one data object by ID in a datastore collection.
+   * - Input document overwrites the matched database object, the _id value is not overwritten.
+   */
+  replaceOne: (
+    collection: string,
+    query: string | object,
+    options?: object
+  ) => Promise<any>;
+  /**
+   * - Replace multiple data objects in a datastore collection.
+   * - Input document overwrites the matched database objects. The _id value is not overwritten
+   */
+  replaceMany: (
+    collection: string,
+    query: object,
+    options?: object
+  ) => Promise<any>;
+  /**
+   * - Remove one data object by ID in a collection in the current Datastore
+   */
+  removeOne: (collection: string, query: string | object) => Promise<any>;
+  /**
+   * - Remove multiple data objects in a collection in the current Datastore
+   */
+  removeMany: (collection: string, query: object) => Promise<any>;
+  /**
+   * - Set a key-value pair in the current Datastore
+   */
+  set: (key: string, value: string | object, options?: object) => Promise<any>;
+  /**
+   * - Get a key-value pair in the current Datastore
+   */
+  get: (key: string, options?: object) => Promise<any>;
+  /**
+   * - Get all key-value pair that matches keypattern in the current Datastore
+   */
+  getAll: (keypattern: string, options?: object) => DataStream;
+  /**
+   * - Increment a key-value pair in the current Datastore
+   */
+  incr: (key: string, value: number, options?: object) => Promise<any>;
+  /**
+   * - Decrement a key-value pair in the current Datastore
+   */
+  decr: (key: string, value: number, options?: object) => Promise<any>;
+  /**
+   * - Delete a key-value pair in the current Datastore
+   */
+  del: (key: string, value: object) => Promise<any>;
+  /**
+   * - Delete a range of key-value pairs in the current Datastore
+   */
+  delAll: (keypattern: string, options?: object) => Promise<any>;
+  /**
+   * - Add a queued job in a datastore.
+   * - Jobs in the queue are processed by your worker function.
+   */
+  enqueue: (topic: string, document: object, options?: object) => Promise<any>;
+
+  /**
+   * Queue each item from the result of a database query to a worker function
+   * @see {@link https://codehooks.io/docs/queueapi#enqueuefromquerycollection-query-topic-options Codehooks docs}
+   * @param collection Collection name
+   * @param query Database Query
+   * @param topic Worker function topic string
+   * @param options Query options
+   * @returns Promise
+   * @example
+   * async function someFunction() {
+   *   const query = {"Market Category": "G"};
+   *   const topic = 'stockWorker';
+   *   const qres = await conn.enqueueFromQuery('stocks', query, topic);
+   * }
+   *
+   * app.worker('stockWorker', (req: httpRequest, res: httpResponse) => {
+   *   const { body } = req;
+   *   console.log('Working on', body.payload)
+   *   // do stuff with body.payload
+   *   res.end()
+   * })
+   */
+  enqueueFromQuery: (
+    collection: string,
+    query: object,
+    topic: string,
+    options?: object
+  ) => Promise<object>;
+  /**
+   * Validate database colletion data agains JSON-Schema
+   * @param collection string
+   * @param schema JSON-schema
+   * @returns Promise with result
+   */
+  createSchema: (collection: string, schema: object) => Promise<object>;
+  /**
+   * Validate database colletion data agains JSON-Schema
+   * @param collection string
+   * @param schema JSON-schema
+   * @returns Promise with result
+   */
+  setSchema: (collection: string, schema: object) => Promise<object>;
+  /**
+   * Remove JSON-schema for database collection
+   * @param collection string
+   * @returns Promise with result
+   */
+  removeSchema: (collection: string) => Promise<object>;
+  /**
+   * Get JSON-schema for database collection
+   * @param collection string
+   * @returns Promise with result
+   */
+  getSchema: (collection: string) => Promise<object>;
+   /**
+   * Count database collection items
+   * @returns Promise result
+   */
+   count: (collection: string) => Promise<object>;
+};
+/**
+ * Persistent NoSql and Kev-Value datastore
+ */
+export type DataStream = {
+  /**
+   * - Emits data, stream.on('data', (data) => //console.debug(data))
+   */
+  on: (event: string, callback: (data: any) => any) => void;
+  /**
+   * - Pipe datastream to JSON output
+   */
+  json: (response: httpResponse) => void;
+  /**
+   * - Return an array of objects
+   */
+  toArray: () => Promise<object[]>;
+  /**
+   * Return an iterator
+   * @param data
+   * @returns Promise with iterator
+   */
+  forEach: (data: object) => Promise<object>;
+};
+export type httpRequest = {
+  /**
+   * - HTTP header key value pairs, e.g. req.headers['content-type']
+   */
+  headers: any;
+  /**
+   * - Get the URL query parameters as key-value pairs
+   */
+  query: any;
+  /**
+   * - Get the URL route variables as key-value pairs
+   */
+  params: any;
+  /**
+   * - Get the request body
+   * - JSON payload
+   */
+  body: any;
+  /**
+   * - Get the URL full path, e.g. /dev/myroute
+   */
+  path: string;
+  /**
+   * - Get the URL api path, e.g. /myroute
+   */
+  apiPath: string;
+  /**
+   * - Get the URL full path and query parameter string
+   */
+  originalUrl: string;
+  /**
+   * - Get the HTTP request verb
+   */
+  method: string;
+  /**
+   * - Get the project URL domain name
+   */
+  hostname: string;
+  /**
+   * Pipe data to stream
+   * @param data
+   * @returns
+   */
+  pipe: (data: any) => void;
+};
+export type httpResponse = {
+  /**
+   * - End request (optional: send text|JSON data to client)
+   */
+  end: (data: string | object | void) => void;
+  /**
+   * - Send text|JSON data to client and end request
+   * @example
+   * res.end()
+   * res.status(404).end()
+   */
+  send: (data: string | object) => void;
+  /**
+   * - End request and send JSON data to client
+   * @example
+   * res.json({ user: 'tobi' })
+   * res.status(500).json({ error: 'message' })
+   */
+  json: (document: object) => any;
+  /**
+   * - Write stream data to the client response.
+   * - Content-type must be set before any write operations
+   * - set optional type to 'buffer' for binary write operations
+   * @example
+   * res.set('content-type', 'text/plain')
+   * res.write('line one')
+   * res.write('\n')
+   * res.write('line two')
+   * res.end()
+   */
+  write: (data: any, type?: string) => any;
+  /**
+   * - Set a response header value,
+   * @example
+   * res.set('Content-Type', 'text/html; charset=UTF-8');
+   */
+  set: (header: string, value: string) => any;
+  /**
+   * - Set multiple response header values,
+   * @example
+   * res.headers({'Content-Type': 'text/html; charset=UTF-8','X-myheader': '123456890'});
+   */
+  headers: (headers: object) => any;
+  /**
+   * Set a response header value
+   * @param header string
+   * @param value string
+   * @returns 
+   */
+  setHeader: (header: string, value: string | string[]) => any;
+  /**
+   * Remove any default headers from a response 
+   * @param header string
+   * @returns 
+   */
+  removeHeader: (header: string) => any;
+  /**
+   * - Return a HTTP response status code for a client request,
+   * @example
+   * res.status(401).end();
+   */
+  status: (code: number) => any;
+  /**
+   * - Render template with object data
+   * @example
+   * res.render('services', {title: "Services page"})
+   */
+  render: (template: string, context: object) => void;
+  /**
+   * - Sets the response header to redirect client request
+   * @param statusCode - optional, set to 302 by default
+   * @param url 
+   * @returns 
+   * @example 
+   * res.redirect('/assets/login.html'); // default status 302, Temporary
+   * res.redirect(301, '/home/correct.html'); // status code 301, Permanently
+   */
+  redirect: (statusCode: number | string, url?: string) => void;
+};
+
+export type nextFunction = (error?: string) => void;
+
+export type Filesystem = {
+  /**
+   * - Get binary file input stream. Takes a path (string) to file (e.g. /static/logo.png) and an options object (Object) for future use. Returns a Promise resolving to a binary data stream emitter.
+   */
+  getReadStream: (filePath: string, options?: any) => Promise<any>;
+  /**
+   * - Get file as text. Takes an absolute path (string) to file (e.g. /static/home.html) and an options object (Object) for future use. Returns a Promise resolving to the file content (string).
+   */
+  readFile: (filePath: string, options?: any) => Promise<string>;
+  /**
+   * - Save file binary buffer. Takes an absolute path (string) to file (e.g. /static/home.html), a buffer (Buffer) to save, and file meta data (Object). Returns a Promise resolving to the save result.
+   */
+  saveFile: (filePath: string, buf: any, options?: any) => Promise<any>;
+  /**
+   * - Delete a file. Takes an absolute path (string) to file and an options object (Object) for future use. Returns a Promise resolving to the result.
+   */
+  deleteFile: (filePath: string, options?: any) => Promise<any>;
+  /**
+   * - List content of a file directory. Takes an absolute path (string) to file and an options object (Object) for future use. Returns a Promise resolving to the result.
+   */
+  list: (filePath: string, options?: any) => Promise<any>;
+  /**
+   * - Read file into a Buffer. Takes an absolute path (*) to file. Returns a Promise resolving to a Buffer.
+   */
+  readFileAsBuffer: (filePath: any) => Promise<any>;
+};
 import { agg } from './aggregation/index.mjs';
-import { crudlify as crud } from './crudlify/index.mjs';
-declare class Codehooks {
-    static getInstance(): Codehooks;
-    settings: {};
-    routes: {};
-    queues: {};
-    jobs: {};
-    auths: {};
-    appmiddleware: any[];
-    datastore: any;
-    listeners: any[];
-    workers: {};
-    realtime: {};
-    startup: {};
-    post: (path: any, ...hook: any[]) => void;
-    get: (path: any, ...hook: any[]) => void;
-    put: (path: any, ...hook: any[]) => void;
-    patch: (path: any, ...hook: any[]) => void;
-    delete: (path: any, ...hook: any[]) => void;
-    all: (path: any, ...hook: any[]) => void;
-    auth: (path: any, ...hook: any[]) => void;
-    use: (...hook: any[]) => void;
-    useRoute: (route: any, ...hook: any[]) => void;
-    queue: (topic: any, ...hook: any[]) => void;
-    worker: (name: any, ...hook: any[]) => void;
-    job: (cronExpression: any, ...hook: any[]) => void;
-    static: (options: any, hook: any) => void;
-    storage: (options: any, hook: any) => void;
-    set: (key: any, val: any) => void;
-    render: (view: any, data: any, cb: any) => Promise<void>;
-    crudlify: (schema?: {}, options?: {}) => Promise<import("./crudlify/lib/eventhooks.mjs").EventHooks>;
-    createWorkflow: (name: any, description: any, steps: any, options?: {}) => {
-        definitions: Map<any, any>;
-        configure(config: {
-            collectionName: string;
-            queuePrefix: string;
-            timeout: number;
-        }): void;
-        getDefinition(stepsName: string, stepName: string): Function;
-        validateStepDefinition(step: Function): void;
-        handleNextStep(stepsName: string, nextStep: string | null, newState: any, instanceId: string, options: any): Promise<string | string[]>;
-        register(app: Codehooks, name: string, description: string, definition: any): Promise<string>;
-        start(name: string, initialState: any): Promise<{
-            id: string;
-        }>;
-        updateState(stepsName: string, instanceId: string, state: any, options?: any): Promise<any>;
-        setState(instanceId: string, { _id, state }: any): Promise<void>;
-        continue(stepsName: string, instanceId: string): Promise<{
-            qId: string;
-        }>;
-        continueAllTimedOut(): Promise<Array<{
-            qId: string;
-        }>>;
-        getStepsStatus(id: string): Promise<any>;
-        getInstances(filter: any): Promise<any[]>;
-        cancelSteps(id: string): Promise<any>;
-        [EventEmitter.captureRejectionSymbol]?<K>(error: Error, event: string | symbol, ...args: any[]): void;
-        addListener<K>(eventName: string | symbol, listener: (...args: any[]) => void): any;
-        on<K>(eventName: string | symbol, listener: (...args: any[]) => void): any;
-        once<K>(eventName: string | symbol, listener: (...args: any[]) => void): any;
-        removeListener<K>(eventName: string | symbol, listener: (...args: any[]) => void): any;
-        off<K>(eventName: string | symbol, listener: (...args: any[]) => void): any;
-        removeAllListeners(eventName?: string | symbol): any;
-        setMaxListeners(n: number): any;
-        getMaxListeners(): number;
-        listeners<K>(eventName: string | symbol): Function[];
-        rawListeners<K>(eventName: string | symbol): Function[];
-        emit<K>(eventName: string | symbol, ...args: any[]): boolean;
-        listenerCount<K>(eventName: string | symbol, listener?: Function): number;
-        prependListener<K>(eventName: string | symbol, listener: (...args: any[]) => void): any;
-        prependOnceListener<K>(eventName: string | symbol, listener: (...args: any[]) => void): any;
-        eventNames(): (string | symbol)[];
-    };
-    init: (hook: any) => {
-        workerhooks: {};
-        routehooks: {};
-        queuehooks: {};
-        jobhooks: {};
-        authhooks: {};
-        globalhooks: any[];
-        settings: {};
-        realtime: {};
-        app: this;
-    };
-    start: (hook: any) => {
-        workerhooks: {};
-        routehooks: {};
-        queuehooks: {};
-        jobhooks: {};
-        authhooks: {};
-        globalhooks: any[];
-        settings: {};
-        realtime: {};
-        app: this;
-    };
-    setDatastore: (ds: any) => void;
-    getDatastore: () => {
-        open: () => Promise<any>;
-    };
-    addListener: (observer: any) => void;
+import * as crud from './crudlify/index.mjs';
+
+export class Codehooks {
+  static getInstance(): Codehooks;
+  /**
+   * Express style api
+   */
+  settings: {};
+  routes: {};
+  queues: {};
+  jobs: {};
+  auths: {};
+  appmiddleware: any[];
+  datastore: any;
+  listeners: any[];
+  workers: {};
+  /**
+   * POST requests - e.g. app.post('/foo', callbackFunction)
+   * @example
+   * app.post('/myroute', (req, res) => {
+   *  //console.debug('Body', req.body)
+   *  res.json({"message": "thanks!"})
+   * })
+   * @param {string} path - API route, e.g. '/foo'
+   * @param  {...function(httpRequest, httpResponse, function(string):void)} hook - callback function(s) with parameters (req, res, [next])
+   */
+  post: (
+    path: string,
+    ...hook: ((
+      request: httpRequest,
+      response: httpResponse,
+      next: nextFunction
+    ) => any)[]
+  ) => void;
+  /**
+   * GET requests - e.g. app.get('/foo/:ID', callbackFunction)
+   * @example
+   * app.get('/myroute', (req, res) => {
+   *  //console.debug('Params', req.params)
+   *  res.json({"message": "thanks!"})
+   * })
+   * @param {string} path - API route, e.g. '/foo/:ID'
+   * @param  {...function(httpRequest, httpResponse, function(string):void)} hook - callback function(s) with parameters (req, res, [next])
+   */
+  get: (
+    path: string,
+    ...hook: ((
+      request: httpRequest,
+      response: httpResponse,
+      next: nextFunction
+    ) => any)[]
+  ) => void;
+  /**
+   * PUT requests
+   * @example
+   * app.put('/myroute', (req, res) => {
+   *  //console.debug('Body', req.body)
+   *  res.json({"message": "thanks!"})
+   * })
+   * @param {string} path - API route, e.g. '/foo/:ID'
+   * @param  {...function(httpRequest, httpResponse, function(string):void):void} hook - callback function(s) with parameters (req, res, [next])
+   */
+  put: (
+    path: string,
+    ...hook: ((
+      request: httpRequest,
+      response: httpResponse,
+      next: nextFunction
+    ) => void)[]
+  ) => void;
+  /**
+   * PATCH requests
+   * @example
+   * app.patch('/myroute', (req, res) => {
+   *  //console.debug('Body', req.body)
+   *  res.json({"message": "thanks!"})
+   * })
+   * @param {string} path - API route, e.g. '/foo/:ID'
+   * @param  {...function(httpRequest, httpResponse, function(string):void)} hook - callback function(s) with parameters (req, res, [next])
+   */
+  patch: (
+    path: string,
+    ...hook: ((
+      request: httpRequest,
+      response: httpResponse,
+      next: nextFunction
+    ) => any)[]
+  ) => void;
+  /**
+   * DELETE requests - app.delete('/foo', callbackFunction)
+   * @example
+   * app.delete('/myroute', (req, res) => {
+   *  res.json({"message": "thanks!"})
+   * })
+   * @param {string} path - API route, e.g. '/foo/:ID'
+   * @param  {...function(httpRequest, httpResponse, function(string):void)} hook - callback function(s) with parameters (req, res, [next])
+   */
+  delete: (
+    path: string,
+    ...hook: ((
+      request: httpRequest,
+      response: httpResponse,
+      next: nextFunction
+    ) => any)[]
+  ) => void;
+  /**
+   * All HTTP methods - app.all('/pets/cat', (req, res) => res.end('Mjau'))
+   * @example
+   * app.all('/myroute', (req, res) => {
+   *  //console.debug('Body', req.body || 'no body')
+   *  res.json({"message": "thanks!"})
+   * })
+   * @param {string} path - API route, e.g. '- API endpoint route, e.g. '/pets'
+   * @param  {...function(httpRequest, httpResponse, function(string)):void} hook - callback function(s) with parameters (req, res, [next])
+   */
+  all: (
+    path: string,
+    ...hook: ((
+      request: httpRequest,
+      response: httpResponse,
+      next: (error?: string) => any
+    ) => void)[]
+  ) => void;
+  /**
+   * Allow custom authentication
+   * @example
+   * app.auth('/*', (req, res, next) => {
+   *  if (1 === 1) {
+   *    next()
+   *  } else {
+   *    res.status(403).end('No soup!')
+   *  }
+   * })
+   * @param {string|RegExp} path - API route, e.g. '/foo/*'
+   * @param  {...function(httpRequest, httpResponse, function(string):void):void} hook - callback function(s) with parameters (req, res, [next])
+   */
+  auth: (
+    path: string | RegExp,
+    ...hook: ((
+      request: httpRequest,
+      response: httpResponse,
+      next: nextFunction
+    ) => void)[]
+  ) => void;
+  /**
+   * Global middleware
+   * @example
+   * // global middleware
+   * app.use((req, res, next) => {
+   *  //console.debug("Global middleware was here!");
+   *  next(); // proceed
+   * })
+   * @param  {...function(httpRequest, httpResponse, function(string):void):void} hook - callback function(s) with parameters (req, res, next)
+   */
+  use(
+    ...hook: ((
+      request: httpRequest,
+      response: httpResponse,
+      next: nextFunction
+    ) => void)[]
+  ): void;
+  /**
+   * Global middleware
+   * @example
+   * // middleware on a route defined by a regular expression
+   * app.use(/^\/(foo|bar)/, (req, res, next) => {
+   *  //console.debug("RegExp route middleware was here!");
+   *  next(); // proceed
+   * })
+   * @param {RegExp} regex
+   * @param  {...function(httpRequest, httpResponse, function(string):void):void} hook - callback function(s) with parameters (req, res, next)
+   */
+  use(
+    regex: RegExp,
+    ...hook: ((
+      request: httpRequest,
+      response: httpResponse,
+      next: nextFunction
+    ) => void)[]
+  ): void;
+  /**
+   * Global middleware
+   * @example
+   * // middleware on a specific route
+   * app.use('/myroute', (req, res, next) => {
+   *  //console.debug("Route middleware was here!");
+   *  next(); // proceed
+   * })
+   * @param {string} path
+   * @param  {...function(httpRequest, httpResponse, function(string):void):void} hook - callback function(s) with parameters (req, res, next)
+   */
+  use(
+    path: string,
+    ...hook: ((
+      request: httpRequest,
+      response: httpResponse,
+      next: nextFunction
+    ) => void)[]
+  ): void;
+  /**
+   * Global route middleware
+   * @example
+   * // Global middleware on a specific route
+   * app.use('/myroute', (req, res, next) => {
+   *  //console.debug("Route middleware was here!");
+   *  next(); // proceed
+   * })
+   * @param {string|RegExp} path - Optional API route or RegExp, e.g. '/myroute/*'
+   * @param  {...function(httpRequest, httpResponse, function(string):void):void} hook - callback function(s) with parameters (req, res, next)
+   */
+  useRoute: (
+    path: string | RegExp,
+    ...hook: ((
+      request: httpRequest,
+      response: httpResponse,
+      next: nextFunction
+    ) => void)[]
+  ) => void;
+  /**
+   * Process queue job items for topic
+   * @param {string} topic
+   * @param  {...function(httpRequest, httpResponse, function(string):void)} hook - callback function(s) with parameters (req, res, [next])
+   */
+  queue: (
+    topic: string,
+    ...hook: ((
+      request: httpRequest,
+      response: httpResponse,
+      next: nextFunction
+    ) => any)[]
+  ) => void;
+  /**
+   * Add application worker function
+   * @param {object} name a unique worker name or JSON configuration
+   * @param  {...function(httpRequest, httpResponse, function(string):void)} hook - callback function(s) with parameters (req, res, [next])
+   * @example
+   * app.worker('myworker', (data, job) => {
+   *  const {body:{payload}} = data
+   *  //console.debug('worker payload data', payload)
+   *  // do stuff with payload data
+   *  job.end()
+   *})
+   * @example
+   * app.worker({name: 'myworker', workers: 5}, (data, job) => {
+   *  const {body:{payload}} = data
+   *  //console.debug('worker payload data', payload)
+   *  // do stuff with payload data
+   *  job.end()
+   *})
+   */
+  worker: (
+    name: string | object,
+    ...hook: ((
+      request: httpRequest,
+      response: httpResponse,
+      next: nextFunction
+    ) => any)[]
+  ) => void;
+  /**
+   * Create cron background jobs
+   * @example
+   * // call function each minute
+   * app.job('* * * * *', (req, res) => {
+   *  //console.debug('tick each minute')
+   *  res.end()
+   * })
+   * @param {string} cronExpression - cron expression
+   * @param  {...function(httpRequest, httpResponse, function(string):void)} hook - callback function(s) with parameters (req, res, [next])
+   */
+  job: (
+    cronExpression: string,
+    ...hook: ((
+      request: httpRequest,
+      response: httpResponse,
+      next: nextFunction
+    ) => any)[]
+  ) => void;
+  /**
+   * Set up a server-sent events channel endpoint (SSE).
+   * This method registers a set of middleware (hooks) for the channel and defines an SSE endpoint.
+   *
+   * @param {string} path - The channel on which to establish a real-time connection. This acts as the base path for the SSE endpoint.
+   * @param  {...function(httpRequest, httpResponse, function(string):void)} hook - Optional middleware functions to be applied to the channel (access check for example). These functions are executed in the order they are provided.
+   */
+  realtime(
+    path: string,
+    ...hook: ((
+      request: httpRequest,
+      response: httpResponse,
+      next: nextFunction
+    ) => any)[]
+  ): void;
+
+  /**
+   * Serve static file content from a source code diretory
+   * @param {Object} options -
+   * - options.route - API route to serve assets
+   * - options.directory - path to directory with assets/files
+   * - options.default - default file name if root is /
+   @param  {...function(httpRequest, httpResponse, function(string):void)} hook - Optional middleware functions to be applied before resource is served
+   * @example
+   * app.static({route:'/static', directory: '/assets'}, (req, res, next) => {
+   *   console.log("Serving a static resource", req.path);
+   *   next();
+   *  })
+   * @returns void
+   */
+  static: (options: any, 
+      ...hook: ((
+      request: httpRequest,
+      response: httpResponse,
+      next: nextFunction
+    ) => any)[]) => void;
+  /**
+   * Serve file content from a blob storage diretory
+   * @param {Object} options - {route: "/documents", directory: "/docs"}
+   * @returns void
+   */
+  storage: (options: any, 
+    ...hook: ((
+    request: httpRequest,
+    response: httpResponse,
+    next: nextFunction
+  ) => any)[]) => void;
+  /**
+   * Configuration settings
+   * @param {string} key
+   * @param {*} val
+   * @example
+   * app.set('views', '/views')
+   * app.set('view engine', {"hbs": handlebars})
+   */
+  set: (key: string, val: any) => void;
+  /**
+   *
+   * @param {string} view
+   * @param {object} data
+   * @param {function(string):void)} cb
+   */
+  render: (view: string, data: object, cb: any) => Promise<void>;
+  /**
+   * Create CRUD REST API for database
+   * @see {@link https://codehooks.io/docs/database-rest-api}
+   * @see {@link https://codehooks.io/docs/database-rest-api#data-validation-with-yup Data validation with Yup, Zod, JSON.schema}
+   * @param {object} schema
+   * @param {object} options - Optional {prefix: "/crud"} serve all crud routes under sub route /crud/*
+   * @returns Promise - Eventhooks
+   */
+  crudlify: (
+    schema?: object,
+    options?: object
+  ) => Promise<import('./crudlify/lib/eventhooks.mjs').EventHooks>;
+  /**
+   * Returns the Codehooks serverless definitions used by a serverless runtime engine
+   * @example
+   * export default app.init();
+   * @returns {Object} App instance
+   */
+  init: (cb?: any) => any;
+  /**
+   * Alias for app.init()
+   * @example
+   * export default app.start();
+   * @returns {Object} App instance
+   */
+  start: (cb?: any) => any;
+  /**
+   * Use Node Express app to run standalone
+   * All Codehooks routes will be applied as Express Routes
+   * @param {Object} express app instance
+   * @param {Object} options for Datastore and routing space
+   */
+  useExpress: (express: any, options: any) => Promise<void>;
+  /**
+   * Set Datastore interface
+   * @param {*} ds
+   */
+  setDatastore: (ds: any) => void;
+  getDatastore: () => {
+    open: () => Promise<any>;
+  };
+  addListener: (observer: any) => void;
+  /**
+   * Create a new workflow
+   * @param name - Unique identifier for the workflow
+   * @param description - Human-readable description of the workflow
+   * @param steps - Object containing step definitions
+   * @param options - Optional configuration options
+   * @returns Workflow instance for managing the workflow
+   */
+  createWorkflow: (name: string, description: string, steps: WorkflowDefinition, options?: WorkflowConfig) => Workflow;
+  /**
+   * Register a workflow with the application
+   * @param name - Unique identifier for the workflow
+   * @param description - Human-readable description
+   * @param steps - Step definitions
+   * @returns Promise with the registered workflow name
+   */
+  registerWorkflow: (name: string, description: string, steps: WorkflowDefinition) => Promise<string>;
 }
-import { Steps as Workflow } from './workflow/index.mjs';
-import { StepsConfig as WorkflowConfig } from './workflow/index.mjs';
 declare const _coho: Codehooks;
-export { Workflow, WorkflowConfig };
+
+/**
+ * Events emitted by the workflow engine
+ */
+export type WorkflowEvents = {
+  /**
+   * Emitted when a new workflow is registered
+   * @event
+   */
+  'workflowCreated': { name: string; description: string };
+  
+  /**
+   * Emitted when a new workflow instance is started
+   * @event
+   */
+  'workflowStarted': { name: string; initialState: any };
+  
+  /**
+   * Emitted when a step begins execution
+   * @event
+   */
+  'stepStarted': { workflowName: string; step: string; state: any; instanceId: string };
+  
+  /**
+   * Emitted when a step's state is updated
+   * @event
+   */
+  'stateUpdated': { workflowName: string; state: any; instanceId: string };
+  
+  /**
+   * Emitted when a step is waiting for input
+   * @event
+   */
+  'stepWaiting': { workflowName: string; step: string; instanceId: string };
+  
+  /**
+   * Emitted when a workflow instance is continued after waiting
+   * @event
+   */
+  'workflowContinued': { workflowName: string; step: string; instanceId: string };
+
+  /**
+   * Emitted when a workflow instance is completed
+   * @event
+   */
+  'completed': { message: string; state: any };
+  
+  /**
+   * Emitted when a workflow instance is cancelled
+   * @event
+   */
+  'cancelled': { id: string };
+
+  /**
+   * Emitted when an error occurs
+   * @event
+   */
+  'error': { error: Error };
+};
+
+/**
+ * Definition of a workflow step function
+ */
+export type WorkflowDefinition = Record<string, (state: any, callback: (nextStep: string | string[] | null, newState: any, options?: any) => void) => Promise<void>>;
+
+/**
+ * Configuration options for a workflow step
+ */
+export type StepOptions = {
+  /** Timeout in milliseconds for this specific step */
+  timeout?: number;
+  /** Maximum number of retries for this step */
+  maxRetries?: number;
+};
+
+/**
+ * Configuration options for the Workflow engine
+ */
+export type WorkflowConfig = {
+  /** Collection name for storing workflow data */
+  collectionName?: string;
+  /** Queue prefix for workflow jobs */
+  queuePrefix?: string;
+  /** Global timeout in milliseconds for workflow steps */
+  timeout?: number;
+  /** Maximum number of times a step can be executed */
+  maxStepCount?: number;
+  /** Step-specific configuration options */
+  steps?: Record<string, StepOptions>;
+};
+
+/**
+ * Engine for managing workflow-based applications
+ * @extends Workflow
+ */
+export type WorkflowEngine = Workflow & {
+  /**
+   * Register a new workflow
+   * @param name - Unique identifier for the workflow
+   * @param description - Human-readable description
+   * @param steps - Step definitions
+   */
+  register: (name: string, description: string, steps: WorkflowDefinition) => Promise<string>;
+};
+
+/**
+ * Workflow engine for managing step-based applications
+ * @extends EventEmitter
+ */
+export type Workflow = {
+  /**
+   * Configure the workflow engine
+   * @param options - Configuration options
+   * @param options.collectionName - Collection name for storing workflow data
+   * @param options.queuePrefix - Queue prefix for workflow jobs
+   * @param options.timeout - Timeout in milliseconds for workflow steps
+   * @param options.maxStepCount - Maximum number of times a step can be executed
+   * @param options.steps - Workflow step configuration
+   * @example
+   * workflow.configure({
+   *   collectionName: 'workflows',
+   *   queuePrefix: 'workflow',
+   *   timeout: 30000,
+   *   maxStepCount: 3,
+   *   steps: {
+   *     stepName: {
+   *       timeout: 3000,
+   *       maxRetries: 3
+   *     }
+   *   }
+   * });
+   */
+  configure: (options: WorkflowConfig) => void;
+
+  /**
+   * Register a new workflow
+   * @param app - Codehooks application instance
+   * @param name - Unique identifier for the workflow
+   * @param description - Human-readable description
+   * @param definition - Object containing step definitions
+   * @returns Promise with the registered workflow name
+   */
+  register: (app: Codehooks, name: string, description: string, definition: Record<string, Function>) => Promise<string>;
+  
+  /**
+   * Start a new workflow instance
+   * @param name - Name of the workflow to start
+   * @param initialState - Initial state for the workflow instance
+   * @returns Promise with the workflow instance ID
+   */
+  start: (name: string, initialState: any) => Promise<{ id: string }>;
+  
+  /**
+   * Update the state of a workflow instance
+   * @param workflowName - Name of the workflow
+   * @param instanceId - ID of the workflow instance
+   * @param state - New state to update with
+   * @param options - Options for the update, { continue: false } to avoid continuing the step
+   * @returns Promise with the updated state
+   */
+  updateState: (workflowName: string, instanceId: string, state: any, options?: UpdateOptions) => Promise<any>;
+  
+  /**
+   * Continue a paused workflow instance
+   * @param workflowName - Name of the workflow
+   * @param instanceId - ID of the workflow instance
+   * @param reset - Whether to reset all step counts (true) or just the current step (false)
+   * @returns Promise with the queue ID for the continued step
+   */
+  continue: (workflowName: string, instanceId: string, reset?: boolean) => Promise<{ qId: string }>;
+  
+  /**
+   * Get the status of a workflow instance
+   * @param id - ID of the workflow instance
+   * @returns Promise with the workflow status
+   */
+  getWorkflowStatus: (id: string) => Promise<any>;
+  
+  /**
+   * Get all workflow instances matching a filter
+   * @param filter - Filter criteria for workflows
+   * @returns Promise with list of workflow instances
+   */
+  getInstances: (filter: any) => Promise<any[]>;
+  
+  /**
+   * Cancel a workflow instance
+   * @param id - ID of the workflow instance to cancel
+   * @returns Promise with the cancellation result
+   */
+  cancelWorkflow: (id: string) => Promise<any>;
+
+  /**
+   * Register an event listener
+   * @param event - Name of the event to listen for
+   * @param listener - Callback function to handle the event
+   * @example
+   * workflow.on('stepStarted', ({ workflowName, step, state, instanceId }) => {
+   *   console.log(`Step ${step} started in workflow ${workflowName}`);
+   * });
+   */
+  on: (event: WorkflowEvent, listener: (data: WorkflowEventData) => void) => Workflow;
+  
+  /**
+   * Register a one-time event listener
+   * @param event - Name of the event to listen for
+   * @param listener - Callback function to handle the event
+   */
+  once: (event: WorkflowEvent, listener: (data: WorkflowEventData) => void) => Workflow;
+  
+  /**
+   * Remove an event listener
+   * @param event - Name of the event
+   * @param listener - Callback function to remove
+   */
+  off: (event: WorkflowEvent, listener: (data: WorkflowEventData) => void) => Workflow;
+  
+  /**
+   * Emit an event
+   * @param event - Name of the event to emit
+   * @param data - Event data
+   */
+  emit: (event: WorkflowEvent, data: WorkflowEventData) => boolean;
+
+  /**
+   * Continue all timed out workflow instances
+   * @returns Promise with array of results containing queue IDs for continued workflows
+   */
+  continueAllTimedOut: () => Promise<Array<{qId: string}>>;
+
+  /**
+   * Check if a specific step in a workflow instance has timed out
+   * @param workflow - The workflow instance to check
+   * @returns Object containing timeout status and details
+   * @example
+   * const status = workflow.isStepTimedOut(workflowInstance);
+   * // Returns:
+   * // {
+   * //   isTimedOut: boolean,
+   * //   executionTime?: number,  // if step has finished
+   * //   runningTime?: number,    // if step is still running
+   * //   timeout: number,         // actual timeout value used
+   * //   step: string,           // name of the step checked
+   * //   startTime: string,      // ISO timestamp
+   * //   finishTime?: string,    // if step has finished
+   * //   currentTime?: string,   // if step is still running
+   * //   timeoutSource: 'stepConfig' | 'defaultOptions' | 'globalTimeout'
+   * // }
+   */
+  isStepTimedOut: (workflow: any) => {
+    isTimedOut: boolean;
+    executionTime?: number;
+    runningTime?: number;
+    timeout: number;
+    step: string;
+    startTime: string;
+    finishTime?: string;
+    currentTime?: string;
+    timeoutSource: 'stepConfig' | 'defaultOptions' | 'globalTimeout';
+    reason?: string;
+  };
+
+  /**
+   * Find all workflow instances with timed out steps
+   * @param filter - Optional filter criteria for workflows
+   * @returns Promise with array of workflow instances that have timed out steps
+   * @example
+   * const timedOutWorkflows = await workflow.findTimedOutSteps();
+   * // Returns array of workflows with timeout details:
+   * // [{
+   * //   workflowId: string,
+   * //   workflowName: string,
+   * //   isTimedOut: true,
+   * //   executionTime?: number,
+   * //   runningTime?: number,
+   * //   timeout: number,
+   * //   step: string,
+   * //   startTime: string,
+   * //   finishTime?: string,
+   * //   currentTime?: string,
+   * //   timeoutSource: string
+   * // }]
+   */
+  findTimedOutSteps: (filter?: any) => Promise<Array<{
+    workflowId: string;
+    workflowName: string;
+    isTimedOut: boolean;
+    executionTime?: number;
+    runningTime?: number;
+    timeout: number;
+    step: string;
+    startTime: string;
+    finishTime?: string;
+    currentTime?: string;
+    timeoutSource: 'stepConfig' | 'defaultOptions' | 'globalTimeout';
+  }>>;
+};
+
+/**
+ * Options for updating workflow state
+ */
+export type UpdateOptions = {
+  /** Whether to continue to the next step after update */
+  continue?: boolean;
+};
+
+/**
+ * Workflow event types
+ */
+export type WorkflowEvent = 
+  | 'workflowCreated'
+  | 'workflowStarted'
+  | 'workflowContinued'
+  | 'stepStarted'
+  | 'stepEnqueued'
+  | 'stateUpdated'
+  | 'completed'
+  | 'cancelled'
+  | 'error';
+
+/**
+ * Data structure for workflow events
+ */
+export type WorkflowEventData = {
+  workflowName: string;
+  step?: string;
+  state?: any;
+  instanceId?: string;
+  error?: Error;
+  [key: string]: any;
+};
+
+//# sourceMappingURL=index.d.ts.map