@trigger.dev/sdk 2.0.0-next.7 → 2.0.0-next.9

package/dist/index.d.ts

@@ -24,6 +24,7 @@ declare class Logger {
 
 declare const EventMatcherSchema: z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodNumber, "many">, z.ZodArray<z.ZodBoolean, "many">]>;
 type EventMatcher = z.infer<typeof EventMatcherSchema>;
+/** A filter for matching against data */
 type EventFilter = {
     [key: string]: EventMatcher | EventFilter;
 };
@@ -1475,13 +1476,44 @@ declare const RedactStringSchema: z.ZodObject<{
 type RedactString = z.infer<typeof RedactStringSchema>;
 type CachedTask = z.infer<typeof CachedTaskSchema>;
 declare const RunTaskOptionsSchema: z.ZodObject<{
+    /** The name of the Task is required. This is displayed on the Task in the logs. */
     name: z.ZodString;
+    /** The Task will wait and only start at the specified Date  */
+    delayUntil: z.ZodOptional<z.ZodDate>;
+    /** Retry options */
+    retry: z.ZodOptional<z.ZodObject<{
+        /** The maximum number of times to retry the request. */
+        limit: z.ZodOptional<z.ZodNumber>;
+        /** The exponential factor to use when calculating the next retry time. */
+        factor: z.ZodOptional<z.ZodNumber>;
+        /** The minimum amount of time to wait before retrying the request. */
+        minTimeoutInMs: z.ZodOptional<z.ZodNumber>;
+        /** The maximum amount of time to wait before retrying the request. */
+        maxTimeoutInMs: z.ZodOptional<z.ZodNumber>;
+        /** Whether to randomize the retry time. */
+        randomize: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        limit?: number | undefined;
+        factor?: number | undefined;
+        minTimeoutInMs?: number | undefined;
+        maxTimeoutInMs?: number | undefined;
+        randomize?: boolean | undefined;
+    }, {
+        limit?: number | undefined;
+        factor?: number | undefined;
+        minTimeoutInMs?: number | undefined;
+        maxTimeoutInMs?: number | undefined;
+        randomize?: boolean | undefined;
+    }>>;
+    /** The icon for the Task, it will appear in the logs.
+     *  You can use the name of a company in lowercase, e.g. "github".
+     *  Or any icon name that [Font Awesome](https://fontawesome.com/icons) supports. */
     icon: z.ZodOptional<z.ZodString>;
+    /** The key for the Task that you want to appear in the logs */
     displayKey: z.ZodOptional<z.ZodString>;
-    noop: z.ZodDefault<z.ZodBoolean>;
-    operation: z.ZodOptional<z.ZodEnum<["fetch"]>>;
-    delayUntil: z.ZodOptional<z.ZodDate>;
+    /** A description of the Task */
     description: z.ZodOptional<z.ZodString>;
+    /** Properties that are displayed in the logs */
     properties: z.ZodOptional<z.ZodArray<z.ZodObject<{
         label: z.ZodString;
         text: z.ZodString;
@@ -1495,7 +1527,32 @@ declare const RunTaskOptionsSchema: z.ZodObject<{
         label: string;
         text: string;
     }>, "many">>;
+    /** The input params to the Task, will be displayed in the logs  */
     params: z.ZodAny;
+    /** The style of the log entry. */
+    style: z.ZodOptional<z.ZodObject<{
+        style: z.ZodEnum<["normal", "minimal"]>;
+        variant: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        variant?: string | undefined;
+        style: "normal" | "minimal";
+    }, {
+        variant?: string | undefined;
+        style: "normal" | "minimal";
+    }>>;
+    /** Allows you to link the Integration connection in the logs. This is handled automatically in integrations.  */
+    connectionKey: z.ZodOptional<z.ZodString>;
+    /** An operation you want to perform on the Trigger.dev platform, current only "fetch" is supported. If you wish to `fetch` use [`io.backgroundFetch()`](https://trigger.dev/docs/sdk/io/backgroundfetch) instead. */
+    operation: z.ZodOptional<z.ZodEnum<["fetch"]>>;
+    /** A No Operation means that the code won't be executed. This is used internally to implement features like [io.wait()](https://trigger.dev/docs/sdk/io/wait).  */
+    noop: z.ZodDefault<z.ZodBoolean>;
+    redact: z.ZodOptional<z.ZodObject<{
+        paths: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        paths: string[];
+    }, {
+        paths: string[];
+    }>>;
     trigger: z.ZodOptional<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
         type: z.ZodLiteral<"dynamic">;
         id: z.ZodString;
@@ -1643,48 +1700,6 @@ declare const RunTaskOptionsSchema: z.ZodObject<{
             type: "interval";
         };
     }>]>>;
-    redact: z.ZodOptional<z.ZodObject<{
-        paths: z.ZodArray<z.ZodString, "many">;
-    }, "strip", z.ZodTypeAny, {
-        paths: string[];
-    }, {
-        paths: string[];
-    }>>;
-    connectionKey: z.ZodOptional<z.ZodString>;
-    style: z.ZodOptional<z.ZodObject<{
-        style: z.ZodEnum<["normal", "minimal"]>;
-        variant: z.ZodOptional<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        variant?: string | undefined;
-        style: "normal" | "minimal";
-    }, {
-        variant?: string | undefined;
-        style: "normal" | "minimal";
-    }>>;
-    retry: z.ZodOptional<z.ZodObject<{
-        /** The maximum number of times to retry the request. */
-        limit: z.ZodOptional<z.ZodNumber>;
-        /** The exponential factor to use when calculating the next retry time. */
-        factor: z.ZodOptional<z.ZodNumber>;
-        /** The minimum amount of time to wait before retrying the request. */
-        minTimeoutInMs: z.ZodOptional<z.ZodNumber>;
-        /** The maximum amount of time to wait before retrying the request. */
-        maxTimeoutInMs: z.ZodOptional<z.ZodNumber>;
-        /** Whether to randomize the retry time. */
-        randomize: z.ZodOptional<z.ZodBoolean>;
-    }, "strip", z.ZodTypeAny, {
-        limit?: number | undefined;
-        factor?: number | undefined;
-        minTimeoutInMs?: number | undefined;
-        maxTimeoutInMs?: number | undefined;
-        randomize?: boolean | undefined;
-    }, {
-        limit?: number | undefined;
-        factor?: number | undefined;
-        minTimeoutInMs?: number | undefined;
-        maxTimeoutInMs?: number | undefined;
-        randomize?: boolean | undefined;
-    }>>;
 }, "strip", z.ZodTypeAny, {
     icon?: string | undefined;
     delayUntil?: Date | undefined;
@@ -1733,11 +1748,6 @@ declare const RunTaskOptionsSchema: z.ZodObject<{
             type: "interval";
         };
     } | undefined;
