@trigger.dev/sdk 3.0.0-beta.11 → 3.0.0-beta.13

package/dist/v3/index.d.mts

@@ -1,5 +1,5 @@
-import { TaskRunContext, InitOutput, RetryOptions, QueueOptions, MachineCpu, MachineMemory, RunFnParams, InitFnParams, HandleErrorFnParams, HandleErrorResult, MiddlewareFnParams, SuccessFnParams, FetchRetryOptions, ReplayRunResponse, CanceledRunResponse } from '@trigger.dev/core/v3';
-export { HandleErrorArgs, HandleErrorFunction, LogLevel, RetryOptions, ProjectConfig as TriggerConfig, logger } from '@trigger.dev/core/v3';
+import { TaskRunContext, QueueOptions, InitOutput, RetryOptions, MachineCpu, MachineMemory, RunFnParams, InitFnParams, HandleErrorFnParams, HandleErrorResult, MiddlewareFnParams, SuccessFnParams, FetchRetryOptions, ReplayRunResponse, CanceledRunResponse, ScheduledTaskPayload, CreateScheduleOptions, ScheduleObject, UpdateScheduleOptions, DeletedScheduleObject, ListScheduleOptions, ListSchedulesResult } from '@trigger.dev/core/v3';
+export { APIError, AuthenticationError, BadRequestError, ConflictError, HandleErrorArgs, HandleErrorFunction, InternalServerError, LogLevel, NotFoundError, PermissionDeniedError, RateLimitError, RetryOptions, ProjectConfig as TriggerConfig, UnprocessableEntityError, logger } from '@trigger.dev/core/v3';
 import { HttpHandler } from 'msw';
 
 type Context = TaskRunContext;
@@ -9,6 +9,9 @@ type RequireOne<T, K extends keyof T> = {
     [P in K]-?: T[P];
 };
 type Queue = RequireOne<QueueOptions, "name">;
