@hotmeshio/hotmesh 0.0.55 → 0.0.56

package/types/redis.ts

@@ -1,27 +1,276 @@
-import {
-  RedisClassType,
-  RedisClientType as RCT,
-  RedisMultiType as RMT,
-  RedisClientOptions as RCO
-} from './redisclient';
-import {
-  RedisClassType as IORRedisClassType,
-  RedisClientType as IORCT,
-  RedisMultiType as IORMT,
-  RedisClientOptions as IORCO
-} from './ioredisclient';
-
-type RedisClass = RedisClassType | IORRedisClassType;
-type RedisClient = RCT | IORCT;
-type RedisMulti = RMT | IORMT;
-type RedisOptions = RCO | IORCO;
+import { StringStringType } from './serializer';
+import { ReclaimedMessageType } from './stream';
 
 type MultiResponseFlags = (string | number)[]; // e.g., [3, 2, '0']
 
+/**
+ * Redis types
+ */
+interface ConnectionOptions {
+  //[key: string]: any;
+  host?: string;
+  port?: number;
+  path?: string; // Creates unix socket connection to path. If this option is specified, host and port are ignored.
+  socket?: any; // Establish secure connection on a given socket rather than creating a new socket
+  NPNProtocols?: string[] | Buffer[]; // Defaults to []
+  ALPNProtocols?: string[] | Buffer[]; // Defaults to []
+  servername?: string; // SNI TLS Extension
+  checkServerIdentity?: (servername: string, cert: Buffer) => Error | undefined;
+  session?: Buffer;
+  minDHSize?: number;
+  secureContext?: any; // If not provided, the entire ConnectionOptions object will be passed to tls.createSecureContext()
+  secureProtocol?: string; // The SSL method to use, e.g., SSLv3_method
+  ciphers?: string;
+  honorCipherOrder?: boolean;
+  requestCert?: boolean;
+  rejectUnauthorized?: boolean;
+  maxVersion?: 'TLSv1.3' | 'TLSv1.2' | 'TLSv1.1' | 'TLSv1';
+  minVersion?: 'TLSv1.3' | 'TLSv1.2' | 'TLSv1.1' | 'TLSv1';
+}
+
+interface RedisRedisClientOptions {
+  url?: string;
+  socket?: {
+    host?: string;
+    port?: number;
+    tls?: boolean;
+    servername?: string;
+    //[key: string]: any;
+  };
+  username?: string;
+  password?: string;
+  database?: number;
+  name?: string;
+  readonly?: boolean;
+  legacyMode?: boolean;
+  commandsQueueMaxLength?: number;
+  disableOfflineQueue?: boolean;
+  connectTimeout?: number;
+  autoResubscribe?: boolean;
+  autoResendUnfulfilledCommands?: boolean;
+  lazyConnect?: boolean;
+  tls?: boolean | ConnectionOptions;
+  enableReadyCheck?: boolean;
+  keepAlive?: number;
+  family?: 'IPv4' | 'IPv6';
+  keyPrefix?: string;
+  retry?: {
+    maxReconnectionAttempts?: number;
+    initialReconnectionDelay?: number;
+    reconnectionBackoffFactor?: number;
+    totalReconnectionTimeout?: number;
+    maxRetryCount?: number;
+  };
+  stringNumbers?: boolean;
+}
+
+interface RedisRedisMultiType {
+  sendCommand(command: string, ...args: string[]): Promise<any>;
+  exec: () => Promise<unknown[]>;
+
+  XADD(key: string, id: string, fields: any): this;
+  XACK(key: string, group: string, id: string): this;
+  XDEL(key: string, id: string): this;
+  XLEN(key: string): this;
+  DEL(key: string): this;
+  EXISTS(key: string): this;
+  HDEL(key: string, itemId: string): this;
+  HGET(key: string, itemId: string): this;
+  HGETALL(key: string): this;
+  HINCRBYFLOAT(key: string, itemId: string, value: number): this;
+  HMGET(key: string, itemIds: string[]): Promise<string[]>;
+  HSET(key: string, values: Record<string, string>): this;
+  LPUSH(key: string, items: string[]): this;
+  LRANGE(key: string, start: number, end: number): this;
+  RPUSH(key: string, items: string[]): this;
+  SET(key: string, value: string): this;
+  ZADD(key: string, values: { score: string, value: string }, opts?: { NX: boolean }): this;
+  ZRANGE_WITHSCORES(key: string, start: number, end: number): this;
+  ZRANK(key: string, member: string): this;
+  ZSCORE(key: string, value: string): this;
+}
+
+interface RedisRedisClientType {
+  multi(): Partial<RedisRedisMultiType>;
+  connect(): Promise<void>;
+  sendCommand(args: any[]): Promise<any>;
+  exec(): Promise<unknown[]>;
+  flushDb(): Promise<string>;
+  quit(): Promise<string>;
+  disconnect(): void;
+  duplicate(): RedisRedisClientType;
+  on(event: string, callback: (...args: any[]) => void): void;
+  publish(channel: string, message: string): Promise<number>;
+  pSubscribe(pattern: string, callback: (channel: string, message: string) => void): void;
+  pUnsubscribe(pattern: string): void;
+  subscribe(channel: string, callback: (channel: string, message: string) => void): void;
+  unsubscribe(channel: string): void;
+  punsubscribe(channel: string): void;
+  get(key: string): Promise<string | null>;
+  set(key: string, value: string): Promise<string>;
+
+  XADD(key: string, id: string, fields: any): Promise<string>;
+  XACK(key: string, group: string, id: string): Promise<number>;
+  XDEL(key: string, id: string): Promise<number>;
+  XLEN(key: string): Promise<number>;
+  DEL(key: string): Promise<number>;
+  EXISTS(key: string): Promise<number>;
+  HDEL(key: string, itemId: string): Promise<number>;
+  HGET(key: string, itemId: string): Promise<string | null>;
+  HGETALL(key: string): Promise<StringStringType>;
+  HINCRBYFLOAT(key: string, itemId: string, value: number): Promise<number>;
+  HMGET(key: string, itemIds: string[]): Promise<string[]>;
+  HSET(key: string, values: Record<string, string>): this;
+  LPUSH(key: string, items: string[]): Promise<number>;
+  LRANGE(key: string, start: number, end: number): Promise<string[]>;
+  RPUSH(key: string, items: string[]): Promise<number>;
+  SET(key: string, value: string): Promise<string>;
+  ZADD(key: string, values: { score: string, value: string }, opts?: { NX: boolean }): Promise<number>;
+  ZRANGE_WITHSCORES(key: string, start: number, end: number): Promise<{ score: number, value: string }>;
+  ZRANK(key: string, member: string): Promise<number>;
+  ZSCORE(key: string, value: string): Promise<number>;
+}
+
+interface RedisRedisClassType {
+  createClient(options: RedisRedisClientOptions): Partial<RedisRedisClientType>;
+}
+
+/**
+ * IORedis types
+ */
+interface IORedisClientOptions {
+  port?: number;
+  host?: string;
+  family?: 'IPv4' | 'IPv6';
+  path?: string;
+  keepAlive?: number;
+  noDelay?: boolean;
+  connectionName?: string;
+  db?: number;
+  password?: string;
+  username?: string;
+  sentinels?: Array<{ host: string; port: number }>;
+  name?: string;
+  readOnly?: boolean;
+  keyPrefix?: string;
+  reconnectOnError?: (err: Error) => boolean;
+}
+
+interface IORedisClient {
+  multi(): IORedisMultiType;
+  exec(): Promise<unknown[]>;
+  sendCommand(args: any[]): Promise<any>;
+  call(command: string, ...args: any[]): Promise<any>;
+  quit(): Promise<string>;
+  flushdb(): Promise<string>;
+
+  publish(channel: string, message: string): Promise<number>;
+  psubscribe(pattern: string, callback: (channel: string, message: string) => void): Promise<void>;
+  punsubscribe(pattern: string): void;
+  subscribe(channel: string, callback: (channel: string, message: string) => void): void;
+  unsubscribe(channel: string): void;
+  punsubscribe(channel: string): void;
+
+  xadd(key: string, id: string, fields: any, message?: string): Promise<string>;
+  xack(key: string, group: string, id: string): Promise<number>;
+  xdel(key: string, id: string): Promise<number>;
+  xlen(key: string): Promise<number>;
+  xpending(
+    key: string,
+    group: string,
+    start?: string,
+    end?: string,
+    count?: number,
+    consumer?: string
+  ): Promise<[string, string, number, [string, number][]][] | [string, string, number, number] | unknown[]>;
+  xclaim(
+    key: string,
+    group: string,
+    consumer: string,
+    minIdleTime: number,
+    id: string,
+    ...args: string[]
+  ): Promise<ReclaimedMessageType>;
+  xinfo(command: 'GROUPS' | string, key: string): Promise<unknown>;
+  xrange(key: string, start: string, end: string): Promise<string[][]>;
+  del(key: string): Promise<number>;
+  exists(key: string): Promise<number>
+  get(key: string): Promise<string | null>;
+  hdel(key: string, itemId: string): Promise<number>;
+  hget(key: string, itemId: string): Promise<string | null>;
+  hgetall(key: string): Promise<StringStringType>;
+  hincrbyfloat(key: string, itemId: string, value: number): Promise<number>;
+  hmget(key: string, itemIds: string[]): Promise<string[]>;
+  hset(key: string, values: Record<string, string>): this;
+  lpush(key: string, ...args: string[]): Promise<number>;
+  lrange(key: string, start: number, end: number): Promise<string[]>;
+  on(event: string, callback: (...args: any[]) => void): void;
+  rpush(key: string, ...args: string[]): Promise<number>;
+  set(key: string, value: string): Promise<string>;
+  zadd(...args: Array<string | number>): Promise<number>;
+  zrange(key: string, start: number, end: number, withScores?: 'WITHSCORES'): Promise<string[]>;
+  zrank(key: string, member: string): Promise<number>;
+  zscore(key: string, value: string): Promise<number>;
+  xgroup(command: 'CREATE' | string, key: string, groupName: string, id: string, mkStream?: 'MKSTREAM'): Promise<string>;
+}
+
+type IORedisClassType = new (options: IORedisClientOptions, ...args: any[]) => IORedisClient;
+interface IORedisMultiType {
+  xadd(key: string, id: string, fields: any, message?: string): this;
+  xack(key: string, group: string, id: string): this;
+  xdel(key: string, id: string): this;
+  xlen(key: string): this;
+  xpending(key: string, group: string, start?: string, end?: string, count?: number, consumer?: string): this;
+  xclaim(
+    key: string,
+    group: string,
+    consumer: string,
+    minIdleTime: number,
+    id: string,
+    ...args: string[]
+  ): this;
+  hdel(key: string, itemId: string): this;
+  hget(key: string, itemId: string): this;
+  hgetall(key: string): this;
+  hincrbyfloat(key: string, itemId: string, value: number): this;
+  hmget(key: string, itemIds: string[]): this;
+  hset(key: string, values: Record<string, string>): this;
+  lrange(key: string, start: number, end: number): this;
+  rpush(key: string, value: string): this;
+  zadd(...args: Array<string | number>): this;
+  xgroup(command: 'CREATE', key: string, groupName: string, id: string, mkStream?: 'MKSTREAM'): this;
+
+  sendCommand(command: string[]): Promise<any>;
+  exec: () => Promise<unknown[]>;
+}
+
+type RedisClass = RedisRedisClassType | IORedisClassType;
+type RedisClient = RedisRedisClientType | IORedisClient;
+type RedisOptions = RedisRedisClientOptions | IORedisClientOptions;
+type RedisMulti = RedisRedisMultiType | IORedisMultiType;
+
+function isRedisClient(client: RedisClient): client is RedisRedisClientType {
+  return 'sendCommand' in client;
+}
+
+function isIORedisClient(client: RedisClient): client is IORedisClient {
+  return 'pipeline' in client;
+}
+
 export {
   RedisClass,
+  RedisRedisClientType,
+  RedisRedisClientOptions,
+  RedisRedisClassType,
+  IORedisClient as IORedisClientType,
   RedisClient,
   RedisMulti,
+  RedisRedisMultiType,
+  IORedisClientOptions,
+  IORedisClassType,
+  IORedisMultiType,
   RedisOptions,
   MultiResponseFlags,
-}
+  isRedisClient,
+  isIORedisClient,
+};