-    displayKey?: string | undefined;
-    redact?: {
-        paths: string[];
-    } | undefined;
-    connectionKey?: string | undefined;
     retry?: {
         limit?: number | undefined;
         factor?: number | undefined;
@@ -1745,6 +1755,11 @@ declare const RunTaskOptionsSchema: z.ZodObject<{
         maxTimeoutInMs?: number | undefined;
         randomize?: boolean | undefined;
     } | undefined;
+    displayKey?: string | undefined;
+    connectionKey?: string | undefined;
+    redact?: {
+        paths: string[];
+    } | undefined;
     name: string;
     noop: boolean;
 }, {
@@ -1796,11 +1811,6 @@ declare const RunTaskOptionsSchema: z.ZodObject<{
             type: "interval";
         };
     } | undefined;
-    displayKey?: string | undefined;
-    redact?: {
-        paths: string[];
-    } | undefined;
-    connectionKey?: string | undefined;
     retry?: {
         limit?: number | undefined;
         factor?: number | undefined;
@@ -1808,17 +1818,53 @@ declare const RunTaskOptionsSchema: z.ZodObject<{
         maxTimeoutInMs?: number | undefined;
         randomize?: boolean | undefined;
     } | undefined;
+    displayKey?: string | undefined;
+    connectionKey?: string | undefined;
+    redact?: {
+        paths: string[];
+    } | undefined;
     name: string;
 }>;
 type RunTaskOptions = z.input<typeof RunTaskOptionsSchema>;
 declare const RunTaskBodyInputSchema: z.ZodObject<z.extendShape<{
+    /** The name of the Task is required. This is displayed on the Task in the logs. */
     name: z.ZodString;
+    /** The Task will wait and only start at the specified Date  */
+    delayUntil: z.ZodOptional<z.ZodDate>;
+    /** Retry options */
+    retry: z.ZodOptional<z.ZodObject<{
+        /** The maximum number of times to retry the request. */
+        limit: z.ZodOptional<z.ZodNumber>;
+        /** The exponential factor to use when calculating the next retry time. */
+        factor: z.ZodOptional<z.ZodNumber>;
+        /** The minimum amount of time to wait before retrying the request. */
+        minTimeoutInMs: z.ZodOptional<z.ZodNumber>;
+        /** The maximum amount of time to wait before retrying the request. */
+        maxTimeoutInMs: z.ZodOptional<z.ZodNumber>;
+        /** Whether to randomize the retry time. */
+        randomize: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        limit?: number | undefined;
+        factor?: number | undefined;
+        minTimeoutInMs?: number | undefined;
+        maxTimeoutInMs?: number | undefined;
+        randomize?: boolean | undefined;
+    }, {
+        limit?: number | undefined;
+        factor?: number | undefined;
+        minTimeoutInMs?: number | undefined;
+        maxTimeoutInMs?: number | undefined;
+        randomize?: boolean | undefined;
+    }>>;
+    /** The icon for the Task, it will appear in the logs.
+     *  You can use the name of a company in lowercase, e.g. "github".
+     *  Or any icon name that [Font Awesome](https://fontawesome.com/icons) supports. */
     icon: z.ZodOptional<z.ZodString>;
+    /** The key for the Task that you want to appear in the logs */
     displayKey: z.ZodOptional<z.ZodString>;
-    noop: z.ZodDefault<z.ZodBoolean>;
-    operation: z.ZodOptional<z.ZodEnum<["fetch"]>>;
-    delayUntil: z.ZodOptional<z.ZodDate>;
+    /** A description of the Task */
     description: z.ZodOptional<z.ZodString>;
+    /** Properties that are displayed in the logs */
     properties: z.ZodOptional<z.ZodArray<z.ZodObject<{
         label: z.ZodString;
         text: z.ZodString;
@@ -1832,7 +1878,32 @@ declare const RunTaskBodyInputSchema: z.ZodObject<z.extendShape<{
         label: string;
         text: string;
     }>, "many">>;
+    /** The input params to the Task, will be displayed in the logs  */
     params: z.ZodAny;
+    /** The style of the log entry. */
+    style: z.ZodOptional<z.ZodObject<{
+        style: z.ZodEnum<["normal", "minimal"]>;
+        variant: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        variant?: string | undefined;
+        style: "normal" | "minimal";
+    }, {
+        variant?: string | undefined;
+        style: "normal" | "minimal";
+    }>>;
+    /** Allows you to link the Integration connection in the logs. This is handled automatically in integrations.  */
+    connectionKey: z.ZodOptional<z.ZodString>;
+    /** An operation you want to perform on the Trigger.dev platform, current only "fetch" is supported. If you wish to `fetch` use [`io.backgroundFetch()`](https://trigger.dev/docs/sdk/io/backgroundfetch) instead. */
+    operation: z.ZodOptional<z.ZodEnum<["fetch"]>>;
+    /** A No Operation means that the code won't be executed. This is used internally to implement features like [io.wait()](https://trigger.dev/docs/sdk/io/wait).  */
+    noop: z.ZodDefault<z.ZodBoolean>;
+    redact: z.ZodOptional<z.ZodObject<{
+        paths: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        paths: string[];
+    }, {
+        paths: string[];
+    }>>;
     trigger: z.ZodOptional<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
         type: z.ZodLiteral<"dynamic">;
         id: z.ZodString;
@@ -1980,48 +2051,6 @@ declare const RunTaskBodyInputSchema: z.ZodObject<z.extendShape<{
             type: "interval";
         };
     }>]>>;
