@trigger.dev/sdk 2.0.0-next.5 → 2.0.0-next.8

package/dist/index.d.ts

@@ -1,11 +1,20 @@
 import * as zod from 'zod';
 import { z } from 'zod';
 
+/**
+ * Represents different log levels.
+ * - `"log"`: Only essential messages.
+ * - `"error"`: Errors and essential messages.
+ * - `"warn"`: Warnings, Errors and essential messages.
+ * - `"info"`: Info, Warnings, Errors and essential messages.
+ * - `"debug"`: Everything.
+ */
 type LogLevel = "log" | "error" | "warn" | "info" | "debug";
 declare class Logger {
     #private;
     constructor(name: string, level?: LogLevel, filteredKeys?: string[], jsonReplacer?: (key: string, value: unknown) => unknown);
     filter(...keys: string[]): Logger;
+    static satisfiesLogLevel(logLevel: LogLevel, setLevel: LogLevel): boolean;
     log(...args: any[]): void;
     error(...args: any[]): void;
     warn(...args: any[]): void;
@@ -733,17 +742,34 @@ declare const JobMetadataSchema: z.ZodObject<{
 }>;
 type JobMetadata = z.infer<typeof JobMetadataSchema>;
 declare const RawEventSchema: z.ZodObject<{
-    id: z.ZodDefault<z.ZodString>;
+    /** The `name` property must exactly match any subscriptions you want to
+        trigger. */
     name: z.ZodString;
-    source: z.ZodOptional<z.ZodString>;
+    /** The `payload` property will be sent to any matching Jobs and will appear
+        as the `payload` param of the `run()` function. You can leave this
+        parameter out if you just want to trigger a Job without any input data. */
     payload: z.ZodAny;
+    /** The optional `context` property will be sent to any matching Jobs and will
+        be passed through as the `context.event.context` param of the `run()`
+        function. This is optional but can be useful if you want to pass through
+        some additional context to the Job. */
     context: z.ZodOptional<z.ZodAny>;
-    timestamp: z.ZodOptional<z.ZodString>;
+    /** The `id` property uniquely identify this particular event. If unset it
+        will be set automatically using `ulid`. */
+    id: z.ZodDefault<z.ZodString>;
+    /** This is optional, it defaults to the current timestamp. Usually you would
+        only set this if you have a timestamp that you wish to pass through, e.g.
+        you receive a timestamp from a service and you want the same timestamp to
+        be used in your Job. */
+    timestamp: z.ZodOptional<z.ZodDate>;
+    /** This is optional, it defaults to "trigger.dev". It can be useful to set
+        this as you can filter events using this in the `eventTrigger()`. */
+    source: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     source?: string | undefined;
     payload?: any;
     context?: any;
-    timestamp?: string | undefined;
+    timestamp?: Date | undefined;
     id: string;
     name: string;
 }, {
@@ -751,20 +777,30 @@ declare const RawEventSchema: z.ZodObject<{
     source?: string | undefined;
     payload?: any;
     context?: any;
-    timestamp?: string | undefined;
+    timestamp?: Date | undefined;
     name: string;
 }>;
+/** The event you wish to send to Trigger a Job */
 type SendEvent = z.input<typeof RawEventSchema>;
+/** Options to control the delivery of the event */
 declare const SendEventOptionsSchema: z.ZodObject<{
-    deliverAt: z.ZodOptional<z.ZodString>;
+    /** An optional Date when you want the event to trigger Jobs. The event will
+        be sent to the platform immediately but won't be acted upon until the
+        specified time. */
+    deliverAt: z.ZodOptional<z.ZodDate>;
+    /** An optional number of seconds you want to wait for the event to trigger
+        any relevant Jobs. The event will be sent to the platform immediately but
+        won't be delivered until after the elapsed number of seconds. */
     deliverAfter: z.ZodOptional<z.ZodNumber>;
+    /** This optional param will be used by Trigger.dev Connect, which
+        is coming soon. */
     accountId: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
-    deliverAt?: string | undefined;
+    deliverAt?: Date | undefined;
     deliverAfter?: number | undefined;
     accountId?: string | undefined;
 }, {
-    deliverAt?: string | undefined;
+    deliverAt?: Date | undefined;
     deliverAfter?: number | undefined;
     accountId?: string | undefined;
 }>;
@@ -1192,12 +1228,24 @@ declare const CreateRunBodySchema: z.ZodObject<{
         preprocessRuns: boolean;
     }>;
     event: z.ZodObject<{
+        /** The `id` of the event that was sent.
+         */
         id: z.ZodString;
+        /** The `name` of the event that was sent. */
         name: z.ZodString;
+        /** The `payload` of the event that was sent */
         payload: z.ZodType<DeserializedJson, z.ZodTypeDef, DeserializedJson>;
+        /** The `context` of the event that was sent. Is `undefined` if no context was
+            set when sending the event. */
         context: z.ZodNullable<z.ZodOptional<z.ZodType<DeserializedJson, z.ZodTypeDef, DeserializedJson>>>;
+        /** The `timestamp` of the event that was sent */
         timestamp: z.ZodDate;
+        /** The timestamp when the event will be delivered to any matching Jobs. Is
+            `undefined` if `deliverAt` or `deliverAfter` wasn't set when sending the
+            event. */
         deliverAt: z.ZodNullable<z.ZodOptional<z.ZodDate>>;
+        /** The timestamp when the event was delivered. Is `undefined` if `deliverAt`
+            or `deliverAfter` were set when sending the event. */
         deliveredAt: z.ZodNullable<z.ZodOptional<z.ZodDate>>;
     }, "strip", z.ZodTypeAny, {
         context?: DeserializedJson | undefined;
@@ -1427,13 +1475,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;
@@ -1447,7 +1526,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;
@@ -1595,43 +1699,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<{
-        limit: z.ZodOptional<z.ZodNumber>;
-        factor: z.ZodOptional<z.ZodNumber>;
-        minTimeoutInMs: z.ZodOptional<z.ZodNumber>;
-        maxTimeoutInMs: z.ZodOptional<z.ZodNumber>;
-        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;
@@ -1680,11 +1747,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;
@@ -1692,6 +1754,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;
 }, {
@@ -1743,11 +1810,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;
@@ -1755,17 +1817,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;
@@ -1779,7 +1877,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;
@@ -1927,43 +2050,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<{
-        limit: z.ZodOptional<z.ZodNumber>;
-        factor: z.ZodOptional<z.ZodNumber>;
-        minTimeoutInMs: z.ZodOptional<z.ZodNumber>;
-        maxTimeoutInMs: z.ZodOptional<z.ZodNumber>;
-        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>;
@@ -2016,11 +2102,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;
@@ -2028,6 +2109,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;
@@ -2081,11 +2167,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;
@@ -2093,18 +2174,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;
@@ -2118,7 +2235,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;
@@ -2266,43 +2408,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<{
-        limit: z.ZodOptional<z.ZodNumber>;
-        factor: z.ZodOptional<z.ZodNumber>;
-        minTimeoutInMs: z.ZodOptional<z.ZodNumber>;
-        maxTimeoutInMs: z.ZodOptional<z.ZodNumber>;
-        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>;
@@ -2689,9 +2794,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;
@@ -2782,14 +2891,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;
@@ -2798,14 +2912,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;
@@ -2822,6 +2940,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;
@@ -3089,8 +3210,11 @@ declare const MissingConnectionResolvedNotificationPayloadSchema: z.ZodDiscrimin
 }>]>;
 type MissingConnectionResolvedNotificationPayload = z.infer<typeof MissingConnectionResolvedNotificationPayloadSchema>;
 
+/** The options for a fetch request */
 declare const FetchRequestInitSchema: z.ZodObject<{
+    /** The HTTP method to use for the request. */
     method: z.ZodOptional<z.ZodString>;
+    /** Any headers to send with the request. Note that you can use [redactString](https://trigger.dev/docs/sdk/redactString) to prevent sensitive information from being stored (e.g. in the logs), like API keys and tokens. */
     headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodObject<{
         __redactedString: z.ZodLiteral<true>;
         strings: z.ZodArray<z.ZodString, "many">;
@@ -3104,6 +3228,7 @@ declare const FetchRequestInitSchema: z.ZodObject<{
         strings: string[];
         interpolations: string[];
     }>]>>>;
+    /** The body of the request. */
     body: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodType<ArrayBuffer, z.ZodTypeDef, ArrayBuffer>]>>;
 }, "strip", z.ZodTypeAny, {
     method?: string | undefined;
@@ -3122,11 +3247,16 @@ declare const FetchRequestInitSchema: z.ZodObject<{
     }> | undefined;
     body?: string | ArrayBuffer | undefined;
 }>;
+/** The options for a fetch request */
 type FetchRequestInit = z.infer<typeof FetchRequestInitSchema>;
 declare const FetchRetryOptionsSchema: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<"strategy", [z.ZodObject<{
+    /** The `headers` strategy retries the request using info from the response headers. */
     strategy: z.ZodLiteral<"headers">;
+    /** The header to use to determine the maximum number of times to retry the request. */
     limitHeader: z.ZodString;
+    /** The header to use to determine the number of remaining retries. */
     remainingHeader: z.ZodString;
+    /** The header to use to determine the time when the number of remaining retries will be reset. */
     resetHeader: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     strategy: "headers";
@@ -3145,6 +3275,7 @@ declare const FetchRetryOptionsSchema: z.ZodRecord<z.ZodString, z.ZodDiscriminat
     maxTimeoutInMs: z.ZodOptional<z.ZodNumber>;
     randomize: z.ZodOptional<z.ZodBoolean>;
 }, {
+    /** The `backoff` strategy retries the request with an exponential backoff. */
     strategy: z.ZodLiteral<"backoff">;
 }>, "strip", z.ZodTypeAny, {
     limit?: number | undefined;
@@ -3161,8 +3292,17 @@ declare const FetchRetryOptionsSchema: z.ZodRecord<z.ZodString, z.ZodDiscriminat
     randomize?: boolean | undefined;
     strategy: "backoff";
 }>]>>;
+/** An object where the key is a status code pattern and the value is a retrying strategy. Supported patterns are:
+  - Specific status codes: 429
+  - Ranges: 500-599
+  - Wildcards: 2xx, 3xx, 4xx, 5xx
+  */
 type FetchRetryOptions = z.infer<typeof FetchRetryOptionsSchema>;
 
+type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+
 type ApiClientOptions = {
     apiKey?: string;
     apiUrl?: string;
@@ -3491,7 +3631,7 @@ declare class ExternalSource<TIntegration extends TriggerIntegration<Integration
             source?: string | undefined;
             payload?: any;
             context?: any;
-            timestamp?: string | undefined;
+            timestamp?: Date | undefined;
             name: string;
         }[];
         response?: {
@@ -3558,15 +3698,29 @@ declare class DynamicTrigger<TEventSpec extends EventSpecification<any>, TExtern
 }
 
 type TriggerClientOptions = {
+    /** The `id` property is used to uniquely identify the client.
+     */
     id: string;
+    /** The `apiKey` property is the API Key for your Trigger.dev environment. We
+        recommend using an environment variable to store your API Key. */
     apiKey?: string;
+    /** The `apiUrl` property is an optional property that specifies the API URL. You
+        only need to specify this if you are not using Trigger.dev Cloud and are
+        running your own Trigger.dev instance. */
     apiUrl?: string;
+    /** The `logLevel` property is an optional property that specifies the level of
+        logging for the TriggerClient. The level is inherited by all Jobs that use this Client, unless they also specify a `logLevel`. */
     logLevel?: LogLevel;
+    /** Very verbose log messages, defaults to false. */
+    verbose?: boolean;
+    /** Default is unset and off. If set to true it will log to the server's console as well as the Trigger.dev platform */
+    ioLogLocalEnabled?: boolean;
 };
+/** A [TriggerClient](https://trigger.dev/docs/documentation/concepts/client-adaptors) is used to connect to a specific [Project](https://trigger.dev/docs/documentation/concepts/projects) by using an [API Key](https://trigger.dev/docs/documentation/concepts/environments-apikeys). */
 declare class TriggerClient {
     #private;
     id: string;
-    constructor(options: TriggerClientOptions);
+    constructor(options: Prettify<TriggerClientOptions>);
     handleRequest(request: Request): Promise<NormalizedResponse>;
     attach(job: Job<Trigger<any>, any>): void;
     attachDynamicTrigger(trigger: DynamicTrigger<any, any>): void;
@@ -3607,6 +3761,11 @@ 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()`](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;
         deliverAt?: Date | null | undefined;
@@ -3765,6 +3924,8 @@ type IOOptions = {
     context: TriggerContext;
     logger?: Logger;
     logLevel?: LogLevel;
+    jobLogger?: Logger;
+    jobLogLevel: LogLevel;
     cachedTasks?: Array<CachedTask>;
 };
 declare class IO {
@@ -3773,13 +3934,36 @@ declare class IO {
     private _apiClient;
     private _triggerClient;
     private _logger;
+    private _jobLogger?;
+    private _jobLogLevel;
     private _cachedTasks;
     private _taskStorage;
     private _context;
     constructor(options: IOOptions);
+    /** Used to send log messages to the [Run log](https://trigger.dev/docs/documentation/guides/viewing-runs). */
     get logger(): IOLogger;
+    /** `io.wait()` waits for the specified amount of time before continuing the Job. Delays work even if you're on a serverless platform with timeouts, or if your server goes down. They utilize [resumability](https://trigger.dev/docs/documentation/concepts/resumability) to ensure that the Run can be resumed after the delay.
+     * @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 seconds The number of seconds to wait. This can be very long, serverless timeouts are not an issue.
+     */
     wait(key: string | any[], seconds: number): Promise<void>;
+    /** `io.backgroundFetch()` fetches data from a URL that can take longer that the serverless timeout. The actual `fetch` request is performed on the Trigger.dev platform, and the response is sent back to you.
+     * @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 url The URL to fetch from.
+     * @param requestInit The options for the request
+     * @param retry The options for retrying the request if it fails
+     * An object where the key is a status code pattern and the value is a retrying strategy.
+     * Supported patterns are:
+     * - Specific status codes: 429
+     * - Ranges: 500-599
+     * - Wildcards: 2xx, 3xx, 4xx, 5xx
+     */
     backgroundFetch<TResponseData>(key: string | any[], url: string, requestInit?: FetchRequestInit, retry?: FetchRetryOptions): Promise<TResponseData>;
+    /** `io.sendEvent()` allows you to send an event from inside a Job run. The sent even will trigger any Jobs that are listening for that event (based on the name).
+     * @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 event The event to send. The event name must match the name of the event that your Jobs are listening for.
+     * @param options Options for sending the event.
+     */
     sendEvent(key: string | any[], event: SendEvent, options?: SendEventOptions): Promise<{
         context?: DeserializedJson | undefined;
         deliverAt?: Date | null | undefined;
@@ -3795,6 +3979,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;
@@ -3813,9 +4004,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;
@@ -3834,28 +4036,59 @@ 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", message: string, properties?: Record<string, any>) => Promise<void>;
+type CallbackFunction = (level: "DEBUG" | "INFO" | "WARN" | "ERROR" | "LOG", message: string, properties?: Record<string, any>) => Promise<void>;
 declare class IOLogger implements TaskLogger {
     private callback;
     constructor(callback: CallbackFunction);
+    /** Log: essential messages */
+    log(message: string, properties?: Record<string, any>): Promise<void>;
+    /** For debugging: the least important log level */
     debug(message: string, properties?: Record<string, any>): Promise<void>;
+    /** Info: the second least important log level */
     info(message: string, properties?: Record<string, any>): Promise<void>;
+    /** Warnings: the third most important log level  */
     warn(message: string, properties?: Record<string, any>): Promise<void>;
+    /** Error: The second most important log level */
     error(message: string, properties?: Record<string, any>): Promise<void>;
 }
 
@@ -3909,28 +4142,69 @@ type ExtractIntegrations<TIntegrations extends Record<string, TriggerIntegration
 type IOWithIntegrations<TIntegrations extends Record<string, TriggerIntegration<IntegrationClient<any, any>>>> = IO & ExtractIntegrations<TIntegrations>;
 
 type JobOptions<TTrigger extends Trigger<EventSpecification<any>>, TIntegrations extends Record<string, TriggerIntegration<IntegrationClient<any, any>>> = {}> = {
+    /** The `id` property is used to uniquely identify the Job. Only change this if you want to create a new Job. */
     id: string;
+    /** The `name` of the Job that you want to appear in the dashboard and logs. You can change this without creating a new Job. */
     name: string;
+    /** The `version` property is used to version your Job. A new version will be created if you change this property. We recommend using [semantic versioning](https://www.baeldung.com/cs/semantic-versioning), e.g. `1.0.3`. */
     version: string;
+    /** The `trigger` property is used to define when the Job should run. There are currently the following Trigger types:
+        - [cronTrigger](https://trigger.dev/docs/sdk/crontrigger)
+        - [intervalTrigger](https://trigger.dev/docs/sdk/intervaltrigger)
+        - [eventTrigger](https://trigger.dev/docs/sdk/eventtrigger)
+        - [DynamicTrigger](https://trigger.dev/docs/sdk/dynamictrigger)
+        - [DynamicSchedule](https://trigger.dev/docs/sdk/dynamicschedule)
+        - integration Triggers, like webhooks. See the [integrations](https://trigger.dev/docs/integrations) page for more information. */
     trigger: TTrigger;
+    /** The `logLevel` property is an optional property that specifies the level of
+        logging for the Job. The level is inherited from the client if you omit this property. */
     logLevel?: LogLevel;
+    /** Imports the specified integrations into the Job. The integrations will be available on the `io` object in the `run()` function with the same name as the key. For example:
+        ```ts
+        new Job(client, {
+          //... other options
+          integrations: {
+            slack,
+            gh: github,
+          },
+          run: async (payload, io, ctx) => {
+            //slack is available on io.slack
+            io.slack.postMessage(...);
+            //github is available on io.gh
+            io.gh.addIssueLabels(...);
+          }
+        });
+        ``` */
     integrations?: TIntegrations;
+    /** The `queue` property is used to specify a custom queue. If you use an Object and specify the `maxConcurrent` option, you can control how many simulataneous runs can happen. */
     queue?: QueueOptions | string;
     startPosition?: "initial" | "latest";
+    /** The `enabled` property is used to enable or disable the Job. If you disable a Job, it will not run. */
     enabled?: boolean;
-    run: (event: TriggerEventType<TTrigger>, io: IOWithIntegrations<TIntegrations>, ctx: TriggerContext) => Promise<any>;
+    /** This function gets called automatically when a Run is Triggered.
+     * This is where you put the code you want to run for a Job. You can use normal code in here and you can also use Tasks. You can return a value from this function and it will be sent back to the Trigger API.
+     * @param payload The payload of the event
+     * @param io An object that contains the integrations that you specified in the `integrations` property and other useful functions like delays and running Tasks.
+     * @param context An object that contains information about the Organization, Job, Run and more.
+     */
+    run: (payload: TriggerEventType<TTrigger>, io: IOWithIntegrations<TIntegrations>, context: TriggerContext) => Promise<any>;
 };
+/** A [Job](https://trigger.dev/docs/documentation/concepts/jobs) is used to define the [Trigger](https://trigger.dev/docs/documentation/concepts/triggers), metadata, and what happens when it runs. */
 declare class Job<TTrigger extends Trigger<EventSpecification<any>>, TIntegrations extends Record<string, TriggerIntegration<IntegrationClient<any, any>>> = {}> {
     #private;
     readonly options: JobOptions<TTrigger, TIntegrations>;
     client: TriggerClient;
-    constructor(client: TriggerClient, options: JobOptions<TTrigger, TIntegrations>);
+    constructor(
+    /** An instance of [TriggerClient](/sdk/triggerclient) that is used to send events
+  to the Trigger API. */
+    client: TriggerClient, options: JobOptions<TTrigger, TIntegrations>);
     get id(): string;
     get enabled(): boolean;
     get name(): string;
     get trigger(): TTrigger;
     get version(): string;
     get integrations(): Record<string, IntegrationConfig>;
+    get logLevel(): LogLevel | undefined;
     toJSON(): JobMetadata;
 }
 
@@ -4066,6 +4340,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;