@trigger.dev/sdk 2.0.14 → 2.1.0-beta.1

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import * as _trigger_dev_core from '@trigger.dev/core';
-import { RunTaskBodyInput, CompleteTaskBodyInput, FailTaskBodyInput, SendEvent, SendEventOptions, UpdateTriggerSourceBody, TriggerSource, RegisterTriggerBody, RegisterSourceEvent, ScheduleMetadata, GetRunOptionsWithTaskDetails, GetRunsOptions, LogLevel, RuntimeEnvironmentType, DisplayProperty, TriggerMetadata, EventFilter, HandleTriggerSource, Logger, NormalizedResponse, Prettify, IntervalOptions, CronOptions, ScheduledPayload, ServerTask, CachedTask, FetchRequestInit, FetchRetryOptions, ConnectionAuth, SerializableJson, RunTaskOptions, IntegrationMetadata, QueueOptions, IntegrationConfig, JobMetadata, MissingConnectionNotificationPayload, MissingConnectionResolvedNotificationPayload, ErrorWithStack, ApiEventLog, RedactString } from '@trigger.dev/core';
-export { EventFilter, Logger, NormalizedRequest, RedactString } 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, 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';
 
@@ -145,8 +145,8 @@ declare class ApiClient {
         deliveredAt?: Date | null | undefined;
         cancelledAt?: Date | null | undefined;
     }>;
-    updateSource(client: string, key: string, source: UpdateTriggerSourceBody): Promise<TriggerSource>;
-    registerTrigger(client: string, id: string, key: string, payload: RegisterTriggerBody): Promise<RegisterSourceEvent>;
+    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: {
@@ -351,10 +351,20 @@ type ExternalSourceChannelMap = {
     };
 };
 type ChannelNames = keyof ExternalSourceChannelMap;
-type RegisterFunctionEvent<TChannel extends ChannelNames, TParams extends any> = {
-    events: Array<string>;
-    missingEvents: Array<string>;
-    orphanedEvents: Array<string>;
+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;
@@ -362,36 +372,49 @@ type RegisterFunctionEvent<TChannel extends ChannelNames, TParams extends any> =
     } & ExternalSourceChannelMap[TChannel]["register"];
     params: TParams;
 };
-type RegisterFunction<TIntegration extends TriggerIntegration<IntegrationClient<any, any>>, TParams extends any, TChannel extends ChannelNames> = (event: RegisterFunctionEvent<TChannel, TParams>, io: IOWithIntegrations<{
+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<UpdateTriggerSourceBody | undefined>;
+}>, ctx: TriggerContext) => Promise<RegisterFunctionOutput<TTriggerOptionDefinitions> | undefined>;
 type HandlerEvent<TChannel extends ChannelNames, TParams extends any = any> = {
     rawEvent: ExternalSourceChannelMap[TChannel]["event"];
-    source: HandleTriggerSource & {
+    source: Prettify<Omit<HandleTriggerSource, "params"> & {
         params: TParams;
-    };
+    }>;
 };