-    redact: z.ZodOptional<z.ZodObject<{
-        paths: z.ZodArray<z.ZodString, "many">;
-    }, "strip", z.ZodTypeAny, {
-        paths: string[];
-    }, {
-        paths: string[];
-    }>>;
-    connectionKey: z.ZodOptional<z.ZodString>;
-    style: z.ZodOptional<z.ZodObject<{
-        style: z.ZodEnum<["normal", "minimal"]>;
-        variant: z.ZodOptional<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        variant?: string | undefined;
-        style: "normal" | "minimal";
-    }, {
-        variant?: string | undefined;
-        style: "normal" | "minimal";
-    }>>;
-    retry: z.ZodOptional<z.ZodObject<{
-        /** The maximum number of times to retry the request. */
-        limit: z.ZodOptional<z.ZodNumber>;
-        /** The exponential factor to use when calculating the next retry time. */
-        factor: z.ZodOptional<z.ZodNumber>;
-        /** The minimum amount of time to wait before retrying the request. */
-        minTimeoutInMs: z.ZodOptional<z.ZodNumber>;
-        /** The maximum amount of time to wait before retrying the request. */
-        maxTimeoutInMs: z.ZodOptional<z.ZodNumber>;
-        /** Whether to randomize the retry time. */
-        randomize: z.ZodOptional<z.ZodBoolean>;
-    }, "strip", z.ZodTypeAny, {
-        limit?: number | undefined;
-        factor?: number | undefined;
-        minTimeoutInMs?: number | undefined;
-        maxTimeoutInMs?: number | undefined;
-        randomize?: boolean | undefined;
-    }, {
-        limit?: number | undefined;
-        factor?: number | undefined;
-        minTimeoutInMs?: number | undefined;
-        maxTimeoutInMs?: number | undefined;
-        randomize?: boolean | undefined;
-    }>>;
 }, {
     idempotencyKey: z.ZodString;
     parentId: z.ZodOptional<z.ZodString>;
@@ -2074,11 +2103,6 @@ declare const RunTaskBodyInputSchema: z.ZodObject<z.extendShape<{
             type: "interval";
         };
     } | undefined;
