import { type DisplayProperty, type EventFilter, type HandleTriggerSource, type RegisterWebhookSource, type TriggerMetadata } from "@systemfsoftware/trigger.dev_core-v2";
import type { IOWithIntegrations, TriggerIntegration } from "../integrations.js";
import { IO } from "../io.js";
import { Job } from "../job.js";
import { TriggerClient } from "../triggerClient.js";
import type { EventSpecification, SchemaParser, Trigger, TriggerContext, VerifyResult } from "../types.js";
import type { SerializableJson } from "@systemfsoftware/trigger.dev_core-v2";
import type { Prettify } from "@systemfsoftware/trigger.dev_core-v2";
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>;
}
export 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>;
export type WebhookHandlerEvent<TParams extends any = any> = {
    rawEvent: Request;
    source: Prettify<Omit<HandleTriggerSource, "params"> & {
        params: TParams;
    }>;
};
export 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[];
};
export 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: {
            name: string;
            id: string;
            instructions?: string | undefined;
        };
    };
    get id(): string;
    get version(): string;
}
export type GetWebhookParams<TWebhook extends WebhookSource<any, any, any>> = TWebhook extends WebhookSource<any, infer TParams, any> ? TParams : never;
export type GetWebhookConfig<TWebhook extends WebhookSource<any, any, any>> = TWebhook extends WebhookSource<any, any, infer TConfig> ? TConfig : never;
export 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;
};
export 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;
    }>;
}
export {};
//# sourceMappingURL=webhook.d.ts.map