package/build/types/ioredisclient.d.ts

@@ -1,5 +0,0 @@
-import { Redis, ChainableCommander, RedisOptions } from 'ioredis';
-type RedisClassType = {
-    new (options: RedisOptions): Redis;
-};
-export { RedisClassType, Redis as RedisClientType, ChainableCommander as RedisMultiType, RedisOptions as RedisClientOptions, };

package/build/types/ioredisclient.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedisClientType = void 0;
-const ioredis_1 = require("ioredis");
-Object.defineProperty(exports, "RedisClientType", { enumerable: true, get: function () { return ioredis_1.Redis; } });

package/build/types/redisclient.d.ts

@@ -1,26 +0,0 @@
-import { createClient, RedisClientOptions } from 'redis';
-type RedisClientType = ReturnType<typeof createClient>;
-interface RedisMultiType {
-    XADD(key: string, id: string, fields: any): this;
-    XACK(key: string, group: string, id: string): this;
-    XDEL(key: string, id: string): this;
-    XLEN(key: string): this;
-    HDEL(key: string, itemId: string): this;
-    HGET(key: string, itemId: string): this;
-    HGETALL(key: string): this;
-    HINCRBYFLOAT(key: string, itemId: string, value: number): this;
-    HMGET(key: string, itemIds: string[]): this;
-    HSET(key: string, values: Record<string, string>): this;
-    LRANGE(key: string, start: number, end: number): this;
-    RPUSH(key: string, value: string): this;
-    ZADD(key: string, values: {
-        score: string;
-        value: string;
-    }): this;
-    sendCommand(command: string[]): Promise<any>;
-    exec: () => Promise<unknown[]>;
-}
-type RedisClassType = {
-    createClient: (options: RedisClientOptions) => any;
-};
-export { RedisClassType, RedisClientType, RedisMultiType, RedisClientOptions, };