-    displayKey?: string | undefined;
-    redact?: {
-        paths: string[];
-    } | undefined;
-    connectionKey?: string | undefined;
     retry?: {
         limit?: number | undefined;
         factor?: number | undefined;
@@ -2086,6 +2110,11 @@ declare const RunTaskBodyInputSchema: z.ZodObject<z.extendShape<{
         maxTimeoutInMs?: number | undefined;
         randomize?: boolean | undefined;
     } | undefined;
+    displayKey?: string | undefined;
+    connectionKey?: string | undefined;
+    redact?: {
+        paths: string[];
+    } | undefined;
     name: string;
     noop: boolean;
     idempotencyKey: string;
@@ -2139,11 +2168,6 @@ declare const RunTaskBodyInputSchema: z.ZodObject<z.extendShape<{
             type: "interval";
         };
     } | undefined;
-    displayKey?: string | undefined;
-    redact?: {
-        paths: string[];
-    } | undefined;
-    connectionKey?: string | undefined;
     retry?: {
         limit?: number | undefined;
         factor?: number | undefined;
@@ -2151,18 +2175,54 @@ declare const RunTaskBodyInputSchema: z.ZodObject<z.extendShape<{
         maxTimeoutInMs?: number | undefined;
         randomize?: boolean | undefined;
     } | undefined;
+    displayKey?: string | undefined;
+    connectionKey?: string | undefined;
+    redact?: {
+        paths: string[];
+    } | undefined;
     name: string;
     idempotencyKey: string;
 }>;
 type RunTaskBodyInput = z.infer<typeof RunTaskBodyInputSchema>;
 declare const CompleteTaskBodyInputSchema: z.ZodObject<z.extendShape<Pick<z.extendShape<{
+    /** The name of the Task is required. This is displayed on the Task in the logs. */
     name: z.ZodString;
+    /** The Task will wait and only start at the specified Date  */
+    delayUntil: z.ZodOptional<z.ZodDate>;
+    /** Retry options */
+    retry: z.ZodOptional<z.ZodObject<{
+        /** The maximum number of times to retry the request. */
+        limit: z.ZodOptional<z.ZodNumber>;
+        /** The exponential factor to use when calculating the next retry time. */
+        factor: z.ZodOptional<z.ZodNumber>;
+        /** The minimum amount of time to wait before retrying the request. */
+        minTimeoutInMs: z.ZodOptional<z.ZodNumber>;
+        /** The maximum amount of time to wait before retrying the request. */
+        maxTimeoutInMs: z.ZodOptional<z.ZodNumber>;
+        /** Whether to randomize the retry time. */
+        randomize: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        limit?: number | undefined;
+        factor?: number | undefined;
+        minTimeoutInMs?: number | undefined;
+        maxTimeoutInMs?: number | undefined;
+        randomize?: boolean | undefined;
+    }, {
+        limit?: number | undefined;
+        factor?: number | undefined;
+        minTimeoutInMs?: number | undefined;
+        maxTimeoutInMs?: number | undefined;
+        randomize?: boolean | undefined;
+    }>>;
+    /** The icon for the Task, it will appear in the logs.
+     *  You can use the name of a company in lowercase, e.g. "github".
+     *  Or any icon name that [Font Awesome](https://fontawesome.com/icons) supports. */
     icon: z.ZodOptional<z.ZodString>;
+    /** The key for the Task that you want to appear in the logs */
     displayKey: z.ZodOptional<z.ZodString>;
-    noop: z.ZodDefault<z.ZodBoolean>;
-    operation: z.ZodOptional<z.ZodEnum<["fetch"]>>;
-    delayUntil: z.ZodOptional<z.ZodDate>;
+    /** A description of the Task */
     description: z.ZodOptional<z.ZodString>;
+    /** Properties that are displayed in the logs */
     properties: z.ZodOptional<z.ZodArray<z.ZodObject<{
         label: z.ZodString;
         text: z.ZodString;
@@ -2176,7 +2236,32 @@ declare const CompleteTaskBodyInputSchema: z.ZodObject<z.extendShape<Pick<z.exte
         label: string;
         text: string;
     }>, "many">>;
+    /** The input params to the Task, will be displayed in the logs  */
     params: z.ZodAny;
+    /** The style of the log entry. */
+    style: z.ZodOptional<z.ZodObject<{
+        style: z.ZodEnum<["normal", "minimal"]>;
+        variant: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        variant?: string | undefined;
+        style: "normal" | "minimal";
+    }, {
+        variant?: string | undefined;
+        style: "normal" | "minimal";
+    }>>;
+    /** Allows you to link the Integration connection in the logs. This is handled automatically in integrations.  */
+    connectionKey: z.ZodOptional<z.ZodString>;
+    /** An operation you want to perform on the Trigger.dev platform, current only "fetch" is supported. If you wish to `fetch` use [`io.backgroundFetch()`](https://trigger.dev/docs/sdk/io/backgroundfetch) instead. */
+    operation: z.ZodOptional<z.ZodEnum<["fetch"]>>;
+    /** A No Operation means that the code won't be executed. This is used internally to implement features like [io.wait()](https://trigger.dev/docs/sdk/io/wait).  */
+    noop: z.ZodDefault<z.ZodBoolean>;
+    redact: z.ZodOptional<z.ZodObject<{
+        paths: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        paths: string[];
+    }, {
+        paths: string[];
+    }>>;
     trigger: z.ZodOptional<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
         type: z.ZodLiteral<"dynamic">;
         id: z.ZodString;
@@ -2324,48 +2409,6 @@ declare const CompleteTaskBodyInputSchema: z.ZodObject<z.extendShape<Pick<z.exte
             type: "interval";
         };
     }>]>>;
