@helmr/sdk 0.1.1-rc.4 → 0.1.1-rc.5

package/dist/internal.d.ts

@@ -1,3 +1,7 @@
+import { type PayloadSchemaInput, type PayloadSchemaOutput, type PayloadSchema } from "./schema/payload.js";
+import type { IdempotencyKeyInput } from "./idempotency.js";
+import type { RunHandle } from "./runtime/run.js";
+export { parsePayloadWithSchema } from "./schema/payload.js";
 export interface CacheMount {
     readonly id: string;
 }
@@ -61,13 +65,38 @@ export interface WorkspaceCapabilities {
         readonly subpath?: string;
     }): WorkspaceSpec;
 }
-export declare class ApprovalTimeoutError extends Error {
-    constructor(message: string);
-    static [Symbol.hasInstance](value: unknown): boolean;
+export type WaitJson = null | boolean | number | string | readonly WaitJson[] | {
+    readonly [key: string]: WaitJson;
+};
+export interface WaitOptions {
+    readonly timeout?: number;
+    readonly policy?: string;
+    readonly displayText?: string;
 }
-export declare class MessageTimeoutError extends Error {
-    constructor(message: string);
-    static [Symbol.hasInstance](value: unknown): boolean;
+export interface WaitManualOptions<TSchema extends PayloadSchema<any, any> = PayloadSchema<any, any>> extends WaitOptions {
+    readonly schema?: TSchema;
+}
+export interface WaitResolution<TPayload = unknown> {
+    readonly kind: string;
+    readonly payload: TPayload;
+    readonly at: Date;
+    readonly principal?: string;
+}
+export type WaitForInput = string | number | {
+    readonly seconds?: number;
+    readonly milliseconds?: number;
+    readonly duration?: string;
+    readonly [key: string]: WaitJson | undefined;
+};
+export type WaitUntilInput = string | Date | {
+    readonly date?: string | Date;
+    readonly [key: string]: WaitJson | Date | undefined;
+};
+export interface WaitCapabilities {
+    for(input: WaitForInput, opts?: Omit<WaitOptions, "timeout" | "policy">): Promise<void>;
+    until(input: WaitUntilInput, opts?: Omit<WaitOptions, "timeout" | "policy">): Promise<void>;
+    manual<TSchema extends PayloadSchema<any, any>>(opts: WaitManualOptions<TSchema>): Promise<PayloadSchemaOutput<TSchema>>;
+    manual<TPayload = unknown>(opts?: WaitManualOptions): Promise<TPayload>;
 }
 export declare class ConcurrentWaitError extends Error {
     constructor(message: string);
@@ -87,25 +116,7 @@ export type Placement = {
 export type SecretDecls = Record<string, Placement>;
 export declare function validateSecretName(name: string, label?: string): void;
 export interface TaskContext {
-    readonly wait: {
-        approval(message: string, opts?: {
-            readonly timeout?: number;
-            readonly policy?: string;
-        }): Promise<{
-            readonly approved: boolean;
-            readonly approvedBy: string;
-            readonly at: Date;
-        }>;
-        message(prompt?: string, opts?: {
-            readonly timeout?: number;
-            readonly policy?: string;
-        }): Promise<{
-            readonly text: string;
-            readonly sentBy: string;
-            readonly at: Date;
-            readonly attachments: readonly unknown[];
-        }>;
-    };
+    readonly wait: WaitCapabilities;
     emit(event: EmitEvent): void;
     readonly log: {
         info(...args: unknown[]): void;
@@ -146,17 +157,98 @@ export interface EmitEvent {
     readonly content: readonly EmitContent[];
 }
 export type MaybePromise<T> = T | Promise<T>;
-export interface TaskConfig<TPayload = unknown, TOutput = unknown, TSecrets extends SecretDecls = Record<never, never>> {
+declare const noPayloadBrand: unique symbol;
+export interface NoPayload {
+    readonly [noPayloadBrand]: "NoPayload";
+}
+export interface TaskConfigBase<TSecrets extends SecretDecls = Record<never, never>> {
     readonly id: string;
     readonly sandbox: SandboxBuilder;
     readonly maxDuration?: number;
+    readonly queue?: TaskQueueConfig;
+    readonly ttl?: string;
     readonly secrets?: TSecrets;
-    readonly run: (payload: TPayload, ctx: TaskContext) => MaybePromise<TOutput>;
 }
-export type Task<TPayload = unknown, TOutput = unknown, TSecrets extends SecretDecls = Record<never, never>> = TaskConfig<TPayload, TOutput, TSecrets>;
-export type AnyTask = Task<any, any, SecretDecls>;
-export type TaskPayload<TTask> = TTask extends Task<infer TPayload, any, any> ? TPayload : never;
-export type TaskOutput<TTask> = TTask extends Task<any, infer TOutput, any> ? Awaited<TOutput> : never;
+export interface TaskQueueConfig {
+    readonly name?: string;
+    readonly concurrencyLimit?: number | null;
+}
+export interface InternalTaskScheduleConfig {
+    readonly cron: string;
+    readonly timezone?: string;
+    readonly secretBindings?: Record<string, string>;
+    readonly workspace: WorkspaceSpec;
+}
+export type TaskRunOptions<TSecrets extends SecretDecls> = {
+    readonly workspace: WorkspaceSpec;
+    readonly deploymentId?: string;
+    readonly version?: string;
+    readonly queue?: string;
+    readonly concurrencyKey?: string;
+    readonly priority?: number;
+    readonly ttl?: string;
+    readonly idempotencyKey?: IdempotencyKeyInput;
+    readonly idempotencyKeyTTL?: string;
+} & ([keyof TSecrets] extends [never] ? {
+    readonly secrets?: Record<never, never>;
+} : {
+    readonly secrets: {
+        readonly [K in keyof TSecrets]: string;
+    };
+});
+export type TaskDirectTrigger<TPayloadInput, TOutput, TSecrets extends SecretDecls> = [TPayloadInput] extends [NoPayload] ? (opts: TaskRunOptions<TSecrets>) => Promise<RunHandle<Awaited<TOutput>>> : (payload: TPayloadInput, opts: TaskRunOptions<TSecrets>) => Promise<RunHandle<Awaited<TOutput>>>;
+export type TaskConfigWithPayload<TPayloadSchema extends PayloadSchema<any, any>, TOutput = unknown, TSecrets extends SecretDecls = Record<never, never>> = TaskConfigBase<TSecrets> & {
+    readonly payload: TPayloadSchema;
+    readonly run: (payload: PayloadSchemaOutput<TPayloadSchema>, ctx: TaskContext) => MaybePromise<TOutput>;
+};
+export type TaskConfigWithoutPayload<TOutput = unknown, TSecrets extends SecretDecls = Record<never, never>> = TaskConfigBase<TSecrets> & {
+    readonly payload?: undefined;
+    readonly run: (ctx: TaskContext) => MaybePromise<TOutput>;
+};
+export type TaskConfig<TPayload = NoPayload, TOutput = unknown, TSecrets extends SecretDecls = Record<never, never>, TPayloadSchema extends PayloadSchema<any, any> | undefined = undefined> = TPayloadSchema extends PayloadSchema<any, any> ? TaskConfigWithPayload<TPayloadSchema, TOutput, TSecrets> : TaskConfigWithoutPayload<TOutput, TSecrets>;
+export type Task<TPayload = NoPayload, TOutput = unknown, TSecrets extends SecretDecls = Record<never, never>, TPayloadInput = TPayload> = TaskConfigBase<TSecrets> & {
+    readonly "~types"?: {
+        readonly payloadInput: TPayloadInput;
+        readonly payload: TPayload;
+        readonly output: TOutput;
+        readonly secrets: TSecrets;
+    };
+    readonly payload?: PayloadSchema<TPayloadInput, TPayload>;
+    readonly run: [TPayloadInput] extends [NoPayload] ? (ctx: TaskContext) => MaybePromise<TOutput> : (payload: TPayload, ctx: TaskContext) => MaybePromise<TOutput>;
+    readonly trigger: TaskDirectTrigger<TPayloadInput, TOutput, TSecrets>;
+};
+export type AnyTask = TaskConfigBase<SecretDecls> & {
+    readonly schedule?: InternalTaskScheduleConfig;
+    readonly "~types"?: {
+        readonly payloadInput: any;
+        readonly payload: any;
+        readonly output: any;
+        readonly secrets: SecretDecls;
+    };
+    readonly payload?: PayloadSchema<any, any>;
+    readonly run: (...args: any[]) => MaybePromise<any>;
+    readonly trigger: (...args: any[]) => Promise<RunHandle<any>>;
+};
+export type TaskPayload<TTask> = TTask extends {
+    readonly "~types"?: {
+        readonly payload: infer TPayload;
+    };
+} ? [TPayload] extends [NoPayload] ? never : TPayload : never;
+export type TaskTriggerPayload<TTask> = TTask extends {
+    readonly "~types"?: {
+        readonly payloadInput: infer TPayloadInput;
+    };
+} ? TPayloadInput : never;
+export type TaskOutput<TTask> = TTask extends {
+    readonly "~types"?: {
+        readonly output: infer TOutput;
+    };
+} ? Awaited<TOutput> : never;
+export type TaskSecrets<TTask> = TTask extends {
+    readonly "~types"?: {
+        readonly secrets: infer TSecrets;
+    };
+} ? TSecrets : never;
 export declare const taskBrand: unique symbol;
 export declare const taskOriginBrand: unique symbol;
 export declare const configBrand: unique symbol;
@@ -217,7 +309,14 @@ export interface SandboxResources {
     readonly cpu?: number;
     readonly memory?: string;
 }
-export declare function markTask<TPayload, TOutput, TSecrets extends SecretDecls>(config: TaskConfig<TPayload, TOutput, TSecrets>): Task<TPayload, Awaited<TOutput>, TSecrets>;
+export type MarkedTask<TPayload, TOutput, TSecrets extends SecretDecls, TPayloadSchema extends PayloadSchema<any, any> | undefined> = TPayloadSchema extends PayloadSchema<any, any> ? Task<PayloadSchemaOutput<TPayloadSchema>, Awaited<TOutput>, TSecrets, PayloadSchemaInput<TPayloadSchema>> : Task<NoPayload, Awaited<TOutput>, TSecrets, NoPayload>;
+export declare function markTask<TPayload, TOutput, TSecrets extends SecretDecls, TPayloadSchema extends PayloadSchema<any, any> | undefined>(config: TaskConfig<TPayload, TOutput, TSecrets, TPayloadSchema>): MarkedTask<TPayload, TOutput, TSecrets, TPayloadSchema>;
+export declare function markScheduledTask<TPayload, TOutput, TSecrets extends SecretDecls, TPayloadSchema extends PayloadSchema<any, any> | undefined>(config: TaskConfig<TPayload, TOutput, TSecrets, TPayloadSchema>, schedule: InternalTaskScheduleConfig | undefined): MarkedTask<TPayload, TOutput, TSecrets, TPayloadSchema>;
+export declare function validateTaskSchedule(taskId: string, value: InternalTaskScheduleConfig | undefined): void;
+export declare function validateTaskQueue(taskId: string, value: TaskQueueConfig | undefined): void;
+export declare function defaultTaskQueueName(taskId: string): string;
+export declare function validateOptionalTTL(value: unknown, label?: string): void;
+export declare function parseTaskPayload<TTask extends AnyTask>(task: TTask, payload: unknown): Promise<TaskPayload<TTask>>;
 export declare function isTaskDefinition(value: unknown): value is AnyTask & {
     readonly [taskBrand]: true;
 };

package/dist/internal.js

@@ -1,9 +1,92 @@
+// sdk/typescript/src/schema/payload.ts
+var payloadSchemaValidationErrorBrand = Symbol.for("helmr.sdk.PayloadSchemaValidationError");
+
+class PayloadSchemaValidationError extends Error {
+  issues;
+  constructor(label, issues) {
+    super(formatPayloadSchemaValidationMessage(label, issues));
+    this.name = "PayloadSchemaValidationError";
+    this.issues = issues;
+    Object.defineProperty(this, payloadSchemaValidationErrorBrand, { value: true });
+  }
+  static [Symbol.hasInstance](value) {
+    return this === PayloadSchemaValidationError && typeof value === "object" && value !== null && payloadSchemaValidationErrorBrand in value;
+  }
+}
+function assertPayloadSchema(value, label = "payload") {
+  if (value === undefined) {
+    return;
+  }
+  assertStandardSchema(value, label);
+}
+function assertStandardSchema(value, label = "schema") {
+  if (value === null || typeof value !== "object" && typeof value !== "function") {
+    throw new Error(`${label} must implement the Standard Schema v1 interface`);
+  }
+  const standard = value["~standard"];
+  if (standard === null || typeof standard !== "object") {
+    throw new Error(`${label} must implement the Standard Schema v1 interface`);
+  }
+  const record = standard;
+  if (record["version"] !== 1 || typeof record["validate"] !== "function") {
+    throw new Error(`${label} must implement the Standard Schema v1 interface`);
+  }
+}
+async function parsePayloadWithSchema(schema, payload, label) {
+  assertStandardSchema(schema, label);
+  const result = await schema["~standard"].validate(payload);
+  if ("issues" in result && result.issues !== undefined) {
+    throw new PayloadSchemaValidationError(label, result.issues);
+  }
+  return result.value;
+}
+function formatPayloadSchemaValidationMessage(label, issues) {
+  if (issues.length === 0) {
+    return `${label} failed validation`;
+  }
+  const formattedIssues = issues.slice(0, 5).map(formatPayloadSchemaIssue);
+  const suffix = issues.length > formattedIssues.length ? `; and ${issues.length - formattedIssues.length} more` : "";
+  return `${label} failed validation: ${formattedIssues.join("; ")}${suffix}`;
+}
+function formatPayloadSchemaIssue(issue) {
+  const path = formatPayloadSchemaIssuePath(issue.path);
+  return path === "" ? issue.message : `${path}: ${issue.message}`;
+}
+function formatPayloadSchemaIssuePath(path) {
+  if (path === undefined || path.length === 0) {
+    return "";
+  }
+  let formatted = "payload";
+  for (const segment of path) {
+    const key = typeof segment === "object" && segment !== null && "key" in segment ? segment.key : segment;
+    if (typeof key === "string" && /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key)) {
+      formatted += `.${key}`;
+    } else if (typeof key === "string" && isArrayIndexKey(key)) {
+      formatted += `[${key}]`;
+    } else if (typeof key === "number") {
+      formatted += `[${key}]`;
+    } else {
+      formatted += `[${JSON.stringify(String(key))}]`;
+    }
+  }
+  return formatted;
+}
+function isArrayIndexKey(value) {
+  if (!/^(0|[1-9]\d*)$/.test(value)) {
+    return false;
+  }
+  const parsed = Number(value);
+  return Number.isSafeInteger(parsed);
+}
+
 // sdk/typescript/src/schema/task.ts
 var TASK_ID_PATTERN = "^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$";
 var TASK_ID_MAX_LENGTH = 128;
 var DEFAULT_MAX_DURATION_SECONDS = 900;
 var MIN_MAX_DURATION_SECONDS = 5;
 var MAX_DURATION_SECONDS = 86400;
+var QUEUE_NAME_PATTERN = "^[A-Za-z0-9][A-Za-z0-9._/-]{0,255}$";
+var QUEUE_NAME_MAX_LENGTH = 256;
 
 class TaskIdError extends Error {
   name = "TaskIdError";
@@ -57,36 +140,60 @@ function readOptionalMaxDurationSeconds(value, label = "task maxDuration") {
 function validateOptionalMaxDurationSeconds(value, label = "task maxDuration") {
   readOptionalMaxDurationSeconds(value, label);
 }
-function isAsciiAlnum(code) {
-  return code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122;
-}
 
-// sdk/typescript/src/internal.ts
-var approvalTimeoutErrorBrand = Symbol.for("helmr.sdk.ApprovalTimeoutError");
-var messageTimeoutErrorBrand = Symbol.for("helmr.sdk.MessageTimeoutError");
-var concurrentWaitErrorBrand = Symbol.for("helmr.sdk.ConcurrentWaitError");
+class TaskQueueNameError extends Error {
+  name = "TaskQueueNameError";
+  value;
+  constructor(value) {
+    super(`queue name must match ${QUEUE_NAME_PATTERN}: ${JSON.stringify(value)}`);
+    this.value = value;
+  }
+}
 
-class ApprovalTimeoutError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "ApprovalTimeoutError";
-    Object.defineProperty(this, approvalTimeoutErrorBrand, { value: true });
+class TaskQueueConcurrencyLimitError extends Error {
+  name = "TaskQueueConcurrencyLimitError";
+  value;
+  constructor(value) {
+    super("queue concurrencyLimit must be a positive integer");
+    this.value = value;
   }
-  static [Symbol.hasInstance](value) {
-    return this === ApprovalTimeoutError && typeof value === "object" && value !== null && approvalTimeoutErrorBrand in value;
+}
+function validateQueueName(value) {
+  if (!isValidQueueName(value)) {
+    throw new TaskQueueNameError(value);
   }
 }
-
-class MessageTimeoutError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "MessageTimeoutError";
-    Object.defineProperty(this, messageTimeoutErrorBrand, { value: true });
+function isValidQueueName(value) {
+  if (value.length === 0 || value.length > QUEUE_NAME_MAX_LENGTH) {
+    return false;
   }
-  static [Symbol.hasInstance](value) {
-    return this === MessageTimeoutError && typeof value === "object" && value !== null && messageTimeoutErrorBrand in value;
+  const first = value.charCodeAt(0);
+  if (!isAsciiAlnum(first)) {
+    return false;
+  }
+  for (let index = 1;index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (!(isAsciiAlnum(code) || code === 46 || code === 95 || code === 45 || code === 47)) {
+      return false;
+    }
   }
+  return true;
 }
+function validateOptionalQueueConcurrencyLimit(value) {
+  if (value === undefined || value === null) {
+    return;
+  }
+  if (typeof value === "number" && Number.isInteger(value) && Number.isFinite(value) && value > 0) {
+    return;
+  }
+  throw new TaskQueueConcurrencyLimitError(value);
+}
+function isAsciiAlnum(code) {
+  return code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122;
+}
+
+// sdk/typescript/src/internal.ts
+var concurrentWaitErrorBrand = Symbol.for("helmr.sdk.ConcurrentWaitError");
 
 class ConcurrentWaitError extends Error {
   constructor(message) {
@@ -162,12 +269,139 @@ var sandboxBuilderBrand = Symbol.for("helmr.sdk.SandboxBuilder");
 var sourceFileRefBrand = Symbol.for("helmr.sdk.SourceFileRef");
 var sourceDirRefBrand = Symbol.for("helmr.sdk.SourceDirRef");
 function markTask(config) {
+  if ("schedule" in config) {
+    throw new Error(`task ${JSON.stringify(config.id)} must use schedules.task(...) for declarative schedules`);
+  }
+  return markTaskInternal(config, undefined);
+}
+function markScheduledTask(config, schedule) {
+  return markTaskInternal(config, schedule);
+}
+function markTaskInternal(config, schedule) {
   validateTaskId(config.id);
   validateOptionalMaxDurationSeconds(config.maxDuration);
+  validateTaskQueue(config.id, config.queue);
+  validateTaskSchedule(config.id, schedule);
+  validateOptionalTTL(config.ttl, `task ${JSON.stringify(config.id)} ttl`);
+  assertPayloadSchema(config.payload, `task ${JSON.stringify(config.id)} payload`);
+  if (schedule !== undefined) {
+    Object.defineProperty(config, "schedule", {
+      value: Object.freeze({ ...schedule }),
+      enumerable: true
+    });
+  }
   Object.defineProperty(config, taskBrand, { value: true });
   Object.defineProperty(config, taskOriginBrand, { value: captureTaskOrigin() });
   return config;
 }
+function validateTaskSchedule(taskId, value) {
+  if (value === undefined) {
+    return;
+  }
+  if (value.cron.trim() === "") {
+    throw new Error(`task ${JSON.stringify(taskId)} schedule cron is required`);
+  }
+  if (value.timezone !== undefined && value.timezone.trim() === "") {
+    throw new Error(`task ${JSON.stringify(taskId)} schedule timezone must not be empty`);
+  }
+  if (value.workspace.kind !== "github") {
+    throw new Error(`task ${JSON.stringify(taskId)} schedule workspace must be workspace.github(...)`);
+  }
+  if (value.secretBindings !== undefined) {
+    if (value.secretBindings === null || typeof value.secretBindings !== "object" || Array.isArray(value.secretBindings)) {
+      throw new Error(`task ${JSON.stringify(taskId)} schedule secretBindings must be an object`);
+    }
+    for (const [name, binding] of Object.entries(value.secretBindings)) {
+      validateSecretName(name, `task ${JSON.stringify(taskId)} schedule secretBindings.${name}`);
+      if (typeof binding !== "string" || binding.trim() === "") {
+        throw new Error(`task ${JSON.stringify(taskId)} schedule secretBindings.${name} must be a non-empty string`);
+      }
+    }
+  }
+}
+function validateTaskQueue(taskId, value) {
+  if (value === undefined) {
+    return;
+  }
+  if (value.name !== undefined) {
+    validateQueueName(value.name);
+  }
+  validateOptionalQueueConcurrencyLimit(value.concurrencyLimit);
+  if (value.name === undefined && value.concurrencyLimit === undefined) {
+    throw new Error(`task ${JSON.stringify(taskId)} queue must include name or concurrencyLimit`);
+  }
+}
+function defaultTaskQueueName(taskId) {
+  return `task/${taskId}`;
+}
+function validateOptionalTTL(value, label = "ttl") {
+  if (value === undefined) {
+    return;
+  }
+  if (typeof value === "string" && isPositiveDurationString(value)) {
+    return;
+  }
+  throw new Error(`${label} must be a positive duration string`);
+}
+function isPositiveDurationString(value) {
+  const raw = value.trim();
+  if (raw === "") {
+    return false;
+  }
+  if (/^[1-9][0-9]*d$/.test(raw)) {
+    return true;
+  }
+  const sign = raw.startsWith("+") || raw.startsWith("-") ? raw.slice(0, 1) : "";
+  if (sign === "-") {
+    return false;
+  }
+  const body = sign === "" ? raw : raw.slice(1);
+  const tokenPattern = /([0-9]+(?:\.[0-9]*)?|\.[0-9]+)(ns|us|µs|μs|ms|s|m|h)/gy;
+  let totalNanoseconds = 0;
+  let offset = 0;
+  for (;; ) {
+    tokenPattern.lastIndex = offset;
+    const match = tokenPattern.exec(body);
+    if (match === null) {
+      return offset === body.length && totalNanoseconds >= 1;
+    }
+    if (match.index !== offset) {
+      return false;
+    }
+    const amount = Number(match[1]);
+    if (!Number.isFinite(amount) || amount < 0) {
+      return false;
+    }
+    totalNanoseconds += amount * durationUnitNanoseconds(match[2] ?? "");
+    offset = tokenPattern.lastIndex;
+  }
+}
+function durationUnitNanoseconds(unit) {
+  switch (unit) {
+    case "ns":
+      return 1;
+    case "us":
+    case "µs":
+    case "μs":
+      return 1000;
+    case "ms":
+      return 1e6;
+    case "s":
+      return 1e9;
+    case "m":
+      return 60000000000;
+    case "h":
+      return 3600000000000;
+    default:
+      return 0;
+  }
+}
+async function parseTaskPayload(task, payload) {
+  if (task.payload === undefined) {
+    throw new Error(`task ${JSON.stringify(task.id)} does not accept payload`);
+  }
+  return await parsePayloadWithSchema(task.payload, payload, `task ${JSON.stringify(task.id)} payload`);
+}
 function isTaskDefinition(value) {
   return hasBrand(value, taskBrand);
 }
@@ -322,11 +556,17 @@ function hasBrand(value, brand) {
   return value !== null && typeof value === "object" && value[brand] === true;
 }
 export {
+  validateTaskSchedule,
+  validateTaskQueue,
   validateSecretName,
+  validateOptionalTTL,
   taskOriginFile,
   taskOriginBrand,
   taskBrand,
+  parseTaskPayload,
+  parsePayloadWithSchema,
   markTask,
+  markScheduledTask,
   markConfig,
   isTaskDefinition,
   isSourceFileRef,
@@ -334,12 +574,11 @@ export {
   isSandboxBuilder,
   isImageBuilder,
   isConfigDefinition,
+  defaultTaskQueueName,
   configBrand,
   SourceFileRefImpl,
   SourceDirRefImpl,
   SandboxBuilderImpl,
-  MessageTimeoutError,
   ImageBuilderImpl,
-  ConcurrentWaitError,
-  ApprovalTimeoutError
+  ConcurrentWaitError
 };