+declare function queue(options: {
+    name: string;
+} & QueueOptions): Queue;
 type TaskOptions<TPayload, TOutput = any, TInitOutput extends InitOutput = any> = {
     /** An id for your task. This must be unique inside your project and not change between versions.  */
     id: string;
@@ -125,7 +128,8 @@ type BatchResult<TOutput = any> = {
     id: string;
     runs: TaskRunResult<TOutput>[];
 };
-type Task<TInput, TOutput = any> = {
+interface Task<TInput, TOutput = any> {
+    id: string;
     trigger: (params: {
         payload: TInput;
         options?: TaskRunOptions;
@@ -148,7 +152,7 @@ type Task<TInput, TOutput = any> = {
         }[];
         batchOptions?: BatchRunOptions;
     }) => Promise<BatchResult<TOutput>>;
-};
+}
 type TaskRunOptions = {
     idempotencyKey?: string;
     maxAttempts?: number;
@@ -180,7 +184,7 @@ type BatchRunOptions = TaskRunOptions & {
  *
  * @returns A task that can be triggered
  */
-declare function task<TInput, TOutput = any, TInitOutput extends InitOutput = any>(options: TaskOptions<TInput, TOutput, TInitOutput>): Task<TInput, TOutput>;
+declare function task$1<TInput, TOutput = any, TInitOutput extends InitOutput = any>(options: TaskOptions<TInput, TOutput, TInitOutput>): Task<TInput, TOutput>;
 
 type WaitOptions = {
     seconds: number;
@@ -258,4 +262,67 @@ declare const runs: {
 declare function replayRun(runId: string): Promise<ReplayRunResponse>;
 declare function cancelRun(runId: string): Promise<CanceledRunResponse>;
 
-export { type CacheEntry, type CacheFunction, type CacheMetadata, type CacheStore, type Context, type Eventually, InMemoryCache, type WaitOptions, createCache, retry, runs, task, wait };
+declare function task<TOutput, TInitOutput extends InitOutput>(params: TaskOptions<ScheduledTaskPayload, TOutput, TInitOutput>): Task<ScheduledTaskPayload, TOutput>;
+/**
+ * Creates a new schedule
+ * @param options
+ * @param options.task - The identifier of the task to be scheduled (Must already exist and be a scheduled task)
+ * @param options.cron - The cron expression for the schedule (e.g. `0 0 * * *`)
+ * @param options.externalId - An optional external identifier for the schedule
+ * @param options.deduplicationKey - An optional deduplication key for the schedule
+ * @returns The created schedule
+ */
+declare function create(options: CreateScheduleOptions): Promise<ScheduleObject>;
+/**
+ * Retrieves a schedule
+ * @param scheduleId - The ID of the schedule to retrieve
+ * @returns The retrieved schedule
+ */
+declare function retrieve(scheduleId: string): Promise<ScheduleObject>;
+/**
+ * Updates a schedule
+ * @param scheduleId - The ID of the schedule to update
+ * @param options - The updated schedule options
+ * @param options.task - The identifier of the task to be scheduled (Must already exist and be a scheduled task)
+ * @param options.cron - The cron expression for the schedule (e.g. `0 0 * * *`)
+ * @param options.externalId - An optional external identifier for the schedule
+ * @returns The updated schedule
+ */
+declare function update(scheduleId: string, options: UpdateScheduleOptions): Promise<ScheduleObject>;
+/**
+ * Deletes a schedule
+ * @param scheduleId - The ID of the schedule to delete
+ */
+declare function del(scheduleId: string): Promise<DeletedScheduleObject>;
+/**
+ * Deactivates a schedule
+ * @param scheduleId - The ID of the schedule to deactivate
+ */
+declare function deactivate(scheduleId: string): Promise<ScheduleObject>;
+/**
+ * Activates a schedule
+ * @param scheduleId - The ID of the schedule to activate
+ */
+declare function activate(scheduleId: string): Promise<ScheduleObject>;
+/**
+ * Lists schedules
+ * @param options - The list options
+ * @param options.page - The page number
+ * @param options.perPage - The number of schedules per page
+ * @returns The list of schedules
+ */
+declare function list(options?: ListScheduleOptions): Promise<ListSchedulesResult>;
+
+declare const index_activate: typeof activate;
+declare const index_create: typeof create;
+declare const index_deactivate: typeof deactivate;
+declare const index_del: typeof del;
+declare const index_list: typeof list;
+declare const index_retrieve: typeof retrieve;
+declare const index_task: typeof task;
+declare const index_update: typeof update;
+declare namespace index {
+  export { index_activate as activate, index_create as create, index_deactivate as deactivate, index_del as del, index_list as list, index_retrieve as retrieve, index_task as task, index_update as update };
+}
+
+export { type CacheEntry, type CacheFunction, type CacheMetadata, type CacheStore, type Context, type Eventually, InMemoryCache, type WaitOptions, createCache, queue, retry, runs, index as schedules, task$1 as task, wait };

package/dist/v3/index.d.ts

@@ -1,5 +1,5 @@
-import { TaskRunContext, InitOutput, RetryOptions, QueueOptions, MachineCpu, MachineMemory, RunFnParams, InitFnParams, HandleErrorFnParams, HandleErrorResult, MiddlewareFnParams, SuccessFnParams, FetchRetryOptions, ReplayRunResponse, CanceledRunResponse } from '@trigger.dev/core/v3';
-export { HandleErrorArgs, HandleErrorFunction, LogLevel, RetryOptions, ProjectConfig as TriggerConfig, logger } from '@trigger.dev/core/v3';
+import { TaskRunContext, QueueOptions, InitOutput, RetryOptions, MachineCpu, MachineMemory, RunFnParams, InitFnParams, HandleErrorFnParams, HandleErrorResult, MiddlewareFnParams, SuccessFnParams, FetchRetryOptions, ReplayRunResponse, CanceledRunResponse, ScheduledTaskPayload, CreateScheduleOptions, ScheduleObject, UpdateScheduleOptions, DeletedScheduleObject, ListScheduleOptions, ListSchedulesResult } from '@trigger.dev/core/v3';
+export { APIError, AuthenticationError, BadRequestError, ConflictError, HandleErrorArgs, HandleErrorFunction, InternalServerError, LogLevel, NotFoundError, PermissionDeniedError, RateLimitError, RetryOptions, ProjectConfig as TriggerConfig, UnprocessableEntityError, logger } from '@trigger.dev/core/v3';
 import { HttpHandler } from 'msw';
 
 type Context = TaskRunContext;
@@ -9,6 +9,9 @@ type RequireOne<T, K extends keyof T> = {
     [P in K]-?: T[P];
 };
 type Queue = RequireOne<QueueOptions, "name">;
+declare function queue(options: {
+    name: string;
+} & QueueOptions): Queue;
 type TaskOptions<TPayload, TOutput = any, TInitOutput extends InitOutput = any> = {
     /** An id for your task. This must be unique inside your project and not change between versions.  */
     id: string;
@@ -125,7 +128,8 @@ type BatchResult<TOutput = any> = {
     id: string;
     runs: TaskRunResult<TOutput>[];
 };
-type Task<TInput, TOutput = any> = {
+interface Task<TInput, TOutput = any> {
+    id: string;
     trigger: (params: {
         payload: TInput;
         options?: TaskRunOptions;
@@ -148,7 +152,7 @@ type Task<TInput, TOutput = any> = {
         }[];
         batchOptions?: BatchRunOptions;
     }) => Promise<BatchResult<TOutput>>;
-};
+}
 type TaskRunOptions = {
     idempotencyKey?: string;
     maxAttempts?: number;
@@ -180,7 +184,7 @@ type BatchRunOptions = TaskRunOptions & {
  *
  * @returns A task that can be triggered
  */
-declare function task<TInput, TOutput = any, TInitOutput extends InitOutput = any>(options: TaskOptions<TInput, TOutput, TInitOutput>): Task<TInput, TOutput>;
+declare function task$1<TInput, TOutput = any, TInitOutput extends InitOutput = any>(options: TaskOptions<TInput, TOutput, TInitOutput>): Task<TInput, TOutput>;
 
 type WaitOptions = {
     seconds: number;
@@ -258,4 +262,67 @@ declare const runs: {
 declare function replayRun(runId: string): Promise<ReplayRunResponse>;
 declare function cancelRun(runId: string): Promise<CanceledRunResponse>;
 
-export { type CacheEntry, type CacheFunction, type CacheMetadata, type CacheStore, type Context, type Eventually, InMemoryCache, type WaitOptions, createCache, retry, runs, task, wait };
+declare function task<TOutput, TInitOutput extends InitOutput>(params: TaskOptions<ScheduledTaskPayload, TOutput, TInitOutput>): Task<ScheduledTaskPayload, TOutput>;
+/**
+ * Creates a new schedule
+ * @param options
+ * @param options.task - The identifier of the task to be scheduled (Must already exist and be a scheduled task)
+ * @param options.cron - The cron expression for the schedule (e.g. `0 0 * * *`)
+ * @param options.externalId - An optional external identifier for the schedule
+ * @param options.deduplicationKey - An optional deduplication key for the schedule
+ * @returns The created schedule
+ */
+declare function create(options: CreateScheduleOptions): Promise<ScheduleObject>;
+/**
+ * Retrieves a schedule
+ * @param scheduleId - The ID of the schedule to retrieve
+ * @returns The retrieved schedule
+ */
+declare function retrieve(scheduleId: string): Promise<ScheduleObject>;
+/**
+ * Updates a schedule
+ * @param scheduleId - The ID of the schedule to update
+ * @param options - The updated schedule options
+ * @param options.task - The identifier of the task to be scheduled (Must already exist and be a scheduled task)
+ * @param options.cron - The cron expression for the schedule (e.g. `0 0 * * *`)
+ * @param options.externalId - An optional external identifier for the schedule
+ * @returns The updated schedule
+ */
+declare function update(scheduleId: string, options: UpdateScheduleOptions): Promise<ScheduleObject>;
+/**
+ * Deletes a schedule
+ * @param scheduleId - The ID of the schedule to delete
+ */
+declare function del(scheduleId: string): Promise<DeletedScheduleObject>;
+/**
+ * Deactivates a schedule
+ * @param scheduleId - The ID of the schedule to deactivate
+ */
+declare function deactivate(scheduleId: string): Promise<ScheduleObject>;
+/**
+ * Activates a schedule
+ * @param scheduleId - The ID of the schedule to activate
+ */
+declare function activate(scheduleId: string): Promise<ScheduleObject>;
+/**
+ * Lists schedules
+ * @param options - The list options
+ * @param options.page - The page number
+ * @param options.perPage - The number of schedules per page
+ * @returns The list of schedules
+ */
+declare function list(options?: ListScheduleOptions): Promise<ListSchedulesResult>;
+
+declare const index_activate: typeof activate;
+declare const index_create: typeof create;
+declare const index_deactivate: typeof deactivate;
+declare const index_del: typeof del;
+declare const index_list: typeof list;
+declare const index_retrieve: typeof retrieve;
+declare const index_task: typeof task;
+declare const index_update: typeof update;
+declare namespace index {
+  export { index_activate as activate, index_create as create, index_deactivate as deactivate, index_del as del, index_list as list, index_retrieve as retrieve, index_task as task, index_update as update };
+}
+
+export { type CacheEntry, type CacheFunction, type CacheMetadata, type CacheStore, type Context, type Eventually, InMemoryCache, type WaitOptions, createCache, queue, retry, runs, index as schedules, task$1 as task, wait };

package/dist/v3/index.js

@@ -8,43 +8,52 @@ var node_async_hooks = require('node:async_hooks');
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __publicField = (obj, key, value) => {
   __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
 
 // package.json
-var version = "3.0.0-beta.11";
+var version = "3.0.0-beta.13";
 var tracer = new v3.TriggerTracer({
   name: "@trigger.dev/sdk",
   version
 });
 
 // src/v3/shared.ts
+function queue(options) {
+  return options;
+}
+__name(queue, "queue");
 function createTask(params) {
-  const task2 = {
+  const task3 = {
+    id: params.id,
     trigger: async ({ payload, options }) => {
       const apiClient = v3.apiClientManager.client;
       if (!apiClient) {
         throw apiClientMissingError();
       }
-      const taskMetadata = v3.runtime.getTaskMetadata(params.id);
+      const taskMetadata = v3.taskCatalog.getTaskMetadata(params.id);
+      const payloadPacket = await v3.stringifyIO(payload);
       const handle = await tracer.startActiveSpan(taskMetadata ? "Trigger" : `${params.id} trigger()`, async (span) => {
         const response = await apiClient.triggerTask(params.id, {
-          payload,
+          payload: payloadPacket.data,
           options: {
             queue: params.queue,
             concurrencyKey: options?.concurrencyKey,
-            test: v3.taskContextManager.ctx?.run.isTest
+            test: v3.taskContextManager.ctx?.run.isTest,
+            payloadType: payloadPacket.dataType,
+            idempotencyKey: options?.idempotencyKey
           }
         }, {
           spanParentAsLink: true
         });
-        if (!response.ok) {
-          throw new Error(response.error);
-        }
-        span.setAttribute("messaging.message.id", response.data.id);
-        return response.data;
+        span.setAttribute("messaging.message.id", response.id);
+        return response;
       }, {
         kind: api.SpanKind.PRODUCER,
         attributes: {
@@ -72,25 +81,27 @@ function createTask(params) {
       if (!apiClient) {
         throw apiClientMissingError();
       }
-      const taskMetadata = v3.runtime.getTaskMetadata(params.id);
+      const taskMetadata = v3.taskCatalog.getTaskMetadata(params.id);
       const response = await tracer.startActiveSpan(taskMetadata ? "Batch trigger" : `${params.id} batchTrigger()`, async (span) => {
         const response2 = await apiClient.batchTriggerTask(params.id, {
-          items: items.map((item) => ({
-            payload: item.payload,
-            options: {
-              queue: item.options?.queue ?? params.queue,
-              concurrencyKey: item.options?.concurrencyKey,
-              test: v3.taskContextManager.ctx?.run.isTest
-            }
+          items: await Promise.all(items.map(async (item) => {
+            const payloadPacket = await v3.stringifyIO(item.payload);
+            return {
+              payload: payloadPacket.data,
+              options: {
+                queue: item.options?.queue ?? params.queue,
+                concurrencyKey: item.options?.concurrencyKey,
+                test: v3.taskContextManager.ctx?.run.isTest,
+                payloadType: payloadPacket.dataType,
+                idempotencyKey: item.options?.idempotencyKey
+              }
+            };
           }))
         }, {
           spanParentAsLink: true
         });
-        if (!response2.ok) {
-          throw new Error(response2.error);
-        }
-        span.setAttribute("messaging.message.id", response2.data.batchId);
-        return response2.data;
+        span.setAttribute("messaging.message.id", response2.batchId);
+        return response2;
       }, {
         kind: api.SpanKind.PRODUCER,
         attributes: {
@@ -123,24 +134,24 @@ function createTask(params) {
       if (!apiClient) {
         throw apiClientMissingError();
       }
-      const taskMetadata = v3.runtime.getTaskMetadata(params.id);
+      const taskMetadata = v3.taskCatalog.getTaskMetadata(params.id);
+      const payloadPacket = await v3.stringifyIO(payload);
       return await tracer.startActiveSpan(taskMetadata ? "Trigger" : `${params.id} triggerAndWait()`, async (span) => {
         const response = await apiClient.triggerTask(params.id, {
-          payload,
+          payload: payloadPacket.data,
           options: {
             dependentAttempt: ctx.attempt.id,
             lockToVersion: v3.taskContextManager.worker?.version,
             queue: params.queue,
             concurrencyKey: options?.concurrencyKey,
-            test: v3.taskContextManager.ctx?.run.isTest
+            test: v3.taskContextManager.ctx?.run.isTest,
+            payloadType: payloadPacket.dataType,
+            idempotencyKey: options?.idempotencyKey
           }
         });
-        if (!response.ok) {
-          throw new Error(response.error);
-        }
-        span.setAttribute("messaging.message.id", response.data.id);
+        span.setAttribute("messaging.message.id", response.id);
         const result = await v3.runtime.waitForTask({
-          id: response.data.id,
+          id: response.id,
           ctx
         });
         const runResult = await handleTaskRunExecutionResult(result);
@@ -177,27 +188,29 @@ function createTask(params) {
       if (!apiClient) {
         throw apiClientMissingError();
       }
-      const taskMetadata = v3.runtime.getTaskMetadata(params.id);
+      const taskMetadata = v3.taskCatalog.getTaskMetadata(params.id);
       return await tracer.startActiveSpan(taskMetadata ? "Batch trigger" : `${params.id} batchTriggerAndWait()`, async (span) => {
         const response = await apiClient.batchTriggerTask(params.id, {
-          items: items.map((item) => ({
-            payload: item.payload,
-            options: {
-              lockToVersion: v3.taskContextManager.worker?.version,
-              queue: item.options?.queue ?? params.queue,
-              concurrencyKey: item.options?.concurrencyKey,
-              test: v3.taskContextManager.ctx?.run.isTest
-            }
+          items: await Promise.all(items.map(async (item) => {
+            const payloadPacket = await v3.stringifyIO(item.payload);
+            return {
+              payload: payloadPacket.data,
+              options: {
+                lockToVersion: v3.taskContextManager.worker?.version,
+                queue: item.options?.queue ?? params.queue,
+                concurrencyKey: item.options?.concurrencyKey,
+                test: v3.taskContextManager.ctx?.run.isTest,
+                payloadType: payloadPacket.dataType,
+                idempotencyKey: item.options?.idempotencyKey
+              }
+            };
           })),
           dependentAttempt: ctx.attempt.id
         });
-        if (!response.ok) {
-          throw new Error(response.error);
-        }
-        span.setAttribute("messaging.message.id", response.data.batchId);
+        span.setAttribute("messaging.message.id", response.batchId);
         const result = await v3.runtime.waitForBatch({
-          id: response.data.batchId,
-          runs: response.data.runs,
+          id: response.batchId,
+          runs: response.runs,
           ctx
         });
         const runs2 = await handleBatchTaskRunExecutionResult(result.items);
@@ -228,27 +241,24 @@ function createTask(params) {
       });
     }
   };
-  Object.defineProperty(task2, "__trigger", {
-    value: {
-      id: params.id,
-      packageVersion: version,
-      queue: params.queue,
-      retry: params.retry ? {
-        ...v3.defaultRetryOptions,
-        ...params.retry
-      } : void 0,
-      machine: params.machine,
-      fns: {
-        run: params.run,
-        init: params.init,
-        cleanup: params.cleanup,
-        middleware: params.middleware,
-        handleError: params.handleError
-      }
-    },
-    enumerable: false
+  v3.taskCatalog.registerTaskMetadata({
+    id: params.id,
+    packageVersion: version,
+    queue: params.queue,
+    retry: params.retry ? {
+      ...v3.defaultRetryOptions,
+      ...params.retry
+    } : void 0,
+    machine: params.machine,
+    fns: {
+      run: params.run,
+      init: params.init,
+      cleanup: params.cleanup,
+      middleware: params.middleware,
+      handleError: params.handleError
+    }
   });
-  return task2;
+  return task3;
 }
 __name(createTask, "createTask");
 async function handleBatchTaskRunExecutionResult(items) {
@@ -887,11 +897,7 @@ async function replayRun(runId) {
   if (!apiClient) {
     throw apiClientMissingError();
   }
-  const response = await apiClient.replayRun(runId);
-  if (!response.ok) {
-    throw new Error(response.error);
-  }
-  return response.data;
+  return await apiClient.replayRun(runId);
 }
 __name(replayRun, "replayRun");
 async function cancelRun(runId) {
@@ -899,22 +905,133 @@ async function cancelRun(runId) {
   if (!apiClient) {
     throw apiClientMissingError();
   }
-  const response = await apiClient.cancelRun(runId);
-  if (!response.ok) {
-    throw new Error(response.error);
-  }
-  return response.data;
+  return await apiClient.cancelRun(runId);
 }
 __name(cancelRun, "cancelRun");
 
+// src/v3/schedules/index.ts
+var schedules_exports = {};
+__export(schedules_exports, {
+  activate: () => activate,
+  create: () => create,
+  deactivate: () => deactivate,
+  del: () => del,
+  list: () => list,
+  retrieve: () => retrieve,
+  task: () => task2,
+  update: () => update
+});
+function task2(params) {
+  const task3 = createTask(params);
+  v3.taskCatalog.updateTaskMetadata(task3.id, {
+    triggerSource: "schedule"
+  });
+  return task3;
+}
+__name(task2, "task");
+async function create(options) {
+  const apiClient = v3.apiClientManager.client;
+  if (!apiClient) {
+    throw apiClientMissingError();
+  }
+  return apiClient.createSchedule(options);
+}
+__name(create, "create");
+async function retrieve(scheduleId) {
+  const apiClient = v3.apiClientManager.client;
+  if (!apiClient) {
+    throw apiClientMissingError();
+  }
+  return apiClient.retrieveSchedule(scheduleId);
+}
+__name(retrieve, "retrieve");
+async function update(scheduleId, options) {
+  const apiClient = v3.apiClientManager.client;
+  if (!apiClient) {
+    throw apiClientMissingError();
+  }
+  return apiClient.updateSchedule(scheduleId, options);
+}
+__name(update, "update");
+async function del(scheduleId) {
+  const apiClient = v3.apiClientManager.client;
+  if (!apiClient) {
+    throw apiClientMissingError();
+  }
+  return apiClient.deleteSchedule(scheduleId);
+}
+__name(del, "del");
+async function deactivate(scheduleId) {
+  const apiClient = v3.apiClientManager.client;
+  if (!apiClient) {
+    throw apiClientMissingError();
+  }
+  return apiClient.deactivateSchedule(scheduleId);
+}
+__name(deactivate, "deactivate");
+async function activate(scheduleId) {
+  const apiClient = v3.apiClientManager.client;
+  if (!apiClient) {
+    throw apiClientMissingError();
+  }
+  return apiClient.activateSchedule(scheduleId);
+}
+__name(activate, "activate");
+async function list(options) {
+  const apiClient = v3.apiClientManager.client;
+  if (!apiClient) {
+    throw apiClientMissingError();
+  }
+  return apiClient.listSchedules(options);
+}
+__name(list, "list");
+
+Object.defineProperty(exports, 'APIError', {
+  enumerable: true,
+  get: function () { return v3.APIError; }
+});
+Object.defineProperty(exports, 'AuthenticationError', {
+  enumerable: true,
+  get: function () { return v3.AuthenticationError; }
+});
+Object.defineProperty(exports, 'BadRequestError', {
+  enumerable: true,
+  get: function () { return v3.BadRequestError; }
+});
+Object.defineProperty(exports, 'ConflictError', {
+  enumerable: true,
+  get: function () { return v3.ConflictError; }
+});
+Object.defineProperty(exports, 'InternalServerError', {
+  enumerable: true,
+  get: function () { return v3.InternalServerError; }
+});
+Object.defineProperty(exports, 'NotFoundError', {
+  enumerable: true,
+  get: function () { return v3.NotFoundError; }
+});
+Object.defineProperty(exports, 'PermissionDeniedError', {
+  enumerable: true,
+  get: function () { return v3.PermissionDeniedError; }
+});
+Object.defineProperty(exports, 'RateLimitError', {
+  enumerable: true,
+  get: function () { return v3.RateLimitError; }
+});
+Object.defineProperty(exports, 'UnprocessableEntityError', {
+  enumerable: true,
+  get: function () { return v3.UnprocessableEntityError; }
+});
 Object.defineProperty(exports, 'logger', {
   enumerable: true,
   get: function () { return v3.logger; }
 });
 exports.InMemoryCache = InMemoryCache;
 exports.createCache = createCache;
+exports.queue = queue;
 exports.retry = retry;
 exports.runs = runs;
+exports.schedules = schedules_exports;
 exports.task = task;
 exports.wait = wait;
 //# sourceMappingURL=out.js.map