-    redact: z.ZodOptional<z.ZodObject<{
-        paths: z.ZodArray<z.ZodString, "many">;
-    }, "strip", z.ZodTypeAny, {
-        paths: string[];
-    }, {
-        paths: string[];
-    }>>;
-    connectionKey: z.ZodOptional<z.ZodString>;
-    style: z.ZodOptional<z.ZodObject<{
-        style: z.ZodEnum<["normal", "minimal"]>;
-        variant: z.ZodOptional<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        variant?: string | undefined;
-        style: "normal" | "minimal";
-    }, {
-        variant?: string | undefined;
-        style: "normal" | "minimal";
-    }>>;
-    retry: z.ZodOptional<z.ZodObject<{
-        /** The maximum number of times to retry the request. */
-        limit: z.ZodOptional<z.ZodNumber>;
-        /** The exponential factor to use when calculating the next retry time. */
-        factor: z.ZodOptional<z.ZodNumber>;
-        /** The minimum amount of time to wait before retrying the request. */
-        minTimeoutInMs: z.ZodOptional<z.ZodNumber>;
-        /** The maximum amount of time to wait before retrying the request. */
-        maxTimeoutInMs: z.ZodOptional<z.ZodNumber>;
-        /** Whether to randomize the retry time. */
-        randomize: z.ZodOptional<z.ZodBoolean>;
-    }, "strip", z.ZodTypeAny, {
-        limit?: number | undefined;
-        factor?: number | undefined;
-        minTimeoutInMs?: number | undefined;
-        maxTimeoutInMs?: number | undefined;
-        randomize?: boolean | undefined;
-    }, {
-        limit?: number | undefined;
-        factor?: number | undefined;
-        minTimeoutInMs?: number | undefined;
-        maxTimeoutInMs?: number | undefined;
-        randomize?: boolean | undefined;
-    }>>;
 }, {
     idempotencyKey: z.ZodString;
     parentId: z.ZodOptional<z.ZodString>;
@@ -2752,9 +2795,13 @@ declare const ErrorWithStackSchema: z.ZodObject<{
 }>;
 type ErrorWithStack = z.infer<typeof ErrorWithStackSchema>;
 
+/** A property that is displayed in the logs */
 declare const DisplayPropertySchema: z.ZodObject<{
+    /** The label for the property */
     label: z.ZodString;
+    /** The value of the property */
     text: z.ZodString;
+    /** The URL to link to when the property is clicked */
     url: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     url?: string | undefined;
@@ -2845,14 +2892,19 @@ declare const ScheduledPayloadSchema: z.ZodObject<{
 }>;
 type ScheduledPayload = z.infer<typeof ScheduledPayloadSchema>;
 declare const IntervalOptionsSchema: z.ZodObject<{
+    /** The number of seconds for the interval. Min = 60, Max = 86400 (1 day) */
     seconds: z.ZodNumber;
 }, "strip", z.ZodTypeAny, {
     seconds: number;
 }, {
     seconds: number;
 }>;
+/** Interval options */
 type IntervalOptions = z.infer<typeof IntervalOptionsSchema>;
 declare const CronOptionsSchema: z.ZodObject<{
+    /** A CRON expression that defines the schedule. A useful tool when writing CRON
+      expressions is [crontab guru](https://crontab.guru). Note that the timezone
+      used is UTC. */
     cron: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     cron: string;
@@ -2861,14 +2913,18 @@ declare const CronOptionsSchema: z.ZodObject<{
 }>;
 type CronOptions = z.infer<typeof CronOptionsSchema>;
 declare const ScheduleMetadataSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    /** An interval reoccurs at the specified number of seconds  */
     type: z.ZodLiteral<"interval">;
+    /** An object containing options about the interval. */
     options: z.ZodObject<{
+        /** The number of seconds for the interval. Min = 60, Max = 86400 (1 day) */
         seconds: z.ZodNumber;
     }, "strip", z.ZodTypeAny, {
         seconds: number;
     }, {
         seconds: number;
     }>;
+    /** Any additional metadata about the schedule. */
     metadata: z.ZodAny;
 }, "strip", z.ZodTypeAny, {
     metadata?: any;
@@ -2885,6 +2941,9 @@ declare const ScheduleMetadataSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObje
 }>, z.ZodObject<{
     type: z.ZodLiteral<"cron">;
     options: z.ZodObject<{
+        /** A CRON expression that defines the schedule. A useful tool when writing CRON
+          expressions is [crontab guru](https://crontab.guru). Note that the timezone
+          used is UTC. */
         cron: z.ZodString;
     }, "strip", z.ZodTypeAny, {
         cron: string;
@@ -3393,36 +3452,43 @@ declare class ApiClient {
 }
 
 interface TriggerContext {
+    /** Job metadata */
     job: {
         id: string;
         version: string;
     };
+    /** Environment metadata */
     environment: {
         slug: string;
         id: string;
         type: RuntimeEnvironmentType;
     };
+    /** Organization metadata */
     organization: {
         slug: string;
         id: string;
         title: string;
     };
+    /** Run metadata */
     run: {
         id: string;
         isTest: boolean;
         startedAt: Date;
     };
+    /** Event metadata */
     event: {
         id: string;
         name: string;
         context: any;
         timestamp: Date;
     };
-    account?: {
+    /** Source metadata */
+    source?: {
         id: string;
         metadata?: any;
     };
-    source?: {
+    /** Account metadata */
+    account?: {
         id: string;
         metadata?: any;
     };
@@ -3703,7 +3769,10 @@ declare class TriggerClient {
         type: "oauth2";
         accessToken: string;
     } | undefined>;
-    /** You can call this function from anywhere in your code to send an event. The other way to send an event is by using `io.sendEvent()` from inside a `run()` function.
+    /** You can call this function from anywhere in your code to send an event. The other way to send an event is by using [`io.sendEvent()`](https://trigger.dev/docs/sdk/io/sendevent) from inside a `run()` function.
+     * @param event The event to send.
+     * @param options Options for sending the event.
+     * @returns A promise that resolves to the event details
      */
     sendEvent(event: SendEvent, options?: SendEventOptions): Promise<{
         context?: DeserializedJson | undefined;
@@ -3918,6 +3987,13 @@ declare class IO {
         id: string;
         key: string;
     }>;
+    /** `io.registerInterval()` allows you to register a [DynamicSchedule](https://trigger.dev/docs/sdk/dynamicschedule) that will trigger any jobs it's attached to on a regular interval.
+     * @param key Should be a stable and unique key inside the `run()`. See [resumability](https://trigger.dev/docs/documentation/concepts/resumability) for more information.
+     * @param dynamicSchedule The [DynamicSchedule](https://trigger.dev/docs/sdk/dynamicschedule) to register a new schedule on.
+     * @param id A unique id for the interval. This is used to identify and unregister the interval later.
+     * @param options The options for the interval.
+     * @returns A promise that has information about the interval.
+     */
     registerInterval(key: string | any[], dynamicSchedule: DynamicSchedule, id: string, options: IntervalOptions): Promise<{
         metadata?: any;
         id: string;
@@ -3936,9 +4012,20 @@ declare class IO {
         };
         active: boolean;
     }>;
+    /** `io.unregisterInterval()` allows you to unregister a [DynamicSchedule](https://trigger.dev/docs/sdk/dynamicschedule) that was previously registered with `io.registerInterval()`.
+     * @param key Should be a stable and unique key inside the `run()`. See [resumability](https://trigger.dev/docs/documentation/concepts/resumability) for more information.
+     * @param dynamicSchedule The [DynamicSchedule](https://trigger.dev/docs/sdk/dynamicschedule) to unregister a schedule on.
+     * @param id A unique id for the interval. This is used to identify and unregister the interval later.
+     */
     unregisterInterval(key: string | any[], dynamicSchedule: DynamicSchedule, id: string): Promise<{
         ok: boolean;
     }>;
+    /** `io.registerCron()` allows you to register a [DynamicSchedule](https://trigger.dev/docs/sdk/dynamicschedule) that will trigger any jobs it's attached to on a regular CRON schedule.
+     * @param key Should be a stable and unique key inside the `run()`. See [resumability](https://trigger.dev/docs/documentation/concepts/resumability) for more information.
+     * @param dynamicSchedule The [DynamicSchedule](https://trigger.dev/docs/sdk/dynamicschedule) to register a new schedule on.
+     * @param id A unique id for the schedule. This is used to identify and unregister the schedule later.
+     * @param options The options for the CRON schedule.
+     */
     registerCron(key: string | any[], dynamicSchedule: DynamicSchedule, id: string, options: CronOptions): Promise<{
         metadata?: any;
         id: string;
@@ -3957,19 +4044,44 @@ declare class IO {
         };
         active: boolean;
     }>;
+    /** `io.unregisterCron()` allows you to unregister a [DynamicSchedule](https://trigger.dev/docs/sdk/dynamicschedule) that was previously registered with `io.registerCron()`.
+     * @param key Should be a stable and unique key inside the `run()`. See [resumability](https://trigger.dev/docs/documentation/concepts/resumability) for more information.
+     * @param dynamicSchedule The [DynamicSchedule](https://trigger.dev/docs/sdk/dynamicschedule) to unregister a schedule on.
+     * @param id A unique id for the interval. This is used to identify and unregister the interval later.
+     */
     unregisterCron(key: string | any[], dynamicSchedule: DynamicSchedule, id: string): Promise<{
         ok: boolean;
     }>;
+    /** `io.registerTrigger()` allows you to register a [DynamicTrigger](https://trigger.dev/docs/sdk/dynamictrigger) with the specified trigger params.
+     * @param key Should be a stable and unique key inside the `run()`. See [resumability](https://trigger.dev/docs/documentation/concepts/resumability) for more information.
+     * @param trigger The [DynamicTrigger](https://trigger.dev/docs/sdk/dynamictrigger) to register.
+     * @param id A unique id for the trigger. This is used to identify and unregister the trigger later.
+     * @param params The params for the trigger.
+     */
     registerTrigger<TTrigger extends DynamicTrigger<EventSpecification<any>, ExternalSource<any, any, any>>>(key: string | any[], trigger: TTrigger, id: string, params: ExternalSourceParams<TTrigger["source"]>): Promise<{
         id: string;
         key: string;
     } | undefined>;
     getAuth(key: string | any[], clientId?: string): Promise<ConnectionAuth | undefined>;
+    /** `io.runTask()` allows you to run a [Task](https://trigger.dev/docs/documentation/concepts/tasks) from inside a Job run. A Task is a resumable unit of a Run that can be retried, resumed and is logged. [Integrations](https://trigger.dev/docs/integrations) use Tasks internally to perform their actions.
+     *
+     * @param key Should be a stable and unique key inside the `run()`. See [resumability](https://trigger.dev/docs/documentation/concepts/resumability) for more information.
+     * @param options The options of how you'd like to run and log the Task. Name is required.
+     * @param callback The callback that will be called when the Task is run. The callback receives the Task and the IO as parameters.
+  =   * @param onError The callback that will be called when the Task fails. The callback receives the error, the Task and the IO as parameters. If you wish to retry then return an object with a `retryAt` property.
+     * @returns A Promise that resolves with the returned value of the callback.
+     */
     runTask<TResult extends SerializableJson | void = void>(key: string | any[], options: RunTaskOptions, callback: (task: IOTask, io: IO) => Promise<TResult>, onError?: (error: unknown, task: IOTask, io: IO) => {
         retryAt: Date;
         error?: Error;
         jitter?: number;
     } | undefined | void): Promise<TResult>;
+    /** `io.try()` allows you to run Tasks and catch any errors that are thrown, it's similar to a normal `try/catch` block but works with [io.runTask()](/sdk/io/runtask).
+     * A regular `try/catch` block on its own won't work as expected with Tasks. Internally `runTask()` throws some special errors to control flow execution. This is necessary to deal with resumability, serverless timeouts, and retrying Tasks.
+     * @param tryCallback The code you wish to run
+     * @param catchCallback Thhis will be called if the Task fails. The callback receives the error
+     * @returns A Promise that resolves with the returned value or the error
+     */
     try<TResult, TCatchResult>(tryCallback: () => Promise<TResult>, catchCallback: (error: unknown) => Promise<TCatchResult>): Promise<TResult | TCatchResult>;
 }
 type CallbackFunction = (level: "DEBUG" | "INFO" | "WARN" | "ERROR" | "LOG", message: string, properties?: Record<string, any>) => Promise<void>;
@@ -4118,12 +4230,40 @@ declare class EventTrigger<TEventSpecification extends EventSpecification<any>>
     attachToJob(triggerClient: TriggerClient, job: Job<Trigger<TEventSpecification>, any>): void;
     get preprocessRuns(): boolean;
 }
+/** Configuration options for an EventTrigger */
 type TriggerOptions<TEvent> = {
+    /** The name of the event you are subscribing to. Must be an exact match (case sensitive). */
     name: string;
+    /** A [Zod](https://trigger.dev/docs/documentation/guides/zod) schema that defines the shape of the event payload.
+     * The default is `z.any()` which is `any`.
+     * */
     schema?: z.Schema<TEvent>;
+    /** You can use this to filter events based on the source. */
     source?: string;
+    /** Used to filter which events trigger the Job
+     * @example
+     * filter:
+     * ```ts
+     * {
+     *    name: ["John", "Jane"],
+     *    age: [18, 21]
+     * }
+     * ```
+     *
+     * This filter would match against an event with the following data:
+     * ```json
+     * {
+     *    "name": "Jane",
+     *    "age": 18,
+     *    "location": "San Francisco"
+     * }
+     * ```
+     */
     filter?: EventFilter;
 };
+/** `eventTrigger()` is set as a [Job's trigger](https://trigger.dev/docs/sdk/job) to subscribe to an event a Job from [a sent event](https://trigger.dev/docs/sdk/triggerclient/instancemethods/sendevent)
+ * @param options options for the EventTrigger
+ */
 declare function eventTrigger<TEvent extends any = any>(options: TriggerOptions<TEvent>): Trigger<EventSpecification<TEvent>>;
 
 declare function missingConnectionNotification(integrations: Array<TriggerIntegration>): MissingConnectionNotification;
@@ -4236,6 +4376,12 @@ declare class RetryWithTaskError {
     retryAt: Date;
     constructor(cause: ErrorWithStack, task: ServerTask, retryAt: Date);
 }
+/** Use this function if you're using a `try/catch` block to catch errors.
+ * It checks if a thrown error is a special internal error that you should ignore.
+ * If this returns `true` then you must rethrow the error: `throw err;`
+ * @param err The error to check
+ * @returns `true` if the error is a Trigger Error, `false` otherwise.
+ */
 declare function isTriggerError(err: unknown): err is ResumeWithTaskError | RetryWithTaskError;
 
 type Task = ServerTask;