-type HandlerFunction<TChannel extends ChannelNames, TParams extends any> = (event: HandlerEvent<TChannel, TParams>, logger: Logger) => Promise<{
+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> = (params: TParams) => EventFilter;
-type ExternalSourceOptions<TChannel extends ChannelNames, TIntegration extends TriggerIntegration<IntegrationClient<any, any>>, TParams extends any> = {
+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>;
-    filter?: FilterFunction<TParams>;
-    handler: HandlerFunction<TChannel, TParams>;
+    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<IntegrationClient<any, any>>, TParams extends any, TChannel extends ChannelNames = ChannelNames> {
+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>);
+    constructor(channel: TChannel, options: ExternalSourceOptions<TChannel, TIntegration, TParams, TTriggerOptionDefinitions>);
     handle(source: HandleTriggerSource, rawEvent: ExternalSourceChannelMap[TChannel]["event"], logger: Logger): Promise<void | {
         events: {
             name: string;
@@ -406,14 +429,11 @@ declare class ExternalSource<TIntegration extends TriggerIntegration<Integration
             body?: any;
             headers?: Record<string, string> | undefined;
         } | undefined;
+        metadata?: _trigger_dev_core.DeserializedJson | undefined;
     }>;
-    filter(params: TParams): EventFilter;
+    filter(params: TParams, options?: TTriggerOptionDefinitions): EventFilter;
     properties(params: TParams): DisplayProperty[];
-    register(params: TParams, registerEvent: RegisterSourceEvent, io: IO, ctx: TriggerContext): Promise<{
-        registeredEvents: string[];
-        secret?: string | undefined;
-        data?: _trigger_dev_core.SerializableJson;
-    } | undefined>;
+    register(params: TParams, registerEvent: RegisterSourceEvent<TTriggerOptionDefinitions>, io: IO, ctx: TriggerContext): Promise<RegisterFunctionOutput<TTriggerOptionDefinitions> | undefined>;
     key(params: TParams): string;
     get integration(): TIntegration;
     get integrationConfig(): {
@@ -430,10 +450,11 @@ declare class ExternalSource<TIntegration extends TriggerIntegration<Integration
 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>> = {
+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;
@@ -480,12 +501,12 @@ declare class DynamicTrigger<TEventSpec extends EventSpecification<any>, TExtern
     toJSON(): TriggerMetadata;
     get id(): string;
     get event(): TEventSpec;
-    registeredTriggerForParams(params: ExternalSourceParams<TExternalSource>): RegisterTriggerBody;
+    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<RegisterSourceEvent>;
+    register(key: string, params: ExternalSourceParams<TExternalSource>): Promise<RegisterSourceEventV2>;
     attachToJob(triggerClient: TriggerClient, job: Job<Trigger<TEventSpec>, any>): void;
     get preprocessRuns(): boolean;
 }
@@ -523,10 +544,22 @@ declare class TriggerClient {
         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: RegisterTriggerBody): Promise<{
+    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;
@@ -540,12 +573,9 @@ declare class TriggerClient {
                 type: "SQS";
             };
             params?: any;
-            data?: _trigger_dev_core.DeserializedJson | undefined;
+            data?: DeserializedJson | undefined;
             clientId?: string | undefined;
         };
-        events: string[];
-        missingEvents: string[];
-        orphanedEvents: string[];
         dynamicTriggerId?: string | undefined;
     }>;
     getAuth(id: string): Promise<{
@@ -563,12 +593,12 @@ declare class TriggerClient {
         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;
+            [key: string]: DeserializedJson;
+        } | DeserializedJson[]) & (string | number | boolean | {
+            [key: string]: DeserializedJson;
+        } | DeserializedJson[] | undefined)) | null;
         timestamp: Date;
-        context?: _trigger_dev_core.DeserializedJson | undefined;
+        context?: DeserializedJson | undefined;
         deliverAt?: Date | null | undefined;
         deliveredAt?: Date | null | undefined;
         cancelledAt?: Date | null | undefined;
@@ -577,12 +607,12 @@ declare class TriggerClient {
         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;
+            [key: string]: DeserializedJson;
+        } | DeserializedJson[]) & (string | number | boolean | {
+            [key: string]: DeserializedJson;
+        } | DeserializedJson[] | undefined)) | null;
         timestamp: Date;
-        context?: _trigger_dev_core.DeserializedJson | undefined;
+        context?: DeserializedJson | undefined;
         deliverAt?: Date | null | undefined;
         deliveredAt?: Date | null | undefined;
         cancelledAt?: Date | null | undefined;
@@ -642,7 +672,7 @@ declare class TriggerClient {
     }>;
     authorized(apiKey?: string | null): "authorized" | "unauthorized" | "missing-client" | "missing-header";
     apiKey(): string | undefined;
-    defineJob<TTrigger extends Trigger<EventSpecification<any>>, TIntegrations extends Record<string, TriggerIntegration<IntegrationClient<any, any>>> = {}>(options: JobOptions<TTrigger, TIntegrations>): Job<TTrigger, TIntegrations>;
+    defineJob<TTrigger extends Trigger<EventSpecification<any>>, TIntegrations extends Record<string, TriggerIntegration> = {}>(options: JobOptions<TTrigger, TIntegrations>): Job<TTrigger, TIntegrations>;
 }
 
 type ScheduledEventSpecification = EventSpecification<ScheduledPayload>;
@@ -787,6 +817,17 @@ type IOOptions = {
     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;
@@ -870,7 +911,7 @@ declare class IO {
     }>;
     updateSource(key: string | any[], options: {
         key: string;
-    } & UpdateTriggerSourceBody): Promise<{
+    } & UpdateTriggerSourceBodyV2): Promise<{
         id: string;
         key: string;
     }>;