package/build/types/redisclient.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/modules/enums.ts

@@ -1,62 +0,0 @@
-import { LogLevel } from "../types/logger";
-
-// HOTMESH SYSTEM
-export const HMSH_LOGLEVEL = process.env.HMSH_LOGLEVEL as LogLevel || 'info';
-
-// HOTMESH STATUS CODES
-export const HMSH_CODE_SUCCESS = 200;
-export const HMSH_CODE_PENDING = 202;
-export const HMSH_CODE_NOTFOUND = 404;
-export const HMSH_CODE_INTERRUPT = 410;
-export const HMSH_CODE_UNKNOWN = 500;
-export const HMSH_CODE_TIMEOUT = 504;
-export const HMSH_CODE_UNACKED = 999;
-// DURABLE STATUS CODES
-export const HMSH_CODE_DURABLE_SLEEP = 588;
-export const HMSH_CODE_DURABLE_ALL = 589;
-export const HMSH_CODE_DURABLE_CHILD = 590;
-export const HMSH_CODE_DURABLE_PROXY = 591;
-export const HMSH_CODE_DURABLE_WAIT = 595;
-export const HMSH_CODE_DURABLE_TIMEOUT = 596;
-export const HMSH_CODE_DURABLE_MAXED = 597;
-export const HMSH_CODE_DURABLE_FATAL = 598;
-export const HMSH_CODE_DURABLE_RETRYABLE = 599;
-
-// HOTMESH MESSAGES
-export const HMSH_STATUS_UNKNOWN = 'unknown';
-
-// QUORUM
-export const HMSH_QUORUM_ROLLCALL_CYCLES = 12; //max iterations
-export const HMSH_QUORUM_DELAY_MS = 250;
-export const HMSH_ACTIVATION_MAX_RETRY = 3;
-
-// ENGINE
-export const HMSH_OTT_WAIT_TIME = parseInt(process.env.HMSH_OTT_WAIT_TIME, 10) || 1000;
-export const HMSH_EXPIRE_JOB_SECONDS = parseInt(process.env.HMSH_EXPIRE_JOB_SECONDS, 10) || 1;
-
-// STREAM ROUTER
-export const HMSH_MAX_RETRIES = parseInt(process.env.HMSH_MAX_RETRIES, 10) || 3;
-export const HMSH_MAX_TIMEOUT_MS = parseInt(process.env.HMSH_MAX_TIMEOUT_MS, 10) || 60000;
-export const HMSH_GRADUATED_INTERVAL_MS = parseInt(process.env.HMSH_GRADUATED_INTERVAL_MS, 10) || 5000;
-
-// DURABLE
-export const HMSH_DURABLE_MAX_ATTEMPTS =  3;
-export const HMSH_DURABLE_MAX_INTERVAL = '120s';
-export const HMSH_DURABLE_EXP_BACKOFF = 10;
-
-const BASE_BLOCK_DURATION = 10000;
-const TEST_BLOCK_DURATION = 1000;
-export const HMSH_BLOCK_TIME_MS = process.env.HMSH_BLOCK_TIME_MS ? parseInt(process.env.HMSH_BLOCK_TIME_MS, 10) : (process.env.NODE_ENV === 'test' ? TEST_BLOCK_DURATION : BASE_BLOCK_DURATION);
-
-export const HMSH_XCLAIM_DELAY_MS = parseInt(process.env.HMSH_XCLAIM_DELAY_MS, 10) || 1000 * 60;
-export const HMSH_XCLAIM_COUNT = parseInt(process.env.HMSH_XCLAIM_COUNT, 10) || 3;
-export const HMSH_XPENDING_COUNT = parseInt(process.env.HMSH_XPENDING_COUNT, 10) || 10;
-
-// TASK WORKER
-export const HMSH_EXPIRE_DURATION = parseInt(process.env.HMSH_EXPIRE_DURATION, 10) || 1;
-
-const BASE_FIDELITY_SECONDS = 5;
-const TEST_FIDELITY_SECONDS = 1;
-export const HMSH_FIDELITY_SECONDS = process.env.HMSH_FIDELITY_SECONDS ? parseInt(process.env.HMSH_FIDELITY_SECONDS, 10) : (process.env.NODE_ENV === 'test' ? TEST_FIDELITY_SECONDS : BASE_FIDELITY_SECONDS);
-
-export const HMSH_SCOUT_INTERVAL_SECONDS = parseInt(process.env.HMSH_SCOUT_INTERVAL_SECONDS, 10) || 60;

