@trigger.dev/sdk 2.2.7 → 2.2.8

package/dist/index.d.ts

@@ -1,8 +1,25 @@
 import * as _trigger_dev_core from '@trigger.dev/core';
-import { RunTaskBodyInput, CompleteTaskBodyV2Input, FailTaskBodyInput, SendEvent, SendEventOptions, StatusUpdate, UpdateTriggerSourceBodyV2, TriggerSource, RegisterTriggerBodyV2, RegisterSourceEventV2, ScheduleMetadata, GetRunOptionsWithTaskDetails, GetRunsOptions, InvokeOptions, EphemeralEventDispatcherRequestBody, LogLevel, RuntimeEnvironmentType, DisplayProperty, TriggerMetadata, EventFilter, SuccessfulRunNotification, FailedRunNotification, HttpEndpointMetadata, RequestFilter, Prettify, HandleTriggerSource, Logger, RegisterTriggerSource, SerializableJson, ConnectionAuth, NormalizedResponse, HttpSourceResponseMetadata, IntervalOptions, CronOptions, ScheduledPayload, DeserializedJson, ServerTask, CachedTask, InitialStatusUpdate, FetchRequestInit, FetchRetryOptions, FetchTimeoutOptions, FetchPollOperation, RunTaskOptions, IntegrationMetadata, QueueOptions, IntegrationConfig, JobMetadata, RunNotification, MissingConnectionNotificationPayload, MissingConnectionResolvedNotificationPayload, ErrorWithStack, ApiEventLog, RedactString } from '@trigger.dev/core';
+import { AsyncMap, KeyValueStoreResponseBody, RunTaskBodyInput, CompleteTaskBodyV2Input, FailTaskBodyInput, SendEvent, SendEventOptions, StatusUpdate, UpdateTriggerSourceBodyV2, TriggerSource, UpdateWebhookBody, RegisterTriggerBodyV2, RegisterSourceEventV2, ScheduleMetadata, GetRunOptionsWithTaskDetails, GetRunsOptions, InvokeOptions, EphemeralEventDispatcherRequestBody, LogLevel, RuntimeEnvironmentType, DisplayProperty, TriggerMetadata, EventFilter, SuccessfulRunNotification, FailedRunNotification, HttpEndpointMetadata, RequestFilter, Prettify, HandleTriggerSource, Logger, RegisterTriggerSource, SerializableJson, ConnectionAuth, NormalizedResponse, HttpSourceResponseMetadata, IntervalOptions, CronOptions, ScheduledPayload, RegisterWebhookSource, DeserializedJson, ServerTask, CachedTask, InitialStatusUpdate, FetchRequestInit, FetchRetryOptions, FetchTimeoutOptions, FetchPollOperation, RunTaskOptions, IntegrationMetadata, QueueOptions, IntegrationConfig, JobMetadata, RunNotification, 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, ZodType, TypeOf } from 'zod';
+import { BinaryToTextEncoding, BinaryLike, KeyObject } from 'crypto';
+
+type QueryKeyValueStoreFunction = (action: "DELETE" | "GET" | "HAS" | "SET", data: {
+    key: string;
+    value?: string;
+}) => Promise<KeyValueStoreResponseBody>;
+declare class KeyValueStoreClient implements AsyncMap {
+    #private;
+    private queryStore;
+    private type;
+    private namespace;
+    constructor(queryStore: QueryKeyValueStoreFunction, type?: string | null, namespace?: string);
+    delete(key: string): Promise<boolean>;
+    get<T extends Json<T>>(key: string): Promise<T>;
+    has(key: string): Promise<boolean>;
+    set<T extends Json<T>>(key: string, value: T): Promise<T>;
+}
 
 type ApiClientOptions = {
     apiKey?: string;
@@ -581,6 +598,7 @@ declare class ApiClient {
         state?: "loading" | "success" | "failure" | undefined;
     }>;
     updateSource(client: string, key: string, source: UpdateTriggerSourceBodyV2): Promise<TriggerSource>;
+    updateWebhook(key: string, webhookData: UpdateWebhookBody): Promise<TriggerSource>;
     registerTrigger(client: string, id: string, key: string, payload: RegisterTriggerBodyV2, idempotencyKey?: string): Promise<RegisterSourceEventV2>;
     registerSchedule(client: string, id: string, key: string, payload: ScheduleMetadata): Promise<{
         id: string;
@@ -699,6 +717,7 @@ declare class ApiClient {
     createEphemeralEventDispatcher(payload: EphemeralEventDispatcherRequestBody): Promise<{
         id: string;
     }>;
+    get store(): KeyValueStoreClient;
 }
 type VersionedResponseBodyMap = {
     [key: string]: z.ZodTypeAny;
@@ -894,6 +913,12 @@ declare const EventSpecificationExampleSchema: z.ZodObject<{
     payload?: any;
 }>;
 type EventSpecificationExample = z.infer<typeof EventSpecificationExampleSchema>;
+type TypedEventSpecificationExample<TEvent> = {
+    id: string;
+    name: string;
+    icon?: string;
+    payload: TEvent;
+};
 interface EventSpecification<TEvent extends any, TInvoke extends any = TEvent> {
     name: string | string[];
     title: string;
@@ -1090,7 +1115,7 @@ type TriggerOptionsRecordWithEvent<TValue, TTriggerOptionDefinitions extends Rec
 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> = {
+type RegisterFunctionEvent$1<TChannel extends ChannelNames, TParams extends any, TTriggerOptionDefinitions extends Record<string, string[]> = any> = {
     options: TriggerOptionDiffs<TTriggerOptionDefinitions>;
     source: {
         active: boolean;
@@ -1105,14 +1130,14 @@ type RegisterSourceEvent<TTriggerOptionDefinitions extends Record<string, string
     dynamicTriggerId?: string;
     options: TriggerOptionDiffs<TTriggerOptionDefinitions>;
 };
-type RegisterFunctionOutput<TTriggerOptionDefinitions extends Record<string, string[]> = any> = {
+type RegisterFunctionOutput$1<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<{
+type RegisterFunction$1<TIntegration extends TriggerIntegration, TParams extends any, TChannel extends ChannelNames, TTriggerOptionDefinitions extends Record<string, string[]> = any> = (event: RegisterFunctionEvent$1<TChannel, TParams, TTriggerOptionDefinitions>, io: IOWithIntegrations<{
     integration: TIntegration;
-}>, ctx: TriggerContext) => Promise<RegisterFunctionOutput<TTriggerOptionDefinitions> | undefined>;
+}>, ctx: TriggerContext) => Promise<RegisterFunctionOutput$1<TTriggerOptionDefinitions> | undefined>;
 type HandlerEvent<TChannel extends ChannelNames, TParams extends any = any> = {
     rawEvent: ExternalSourceChannelMap[TChannel]["event"];
     source: Prettify<Omit<HandleTriggerSource, "params"> & {
@@ -1124,18 +1149,18 @@ type HandlerFunction<TChannel extends ChannelNames, TParams extends any, TTrigge
     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 KeyFunction$1<TParams extends any> = (params: TParams) => string;
+type FilterFunction$1<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: SchemaParser<TParams>;
     optionSchema?: SchemaParser<TTriggerOptionDefinitions>;
     integration: TIntegration;
-    register: RegisterFunction<TIntegration, TParams, TChannel, TTriggerOptionDefinitions>;
-    filter?: FilterFunction<TParams, TTriggerOptionDefinitions>;
+    register: RegisterFunction$1<TIntegration, TParams, TChannel, TTriggerOptionDefinitions>;
+    filter?: FilterFunction$1<TParams, TTriggerOptionDefinitions>;
     handler: HandlerFunction<TChannel, TParams, TIntegration>;
-    key: KeyFunction<TParams>;
+    key: KeyFunction$1<TParams>;
     properties?: (params: TParams) => DisplayProperty[];
 };
 declare class ExternalSource<TIntegration extends TriggerIntegration, TParams extends any, TChannel extends ChannelNames = ChannelNames, TTriggerOptionDefinitions extends Record<string, string[]> = any> {
@@ -1161,7 +1186,7 @@ declare class ExternalSource<TIntegration extends TriggerIntegration, TParams ex
     }>;
     filter(params: TParams, options?: TTriggerOptionDefinitions): EventFilter;
     properties(params: TParams): DisplayProperty[];
-    register(params: TParams, registerEvent: RegisterSourceEvent<TTriggerOptionDefinitions>, io: IO, ctx: TriggerContext): Promise<RegisterFunctionOutput<TTriggerOptionDefinitions> | undefined>;
+    register(params: TParams, registerEvent: RegisterSourceEvent<TTriggerOptionDefinitions>, io: IO, ctx: TriggerContext): Promise<RegisterFunctionOutput$1<TTriggerOptionDefinitions> | undefined>;
     key(params: TParams): string;
     get integration(): TIntegration;
     get integrationConfig(): {
@@ -1390,6 +1415,157 @@ declare class DynamicSchedule implements Trigger<ScheduledEventSpecification> {
     toJSON(): TriggerMetadata;
 }
 
+type WebhookCRUDContext<TParams extends any, TConfig extends Record<string, string[]>> = {
+    active: boolean;
+    params: TParams;
+    config: {
+        current: Partial<TConfig>;
+        desired: TConfig;
+    };
+    url: string;
+    secret: string;
+};
+type WebhookCRUDFunction<TIntegration extends TriggerIntegration, TParams extends any, TConfig extends Record<string, string[]>> = (options: {
+    io: IOWithIntegrations<{
+        integration: TIntegration;
+    }>;
+    ctx: WebhookCRUDContext<TParams, TConfig>;
+}) => Promise<any>;
+interface WebhookCRUD<TIntegration extends TriggerIntegration, TParams extends any, TConfig extends Record<string, string[]>> {
+    create: WebhookCRUDFunction<TIntegration, TParams, TConfig>;
+    read?: WebhookCRUDFunction<TIntegration, TParams, TConfig>;
+    update?: WebhookCRUDFunction<TIntegration, TParams, TConfig>;
+    delete: WebhookCRUDFunction<TIntegration, TParams, TConfig>;
+}
+type WebhookConfig<TConfigKeys extends string> = {
+    [K in TConfigKeys]: string[];
+};
+type RegisterFunctionEvent<TParams extends any, TConfig extends Record<string, string[]>> = {
+    source: {
+        active: boolean;
+        data?: any;
+        secret: string;
+        url: string;
+    };
+    params: TParams;
+    config: TConfig;
+};
+type WebhookRegisterEvent<TConfig extends Record<string, string[]>> = {
+    id: string;
+    source: RegisterWebhookSource;
+    dynamicTriggerId?: string;
+    config: TConfig;
+};
+type RegisterFunctionOutput<TConfig extends Record<string, string[]>> = {
+    secret?: string;
+    data?: SerializableJson;
+    config: TConfig;
+};
+type RegisterFunction<TIntegration extends TriggerIntegration, TParams extends any, TConfig extends Record<string, string[]>> = (event: RegisterFunctionEvent<TParams, TConfig>, io: IOWithIntegrations<{
+    integration: TIntegration;
+}>, ctx: TriggerContext) => Promise<RegisterFunctionOutput<TConfig> | undefined>;
+type WebhookHandlerEvent<TParams extends any = any> = {
+    rawEvent: Request;
+    source: Prettify<Omit<HandleTriggerSource, "params"> & {
+        params: TParams;
+    }>;
+};
+type WebhookDeliveryContext = {
+    key: string;
+    secret: string;
+    params: any;
+};
+type EventGenerator<TParams extends any, TConfig extends Record<string, string[]>, TIntegration extends TriggerIntegration> = (options: {
+    request: Request;
+    client: TriggerClient;
+    ctx: WebhookDeliveryContext;
+}) => Promise<any>;
+type KeyFunction<TParams extends any> = (params: TParams) => string;
+type FilterFunction<TParams extends any, TConfig extends Record<string, string[]>> = (params: TParams, config?: TConfig) => EventFilter;
+type WebhookOptions<TIntegration extends TriggerIntegration, TParams extends any, TConfig extends Record<string, string[]>> = {
+    id: string;
+    version: string;
+    integration: TIntegration;
+    schemas: {
+        params: SchemaParser<TParams>;
+        config?: SchemaParser<TConfig>;
+    };
+    key: KeyFunction<TParams>;
+    crud: WebhookCRUD<TIntegration, TParams, TConfig>;
+    filter?: FilterFunction<TParams, TConfig>;
+    register?: RegisterFunction<TIntegration, TParams, TConfig>;
+    verify?: (options: {
+        request: Request;
+        client: TriggerClient;
+        ctx: WebhookDeliveryContext;
+    }) => Promise<VerifyResult>;
+    generateEvents: EventGenerator<TParams, TConfig, TIntegration>;
+    properties?: (params: TParams) => DisplayProperty[];
+};
+declare class WebhookSource<TIntegration extends TriggerIntegration, TParams extends any = any, TConfig extends Record<string, string[]> = Record<string, string[]>> {
+    #private;
+    private options;
+    constructor(options: WebhookOptions<TIntegration, TParams, TConfig>);
+    generateEvents(request: Request, client: TriggerClient, ctx: WebhookDeliveryContext): Promise<any>;
+    filter(params: TParams, config?: TConfig): EventFilter;
+    properties(params: TParams): DisplayProperty[];
+    get crud(): WebhookCRUD<TIntegration, TParams, TConfig>;
+    register(params: TParams, registerEvent: WebhookRegisterEvent<TConfig>, io: IO, ctx: TriggerContext): Promise<RegisterFunctionOutput<TConfig> | undefined>;
+    verify(request: Request, client: TriggerClient, ctx: WebhookDeliveryContext): Promise<VerifyResult>;
+    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 GetWebhookParams<TWebhook extends WebhookSource<any, any, any>> = TWebhook extends WebhookSource<any, infer TParams, any> ? TParams : never;
+type GetWebhookConfig<TWebhook extends WebhookSource<any, any, any>> = TWebhook extends WebhookSource<any, any, infer TConfig> ? TConfig : never;
+type WebhookTriggerOptions<TEventSpecification extends EventSpecification<any>, TEventSource extends WebhookSource<any, any, any>, TConfig extends Record<string, string[]> = Record<string, string[]>> = {
+    event: TEventSpecification;
+    source: TEventSource;
+    params: GetWebhookParams<TEventSource>;
+    config: TConfig;
+};
+declare class WebhookTrigger<TEventSpecification extends EventSpecification<any>, TEventSource extends WebhookSource<any, any, any>> implements Trigger<TEventSpecification> {
+    private options;
+    constructor(options: WebhookTriggerOptions<TEventSpecification, TEventSource>);
+    get event(): TEventSpecification;
+    get source(): TEventSource;
+    get key(): string;
+    toJSON(): TriggerMetadata;
+    filter(eventFilter: EventFilter): WebhookTrigger<Omit<TEventSpecification, "filter"> & {
+        filter: EventFilter;
+    }, TEventSource>;
+    attachToJob(triggerClient: TriggerClient, job: Job<Trigger<TEventSpecification>, any>): void;
+    get preprocessRuns(): boolean;
+    verifyPayload(payload: ReturnType<TEventSpecification["parsePayload"]>): Promise<{
+        success: true;
+    }>;
+}
+
+declare class KeyValueStore {
+    #private;
+    private apiClient;
+    private type;
+    private namespace;
+    constructor(apiClient: ApiClient, type?: string | null, namespace?: string);
+    delete(cacheKey: string | any[], key: string): Promise<boolean>;
+    delete(key: string): Promise<boolean>;
+    get<T extends Json<T> = any>(cacheKey: string | any[], key: string): Promise<T>;
+    get<T extends Json<T> = any>(key: string): Promise<T>;
+    has(cacheKey: string | any[], key: string): Promise<boolean>;
+    has(key: string): Promise<boolean>;
+    set<T extends Json<T>>(cacheKey: string | any[], key: string, value: T): Promise<T>;
+    set<T extends Json<T>>(key: string, value: T): Promise<T>;
+}
+
 type TriggerClientOptions = {
     /** The `id` property is used to uniquely identify the client.
      */
@@ -1432,7 +1608,7 @@ declare class TriggerClient {
      * @returns An HTTP Endpoint, that can be used to create an HTTP Trigger.
      * @link https://trigger.dev/docs/documentation/concepts/http-endpoints
      */
-    defineHttpEndpoint(options: EndpointOptions): HttpEndpoint<EventSpecification<Request, Request>>;
+    defineHttpEndpoint(options: EndpointOptions, suppressWarnings?: boolean): HttpEndpoint<EventSpecification<Request, Request>>;
     attach(job: Job<Trigger<any>, any>): void;
     attachDynamicTrigger(trigger: DynamicTrigger<any, any>): void;
     attachJobToDynamicTrigger(job: Job<Trigger<any>, any>, trigger: DynamicTrigger<any, any>): void;
@@ -1445,6 +1621,13 @@ declare class TriggerClient {
     }): void;
     attachDynamicSchedule(key: string): void;
     attachDynamicScheduleToJob(key: string, job: Job<Trigger<any>, any>): void;
+    attachWebhook<TIntegration extends TriggerIntegration, TParams extends any, TConfig extends Record<string, string[]>>(options: {
+        key: string;
+        source: WebhookSource<TIntegration, TParams, TConfig>;
+        event: EventSpecification<any>;
+        params: any;
+        config: TConfig;
+    }): void;
     registerTrigger(id: string, key: string, options: RegisterTriggerBodyV2, idempotencyKey?: string): Promise<{
         id: string;
         options: {
@@ -1660,6 +1843,9 @@ declare class TriggerClient {
     createEphemeralEventDispatcher(payload: EphemeralEventDispatcherRequestBody): Promise<{
         id: string;
     }>;
+    get store(): {
+        env: KeyValueStore;
+    };
     authorized(apiKey?: string | null): "authorized" | "unauthorized" | "missing-client" | "missing-header";
     apiKey(): string | undefined;
 }
@@ -1667,6 +1853,7 @@ declare class TriggerClient {
 type IOTask = ServerTask;
 type IOOptions = {
     id: string;
+    jobId: string;
     apiClient: ApiClient;
     client: TriggerClient;
     context: TriggerContext;
@@ -1719,6 +1906,7 @@ type BackgroundFetchResponse<T> = {
 declare class IO {
     #private;
     private _id;
+    private _jobId;
     private _apiClient;
     private _triggerClient;
     private _logger;
@@ -1736,6 +1924,9 @@ declare class IO {
     private _executionTimeout?;
     private _outputSerializer;
     private _visitedCacheKeys;
+    private _envStore;
+    private _jobStore;
+    private _runStore;
     get stats(): IOStats;
     constructor(options: IOOptions);
     /** Used to send log messages to the [Run log](https://trigger.dev/docs/documentation/guides/viewing-runs). */
@@ -1960,6 +2151,12 @@ declare class IO {
         id: string;
         key: string;
     }>;
+    updateWebhook(cacheKey: string | any[], options: {
+        key: string;
+    } & UpdateWebhookBody): 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 cacheKey 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.
@@ -2072,6 +2269,11 @@ declare class IO {
      * @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>;
+    get store(): {
+        env: KeyValueStore;
+        job: KeyValueStore;
+        run: KeyValueStore;
+    };
 }
 type CallbackFunction = (level: "DEBUG" | "INFO" | "WARN" | "ERROR" | "LOG", message: string, properties?: Record<string, any>) => Promise<void>;
 declare class IOLogger implements TaskLogger {
@@ -2187,6 +2389,7 @@ type EventTriggerOptions<TEventSpecification extends EventSpecification<any>> =
     name?: string | string[];
     source?: string;
     filter?: EventFilter;
+    verify?: EventTypeFromSpecification<TEventSpecification> extends Request ? VerifyCallback : never;
 };
 declare class EventTrigger<TEventSpecification extends EventSpecification<any>> implements Trigger<TEventSpecification> {
     #private;
@@ -2195,9 +2398,7 @@ declare class EventTrigger<TEventSpecification extends EventSpecification<any>>
     get event(): TEventSpecification;
     attachToJob(triggerClient: TriggerClient, job: Job<Trigger<TEventSpecification>, any>): void;
     get preprocessRuns(): boolean;
-    verifyPayload(payload: ReturnType<TEventSpecification["parsePayload"]>): Promise<{
-        success: true;
-    }>;
+    verifyPayload(payload: ReturnType<TEventSpecification["parsePayload"]>): Promise<VerifyResult>;
 }
 /** Configuration options for an EventTrigger */
 type TriggerOptions<TEvent> = {
@@ -2376,20 +2577,24 @@ declare class InvokeTrigger<TSchema extends ZodType = z.ZodTypeAny> implements T
 }
 declare function invokeTrigger<TSchema extends ZodType = z.ZodTypeAny>(options?: InvokeTriggerOptions<TSchema>): Trigger<EventSpecification<TypeOf<TSchema>, z.input<TSchema>>>;
 
+declare function slugifyId(input: string): string;
+
 /** Easily verify webhook payloads when they're using common signing methods. */
-declare function verifyRequestSignature({ request, headerName, secret, algorithm, }: {
+declare function verifyRequestSignature({ request, headerName, headerEncoding, secret, algorithm, }: {
     /** The web request that you want to verify. */
     request: Request;
     /** The name of the header that contains the signature. E.g. `X-Cal-Signature-256`. */
     headerName: string;
+    /** The header encoding. Defaults to `hex`. */
+    headerEncoding?: BinaryToTextEncoding;
     /** The secret that you use to hash the payload. For HttpEndpoints this will usually originally
         come from the Trigger.dev dashboard and should be stored in an environment variable. */
-    secret: string;
+    secret: BinaryLike | KeyObject;
     /** The hashing algorithm that was used to create the signature. Currently only `sha256` is
         supported. */
     algorithm: "sha256";
 }): Promise<VerifyResult>;
-declare function verifyHmacSha256(headerValue: string, secret: string, body: string): boolean;
+declare function verifyHmacSha256(headerValue: string, headerEncoding: BinaryToTextEncoding, secret: BinaryLike | KeyObject, body: string): boolean;
 
 declare class ResumeWithTaskError {
     task: ServerTask;
@@ -2466,4 +2671,4 @@ type Task = ServerTask;
 type SentEvent = ApiEventLog;
 declare function redactString(strings: TemplateStringsArray, ...interpolations: string[]): RedactString;
 
-export { AuthResolverResult, BackgroundFetchResponse, CronTrigger, DynamicIntervalOptions, DynamicSchedule, DynamicTrigger, DynamicTriggerOptions, EventSpecification, EventSpecificationExample, EventSpecificationExampleSchema, EventTrigger, EventTypeFromSpecification, ExternalSource, ExternalSourceParams, ExternalSourceTrigger, ExternalSourceTriggerOptions, HandlerEvent, HttpSourceEvent, IO, IOLogger, IOOptions, IOStats, IOTask, IOWithIntegrations, IntegrationTaskKey, IntervalTrigger, InvokeTrigger, JSONOutputSerializer, Job, JobIO, JobOptions, JobPayload, Json, MissingConnectionNotification, MissingConnectionResolvedNotification, NotificationEvents, NotificationsEventEmitter, OutputSerializer, PreprocessResults, RunTaskErrorCallback, SchemaParser, SchemaParserIssue, SchemaParserResult, SentEvent, Task, TaskLogger, Trigger, TriggerAuthResolver, TriggerClient, TriggerClientOptions, TriggerContext, TriggerEventType, TriggerIntegration, TriggerInvokeType, TriggerOptionRecord, TriggerPayload, TriggerPreprocessContext, VerifyResult, WaitForEventResult, cronTrigger, eventTrigger, intervalTrigger, invokeTrigger, isTriggerError, missingConnectionNotification, missingConnectionResolvedNotification, omit, redactString, retry, verifyHmacSha256, verifyRequestSignature, waitForEventSchema };
+export { AuthResolverResult, BackgroundFetchResponse, CronTrigger, DynamicIntervalOptions, DynamicSchedule, DynamicTrigger, DynamicTriggerOptions, EventSpecification, EventSpecificationExample, EventSpecificationExampleSchema, EventTrigger, EventTypeFromSpecification, ExternalSource, ExternalSourceParams, ExternalSourceTrigger, ExternalSourceTriggerOptions, GetWebhookConfig, GetWebhookParams, HandlerEvent, HttpSourceEvent, IO, IOLogger, IOOptions, IOStats, IOTask, IOWithIntegrations, IntegrationTaskKey, IntervalTrigger, InvokeTrigger, JSONOutputSerializer, Job, JobIO, JobOptions, JobPayload, Json, MissingConnectionNotification, MissingConnectionResolvedNotification, NotificationEvents, NotificationsEventEmitter, OutputSerializer, PreprocessResults, RunTaskErrorCallback, SchemaParser, SchemaParserIssue, SchemaParserResult, SentEvent, Task, TaskLogger, Trigger, TriggerAuthResolver, TriggerClient, TriggerClientOptions, TriggerContext, TriggerEventType, TriggerIntegration, TriggerInvokeType, TriggerOptionRecord, TriggerPayload, TriggerPreprocessContext, TypedEventSpecificationExample, VerifyResult, WaitForEventResult, WebhookConfig, WebhookDeliveryContext, WebhookHandlerEvent, WebhookSource, WebhookTrigger, WebhookTriggerOptions, cronTrigger, eventTrigger, intervalTrigger, invokeTrigger, isTriggerError, missingConnectionNotification, missingConnectionResolvedNotification, omit, redactString, retry, slugifyId, verifyHmacSha256, verifyRequestSignature, waitForEventSchema };