@@ -958,11 +999,7 @@ declare class IO {
   =   * @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, TCallbackResult extends unknown = TResult>(key: string | any[], options: RunTaskOptions, callback: (task: IOTask, io: IO) => Promise<TCallbackResult | TResult>, onError?: (error: unknown, task: IOTask, io: IO) => {
-        retryAt: Date;
-        error?: Error;
-        jitter?: number;
-    } | Error | undefined | void): Promise<TResult>;
+    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
@@ -987,60 +1024,16 @@ declare class IOLogger implements TaskLogger {
     error(message: string, properties?: Record<string, any>): Promise<void>;
 }
 
-type IntegrationRunTaskFunction<TClient> = <TResult>(key: string | any[], callback: (client: TClient, task: IOTask, io: IO) => Promise<TResult>, options?: RunTaskOptions) => Promise<TResult>;
-type ClientFactory<TClient> = (auth: ConnectionAuth) => TClient;
-interface TriggerIntegration<TIntegrationClient extends IntegrationClient<any, any> = IntegrationClient<any, any>> {
-    client: TIntegrationClient;
+interface TriggerIntegration {
     id: string;
     metadata: IntegrationMetadata;
+    authSource: "LOCAL" | "HOSTED";
+    cloneForRun: (io: IO, connectionKey: string, auth?: ConnectionAuth) => TriggerIntegration;
 }
-type IntegrationClient<TClient, TTasks extends Record<string, AuthenticatedTask<TClient, any, any, any>>> = {
-    usesLocalAuth: true;
-    client: TClient;
-    tasks?: TTasks;
-    auth: any;
-} | {
-    usesLocalAuth: false;
-    clientFactory: ClientFactory<TClient>;
-    tasks?: TTasks;
-};
-type AuthenticatedTask<TClient, TParams, TResult, TAuth = ConnectionAuth> = {
-    run: (params: TParams, client: TClient, task: ServerTask, io: IO, auth: TAuth) => Promise<TResult>;
-    init: (params: TParams) => RunTaskOptions;
-    onError?: (error: unknown, task: ServerTask) => {
-        retryAt: Date;
-        error?: Error;
-    } | Error | undefined | void;
-};
-declare function authenticatedTask<TClient, TParams, TResult>(options: {
-    run: (params: TParams, client: TClient, task: ServerTask, io: IO) => Promise<TResult>;
-    init: (params: TParams) => RunTaskOptions;
-}): AuthenticatedTask<TClient, TParams, TResult>;
-type ExtractRunFunction<T> = T extends AuthenticatedTask<any, infer TParams, infer TResult, infer TAuth> ? (key: string, params: TParams) => Promise<TResult> : never;
-type ExtractTasks<TTasks extends Record<string, AuthenticatedTask<any, any, any, any>>> = {
-    [key in keyof TTasks]: ExtractRunFunction<TTasks[key]>;
-};
-type ExtractIntegrationClientClient<TIntegrationClient extends IntegrationClient<any, any>> = TIntegrationClient extends {
-    usesLocalAuth: true;
-    client: infer TClient;
-} ? {
-    client: TClient;
-    runTask: IntegrationRunTaskFunction<TClient>;
-} : TIntegrationClient extends {
-    usesLocalAuth: false;
-    clientFactory: ClientFactory<infer TClient>;
-} ? {
-    client: TClient;
-    runTask: IntegrationRunTaskFunction<TClient>;
-} : never;
-type ExtractIntegrationClient<TIntegrationClient extends IntegrationClient<any, any>> = ExtractIntegrationClientClient<TIntegrationClient> & ExtractTasks<TIntegrationClient["tasks"]>;
-type IntegrationIO<TIntegration extends TriggerIntegration<IntegrationClient<any, any>>> = ExtractIntegrationClient<TIntegration["client"]>;
-type ExtractIntegrations<TIntegrations extends Record<string, TriggerIntegration<IntegrationClient<any, any>>>> = {
-    [key in keyof TIntegrations]: ExtractIntegrationClient<TIntegrations[key]["client"]>;
-};
-type IOWithIntegrations<TIntegrations extends Record<string, TriggerIntegration<IntegrationClient<any, any>>>> = IO & ExtractIntegrations<TIntegrations>;
+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<IntegrationClient<any, 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. */
@@ -1091,7 +1084,7 @@ type JobOptions<TTrigger extends Trigger<EventSpecification<any>>, TIntegrations
 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<IntegrationClient<any, any>>> = {}> {
+declare class Job<TTrigger extends Trigger<EventSpecification<any>>, TIntegrations extends Record<string, TriggerIntegration> = {}> {
     #private;
     readonly options: JobOptions<TTrigger, TIntegrations>;
     client: TriggerClient;
@@ -1282,9 +1275,19 @@ declare class CanceledWithTaskError {
  */
 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 { AuthenticatedTask, ClientFactory, CronTrigger, DynamicIntervalOptions, DynamicSchedule, DynamicTrigger, DynamicTriggerOptions, EventSpecification, EventSpecificationExample, EventTrigger, EventTypeFromSpecification, ExternalSource, ExternalSourceParams, ExternalSourceTrigger, ExternalSourceTriggerOptions, HandlerEvent, HttpSourceEvent, IO, IOLogger, IOOptions, IOTask, IOWithIntegrations, IntegrationClient, IntegrationIO, IntervalTrigger, Job, JobIO, JobOptions, JobPayload, MissingConnectionNotification, MissingConnectionResolvedNotification, PreprocessResults, SentEvent, Task, TaskLogger, Trigger, TriggerClient, TriggerClientOptions, TriggerContext, TriggerEventType, TriggerIntegration, TriggerPayload, TriggerPreprocessContext, authenticatedTask, cronTrigger, eventTrigger, intervalTrigger, isTriggerError, missingConnectionNotification, missingConnectionResolvedNotification, omit, 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 };