@trigger.dev/sdk 0.0.0-background-tasks-20230906212613

package/dist/index.d.ts

@@ -0,0 +1,1325 @@
+import * as _trigger_dev_core from '@trigger.dev/core';
+import { RunTaskBodyInput, CompleteTaskBodyInput, FailTaskBodyInput, SendEvent, SendEventOptions, UpdateTriggerSourceBodyV2, TriggerSource, RegisterTriggerBodyV2, RegisterSourceEventV2, ScheduleMetadata, GetRunOptionsWithTaskDetails, GetRunsOptions, LogLevel, RuntimeEnvironmentType, DisplayProperty, TriggerMetadata, EventFilter, Prettify, HandleTriggerSource, Logger, RegisterTriggerSource, SerializableJson, ConnectionAuth, NormalizedResponse, HttpSourceResponseMetadata, BackgroundTaskMetadata, DeserializedJson, IntervalOptions, CronOptions, ScheduledPayload, ServerTask, CachedTask, FetchRequestInit, FetchRetryOptions, RunTaskOptions, IntegrationMetadata, QueueOptions, IntegrationConfig, JobMetadata, MissingConnectionNotificationPayload, MissingConnectionResolvedNotificationPayload, ErrorWithStack, ApiEventLog, RedactString } from '@trigger.dev/core';
+export { ConnectionAuth, DisplayProperty, EventFilter, Logger, NormalizedRequest, OverridableRunTaskOptions, Prettify, RedactString, RegisteredOptionsDiff, RunTaskOptions, SourceEventOption } from '@trigger.dev/core';
+import * as zod from 'zod';
+import { z } from 'zod';
+
+type ApiClientOptions = {
+    apiKey?: string;
+    apiUrl?: string;
+    logLevel?: LogLevel;
+};
+type EndpointRecord = {
+    id: string;
+    name: string;
+    url: string;
+};
+declare class ApiClient {
+    #private;
+    constructor(options: ApiClientOptions);
+    registerEndpoint(options: {
+        url: string;
+        name: string;
+    }): Promise<EndpointRecord>;
+    runTask(runId: string, task: RunTaskBodyInput): Promise<{
+        id: string;
+        name: string;
+        noop: boolean;
+        status: "PENDING" | "WAITING" | "RUNNING" | "COMPLETED" | "ERRORED" | "CANCELED";
+        idempotencyKey: string;
+        attempts: number;
+        icon?: string | null | undefined;
+        startedAt?: Date | null | undefined;
+        completedAt?: Date | null | undefined;
+        delayUntil?: Date | null | undefined;
+        description?: string | null | undefined;
+        params?: _trigger_dev_core.DeserializedJson | undefined;
+        properties?: {
+            label: string;
+            text: string;
+            url?: string | undefined;
+        }[] | null | undefined;
+        outputProperties?: {
+            label: string;
+            text: string;
+            url?: string | undefined;
+        }[] | null | undefined;
+        output?: _trigger_dev_core.DeserializedJson | undefined;
+        error?: string | null | undefined;
+        parentId?: string | null | undefined;
+        style?: {
+            style: "normal" | "minimal";
+            variant?: string | undefined;
+        } | null | undefined;
+        operation?: string | null | undefined;
+    }>;
+    completeTask(runId: string, id: string, task: CompleteTaskBodyInput): Promise<{
+        id: string;
+        name: string;
+        noop: boolean;
+        status: "PENDING" | "WAITING" | "RUNNING" | "COMPLETED" | "ERRORED" | "CANCELED";
+        idempotencyKey: string;
+        attempts: number;
+        icon?: string | null | undefined;
+        startedAt?: Date | null | undefined;
+        completedAt?: Date | null | undefined;
+        delayUntil?: Date | null | undefined;
+        description?: string | null | undefined;
+        params?: _trigger_dev_core.DeserializedJson | undefined;
+        properties?: {
+            label: string;
+            text: string;
+            url?: string | undefined;
+        }[] | null | undefined;
+        outputProperties?: {
+            label: string;
+            text: string;
+            url?: string | undefined;
+        }[] | null | undefined;
+        output?: _trigger_dev_core.DeserializedJson | undefined;
+        error?: string | null | undefined;
+        parentId?: string | null | undefined;
+        style?: {
+            style: "normal" | "minimal";
+            variant?: string | undefined;
+        } | null | undefined;
+        operation?: string | null | undefined;
+    }>;
+    failTask(runId: string, id: string, body: FailTaskBodyInput): Promise<{
+        id: string;
+        name: string;
+        noop: boolean;
+        status: "PENDING" | "WAITING" | "RUNNING" | "COMPLETED" | "ERRORED" | "CANCELED";
+        idempotencyKey: string;
+        attempts: number;
+        icon?: string | null | undefined;
+        startedAt?: Date | null | undefined;
+        completedAt?: Date | null | undefined;
+        delayUntil?: Date | null | undefined;
+        description?: string | null | undefined;
+        params?: _trigger_dev_core.DeserializedJson | undefined;
+        properties?: {
+            label: string;
+            text: string;
+            url?: string | undefined;
+        }[] | null | undefined;
+        outputProperties?: {
+            label: string;
+            text: string;
+            url?: string | undefined;
+        }[] | null | undefined;
+        output?: _trigger_dev_core.DeserializedJson | undefined;
+        error?: string | null | undefined;
+        parentId?: string | null | undefined;
+        style?: {
+            style: "normal" | "minimal";
+            variant?: string | undefined;
+        } | null | undefined;
+        operation?: string | null | undefined;
+    }>;
+    sendEvent(event: SendEvent, options?: SendEventOptions): Promise<{
+        id: string;
+        name: string;
+        payload: ((string | number | boolean | {
+            [key: string]: _trigger_dev_core.DeserializedJson;
+        } | _trigger_dev_core.DeserializedJson[]) & (string | number | boolean | {
+            [key: string]: _trigger_dev_core.DeserializedJson;
+        } | _trigger_dev_core.DeserializedJson[] | undefined)) | null;
+        timestamp: Date;
+        context?: _trigger_dev_core.DeserializedJson | undefined;
+        deliverAt?: Date | null | undefined;
+        deliveredAt?: Date | null | undefined;
+        cancelledAt?: Date | null | undefined;
+    }>;
+    cancelEvent(eventId: string): Promise<{
+        id: string;
+        name: string;
+        payload: ((string | number | boolean | {
+            [key: string]: _trigger_dev_core.DeserializedJson;
+        } | _trigger_dev_core.DeserializedJson[]) & (string | number | boolean | {
+            [key: string]: _trigger_dev_core.DeserializedJson;
+        } | _trigger_dev_core.DeserializedJson[] | undefined)) | null;
+        timestamp: Date;
+        context?: _trigger_dev_core.DeserializedJson | undefined;
+        deliverAt?: Date | null | undefined;
+        deliveredAt?: Date | null | undefined;
+        cancelledAt?: Date | null | undefined;
+    }>;
+    updateSource(client: string, key: string, source: UpdateTriggerSourceBodyV2): Promise<TriggerSource>;
+    registerTrigger(client: string, id: string, key: string, payload: RegisterTriggerBodyV2): Promise<RegisterSourceEventV2>;
+    registerSchedule(client: string, id: string, key: string, payload: ScheduleMetadata): Promise<{
+        id: string;
+        schedule: {
+            options: {
+                cron: string;
+            };
+            type: "cron";
+            metadata?: any;
+        } | {
+            options: {
+                seconds: number;
+            };
+            type: "interval";
+            metadata?: any;
+        };
+        active: boolean;
+        metadata?: any;
+    }>;
+    unregisterSchedule(client: string, id: string, key: string): Promise<{
+        ok: boolean;
+    }>;
+    getAuth(client: string, id: string): Promise<{
+        type: "oauth2";
+        accessToken: string;
+        scopes?: string[] | undefined;
+        additionalFields?: Record<string, string> | undefined;
+    } | undefined>;
+    getEvent(eventId: string): Promise<{
+        id: string;
+        name: string;
+        createdAt: Date;
+        updatedAt: Date;
+        runs: {
+            id: string;
+            status: "PENDING" | "CANCELED" | "SUCCESS" | "QUEUED" | "WAITING_ON_CONNECTIONS" | "PREPROCESSING" | "STARTED" | "FAILURE" | "TIMED_OUT" | "ABORTED";
+            startedAt?: Date | null | undefined;
+            completedAt?: Date | null | undefined;
+        }[];
+    }>;
+    getRun(runId: string, options?: GetRunOptionsWithTaskDetails): Promise<{
+        id: string;
+        startedAt: Date | null;
+        completedAt: Date | null;
+        status: "PENDING" | "CANCELED" | "SUCCESS" | "QUEUED" | "WAITING_ON_CONNECTIONS" | "PREPROCESSING" | "STARTED" | "FAILURE" | "TIMED_OUT" | "ABORTED";
+        tasks: _trigger_dev_core.RunTaskWithSubtasks[];
+        updatedAt: Date | null;
+        output?: any;
+        nextCursor?: string | undefined;
+    }>;
+    getRuns(jobSlug: string, options?: GetRunsOptions): Promise<{
+        runs: {
+            id: string;
+            startedAt: Date | null;
+            completedAt: Date | null;
+            status: "PENDING" | "CANCELED" | "SUCCESS" | "QUEUED" | "WAITING_ON_CONNECTIONS" | "PREPROCESSING" | "STARTED" | "FAILURE" | "TIMED_OUT" | "ABORTED";
+            updatedAt: Date | null;
+        }[];
+        nextCursor?: string | undefined;
+    }>;
+}
+
+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;
+        isRetry: boolean;
+    };
+    /** Event metadata */
+    event: {
+        id: string;
+        name: string;
+        context: any;
+        timestamp: Date;
+    };
+    /** Source metadata */
+    source?: {
+        id: string;
+        metadata?: any;
+    };
+    /** Account metadata */
+    account?: {
+        id: string;
+        metadata?: any;
+    };
+}
+interface TriggerPreprocessContext {
+    job: {
+        id: string;
+        version: string;
+    };
+    environment: {
+        slug: string;
+        id: string;
+        type: RuntimeEnvironmentType;
+    };
+    organization: {
+        slug: string;
+        id: string;
+        title: string;
+    };
+    run: {
+        id: string;
+        isTest: boolean;
+    };
+    event: {
+        id: string;
+        name: string;
+        context: any;
+        timestamp: Date;
+    };
+    account?: {
+        id: string;
+        metadata?: any;
+    };
+}
+interface TaskLogger {
+    debug(message: string, properties?: Record<string, any>): Promise<void>;
+    info(message: string, properties?: Record<string, any>): Promise<void>;
+    warn(message: string, properties?: Record<string, any>): Promise<void>;
+    error(message: string, properties?: Record<string, any>): Promise<void>;
+}
+type PreprocessResults = {
+    abort: boolean;
+    properties: DisplayProperty[];
+};
+type TriggerEventType<TTrigger extends Trigger<any>> = TTrigger extends Trigger<infer TEventSpec> ? ReturnType<TEventSpec["parsePayload"]> : never;
+interface Trigger<TEventSpec extends EventSpecification<any>> {
+    event: TEventSpec;
+    toJSON(): TriggerMetadata;
+    attachToJob(triggerClient: TriggerClient, job: Job<Trigger<TEventSpec>, any>): void;
+    preprocessRuns: boolean;
+}
+type TriggerPayload<TTrigger> = TTrigger extends Trigger<EventSpecification<infer TEvent>> ? TEvent : never;
+type EventSpecificationExample = {
+    id: string;
+    name: string;
+    icon?: string;
+    payload: any;
+};
+interface EventSpecification<TEvent extends any> {
+    name: string | string[];
+    title: string;
+    source: string;
+    icon: string;
+    properties?: DisplayProperty[];
+    schema?: any;
+    examples?: Array<EventSpecificationExample>;
+    filter?: EventFilter;
+    parsePayload: (payload: unknown) => TEvent;
+    runProperties?: (payload: TEvent) => DisplayProperty[];
+}
+type EventTypeFromSpecification<TEventSpec extends EventSpecification<any>> = TEventSpec extends EventSpecification<infer TEvent> ? TEvent : never;
+
+type HttpSourceEvent = {
+    url: string;
+    method: string;
+    headers: Record<string, string>;
+    rawBody?: Buffer | null;
+};
+type SmtpSourceEvent = {
+    from: string;
+    to: string;
+    subject: string;
+    body: string;
+};
+type SqsSourceEvent = {
+    body: string;
+};
+type ExternalSourceChannelMap = {
+    HTTP: {
+        event: Request;
+        register: {
+            url: string;
+        };
+    };
+    SMTP: {
+        event: SmtpSourceEvent;
+        register: {};
+    };
+    SQS: {
+        event: SqsSourceEvent;
+        register: {};
+    };
+};
+type ChannelNames = keyof ExternalSourceChannelMap;
+type TriggerOptionDiff = {
+    desired: string[];
+    missing: string[];
+    orphaned: string[];
+};
+type TriggerOptionDiffs<TTriggerOptionDefinitions extends Record<string, string[]> = any> = TriggerOptionsRecordWithEvent<TriggerOptionDiff, TTriggerOptionDefinitions>;
+type TriggerOptionsRecordWithEvent<TValue, TTriggerOptionDefinitions extends Record<string, string[]>> = {
+    event: TValue;
+} & TriggerOptionRecord<TValue, TTriggerOptionDefinitions>;
+type TriggerOptionRecord<TValue, TTriggerOptionDefinitions extends Record<string, string[]> = any> = {
+    [K in keyof TTriggerOptionDefinitions]: TValue;
+};
+type RegisterFunctionEvent<TChannel extends ChannelNames, TParams extends any, TTriggerOptionDefinitions extends Record<string, string[]> = any> = {
+    options: TriggerOptionDiffs<TTriggerOptionDefinitions>;
+    source: {
+        active: boolean;
+        data?: any;
+        secret: string;
+    } & ExternalSourceChannelMap[TChannel]["register"];
+    params: TParams;
+};
+type RegisterSourceEvent<TTriggerOptionDefinitions extends Record<string, string[]> = any> = {
+    id: string;
+    source: RegisterTriggerSource;
+    dynamicTriggerId?: string;
+    options: TriggerOptionDiffs<TTriggerOptionDefinitions>;
+};
+type RegisterFunctionOutput<TTriggerOptionDefinitions extends Record<string, string[]> = any> = {
+    secret?: string;
+    data?: SerializableJson;
+    options: TriggerOptionsRecordWithEvent<string[], TTriggerOptionDefinitions>;
+};
+type RegisterFunction<TIntegration extends TriggerIntegration, TParams extends any, TChannel extends ChannelNames, TTriggerOptionDefinitions extends Record<string, string[]> = any> = (event: RegisterFunctionEvent<TChannel, TParams, TTriggerOptionDefinitions>, io: IOWithIntegrations<{
+    integration: TIntegration;
+}>, ctx: TriggerContext) => Promise<RegisterFunctionOutput<TTriggerOptionDefinitions> | undefined>;
+type HandlerEvent<TChannel extends ChannelNames, TParams extends any = any> = {
+    rawEvent: ExternalSourceChannelMap[TChannel]["event"];
+    source: Prettify<Omit<HandleTriggerSource, "params"> & {
+        params: TParams;
+    }>;
+};
+type HandlerFunction<TChannel extends ChannelNames, TParams extends any, TTriggerIntegration extends TriggerIntegration> = (event: HandlerEvent<TChannel, TParams>, logger: Logger, integration: TTriggerIntegration, auth?: ConnectionAuth) => Promise<{
+    events: SendEvent[];
+    response?: NormalizedResponse;
+    metadata?: HttpSourceResponseMetadata;
+} | void>;
+type KeyFunction<TParams extends any> = (params: TParams) => string;
+type FilterFunction<TParams extends any, TTriggerOptionDefinitions extends Record<string, string[]> = any> = (params: TParams, options?: TTriggerOptionDefinitions) => EventFilter;
+type ExternalSourceOptions<TChannel extends ChannelNames, TIntegration extends TriggerIntegration, TParams extends any, TTriggerOptionDefinitions extends Record<string, string[]> = any> = {
+    id: string;
+    version: string;
+    schema: z.Schema<TParams>;
+    optionSchema?: z.Schema<TTriggerOptionDefinitions>;
+    integration: TIntegration;
+    register: RegisterFunction<TIntegration, TParams, TChannel, TTriggerOptionDefinitions>;
+    filter?: FilterFunction<TParams, TTriggerOptionDefinitions>;
+    handler: HandlerFunction<TChannel, TParams, TIntegration>;
+    key: KeyFunction<TParams>;
+    properties?: (params: TParams) => DisplayProperty[];
+};
+declare class ExternalSource<TIntegration extends TriggerIntegration, TParams extends any, TChannel extends ChannelNames = ChannelNames, TTriggerOptionDefinitions extends Record<string, string[]> = any> {
+    private options;
+    channel: TChannel;
+    constructor(channel: TChannel, options: ExternalSourceOptions<TChannel, TIntegration, TParams, TTriggerOptionDefinitions>);
+    handle(source: HandleTriggerSource, rawEvent: ExternalSourceChannelMap[TChannel]["event"], logger: Logger): Promise<void | {
+        events: {
+            name: string;
+            payload?: any;
+            context?: any;
+            id?: string | undefined;
+            timestamp?: Date | undefined;
+            source?: string | undefined;
+        }[];
+        response?: {
+            status: number;
+            body?: any;
+            headers?: Record<string, string> | undefined;
+        } | undefined;
+        metadata?: _trigger_dev_core.DeserializedJson | undefined;
+    }>;
+    filter(params: TParams, options?: TTriggerOptionDefinitions): EventFilter;
+    properties(params: TParams): DisplayProperty[];
+    register(params: TParams, registerEvent: RegisterSourceEvent<TTriggerOptionDefinitions>, io: IO, ctx: TriggerContext): Promise<RegisterFunctionOutput<TTriggerOptionDefinitions> | undefined>;
+    key(params: TParams): string;
+    get integration(): TIntegration;
+    get integrationConfig(): {
+        id: string;
+        metadata: {
+            id: string;
+            name: string;
+            instructions?: string | undefined;
+        };
+    };
+    get id(): string;
+    get version(): string;
+}
+type ExternalSourceParams<TExternalSource extends ExternalSource<any, any, any>> = TExternalSource extends ExternalSource<any, infer TParams, any> ? TParams & {
+    filter?: EventFilter;
+} : never;
+type ExternalSourceTriggerOptions<TEventSpecification extends EventSpecification<any>, TEventSource extends ExternalSource<any, any, any>, TTriggerOptionDefinitions extends Record<string, string[]> = any> = {
+    event: TEventSpecification;
+    source: TEventSource;
+    params: ExternalSourceParams<TEventSource>;
+    options: TriggerOptionRecord<string[], TTriggerOptionDefinitions>;
+};
+declare class ExternalSourceTrigger<TEventSpecification extends EventSpecification<any>, TEventSource extends ExternalSource<any, any, any>> implements Trigger<TEventSpecification> {
+    private options;
+    constructor(options: ExternalSourceTriggerOptions<TEventSpecification, TEventSource>);
+    get event(): TEventSpecification;
+    toJSON(): TriggerMetadata;
+    attachToJob(triggerClient: TriggerClient, job: Job<Trigger<TEventSpecification>, any>): void;
+    get preprocessRuns(): boolean;
+}
+declare function omit<T extends Record<string, unknown>, K extends keyof T>(obj: T, key: K): {
+    result: Omit<T, K>;
+    ommited: T[K];
+};
+
+/** Options for a DynamicTrigger  */
+type DynamicTriggerOptions<TEventSpec extends EventSpecification<any>, TExternalSource extends ExternalSource<any, any, any>> = {
+    /** Used to uniquely identify a DynamicTrigger */
+    id: string;
+    /** An event from an [Integration](https://trigger.dev/docs/integrations) package that you want to attach to the DynamicTrigger. The event types will come through to the payload in your Job's run. */
+    event: TEventSpec;
+    /** An external source fron an [Integration](https://trigger.dev/docs/integrations) package
+     * @example
+     * ```ts
+     *  import { events } from "@trigger.dev/github";
+     *
+     *  const dynamicOnIssueOpened = new DynamicTrigger(client, {
+          id: "github-issue-opened",
+          event: events.onIssueOpened,
+          source: github.sources.repo,
+        });
+     * ```
+      */
+    source: TExternalSource;
+};
+/** `DynamicTrigger` allows you to define a trigger that can be configured dynamically at runtime. */
+declare class DynamicTrigger<TEventSpec extends EventSpecification<any>, TExternalSource extends ExternalSource<any, any, any>> implements Trigger<TEventSpec> {
+    #private;
+    source: TExternalSource;
+    /** `DynamicTrigger` allows you to define a trigger that can be configured dynamically at runtime.
+     * @param client The `TriggerClient` instance to use for registering the trigger.
+     * @param options The options for the dynamic trigger.
+     * */
+    constructor(client: TriggerClient, options: DynamicTriggerOptions<TEventSpec, TExternalSource>);
+    toJSON(): TriggerMetadata;
+    get id(): string;
+    get event(): TEventSpec;
+    registeredTriggerForParams(params: ExternalSourceParams<TExternalSource>): RegisterTriggerBodyV2;
+    /** Use this method to register a new configuration with the DynamicTrigger.
+     * @param key The key for the configuration. This will be used to identify the configuration when it is triggered.
+     * @param params The params for the configuration.
+     */
+    register(key: string, params: ExternalSourceParams<TExternalSource>): Promise<RegisterSourceEventV2>;
+    attachToJob(triggerClient: TriggerClient, job: Job<Trigger<TEventSpec>, any>): void;
+    get preprocessRuns(): boolean;
+}
+
+type BackgroundTaskOptions<TPayload = any> = {
+    id: string;
+    name: string;
+    version: string;
+    schema?: z.Schema<TPayload>;
+    logLevel?: LogLevel;
+    cpu?: 1 | 2 | 4 | 8 | 16 | 32 | 64 | 128;
+    memory?: 256 | 512 | 1024 | 2048 | 4096 | 8192 | 16384 | 32768;
+    concurrency?: number;
+    secrets?: {
+        [key: string]: string;
+    };
+    enabled?: boolean;
+    run: (payload: TPayload) => Promise<any>;
+};
+declare class BackgroundTask<TPayload = any> {
+    #private;
+    readonly options: BackgroundTaskOptions<TPayload>;
+    client: TriggerClient;
+    constructor(client: TriggerClient, options: BackgroundTaskOptions<TPayload>);
+    get id(): string;
+    get enabled(): boolean;
+    get name(): string;
+    get schema(): z.ZodType<TPayload, z.ZodTypeDef, TPayload> | undefined;
+    get version(): string;
+    get logLevel(): LogLevel | undefined;
+    invoke(key: string, payload: TPayload): Promise<any>;
+    toJSON(): BackgroundTaskMetadata;
+}
+
+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: Prettify<TriggerClientOptions>);
+    handleRequest(request: Request): Promise<NormalizedResponse>;
+    attach(job: Job<Trigger<any>, any>): void;
+    attachBackgroundTask(task: BackgroundTask<any>): void;
+    attachDynamicTrigger(trigger: DynamicTrigger<any, any>): void;
+    attachJobToDynamicTrigger(job: Job<Trigger<any>, any>, trigger: DynamicTrigger<any, any>): void;
+    attachSource(options: {
+        key: string;
+        source: ExternalSource<any, any>;
+        event: EventSpecification<any>;
+        params: any;
+        options?: Record<string, string[]>;
+    }): void;
+    attachDynamicSchedule(key: string, job: Job<Trigger<any>, any>): void;
+    registerTrigger(id: string, key: string, options: RegisterTriggerBodyV2): Promise<{
+        id: string;
+        options: {
+            event: {
+                desired: string[];
+                missing: string[];
+                orphaned: string[];
+            };
+        } & Record<string, {
+            desired: string[];
+            missing: string[];
+            orphaned: string[];
+        }>;
+        source: {
+            key: string;
+            secret: string;
+            active: boolean;
+            channel: {
+                url: string;
+                type: "HTTP";
+            } | {
+                type: "SMTP";
+            } | {
+                type: "SQS";
+            };
+            params?: any;
+            data?: DeserializedJson | undefined;
+            clientId?: string | undefined;
+        };
+        dynamicTriggerId?: string | undefined;
+    }>;
+    getAuth(id: string): Promise<{
+        type: "oauth2";
+        accessToken: string;
+        scopes?: string[] | undefined;
+        additionalFields?: Record<string, string> | undefined;
+    } | 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<{
+        id: string;
+        name: string;
+        payload: ((string | number | boolean | {
+            [key: string]: DeserializedJson;
+        } | DeserializedJson[]) & (string | number | boolean | {
+            [key: string]: DeserializedJson;
+        } | DeserializedJson[] | undefined)) | null;
+        timestamp: Date;
+        context?: DeserializedJson | undefined;
+        deliverAt?: Date | null | undefined;
+        deliveredAt?: Date | null | undefined;
+        cancelledAt?: Date | null | undefined;
+    }>;
+    cancelEvent(eventId: string): Promise<{
+        id: string;
+        name: string;
+        payload: ((string | number | boolean | {
+            [key: string]: DeserializedJson;
+        } | DeserializedJson[]) & (string | number | boolean | {
+            [key: string]: DeserializedJson;
+        } | DeserializedJson[] | undefined)) | null;
+        timestamp: Date;
+        context?: DeserializedJson | undefined;
+        deliverAt?: Date | null | undefined;
+        deliveredAt?: Date | null | undefined;
+        cancelledAt?: Date | null | undefined;
+    }>;
+    registerSchedule(id: string, key: string, schedule: ScheduleMetadata): Promise<{
+        id: string;
+        schedule: {
+            options: {
+                cron: string;
+            };
+            type: "cron";
+            metadata?: any;
+        } | {
+            options: {
+                seconds: number;
+            };
+            type: "interval";
+            metadata?: any;
+        };
+        active: boolean;
+        metadata?: any;
+    }>;
+    unregisterSchedule(id: string, key: string): Promise<{
+        ok: boolean;
+    }>;
+    getEvent(eventId: string): Promise<{
+        id: string;
+        name: string;
+        createdAt: Date;
+        updatedAt: Date;
+        runs: {
+            id: string;
+            status: "PENDING" | "CANCELED" | "SUCCESS" | "QUEUED" | "WAITING_ON_CONNECTIONS" | "PREPROCESSING" | "STARTED" | "FAILURE" | "TIMED_OUT" | "ABORTED";
+            startedAt?: Date | null | undefined;
+            completedAt?: Date | null | undefined;
+        }[];
+    }>;
+    getRun(runId: string, options?: GetRunOptionsWithTaskDetails): Promise<{
+        id: string;
+        startedAt: Date | null;
+        completedAt: Date | null;
+        status: "PENDING" | "CANCELED" | "SUCCESS" | "QUEUED" | "WAITING_ON_CONNECTIONS" | "PREPROCESSING" | "STARTED" | "FAILURE" | "TIMED_OUT" | "ABORTED";
+        tasks: _trigger_dev_core.RunTaskWithSubtasks[];
+        updatedAt: Date | null;
+        output?: any;
+        nextCursor?: string | undefined;
+    }>;
+    getRuns(jobSlug: string, options?: GetRunsOptions): Promise<{
+        runs: {
+            id: string;
+            startedAt: Date | null;
+            completedAt: Date | null;
+            status: "PENDING" | "CANCELED" | "SUCCESS" | "QUEUED" | "WAITING_ON_CONNECTIONS" | "PREPROCESSING" | "STARTED" | "FAILURE" | "TIMED_OUT" | "ABORTED";
+            updatedAt: Date | null;
+        }[];
+        nextCursor?: string | undefined;
+    }>;
+    authorized(apiKey?: string | null): "authorized" | "unauthorized" | "missing-client" | "missing-header";
+    apiKey(): string | undefined;
+    defineJob<TTrigger extends Trigger<EventSpecification<any>>, TIntegrations extends Record<string, TriggerIntegration> = {}>(options: JobOptions<TTrigger, TIntegrations>): Job<TTrigger, TIntegrations>;
+    defineBackgroundTask<TPayload = any>(options: BackgroundTaskOptions<TPayload>): BackgroundTask<TPayload>;
+}
+
+type ScheduledEventSpecification = EventSpecification<ScheduledPayload>;
+declare class IntervalTrigger implements Trigger<ScheduledEventSpecification> {
+    private options;
+    constructor(options: IntervalOptions);
+    get event(): {
+        name: string;
+        title: string;
+        source: string;
+        icon: string;
+        examples: {
+            id: string;
+            name: string;
+            icon: string;
+            payload: {
+                ts: string;
+                lastTimestamp: string;
+            };
+        }[];
+        parsePayload: (data: unknown, params?: Partial<zod.ParseParams> | undefined) => {
+            ts: Date;
+            lastTimestamp?: Date | undefined;
+        };
+        properties: {
+            label: string;
+            text: string;
+        }[];
+    };
+    attachToJob(triggerClient: TriggerClient, job: Job<Trigger<ScheduledEventSpecification>, any>): void;
+    get preprocessRuns(): boolean;
+    toJSON(): TriggerMetadata;
+}
+/** `intervalTrigger()` is set as a [Job's trigger](/sdk/job) to trigger a Job at a recurring interval.
+ * @param options An object containing options about the interval.
+ */
+declare function intervalTrigger(options: IntervalOptions): IntervalTrigger;
+declare class CronTrigger implements Trigger<ScheduledEventSpecification> {
+    private options;
+    constructor(options: CronOptions);
+    get event(): {
+        name: string;
+        title: string;
+        source: string;
+        icon: string;
+        examples: {
+            id: string;
+            name: string;
+            icon: string;
+            payload: {
+                ts: string;
+                lastTimestamp: string;
+            };
+        }[];
+        parsePayload: (data: unknown, params?: Partial<zod.ParseParams> | undefined) => {
+            ts: Date;
+            lastTimestamp?: Date | undefined;
+        };
+        properties: {
+            label: string;
+            text: string;
+        }[];
+    };
+    attachToJob(triggerClient: TriggerClient, job: Job<Trigger<ScheduledEventSpecification>, any>): void;
+    get preprocessRuns(): boolean;
+    toJSON(): TriggerMetadata;
+}
+/** `cronTrigger()` is set as a [Job's trigger](https://trigger.dev/docs/sdk/job) to trigger a Job on a recurring schedule using a CRON expression.
+ * @param options An object containing options about the CRON schedule.
+ */
+declare function cronTrigger(options: CronOptions): CronTrigger;
+/** DynamicSchedule options
+ * @param id Used to uniquely identify a DynamicSchedule
+ */
+type DynamicIntervalOptions = {
+    id: string;
+};
+/** DynamicSchedule` allows you to define a scheduled trigger that can be configured dynamically at runtime. */
+declare class DynamicSchedule implements Trigger<ScheduledEventSpecification> {
+    private client;
+    private options;
+    /**
+     * @param client The `TriggerClient` instance to use for registering the trigger.
+     * @param options The options for the schedule.
+     */
+    constructor(client: TriggerClient, options: DynamicIntervalOptions);
+    get id(): string;
+    get event(): {
+        name: string;
+        title: string;
+        source: string;
+        icon: string;
+        examples: {
+            id: string;
+            name: string;
+            icon: string;
+            payload: {
+                ts: string;
+                lastTimestamp: string;
+            };
+        }[];
+        parsePayload: (data: unknown, params?: Partial<zod.ParseParams> | undefined) => {
+            ts: Date;
+            lastTimestamp?: Date | undefined;
+        };
+    };
+    register(key: string, metadata: ScheduleMetadata): Promise<{
+        id: string;
+        schedule: {
+            options: {
+                cron: string;
+            };
+            type: "cron";
+            metadata?: any;
+        } | {
+            options: {
+                seconds: number;
+            };
+            type: "interval";
+            metadata?: any;
+        };
+        active: boolean;
+        metadata?: any;
+    }>;
+    unregister(key: string): Promise<{
+        ok: boolean;
+    }>;
+    attachToJob(triggerClient: TriggerClient, job: Job<Trigger<ScheduledEventSpecification>, any>): void;
+    get preprocessRuns(): boolean;
+    toJSON(): TriggerMetadata;
+}
+
+type IOTask = ServerTask;
+type IOOptions = {
+    id: string;
+    apiClient: ApiClient;
+    client: TriggerClient;
+    context: TriggerContext;
+    logger?: Logger;
+    logLevel?: LogLevel;
+    jobLogger?: Logger;
+    jobLogLevel: LogLevel;
+    cachedTasks?: Array<CachedTask>;
+};
+type JsonPrimitive = string | number | boolean | null | undefined | Date | symbol;
+type JsonArray = Json[];
+type JsonRecord<T> = {
+    [Property in keyof T]: Json;
+};
+type Json<T = any> = JsonPrimitive | JsonArray | JsonRecord<T>;
+type RunTaskErrorCallback = (error: unknown, task: IOTask, io: IO) => {
+    retryAt: Date;
+    error?: Error;
+    jitter?: number;
+} | Error | undefined | void;
+declare class IO {
+    #private;
+    private _id;
+    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<{
+        id: string;
+        name: string;
+        payload: ((string | number | boolean | {
+            [key: string]: _trigger_dev_core.DeserializedJson;
+        } | _trigger_dev_core.DeserializedJson[]) & (string | number | boolean | {
+            [key: string]: _trigger_dev_core.DeserializedJson;
+        } | _trigger_dev_core.DeserializedJson[] | undefined)) | null;
+        timestamp: Date;
+        context?: _trigger_dev_core.DeserializedJson | undefined;
+        deliverAt?: Date | null | undefined;
+        deliveredAt?: Date | null | undefined;
+        cancelledAt?: Date | null | undefined;
+    }>;
+    getEvent(key: string | any[], id: string): Promise<{
+        id: string;
+        name: string;
+        createdAt: Date;
+        updatedAt: Date;
+        runs: {
+            id: string;
+            status: "PENDING" | "CANCELED" | "SUCCESS" | "QUEUED" | "WAITING_ON_CONNECTIONS" | "PREPROCESSING" | "STARTED" | "FAILURE" | "TIMED_OUT" | "ABORTED";
+            startedAt?: Date | null | undefined;
+            completedAt?: Date | null | undefined;
+        }[];
+    }>;
+    /** `io.cancelEvent()` allows you to cancel an event that was previously sent with `io.sendEvent()`. This will prevent any Jobs from running that are listening for that event if the event was sent with a delay
+     * @param key
+     * @param eventId
+     * @returns
+     */
+    cancelEvent(key: string | any[], eventId: string): Promise<{
+        id: string;
+        name: string;
+        payload: ((string | number | boolean | {
+            [key: string]: _trigger_dev_core.DeserializedJson;
+        } | _trigger_dev_core.DeserializedJson[]) & (string | number | boolean | {
+            [key: string]: _trigger_dev_core.DeserializedJson;
+        } | _trigger_dev_core.DeserializedJson[] | undefined)) | null;
+        timestamp: Date;
+        context?: _trigger_dev_core.DeserializedJson | undefined;
+        deliverAt?: Date | null | undefined;
+        deliveredAt?: Date | null | undefined;
+        cancelledAt?: Date | null | undefined;
+    }>;
+    updateSource(key: string | any[], options: {
+        key: string;
+    } & UpdateTriggerSourceBodyV2): Promise<{
+        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<{
+        id: string;
+        schedule: {
+            options: {
+                cron: string;
+            };
+            type: "cron";
+            metadata?: any;
+        } | {
+            options: {
+                seconds: number;
+            };
+            type: "interval";
+            metadata?: any;
+        };
+        active: boolean;
+        metadata?: any;
+    }>;
+    /** `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<{
+        id: string;
+        schedule: {
+            options: {
+                cron: string;
+            };
+            type: "cron";
+            metadata?: any;
+        } | {
+            options: {
+                seconds: number;
+            };
+            type: "interval";
+            metadata?: any;
+        };
+        active: boolean;
+        metadata?: any;
+    }>;
+    /** `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 callback The callback that will be called when the Task is run. The callback receives the Task and the IO as parameters.
+     * @param options The options of how you'd like to run and log the Task.
+     * @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<T extends Json<T> | void>(key: string | any[], callback: (task: ServerTask, io: IO) => Promise<T>, options?: RunTaskOptions, onError?: RunTaskErrorCallback): Promise<T>;
+    /** `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>;
+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>;
+}
+
+interface TriggerIntegration {
+    id: string;
+    metadata: IntegrationMetadata;
+    authSource: "LOCAL" | "HOSTED";
+    cloneForRun: (io: IO, connectionKey: string, auth?: ConnectionAuth) => TriggerIntegration;
+}
+type IOWithIntegrations<TIntegrations extends Record<string, TriggerIntegration>> = IO & TIntegrations;
+type IntegrationTaskKey = string | any[];
+
+type JobOptions<TTrigger extends Trigger<EventSpecification<any>>, TIntegrations extends Record<string, TriggerIntegration> = {}> = {
+    /** 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
+        client.defineJob({
+          //... 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;
+    /** @deprecated This property is deprecated and no longer effects the execution of the Job
+     * */
+    queue?: QueueOptions | string;
+    /** The `enabled` property is used to enable or disable the Job. If you disable a Job, it will not run. */
+    enabled?: boolean;
+    /** 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>;
+};
+type JobPayload<TJob> = TJob extends Job<Trigger<EventSpecification<infer TEvent>>, any> ? TEvent : never;
+type JobIO<TJob> = TJob extends Job<any, infer TIntegrations> ? IOWithIntegrations<TIntegrations> : never;
+/** 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> = {}> {
+    #private;
+    readonly options: JobOptions<TTrigger, TIntegrations>;
+    client: TriggerClient;
+    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;
+}
+
+type EventTriggerOptions<TEventSpecification extends EventSpecification<any>> = {
+    event: TEventSpecification;
+    name?: string | string[];
+    source?: string;
+    filter?: EventFilter;
+};
+declare class EventTrigger<TEventSpecification extends EventSpecification<any>> implements Trigger<TEventSpecification> {
+    #private;
+    constructor(options: EventTriggerOptions<TEventSpecification>);
+    toJSON(): TriggerMetadata;
+    get event(): TEventSpecification;
+    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). To trigger on multiple possible events, pass in an array of event names */
+    name: string | 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;
+    examples?: EventSpecificationExample[];
+};
+/** `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;
+declare function missingConnectionResolvedNotification(integrations: Array<TriggerIntegration>): MissingConnectionResolvedNotification;
+type MissingConnectionNotificationSpecification = EventSpecification<MissingConnectionNotificationPayload>;
+type MissingConnectionNotificationOptions = {
+    integrations: Array<TriggerIntegration>;
+};
+declare class MissingConnectionNotification implements Trigger<MissingConnectionNotificationSpecification> {
+    private options;
+    constructor(options: MissingConnectionNotificationOptions);
+    get event(): {
+        name: string;
+        title: string;
+        source: string;
+        icon: string;
+        parsePayload: (data: unknown, params?: Partial<zod.ParseParams> | undefined) => {
+            id: string;
+            type: "DEVELOPER";
+            client: {
+                id: string;
+                scopes: string[];
+                title: string;
+                createdAt: Date;
+                updatedAt: Date;
+            };
+            authorizationUrl: string;
+        } | {
+            id: string;
+            type: "EXTERNAL";
+            account: {
+                id: string;
+                metadata?: any;
+            };
+            client: {
+                id: string;
+                scopes: string[];
+                title: string;
+                createdAt: Date;
+                updatedAt: Date;
+            };
+            authorizationUrl: string;
+        };
+        properties: {
+            label: string;
+            text: string;
+        }[];
+    };
+    attachToJob(triggerClient: TriggerClient, job: Job<Trigger<MissingConnectionNotificationSpecification>, any>): void;
+    get preprocessRuns(): boolean;
+    toJSON(): TriggerMetadata;
+}
+type MissingConnectionResolvedNotificationSpecification = EventSpecification<MissingConnectionResolvedNotificationPayload>;
+declare class MissingConnectionResolvedNotification implements Trigger<MissingConnectionResolvedNotificationSpecification> {
+    private options;
+    constructor(options: MissingConnectionNotificationOptions);
+    get event(): {
+        name: string;
+        title: string;
+        source: string;
+        icon: string;
+        parsePayload: (data: unknown, params?: Partial<zod.ParseParams> | undefined) => {
+            id: string;
+            type: "DEVELOPER";
+            client: {
+                id: string;
+                scopes: string[];
+                title: string;
+                createdAt: Date;
+                updatedAt: Date;
+                integrationIdentifier: string;
+                integrationAuthMethod: string;
+            };
+            expiresAt: Date;
+        } | {
+            id: string;
+            type: "EXTERNAL";
+            account: {
+                id: string;
+                metadata?: any;
+            };
+            client: {
+                id: string;
+                scopes: string[];
+                title: string;
+                createdAt: Date;
+                updatedAt: Date;
+                integrationIdentifier: string;
+                integrationAuthMethod: string;
+            };
+            expiresAt: Date;
+        };
+        properties: {
+            label: string;
+            text: string;
+        }[];
+    };
+    attachToJob(triggerClient: TriggerClient, job: Job<Trigger<MissingConnectionResolvedNotificationSpecification>, any>): void;
+    get preprocessRuns(): boolean;
+    toJSON(): TriggerMetadata;
+}
+
+declare class ResumeWithTaskError {
+    task: ServerTask;
+    constructor(task: ServerTask);
+}
+declare class RetryWithTaskError {
+    cause: ErrorWithStack;
+    task: ServerTask;
+    retryAt: Date;
+    constructor(cause: ErrorWithStack, task: ServerTask, retryAt: Date);
+}
+declare class CanceledWithTaskError {
+    task: ServerTask;
+    constructor(task: ServerTask);
+}
+/** 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 | CanceledWithTaskError;
+
+declare const retry: {
+    readonly standardBackoff: {
+        readonly limit: 8;
+        readonly factor: 1.8;
+        readonly minTimeoutInMs: 500;
+        readonly maxTimeoutInMs: 30000;
+        readonly randomize: true;
+    };
+};
+
+type Task = ServerTask;
+
+type SentEvent = ApiEventLog;
+declare function redactString(strings: TemplateStringsArray, ...interpolations: string[]): RedactString;
+
+export { CronTrigger, DynamicIntervalOptions, DynamicSchedule, DynamicTrigger, DynamicTriggerOptions, EventSpecification, EventSpecificationExample, EventTrigger, EventTypeFromSpecification, ExternalSource, ExternalSourceParams, ExternalSourceTrigger, ExternalSourceTriggerOptions, HandlerEvent, HttpSourceEvent, IO, IOLogger, IOOptions, IOTask, IOWithIntegrations, IntegrationTaskKey, IntervalTrigger, Job, JobIO, JobOptions, JobPayload, Json, MissingConnectionNotification, MissingConnectionResolvedNotification, PreprocessResults, RunTaskErrorCallback, SentEvent, Task, TaskLogger, Trigger, TriggerClient, TriggerClientOptions, TriggerContext, TriggerEventType, TriggerIntegration, TriggerOptionRecord, TriggerPayload, TriggerPreprocessContext, cronTrigger, eventTrigger, intervalTrigger, isTriggerError, missingConnectionNotification, missingConnectionResolvedNotification, omit, redactString, retry };