import { type ConnectionAuth, type DisplayProperty, type EventFilter, type HandleTriggerSource, type HttpSourceResponseMetadata, type NormalizedResponse, type Prettify, type RegisterTriggerSource, type SendEvent, type SerializableJson, type TriggerMetadata } from "@systemfsoftware/trigger.dev_core-v2";
import { Logger } from "@systemfsoftware/trigger.dev_core-backend";
import type { Buffer } from "buffer";
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 } from "../types.js";
export 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>;
export 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>;
export 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: SchemaParser<TParams>;
    optionSchema?: SchemaParser<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[];
};
export 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: SendEvent[];
        response?: NormalizedResponse;
        metadata?: HttpSourceResponseMetadata;
    }>;
    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: {
            name: string;
            id: string;
            instructions?: string | undefined;
        };
    };
    get id(): string;
    get version(): string;
}
export type ExternalSourceParams<TExternalSource extends ExternalSource<any, any, any>> = TExternalSource extends ExternalSource<any, infer TParams, any> ? TParams : never;
export 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>;
};
export 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;
    verifyPayload(payload: ReturnType<TEventSpecification["parsePayload"]>): Promise<{
        success: true;
    }>;
}
export declare function omit<T extends Record<string, unknown>, K extends keyof T>(obj: T, key: K): {
    result: Omit<T, K>;
    ommited: T[K];
};
export {};
//# sourceMappingURL=externalSource.d.ts.map