package/modules/errors.ts

@@ -1,280 +0,0 @@
-import {
-  HMSH_CODE_DURABLE_MAXED,
-  HMSH_CODE_DURABLE_TIMEOUT,
-  HMSH_CODE_DURABLE_FATAL,
-  HMSH_CODE_NOTFOUND,
-  HMSH_CODE_DURABLE_RETRYABLE,
-  HMSH_CODE_DURABLE_WAIT,
-  HMSH_CODE_DURABLE_PROXY,
-  HMSH_CODE_DURABLE_CHILD,
-  HMSH_CODE_DURABLE_ALL,
-  HMSH_CODE_DURABLE_SLEEP } from "./enums";
-import { ActivityDuplex } from "../types/activity";
-import { CollationFaultType, CollationStage } from "../types/collator";
-import {
-  DurableChildErrorType,
-  DurableProxyErrorType,
-  DurableSleepErrorType,
-  DurableWaitForAllErrorType,
-  DurableWaitForErrorType } from "../types/error";
-
-class GetStateError extends Error {
-  jobId: string;
-  code = HMSH_CODE_NOTFOUND;
-  constructor(jobId: string) {
-    super(`${jobId} Not Found`);
-    this.jobId = jobId;
-  }
-}
-class SetStateError extends Error {
-  constructor() {
-    super("Error occurred while setting job state");
-  }
-}
-
-class DurableWaitForError extends Error {
-  code: number;
-  signalId: string;
-  workflowId: string;
-  index: number;
-  workflowDimension: string; //hook workflowDimension (e.g., ',0,1,0') (use empty string for `null`)
-  constructor(params: DurableWaitForErrorType) {
-    super(`WaitFor Interruption`);
-    this.signalId = params.signalId;
-    this.index = params.index;
-    this.workflowDimension = params.workflowDimension;
-    this.code = HMSH_CODE_DURABLE_WAIT;
-  }
-}
-
-class DurableProxyError extends Error {
-  activityName: string;
-  arguments: string[];
-  backoffCoefficient: number;
-  code: number;
-  index: number;
-  maximumAttempts: number;
-  maximumInterval: number;
-  originJobId: string | null;
-  parentWorkflowId: string;
-  workflowDimension: string;
-  workflowId: string;
-  workflowTopic: string;
-  constructor(params: DurableProxyErrorType) {
-    super(`ProxyActivity Interruption`);
-    this.arguments = params.arguments;
-    this.workflowId = params.workflowId;
-    this.workflowTopic = params.workflowTopic;
-    this.parentWorkflowId = params.parentWorkflowId;
-    this.originJobId = params.originJobId;
-    this.index = params.index;
-    this.activityName = params.activityName;
-    this.workflowDimension = params.workflowDimension;
-    this.backoffCoefficient = params.backoffCoefficient;
-    this.maximumAttempts = params.maximumAttempts;
-    this.maximumInterval = params.maximumInterval;
-    this.code = HMSH_CODE_DURABLE_PROXY;
-  }
-}
-
-class DurableChildError extends Error {
-  await: boolean;
-  arguments: string[];
-  backoffCoefficient: number;
-  code: number;
-  workflowDimension: string;
-  index: number;
-  maximumAttempts: number;
-  maximumInterval: number;
-  originJobId: string | null;
-  parentWorkflowId: string;
-  workflowId: string;
-  workflowTopic: string;
-  constructor(params: DurableChildErrorType) {
-    super(`ExecChild Interruption`);
-    this.arguments = params.arguments;
-    this.workflowId = params.workflowId;
-    this.workflowTopic = params.workflowTopic;
-    this.parentWorkflowId = params.parentWorkflowId;
-    this.originJobId = params.originJobId;
-    this.index = params.index;
-    this.workflowDimension = params.workflowDimension;
-    this.code = HMSH_CODE_DURABLE_CHILD;
-    this.await = params.await;
-    this.backoffCoefficient = params.backoffCoefficient;
-    this.maximumAttempts = params.maximumAttempts;
-    this.maximumInterval = params.maximumInterval;
-  }
-}
-
-class DurableWaitForAllError extends Error {
-  items: any[];
-  code: number;
-  workflowDimension: string;
-  size: number;
-  index: number;
-  originJobId: string | null;
-  parentWorkflowId: string;
-  workflowId: string;
-  workflowTopic: string;
-  constructor(params: DurableWaitForAllErrorType) {
-    super(`Collation Interruption`);
-    this.items = params.items;
-    this.size = params.size;
-    this.workflowId = params.workflowId;
-    this.workflowTopic = params.workflowTopic;
-    this.parentWorkflowId = params.parentWorkflowId;
-    this.originJobId = params.originJobId;
-    this.index = params.index;
-    this.workflowDimension = params.workflowDimension;
-    this.code = HMSH_CODE_DURABLE_ALL;
-  }
-}
-
-class DurableSleepError extends Error {
-  workflowId: string;
-  code: number;
-  duration: number; //seconds
-  index: number;
-  workflowDimension: string; //empty string for null
-  constructor(params: DurableSleepErrorType) {
-    super(`SleepFor Interruption`);
-    this.duration = params.duration;
-    this.workflowId = params.workflowId;
-    this.index = params.index;
-    this.workflowDimension = params.workflowDimension;
-    this.code = HMSH_CODE_DURABLE_SLEEP;
-  }
-}
-
-class DurableTimeoutError extends Error {
-  code: number;
-  constructor(message: string, stack?: string) {
-    super(message);
-    if (this.stack) {
-      this.stack = stack;
-    }
-    this.code = HMSH_CODE_DURABLE_TIMEOUT;
-  }
-}
-class DurableMaxedError extends Error {
-  code: number;
-  constructor(message: string, stackTrace?: string) {
-    super(message);
-    if (stackTrace) {
-      this.stack = stackTrace;
-    }
-    this.code = HMSH_CODE_DURABLE_MAXED;
-  }
-}
-class DurableFatalError extends Error {
-  code: number;
-  constructor(message: string, stackTrace?: string) {
-    super(message);
-    if (stackTrace) {
-      this.stack = stackTrace;
-    }
-    this.code = HMSH_CODE_DURABLE_FATAL;
-  }
-}
-class DurableRetryError extends Error {
-  code: number;
-  constructor(message: string, stackTrace?: string) {
-    super(message);
-    if (stackTrace) {
-      this.stack = stackTrace;
-    }
-    this.code = HMSH_CODE_DURABLE_RETRYABLE;
-  }
-}
-
-class MapDataError extends Error {
-  constructor() {
-    super("Error occurred while mapping data");
-  }
-}
-
-class RegisterTimeoutError extends Error {
-  constructor() {
-    super("Error occurred while registering activity timeout");
-  }
-}
-
-class DuplicateJobError extends Error {
-  jobId: string;
-  constructor(jobId: string) {
-    super("Duplicate job");
-    this.jobId = jobId;
-    this.message = `Duplicate job: ${jobId}`;
-  }
-}
-class InactiveJobError extends Error {
-  jobId: string;
-  activityId: string;
-  status: number; //non-positive integer
-  constructor(jobId: string, status: number, activityId: string) {
-    super("Inactive job");
-    this.jobId = jobId;
-    this.activityId = activityId;
-    this.message = `Inactive job: ${jobId}`;
-    this.status = status;
-  }
-}
-class GenerationalError extends Error {
-  expected: string;
-  actual: string;
-  jobId: string;
-  activityId: string;
-  dimensionalAddress: string;
-
-  constructor(expected: string, actual: string, jobId: string, activityId: string, dimensionalAddress: string) {
-    super("Generational Error");
-    this.expected = expected;
-    this.actual = actual;
-    this.jobId = jobId;
-    this.activityId = activityId;
-    this.dimensionalAddress = dimensionalAddress;
-  }
-}
-
-class ExecActivityError extends Error {
-  constructor() {
-    super("Error occurred while executing activity");
-  }
-}
-
-class CollationError extends Error {
-  status: number; //15-digit activity collation integer (889000001000001)
-  leg: ActivityDuplex;
-  stage: CollationStage; //enter | exit | confirm
-  fault: CollationFaultType; //missing, invalid, etc
-
-  constructor(status: number, leg: ActivityDuplex, stage: CollationStage, fault?: CollationFaultType) {
-    super("collation-error");
-    this.leg = leg;
-    this.status = status;
-    this.stage = stage;
-    this.fault = fault;
-  }
-}
-
-export {
-  CollationError,
-  DurableChildError,
-  DurableFatalError,
-  DurableMaxedError,
-  DurableProxyError,
-  DurableRetryError,
-  DurableSleepError,
-  DurableTimeoutError,
-  DurableWaitForAllError,
-  DurableWaitForError,
-  DuplicateJobError,
-  ExecActivityError,
-  GenerationalError,
-  GetStateError,
-  InactiveJobError,
-  MapDataError,
-  RegisterTimeoutError,
-  SetStateError,
-};