@keystrokehq/keystroke 0.0.0-staging-20260714181321

package/dist/trigger.d.cts

@@ -0,0 +1,1309 @@
+import { p as CredentialRunContext } from "./index-whyhiCRD.cjs";
+import { E as WorkflowDefinition } from "./index-CX3Pvwnv.cjs";
+import { n as Agent } from "./index-DVFIo-WE.cjs";
+import { ZodType, z } from "zod";
+
+//#region ../../node_modules/.pnpm/cron-parser@5.5.0/node_modules/cron-parser/dist/types/CronDate.d.ts
+declare enum TimeUnit {
+  Second = "Second",
+  Minute = "Minute",
+  Hour = "Hour",
+  Day = "Day",
+  Month = "Month",
+  Year = "Year"
+}
+declare enum DateMathOp {
+  Add = "Add",
+  Subtract = "Subtract"
+}
+/**
+ * CronDate class that wraps the Luxon DateTime object to provide
+ * a consistent API for working with dates and times in the context of cron.
+ */
+declare class CronDate {
+  #private;
+  /**
+   * Constructs a new CronDate instance.
+   * @param {CronDate | Date | number | string} [timestamp] - The timestamp to initialize the CronDate with.
+   * @param {string} [tz] - The timezone to use for the CronDate.
+   */
+  constructor(timestamp?: CronDate | Date | number | string, tz?: string);
+  /**
+   * Returns daylight savings start time.
+   * @returns {number | null}
+   */
+  get dstStart(): number | null;
+  /**
+   * Sets daylight savings start time.
+   * @param {number | null} value
+   */
+  set dstStart(value: number | null);
+  /**
+   * Returns daylight savings end time.
+   * @returns {number | null}
+   */
+  get dstEnd(): number | null;
+  /**
+   * Sets daylight savings end time.
+   * @param {number | null} value
+   */
+  set dstEnd(value: number | null);
+  /**
+   * Adds one year to the current CronDate.
+   */
+  addYear(): void;
+  /**
+   * Adds one month to the current CronDate.
+   */
+  addMonth(): void;
+  /**
+   * Adds one day to the current CronDate.
+   */
+  addDay(): void;
+  /**
+   * Adds one hour to the current CronDate.
+   */
+  addHour(): void;
+  /**
+   * Adds one minute to the current CronDate.
+   */
+  addMinute(): void;
+  /**
+   * Adds one second to the current CronDate.
+   */
+  addSecond(): void;
+  /**
+   * Subtracts one year from the current CronDate.
+   */
+  subtractYear(): void;
+  /**
+   * Subtracts one month from the current CronDate.
+   * If the month is 1, it will subtract one year instead.
+   */
+  subtractMonth(): void;
+  /**
+   * Subtracts one day from the current CronDate.
+   * If the day is 1, it will subtract one month instead.
+   */
+  subtractDay(): void;
+  /**
+   * Subtracts one hour from the current CronDate.
+   * If the hour is 0, it will subtract one day instead.
+   */
+  subtractHour(): void;
+  /**
+   * Subtracts one minute from the current CronDate.
+   * If the minute is 0, it will subtract one hour instead.
+   */
+  subtractMinute(): void;
+  /**
+   * Subtracts one second from the current CronDate.
+   * If the second is 0, it will subtract one minute instead.
+   */
+  subtractSecond(): void;
+  /**
+   * Adds a unit of time to the current CronDate.
+   * @param {TimeUnit} unit
+   */
+  addUnit(unit: TimeUnit): void;
+  /**
+   * Subtracts a unit of time from the current CronDate.
+   * @param {TimeUnit} unit
+   */
+  subtractUnit(unit: TimeUnit): void;
+  /**
+   * Handles a math operation.
+   * @param {DateMathOp} verb - {'add' | 'subtract'}
+   * @param {TimeUnit} unit - {'year' | 'month' | 'day' | 'hour' | 'minute' | 'second'}
+   */
+  invokeDateOperation(verb: DateMathOp, unit: TimeUnit): void;
+  /**
+   * Returns the day.
+   * @returns {number}
+   */
+  getDate(): number;
+  /**
+   * Returns the year.
+   * @returns {number}
+   */
+  getFullYear(): number;
+  /**
+   * Returns the day of the week.
+   * @returns {number}
+   */
+  getDay(): number;
+  /**
+   * Returns the month.
+   * @returns {number}
+   */
+  getMonth(): number;
+  /**
+   * Returns the hour.
+   * @returns {number}
+   */
+  getHours(): number;
+  /**
+   * Returns the minutes.
+   * @returns {number}
+   */
+  getMinutes(): number;
+  /**
+   * Returns the seconds.
+   * @returns {number}
+   */
+  getSeconds(): number;
+  /**
+   * Returns the milliseconds.
+   * @returns {number}
+   */
+  getMilliseconds(): number;
+  /**
+   * Returns the timezone offset from UTC in minutes (e.g. UTC+2 => 120).
+   * Useful for detecting DST transition days.
+   *
+   * @returns {number} UTC offset in minutes
+   */
+  getUTCOffset(): number;
+  /**
+   * Sets the time to the start of the day (00:00:00.000) in the current timezone.
+   */
+  setStartOfDay(): void;
+  /**
+   * Sets the time to the end of the day (23:59:59.999) in the current timezone.
+   */
+  setEndOfDay(): void;
+  /**
+   * Returns the time.
+   * @returns {number}
+   */
+  getTime(): number;
+  /**
+   * Returns the UTC day.
+   * @returns {number}
+   */
+  getUTCDate(): number;
+  /**
+   * Returns the UTC year.
+   * @returns {number}
+   */
+  getUTCFullYear(): number;
+  /**
+   * Returns the UTC day of the week.
+   * @returns {number}
+   */
+  getUTCDay(): number;
+  /**
+   * Returns the UTC month.
+   * @returns {number}
+   */
+  getUTCMonth(): number;
+  /**
+   * Returns the UTC hour.
+   * @returns {number}
+   */
+  getUTCHours(): number;
+  /**
+   * Returns the UTC minutes.
+   * @returns {number}
+   */
+  getUTCMinutes(): number;
+  /**
+   * Returns the UTC seconds.
+   * @returns {number}
+   */
+  getUTCSeconds(): number;
+  /**
+   * Returns the UTC milliseconds.
+   * @returns {string | null}
+   */
+  toISOString(): string | null;
+  /**
+   * Returns the date as a JSON string.
+   * @returns {string | null}
+   */
+  toJSON(): string | null;
+  /**
+   * Sets the day.
+   * @param d
+   */
+  setDate(d: number): void;
+  /**
+   * Sets the year.
+   * @param y
+   */
+  setFullYear(y: number): void;
+  /**
+   * Sets the day of the week.
+   * @param d
+   */
+  setDay(d: number): void;
+  /**
+   * Sets the month.
+   * @param m
+   */
+  setMonth(m: number): void;
+  /**
+   * Sets the hour.
+   * @param h
+   */
+  setHours(h: number): void;
+  /**
+   * Sets the minutes.
+   * @param m
+   */
+  setMinutes(m: number): void;
+  /**
+   * Sets the seconds.
+   * @param s
+   */
+  setSeconds(s: number): void;
+  /**
+   * Sets the milliseconds.
+   * @param s
+   */
+  setMilliseconds(s: number): void;
+  /**
+   * Returns the date as a string.
+   * @returns {string}
+   */
+  toString(): string;
+  /**
+   * Returns the date as a Date object.
+   * @returns {Date}
+   */
+  toDate(): Date;
+  /**
+   * Returns true if the day is the last day of the month.
+   * @returns {boolean}
+   */
+  isLastDayOfMonth(): boolean;
+  /**
+   * Returns true if the day is the last weekday of the month.
+   * @returns {boolean}
+   */
+  isLastWeekdayOfMonth(): boolean;
+  /**
+   * Primarily for internal use.
+   * @param {DateMathOp} op - The operation to perform.
+   * @param {TimeUnit} unit - The unit of time to use.
+   * @param {number} [hoursLength] - The length of the hours. Required when unit is not month or day.
+   */
+  applyDateOperation(op: DateMathOp, unit: TimeUnit, hoursLength?: number): void;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/cron-parser@5.5.0/node_modules/cron-parser/dist/types/fields/types.d.ts
+type RangeFrom<LENGTH extends number, ACC extends unknown[] = []> = ACC['length'] extends LENGTH ? ACC : RangeFrom<LENGTH, [...ACC, 1]>;
+type IntRange<FROM extends number[], TO extends number, ACC extends number = never> = FROM['length'] extends TO ? ACC | TO : IntRange<[...FROM, 1], TO, ACC | FROM['length']>;
+type SixtyRange = IntRange<RangeFrom<0>, 59>;
+type HourRange = IntRange<RangeFrom<0>, 23>;
+type DayOfMonthRange = IntRange<RangeFrom<1>, 31> | 'L';
+type MonthRange = IntRange<RangeFrom<1>, 12>;
+type DayOfWeekRange = IntRange<RangeFrom<0>, 7> | 'L';
+type CronFieldType = SixtyRange[] | HourRange[] | DayOfMonthRange[] | MonthRange[] | DayOfWeekRange[];
+type CronChars = 'L' | 'W';
+type CronMin = 0 | 1;
+type CronMax = 7 | 12 | 23 | 31 | 59;
+type CronConstraints = {
+  min: CronMin;
+  max: CronMax;
+  chars: readonly CronChars[];
+  validChars: RegExp;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/cron-parser@5.5.0/node_modules/cron-parser/dist/types/fields/CronField.d.ts
+/**
+ * Represents the serialized form of a cron field.
+ * @typedef {Object} SerializedCronField
+ * @property {boolean} wildcard - Indicates if the field is a wildcard.
+ * @property {(number|string)[]} values - The values of the field.
+ */
+type SerializedCronField = {
+  wildcard: boolean;
+  values: (number | string)[];
+};
+/**
+ * Represents the options for a cron field.
+ * @typedef {Object} CronFieldOptions
+ * @property {string} rawValue - The raw value of the field.
+ * @property {boolean} [wildcard] - Indicates if the field is a wildcard.
+ * @property {number} [nthDayOfWeek] - The nth day of the week.
+ */
+type CronFieldOptions = {
+  rawValue?: string;
+  wildcard?: boolean;
+  nthDayOfWeek?: number;
+};
+/**
+ * Represents a field within a cron expression.
+ * This is a base class and should not be instantiated directly.
+ * @class CronField
+ */
+declare abstract class CronField$1 {
+  #private;
+  protected readonly options: CronFieldOptions & {
+    rawValue: string;
+  };
+  /**
+   * Returns the minimum value allowed for this field.
+   */
+  static get min(): CronMin;
+  /**
+   * Returns the maximum value allowed for this field.
+   */
+  static get max(): CronMax;
+  /**
+   * Returns the allowed characters for this field.
+   */
+  static get chars(): readonly CronChars[];
+  /**
+   * Returns the regular expression used to validate this field.
+   */
+  static get validChars(): RegExp;
+  /**
+   * Returns the constraints for this field.
+   */
+  static get constraints(): CronConstraints;
+  /**
+   * CronField constructor. Initializes the field with the provided values.
+   * @param {number[] | string[]} values - Values for this field
+   * @param {CronFieldOptions} [options] - Options provided by the parser
+   * @throws {TypeError} if the constructor is called directly
+   * @throws {Error} if validation fails
+   */
+  protected constructor(values: (number | string)[], options?: CronFieldOptions);
+  /**
+   * Returns the minimum value allowed for this field.
+   * @returns {number}
+   */
+  get min(): number;
+  /**
+   * Returns the maximum value allowed for this field.
+   * @returns {number}
+   */
+  get max(): number;
+  /**
+   * Returns an array of allowed special characters for this field.
+   * @returns {string[]}
+   */
+  get chars(): readonly string[];
+  /**
+   * Indicates whether this field has a "last" character.
+   * @returns {boolean}
+   */
+  get hasLastChar(): boolean;
+  /**
+   * Indicates whether this field has a "question mark" character.
+   * @returns {boolean}
+   */
+  get hasQuestionMarkChar(): boolean;
+  /**
+   * Indicates whether this field is a wildcard.
+   * @returns {boolean}
+   */
+  get isWildcard(): boolean;
+  /**
+   * Returns an array of allowed values for this field.
+   * @returns {CronFieldType}
+   */
+  get values(): CronFieldType;
+  /**
+   * Helper function to sort values in ascending order.
+   * @param {number | string} a - First value to compare
+   * @param {number | string} b - Second value to compare
+   * @returns {number} - A negative, zero, or positive value, depending on the sort order
+   */
+  static sorter(a: number | string, b: number | string): number;
+  /**
+   * Find the next (or previous when `reverse` is true) numeric value in a sorted list.
+   * Returns null if there's no value strictly after/before the current one.
+   *
+   * @param values - Sorted numeric values
+   * @param currentValue - Current value to compare against
+   * @param reverse - When true, search in reverse for previous smaller value
+   */
+  static findNearestValueInList(values: number[], currentValue: number, reverse?: boolean): number | null;
+  /**
+   * Instance helper that operates on this field's numeric `values`.
+   *
+   * @param currentValue - Current value to compare against
+   * @param reverse - When true, search in reverse for previous smaller value
+   */
+  findNearestValue(currentValue: number, reverse?: boolean): number | null;
+  /**
+   * Serializes the field to an object.
+   * @returns {SerializedCronField}
+   */
+  serialize(): SerializedCronField;
+  /**
+   * Validates the field values against the allowed range and special characters.
+   * @throws {Error} if validation fails
+   */
+  validate(): void;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/cron-parser@5.5.0/node_modules/cron-parser/dist/types/fields/CronDayOfMonth.d.ts
+/**
+ * Represents the "day of the month" field within a cron expression.
+ * @class CronDayOfMonth
+ * @extends CronField
+ */
+declare class CronDayOfMonth extends CronField$1 {
+  static get min(): CronMin;
+  static get max(): CronMax;
+  static get chars(): CronChars[];
+  static get validChars(): RegExp;
+  /**
+   * CronDayOfMonth constructor. Initializes the "day of the month" field with the provided values.
+   * @param {DayOfMonthRange[]} values - Values for the "day of the month" field
+   * @param {CronFieldOptions} [options] - Options provided by the parser
+   * @throws {Error} if validation fails
+   */
+  constructor(values: DayOfMonthRange[], options?: CronFieldOptions);
+  /**
+   * Returns an array of allowed values for the "day of the month" field.
+   * @returns {DayOfMonthRange[]}
+   */
+  get values(): DayOfMonthRange[];
+}
+//#endregion
+//#region ../../node_modules/.pnpm/cron-parser@5.5.0/node_modules/cron-parser/dist/types/fields/CronDayOfWeek.d.ts
+/**
+ * Represents the "day of the week" field within a cron expression.
+ * @class CronDayOfTheWeek
+ * @extends CronField
+ */
+declare class CronDayOfWeek extends CronField$1 {
+  static get min(): CronMin;
+  static get max(): CronMax;
+  static get chars(): readonly CronChars[];
+  static get validChars(): RegExp;
+  /**
+   * CronDayOfTheWeek constructor. Initializes the "day of the week" field with the provided values.
+   * @param {DayOfWeekRange[]} values - Values for the "day of the week" field
+   * @param {CronFieldOptions} [options] - Options provided by the parser
+   */
+  constructor(values: DayOfWeekRange[], options?: CronFieldOptions);
+  /**
+   * Returns an array of allowed values for the "day of the week" field.
+   * @returns {DayOfWeekRange[]}
+   */
+  get values(): DayOfWeekRange[];
+  /**
+   * Returns the nth day of the week if specified in the cron expression.
+   * This is used for the '#' character in the cron expression.
+   * @returns {number} The nth day of the week (1-5) or 0 if not specified.
+   */
+  get nthDay(): number;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/cron-parser@5.5.0/node_modules/cron-parser/dist/types/fields/CronHour.d.ts
+/**
+ * Represents the "hour" field within a cron expression.
+ * @class CronHour
+ * @extends CronField
+ */
+declare class CronHour extends CronField$1 {
+  static get min(): CronMin;
+  static get max(): CronMax;
+  static get chars(): readonly CronChars[];
+  /**
+   * CronHour constructor. Initializes the "hour" field with the provided values.
+   * @param {HourRange[]} values - Values for the "hour" field
+   * @param {CronFieldOptions} [options] - Options provided by the parser
+   */
+  constructor(values: HourRange[], options?: CronFieldOptions);
+  /**
+   * Returns an array of allowed values for the "hour" field.
+   * @returns {HourRange[]}
+   */
+  get values(): HourRange[];
+}
+//#endregion
+//#region ../../node_modules/.pnpm/cron-parser@5.5.0/node_modules/cron-parser/dist/types/fields/CronMinute.d.ts
+/**
+ * Represents the "second" field within a cron expression.
+ * @class CronSecond
+ * @extends CronField
+ */
+declare class CronMinute extends CronField$1 {
+  static get min(): CronMin;
+  static get max(): CronMax;
+  static get chars(): readonly CronChars[];
+  /**
+   * CronSecond constructor. Initializes the "second" field with the provided values.
+   * @param {SixtyRange[]} values - Values for the "second" field
+   * @param {CronFieldOptions} [options] - Options provided by the parser
+   */
+  constructor(values: SixtyRange[], options?: CronFieldOptions);
+  /**
+   * Returns an array of allowed values for the "second" field.
+   * @returns {SixtyRange[]}
+   */
+  get values(): SixtyRange[];
+}
+//#endregion
+//#region ../../node_modules/.pnpm/cron-parser@5.5.0/node_modules/cron-parser/dist/types/fields/CronMonth.d.ts
+/**
+ * Represents the "day of the month" field within a cron expression.
+ * @class CronDayOfMonth
+ * @extends CronField
+ */
+declare class CronMonth extends CronField$1 {
+  static get min(): CronMin;
+  static get max(): CronMax;
+  static get chars(): readonly CronChars[];
+  static get daysInMonth(): readonly number[];
+  /**
+   * CronDayOfMonth constructor. Initializes the "day of the month" field with the provided values.
+   * @param {MonthRange[]} values - Values for the "day of the month" field
+   * @param {CronFieldOptions} [options] - Options provided by the parser
+   */
+  constructor(values: MonthRange[], options?: CronFieldOptions);
+  /**
+   * Returns an array of allowed values for the "day of the month" field.
+   * @returns {MonthRange[]}
+   */
+  get values(): MonthRange[];
+}
+//#endregion
+//#region ../../node_modules/.pnpm/cron-parser@5.5.0/node_modules/cron-parser/dist/types/fields/CronSecond.d.ts
+/**
+ * Represents the "second" field within a cron expression.
+ * @class CronSecond
+ * @extends CronField
+ */
+declare class CronSecond extends CronField$1 {
+  static get min(): CronMin;
+  static get max(): CronMax;
+  static get chars(): readonly CronChars[];
+  /**
+   * CronSecond constructor. Initializes the "second" field with the provided values.
+   * @param {SixtyRange[]} values - Values for the "second" field
+   * @param {CronFieldOptions} [options] - Options provided by the parser
+   */
+  constructor(values: SixtyRange[], options?: CronFieldOptions);
+  /**
+   * Returns an array of allowed values for the "second" field.
+   * @returns {SixtyRange[]}
+   */
+  get values(): SixtyRange[];
+}
+//#endregion
+//#region ../../node_modules/.pnpm/cron-parser@5.5.0/node_modules/cron-parser/dist/types/CronFieldCollection.d.ts
+type FieldRange = {
+  start: number | CronChars;
+  count: number;
+  end?: number;
+  step?: number;
+};
+type CronFields = {
+  second: CronSecond;
+  minute: CronMinute;
+  hour: CronHour;
+  dayOfMonth: CronDayOfMonth;
+  month: CronMonth;
+  dayOfWeek: CronDayOfWeek;
+};
+type CronFieldOverride = {
+  second?: CronSecond | SixtyRange[];
+  minute?: CronMinute | SixtyRange[];
+  hour?: CronHour | HourRange[];
+  dayOfMonth?: CronDayOfMonth | DayOfMonthRange[];
+  month?: CronMonth | MonthRange[];
+  dayOfWeek?: CronDayOfWeek | DayOfWeekRange[];
+};
+type SerializedCronFields = {
+  second: SerializedCronField;
+  minute: SerializedCronField;
+  hour: SerializedCronField;
+  dayOfMonth: SerializedCronField;
+  month: SerializedCronField;
+  dayOfWeek: SerializedCronField;
+};
+/**
+ * Represents a complete set of cron fields.
+ * @class CronFieldCollection
+ */
+declare class CronFieldCollection {
+  #private;
+  /**
+   * Creates a new CronFieldCollection instance by partially overriding fields from an existing one.
+   * @param {CronFieldCollection} base - The base CronFieldCollection to copy fields from
+   * @param {CronFieldOverride} fields - The fields to override, can be CronField instances or raw values
+   * @returns {CronFieldCollection} A new CronFieldCollection instance
+   * @example
+   * const base = new CronFieldCollection({
+   *   second: new CronSecond([0]),
+   *   minute: new CronMinute([0]),
+   *   hour: new CronHour([12]),
+   *   dayOfMonth: new CronDayOfMonth([1]),
+   *   month: new CronMonth([1]),
+   *   dayOfWeek: new CronDayOfWeek([1])
+   * });
+   *
+   * // Using CronField instances
+   * const modified1 = CronFieldCollection.from(base, {
+   *   hour: new CronHour([15]),
+   *   minute: new CronMinute([30])
+   * });
+   *
+   * // Using raw values
+   * const modified2 = CronFieldCollection.from(base, {
+   *   hour: [15],        // Will create new CronHour
+   *   minute: [30]       // Will create new CronMinute
+   * });
+   */
+  static from(base: CronFieldCollection, fields: CronFieldOverride): CronFieldCollection;
+  /**
+   * Resolves a field value, either using the provided CronField instance or creating a new one from raw values.
+   * @param constructor - The constructor for creating new field instances
+   * @param baseField - The base field to use if no override is provided
+   * @param fieldValue - The override value, either a CronField instance or raw values
+   * @returns The resolved CronField instance
+   * @private
+   */
+  private static resolveField;
+  /**
+   * CronFieldCollection constructor. Initializes the cron fields with the provided values.
+   * @param {CronFields} param0 - The cron fields values
+   * @throws {Error} if validation fails
+   * @example
+   * const cronFields = new CronFieldCollection({
+   *   second: new CronSecond([0]),
+   *   minute: new CronMinute([0, 30]),
+   *   hour: new CronHour([9]),
+   *   dayOfMonth: new CronDayOfMonth([15]),
+   *   month: new CronMonth([1]),
+   *   dayOfWeek: new CronDayOfTheWeek([1, 2, 3, 4, 5]),
+   * })
+   *
+   * console.log(cronFields.second.values); // [0]
+   * console.log(cronFields.minute.values); // [0, 30]
+   * console.log(cronFields.hour.values); // [9]
+   * console.log(cronFields.dayOfMonth.values); // [15]
+   * console.log(cronFields.month.values); // [1]
+   * console.log(cronFields.dayOfWeek.values); // [1, 2, 3, 4, 5]
+   */
+  constructor({
+    second,
+    minute,
+    hour,
+    dayOfMonth,
+    month,
+    dayOfWeek
+  }: CronFields);
+  /**
+   * Returns the second field.
+   * @returns {CronSecond}
+   */
+  get second(): CronSecond;
+  /**
+   * Returns the minute field.
+   * @returns {CronMinute}
+   */
+  get minute(): CronMinute;
+  /**
+   * Returns the hour field.
+   * @returns {CronHour}
+   */
+  get hour(): CronHour;
+  /**
+   * Returns the day of the month field.
+   * @returns {CronDayOfMonth}
+   */
+  get dayOfMonth(): CronDayOfMonth;
+  /**
+   * Returns the month field.
+   * @returns {CronMonth}
+   */
+  get month(): CronMonth;
+  /**
+   * Returns the day of the week field.
+   * @returns {CronDayOfWeek}
+   */
+  get dayOfWeek(): CronDayOfWeek;
+  /**
+   * Returns a string representation of the cron fields.
+   * @param {(number | CronChars)[]} input - The cron fields values
+   * @static
+   * @returns {FieldRange[]} - The compacted cron fields
+   */
+  static compactField(input: (number | CronChars)[]): FieldRange[];
+  /**
+   * Returns a string representation of the cron fields.
+   * @param {CronField} field - The cron field to stringify
+   * @static
+   * @returns {string} - The stringified cron field
+   */
+  stringifyField(field: CronField$1): string;
+  /**
+   * Returns a string representation of the cron field values.
+   * @param {boolean} includeSeconds - Whether to include seconds in the output
+   * @returns {string} The formatted cron string
+   */
+  stringify(includeSeconds?: boolean): string;
+  /**
+   * Returns a serialized representation of the cron fields values.
+   * @returns {SerializedCronFields} An object containing the cron field values
+   */
+  serialize(): SerializedCronFields;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/cron-parser@5.5.0/node_modules/cron-parser/dist/types/CronExpression.d.ts
+type CronExpressionOptions = {
+  currentDate?: Date | string | number | CronDate;
+  endDate?: Date | string | number | CronDate;
+  startDate?: Date | string | number | CronDate;
+  tz?: string;
+  expression?: string;
+  hashSeed?: string;
+  strict?: boolean;
+};
+/**
+ * Class representing a Cron expression.
+ */
+declare class CronExpression$1 {
+  #private;
+  /**
+   * Creates a new CronExpression instance.
+   *
+   * @param {CronFieldCollection} fields - Cron fields.
+   * @param {CronExpressionOptions} options - Parser options.
+   */
+  constructor(fields: CronFieldCollection, options: CronExpressionOptions);
+  /**
+   * Getter for the cron fields.
+   *
+   * @returns {CronFieldCollection} Cron fields.
+   */
+  get fields(): CronFieldCollection;
+  /**
+   * Converts cron fields back to a CronExpression instance.
+   *
+   * @public
+   * @param {Record<string, number[]>} fields - The input cron fields object.
+   * @param {CronExpressionOptions} [options] - Optional parsing options.
+   * @returns {CronExpression} - A new CronExpression instance.
+   */
+  static fieldsToExpression(fields: CronFieldCollection, options?: CronExpressionOptions): CronExpression$1;
+  /**
+   * Find the next scheduled date based on the cron expression.
+   * @returns {CronDate} - The next scheduled date or an ES6 compatible iterator object.
+   * @memberof CronExpression
+   * @public
+   */
+  next(): CronDate;
+  /**
+   * Find the previous scheduled date based on the cron expression.
+   * @returns {CronDate} - The previous scheduled date or an ES6 compatible iterator object.
+   * @memberof CronExpression
+   * @public
+   */
+  prev(): CronDate;
+  /**
+   * Check if there is a next scheduled date based on the current date and cron expression.
+   * @returns {boolean} - Returns true if there is a next scheduled date, false otherwise.
+   * @memberof CronExpression
+   * @public
+   */
+  hasNext(): boolean;
+  /**
+   * Check if there is a previous scheduled date based on the current date and cron expression.
+   * @returns {boolean} - Returns true if there is a previous scheduled date, false otherwise.
+   * @memberof CronExpression
+   * @public
+   */
+  hasPrev(): boolean;
+  /**
+   * Iterate over a specified number of steps and optionally execute a callback function for each step.
+   * @param {number} steps - The number of steps to iterate. Positive value iterates forward, negative value iterates backward.
+   * @returns {CronDate[]} - An array of iterator fields or CronDate objects.
+   * @memberof CronExpression
+   * @public
+   */
+  take(limit: number): CronDate[];
+  /**
+   * Reset the iterators current date to a new date or the initial date.
+   * @param {Date | CronDate} [newDate] - Optional new date to reset to. If not provided, it will reset to the initial date.
+   * @memberof CronExpression
+   * @public
+   */
+  reset(newDate?: Date | CronDate): void;
+  /**
+   * Generate a string representation of the cron expression.
+   * @param {boolean} [includeSeconds=false] - Whether to include the seconds field in the string representation.
+   * @returns {string} - The string representation of the cron expression.
+   * @memberof CronExpression
+   * @public
+   */
+  stringify(includeSeconds?: boolean): string;
+  /**
+   * Check if the cron expression includes the given date
+   * @param {Date|CronDate} date
+   * @returns {boolean}
+   */
+  includesDate(date: Date | CronDate): boolean;
+  /**
+   * Returns the string representation of the cron expression.
+   * @returns {CronDate} - The next schedule date.
+   */
+  toString(): string;
+  /**
+   * Returns an iterator for iterating through future CronDate instances
+   *
+   * @name Symbol.iterator
+   * @memberof CronExpression
+   * @returns {Iterator<CronDate>} An iterator object for CronExpression that returns CronDate values.
+   */
+  [Symbol.iterator](): Iterator<CronDate>;
+}
+//#endregion
+//#region ../trigger/dist/index.d.mts
+//#region src/cron/cron-schedule.d.ts
+/**
+ * A single cron field — best-effort compile-time hint, NOT a full validator.
+ *
+ * `${number}` accepts any number (so out-of-range values slip through) and this
+ * union omits named months/weekdays (`jan`, `mon`, …). The real gate is
+ * `cronScheduleSchema` at runtime; this just catches obvious shape mistakes in
+ * string literals (e.g. wrong field count) and powers editor hints.
+ */
+type CronField = "*" | `${number}` | `${number}-${number}` | `*/${number}` | `${number}/${number}` | `${number}-${number}/${number}` | `${number},${string}`;
+/**
+ * Compile-time shape for a 5-field cron expression literal
+ * (minute hour day month weekday).
+ *
+ * For anything this can't express (6-field/seconds expressions, named
+ * months/weekdays, `@daily`-style nicknames, dynamic strings), route through
+ * `parseCronSchedule(...)`, which validates at runtime and returns a branded
+ * `CronSchedule`.
+ */
+type CronExpression = `${CronField} ${CronField} ${CronField} ${CronField} ${CronField}`;
+/**
+ * Validates and brands a cron expression. Accepts anything the `cron-parser`
+ * engine accepts (5/6 fields, named months/weekdays, `@daily`-style nicknames)
+ * so authoring validation never rejects a schedule the scheduler can run. The
+ * `.brand()` makes `CronSchedule` nominally distinct from a plain `string`, so
+ * a raw string can't be passed where a validated schedule is expected.
+ */
+declare const cronScheduleSchema: z.core.$ZodBranded<z.ZodString, "CronSchedule", "out">;
+/** A cron expression that has been validated by `cronScheduleSchema`. */
+type CronSchedule = z.infer<typeof cronScheduleSchema>;
+/** Authoring input for a schedule: a shape-checked literal or a pre-validated `CronSchedule`. */
+type CronScheduleInput = CronExpression | CronSchedule;
+/** Parse/validate an arbitrary value into a branded `CronSchedule` (throws on failure). */
+declare function parseCronSchedule(value: string): CronSchedule;
+/**
+ * Validates and brands a cron expression for poll triggers. Polls may not fire
+ * more often than once per minute, so only minute-level schedules are allowed:
+ * 5-field expressions and `@daily`-style nicknames. 6-field (seconds)
+ * expressions are rejected — use `parseCronSchedule` for cron triggers.
+ */
+declare const pollScheduleSchema: z.core.$ZodBranded<z.ZodString, "CronSchedule", "out">;
+/** A poll schedule that has been validated by `pollScheduleSchema`. */
+type PollSchedule = z.infer<typeof pollScheduleSchema>;
+/** Parse/validate a poll schedule (throws on 6-field/seconds expressions). */
+declare function parsePollSchedule(value: string): PollSchedule;
+/**
+ * Resolves the effective schedule for an attachment, applying overrides by
+ * precedence: per-attachment override → global override → the authored
+ * schedule. Pure string precedence — no cron parsing.
+ */
+declare function resolveCronSchedule(attachmentId: string, schedule: string, options: {
+  cronScheduleOverride?: string;
+  attachmentScheduleOverrides?: Record<string, string>;
+}): string;
+/** Default timezone when none is authored — preserves historical UTC evaluation. */
+declare const DEFAULT_TRIGGER_TIMEZONE = "UTC";
+/**
+ * Validates and brands an IANA timezone (e.g. `America/New_York`). Uses
+ * `Intl.DateTimeFormat` so we don't need a timezone database dependency.
+ */
+declare const timezoneSchema: z.core.$ZodBranded<z.ZodString, "Timezone", "out">;
+/** An IANA timezone that has been validated by `timezoneSchema`. */
+type Timezone = z.infer<typeof timezoneSchema>;
+/** Parse/validate an IANA timezone (throws on failure). */
+declare function parseTimezone(value: string): Timezone;
+/** Parse a schedule into a `cron-parser` expression (throws on invalid input). */
+declare function parseTriggerSchedule(schedule: string, timezone?: string): CronExpression$1;
+/**
+ * The next time the schedule fires at or after `from`.
+ *
+ * Cron fields are wall-clock times in `timezone` (default UTC). Absolute
+ * instants are computed here — do not convert the cron string to UTC at write time.
+ */
+declare function nextTriggerRunAt(schedule: string, from?: Date, timezone?: string): Date; //#endregion
+//#region src/attach-options.d.ts
+type WorkflowAttachOptions<TInput = unknown, TOutput = unknown, TPayload = unknown> = {
+  workflow: WorkflowDefinition<TInput, TOutput>;
+  transform?: (payload: TPayload) => TInput;
+};
+type AgentAttachOptions<TPayload = unknown> = {
+  agent: Agent;
+  prompt: string | ((payload: TPayload) => string);
+};
+type AttachOptions<TInput = unknown, TOutput = unknown, TPayload = unknown> = WorkflowAttachOptions<TInput, TOutput, TPayload> | AgentAttachOptions<TPayload>; //#endregion
+//#region src/cron-payload.d.ts
+/** JSON-serializable value suitable for a static cron payload. */
+type JsonValue = string | number | boolean | null | JsonValue[] | {
+  [key: string]: JsonValue;
+};
+/** Runtime schema for an optional static cron payload (JSON only). */
+declare const cronPayloadSchema: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+/** Validate a cron payload at define time; throws if not JSON-serializable. */
+declare function parseCronPayload(value: unknown): JsonValue; //#endregion
+//#region src/trigger-slug.d.ts
+/** Human-facing metadata (same as agents/workflows). */
+type TriggerMetaInput = {
+  name: string;
+  description: string;
+};
+/** Authoring input: `slug` is canonical; `key` is legacy. */
+type TriggerAuthoringSlugInput = {
+  slug?: string; /** @deprecated Use `slug`. Accepted for backwards-compatible trigger definitions. */
+  key?: string;
+};
+/** Authoring options shared by all `define*Source` factories. */
+type TriggerSourceAuthoringInput = TriggerAuthoringSlugInput & TriggerMetaInput;
+/** Resolve slug from authoring options (`slug` preferred, `key` fallback). */
+declare function resolveAuthoringSlug(input: TriggerAuthoringSlugInput, label?: string): string;
+/** Composite attachment slug `{sourceSlug}:{targetSlug}`. */
+declare function attachmentSlugFrom(sourceSlug: string, targetSlug: string): string;
+/** Read slug from a trigger source (`slug` preferred, legacy `key` fallback). */
+declare function sourceSlugFrom(source: {
+  slug?: string;
+  key?: string;
+}): string;
+/** Read slug from a trigger attachment (`slug` preferred, legacy `key` fallback). */
+declare function attachmentSlugFromRecord(attachment: {
+  slug?: string;
+  key?: string;
+}): string;
+/** Source slug prefix from a composite attachment slug. */
+declare function triggerSourceSlugFromAttachmentSlug(attachmentSlug: string): string;
+/** Target slug suffix from a composite attachment slug. */
+declare function triggerTargetSlugFromAttachmentSlug(attachmentSlug: string): string; //#endregion
+//#region src/sources/cron-source.d.ts
+type TriggerSourceBase = {
+  slug: string;
+  name: string;
+  description: string;
+};
+/**
+ * Workflow attach options for a cron source.
+ *
+ * When `TPayload` is assignable to the workflow input, `transform` is optional.
+ * Otherwise `transform` is required and must map `TPayload` → `TInput`.
+ */
+type CronWorkflowAttachOptions<TPayload, TInput, TOutput> = {
+  workflow: WorkflowDefinition<TInput, TOutput>;
+} & ([TPayload] extends [TInput] ? {
+  transform?: (payload: TPayload) => TInput;
+} : {
+  transform: (payload: TPayload) => TInput;
+});
+type CronAgentAttachOptions<TPayload> = {
+  agent: Agent;
+  prompt: string | ((payload: TPayload) => string);
+};
+type CronAttachOptions<TPayload, TInput = unknown, TOutput = unknown> = CronWorkflowAttachOptions<TPayload, TInput, TOutput> | CronAgentAttachOptions<TPayload>;
+/**
+ * Result of `cronSource.attach(...)`. Keeps `TPayload` so chained attaches stay typed.
+ */
+type ChainableCronTriggerAttachment<TPayload> = ChainableTriggerAttachment & {
+  attach<TInput, TOutput>(options: CronAttachOptions<TPayload, TInput, TOutput>): ChainableCronTriggerAttachment<TPayload>;
+};
+type CronSource<TPayload extends JsonValue = Record<string, never>> = TriggerSourceBase & {
+  kind: "cron";
+  schedule: CronSchedule;
+  /**
+   * IANA timezone for interpreting `schedule` wall-clock fields.
+   * When omitted, schedules evaluate in UTC.
+   */
+  timezone?: Timezone; /** Static payload passed to attachments on each tick. Defaults to `{}` when omitted. */
+  payload?: TPayload;
+  attach<TInput, TOutput>(options: CronAttachOptions<TPayload, TInput, TOutput>): ChainableCronTriggerAttachment<TPayload>;
+};
+/**
+ * Defines a cron trigger source — fires its attached workflow on a schedule.
+ *
+ * @param options.slug - Stable trigger source slug; attachment slug is `{slug}:{targetSlug}`.
+ * @param options.key - **Deprecated.** Accepted for backwards-compatible definitions.
+ * @param options.name - Human-readable name shown in the platform.
+ * @param options.description - Short description shown in the platform.
+ * @param options.schedule - A cron expression. Pass a 5-field literal (e.g.
+ *   `"0 9 * * *"`) for compile-time shape checking, or wrap with
+ *   `parseCronSchedule(...)` for 6-field, named (`MON`), or `@daily`-style
+ *   schedules. Validated at runtime; throws if the expression is invalid.
+ * @param options.timezone - Optional IANA timezone (e.g. `America/New_York`).
+ *   Cron fields are wall-clock times in this zone. When omitted, UTC.
+ * @param options.payload - Optional static JSON payload passed to attachments on
+ *   each tick (like a webhook body). When omitted, attachments receive `{}`.
+ *   Without a `transform`, the payload must be assignable to the workflow input.
+ * @example
+ * defineCronSource({ slug: "morning", schedule: "0 9 * * *" }).attach({ workflow });
+ * @example
+ * defineCronSource({
+ *   slug: "morning-report",
+ *   schedule: "0 9 * * *",
+ *   timezone: "America/New_York",
+ *   payload: { report: "daily", region: "us" },
+ * }).attach({ workflow });
+ */
+declare function defineCronSource<TPayload extends JsonValue = Record<string, never>>(options: TriggerSourceAuthoringInput & {
+  schedule: CronScheduleInput;
+  timezone?: string;
+  payload?: TPayload;
+}): CronSource<TPayload>; //#endregion
+//#region src/sources/poll-source.d.ts
+type PollRunContext<TState> = {
+  state: TState | undefined;
+  setState(next: TState): void;
+};
+type PollSource<TResult = unknown, TState = unknown> = {
+  kind: "poll";
+  slug: string;
+  name: string;
+  description: string;
+  id?: string;
+  schedule: PollSchedule;
+  /**
+   * IANA timezone for interpreting `schedule` wall-clock fields.
+   * When omitted, schedules evaluate in UTC.
+   */
+  timezone?: Timezone;
+  run: (ctx?: PollRunContext<TState>) => TResult | Promise<TResult>;
+  stateSchema?: ZodType<TState>;
+  filters: Array<(payload: unknown) => boolean>;
+  passes: (payload: unknown) => boolean;
+  attach<TInput, TOutput>(options: AttachOptions<TInput, TOutput, TResult>): ChainableTriggerAttachment;
+};
+type PollSourceChain<TResult, TState = unknown> = PollSource<TResult, TState> & {
+  filter: (fn: (payload: TResult) => boolean) => PollSourceChain<TResult, TState>;
+};
+/**
+ * Defines a poll trigger source — runs `run` on a schedule and, when the result
+ * passes any `.filter(...)`, fires the attached workflow with it.
+ *
+ * With a `state` schema, `run` always receives `{ state, setState }`; without one,
+ * `run` is called with no arguments.
+ *
+ * @param options.slug - Stable trigger source slug; attachment slug is `{slug}:{targetSlug}`.
+ * @param options.key - **Deprecated.** Accepted for backwards-compatible definitions.
+ * @param options.id - Optional group id; poll sources sharing an id poll together.
+ * @param options.schedule - Cron expression for the poll cadence (minimum one minute between fires).
+ * @param options.timezone - Optional IANA timezone for wall-clock schedule fields. When omitted, UTC.
+ * @param options.state - Optional Zod schema for cursor state persisted between poll ticks.
+ * @param options.run - Produces the payload checked by `filter` and passed to the workflow.
+ * @param options.filter - Source-level predicate; the workflow only fires when it returns true.
+ * @example
+ * definePollSource({ slug: "inbox", schedule: "0 * * * *", run: fetchInbox })
+ *   .filter((r) => r.length > 0)
+ *   .attach({ workflow });
+ */
+declare function definePollSource<TResult, TState>(options: TriggerSourceAuthoringInput & {
+  schedule: CronScheduleInput;
+  timezone?: string;
+  state: ZodType<TState>;
+  run: (ctx: PollRunContext<TState>) => TResult | Promise<TResult>;
+  filter?: (payload: TResult) => boolean;
+}): PollSourceChain<TResult, TState>;
+declare function definePollSource<TResult>(options: TriggerSourceAuthoringInput & {
+  id?: string;
+  schedule: CronScheduleInput;
+  timezone?: string;
+  run: () => TResult | Promise<TResult>;
+  filter?: (payload: TResult) => boolean;
+}): PollSourceChain<TResult>; //#endregion
+//#region src/attachment-definition.d.ts
+declare const TRIGGER_ATTACHMENT: unique symbol;
+/** Trigger source as seen from outside the source factories. */
+type TriggerSource = WebhookSource | CronSource<JsonValue> | PollSource;
+type WorkflowTriggerAttachment = {
+  slug: string;
+  name?: string;
+  description?: string;
+  source: TriggerSource;
+  target: "workflow";
+  workflow: WorkflowDefinition<any, any>;
+  transform?: (payload: unknown) => unknown;
+  readonly [TRIGGER_ATTACHMENT]: true;
+};
+type AgentTriggerAttachment = {
+  slug: string;
+  name?: string;
+  description?: string;
+  source: TriggerSource;
+  target: "agent";
+  agent: Agent;
+  prompt: string | ((payload: unknown) => string);
+  readonly [TRIGGER_ATTACHMENT]: true;
+};
+/**
+ * Stored shape of a trigger attachment after `.attach(...)`. Validated via
+ * `triggerAttachmentCoreSchema` and tagged with `TRIGGER_ATTACHMENT`.
+ */
+type TriggerAttachment = WorkflowTriggerAttachment | AgentTriggerAttachment;
+/**
+ * Validates brand + shape via `triggerAttachmentCoreSchema` so server discovery
+ * rejects unbranded or malformed attachments.
+ */
+declare function isTriggerAttachment(value: unknown): value is TriggerAttachment;
+declare function isWorkflowTriggerAttachment(attachment: TriggerAttachment): attachment is WorkflowTriggerAttachment;
+declare function isAgentTriggerAttachment(attachment: TriggerAttachment): attachment is AgentTriggerAttachment; //#endregion
+//#region src/attach-from-source.d.ts
+/**
+ * Hidden link from a chained `.attach(...)` result back to every attachment in the
+ * same chain. Lets discovery expand a single default export into all fan-out targets.
+ */
+declare const TRIGGER_ATTACHMENT_SIBLINGS: unique symbol;
+/**
+ * Result of `source.attach(...)`. A `TriggerAttachment` (so existing single-target
+ * usage is unchanged) that additionally chains: `source.attach(a).attach(b)` binds
+ * the same source to multiple workflows/agents.
+ */
+type ChainableTriggerAttachment = TriggerAttachment & {
+  attach<TInput, TOutput, TPayload = unknown>(options: AttachOptions<TInput, TOutput, TPayload>): ChainableTriggerAttachment;
+};
+declare function attachFromSource(source: TriggerSource, sourceSlug: string, options: AttachOptions): ChainableTriggerAttachment;
+/**
+ * Flatten a trigger module's default export into its individual attachments —
+ * a single `.attach(...)`, a `.attach(...).attach(...)` chain, or an array of either.
+ */
+declare function triggerAttachmentsFromExport(value: unknown): TriggerAttachment[]; //#endregion
+//#region src/sources/webhook-source.d.ts
+declare function normalizeWebhookEndpoint(endpoint: string): string;
+type WebhookSource<TPayload = unknown> = {
+  kind: "webhook";
+  slug: string;
+  name: string;
+  description: string;
+  endpoint: string;
+  payload: z.ZodType<TPayload>;
+  /**
+   * ponytail: legacy narrowing filter from artifacts built before the `payload` rename.
+   * Preserved so registry sync keeps writing `filterSchema` and matching semantics are
+   * unchanged for old deployed code. TODO: remove after all projects redeploy with `payload`.
+   */
+  filter?: z.ZodType;
+  passes: (payload: unknown) => boolean;
+  attach<TInput, TOutput>(options: AttachOptions<TInput, TOutput, TPayload>): ChainableTriggerAttachment;
+};
+/**
+ * Defines a webhook trigger source — fires its attached workflow when a request
+ * hits `/triggers/{endpoint}` and satisfies `payload`.
+ *
+ * @param options.slug - Stable trigger source slug; attachment slug is `{slug}:{targetSlug}`.
+ * @param options.key - **Deprecated.** Accepted for backwards-compatible definitions.
+ * @param options.endpoint - Shared route suffix under `/triggers/` (e.g. `"stripe"`).
+ * @param options.payload - Zod schema the incoming body must match for the trigger to fire.
+ */
+declare function defineWebhookSource<TPayload>(options: TriggerSourceAuthoringInput & {
+  endpoint: string;
+  payload: z.ZodType<TPayload>;
+}): WebhookSource<TPayload>; //#endregion
+//#region src/trigger-match-schema.d.ts
+type WebhookMatchIssue = {
+  path: string;
+  message: string;
+};
+declare function formatIssuesDetail(issues: WebhookMatchIssue[]): string;
+type WebhookAttachmentSchema = {
+  attachmentSlug: string; /** Trigger row id when known (platform ingress / persisted bindings). */
+  triggerId?: string;
+  requestSchema: Record<string, unknown>;
+  /**
+   * ponytail: legacy stored configs only — authoring no longer writes filterSchema.
+   * Remove once Keystroke + Angel projects have redeployed (see plan production survey).
+   */
+  filterSchema?: Record<string, unknown>;
+};
+type WebhookPayloadMatch = {
+  attachmentSlug: string;
+  triggerId?: string;
+  data: unknown;
+};
+type WebhookPayloadUnmatched = {
+  attachmentSlug: string;
+  triggerId?: string;
+  issues: WebhookMatchIssue[];
+  reason: "invalid_payload" | "filter_rejected";
+};
+type WebhookPayloadMatchResult = {
+  matches: WebhookPayloadMatch[];
+  filterRejected: WebhookPayloadMatch[];
+  unmatched: WebhookPayloadUnmatched[];
+};
+declare function matchWebhookPayload(raw: unknown, schemas: WebhookAttachmentSchema[]): WebhookPayloadMatchResult; //#endregion
+//#region src/ephemeral-match.d.ts
+/**
+ * Agent-friendly shallow payload matcher for ephemeral webhook triggers —
+ * dot-separated paths mapped to exact values, e.g.
+ * `{ "type": "invoice.paid", "data.object.status": "paid" }`. Same role as
+ * `defineWebhookSource({ payload })` in project code.
+ */
+type EphemeralWebhookMatch = Record<string, unknown>;
+/**
+ * Compiles a shallow payload matcher into a JSON Schema stored as webhook
+ * `requestSchema` (persisted wire key). Dots in keys are path separators; an empty
+ * matcher produces a schema that accepts any JSON object payload.
+ */
+declare function matchToJsonSchema(payload: EphemeralWebhookMatch): Record<string, unknown>; //#endregion
+//#region src/interpolate-prompt.d.ts
+/**
+ * Resolves `{{path}}` / `{{payload.path}}` dot-path tokens in an ephemeral trigger
+ * prompt against the webhook payload. Unresolved tokens are left untouched so the
+ * agent can see what failed to bind.
+ */
+declare function interpolatePrompt(template: string, payload: unknown): string; //#endregion
+//#region src/resolve-agent-prompt.d.ts
+/** Resolves the agent prompt for a validated trigger payload. */
+declare function resolveAgentPrompt(attachment: AgentTriggerAttachment, payload: unknown): string; //#endregion
+//#region src/resolve-attachment-input.d.ts
+/**
+ * Applies attachment `transform` to a payload that already passed source validation.
+ * Webhook payloads are matched at ingress via persisted Zod JSON schemas.
+ */
+declare function resolveAttachmentTransform(attachment: TriggerAttachment, payload: unknown): unknown;
+/** Applies poll source filters and attachment `transform`. Webhook ingress already matched Zod schemas. */
+declare function resolveAttachmentInput(attachment: TriggerAttachment, payload: unknown): unknown; //#endregion
+//#region src/types.d.ts
+type RunContext = {
+  trigger: "cron" | "webhook" | "poll" | "retry";
+  payload?: unknown;
+  triggeredAt: Date;
+  credentials?: CredentialRunContext;
+};
+type WebhookSkipResponse = {
+  ok: true;
+  skipped: true;
+};
+type PollSkipResponse = {
+  ok: true;
+  skipped: true;
+}; //#endregion
+//#region src/trigger-meta.d.ts
+declare function triggerMetaFromSource(source: TriggerSource): {
+  name: string;
+  description: string;
+};
+declare function triggerMetaFromAttachment(attachment: TriggerAttachment): {
+  name: string;
+  description: string;
+};
+declare function triggerMetaRecordFromAttachment(attachment: TriggerAttachment): {
+  name: string;
+  description: string;
+}; //#endregion
+//#region src/attachment-slug.d.ts
+declare function workflowSlugFromDefinition(workflow: WorkflowDefinition<unknown, unknown>): string;
+declare function agentSlugFromAgent(agent: Agent): string;
+/** @deprecated Use {@link attachmentSlugFrom}. */
+declare const attachmentKeyFrom: typeof attachmentSlugFrom;
+/** @deprecated Use {@link workflowSlugFromDefinition}. */
+declare const workflowKeyFromDefinition: typeof workflowSlugFromDefinition;
+/** @deprecated Use {@link agentSlugFromAgent}. */
+declare const agentKeyFromAgent: typeof agentSlugFromAgent; //#endregion
+//#endregion
+export { type AgentAttachOptions, type AgentTriggerAttachment, type AttachOptions, type ChainableCronTriggerAttachment, type ChainableTriggerAttachment, type CronAgentAttachOptions, type CronAttachOptions, type CronExpression, type CronSchedule, type CronScheduleInput, type CronSource, type CronWorkflowAttachOptions, DEFAULT_TRIGGER_TIMEZONE, type EphemeralWebhookMatch, type JsonValue, type PollRunContext, type PollSchedule, type PollSkipResponse, type PollSource, type RunContext, TRIGGER_ATTACHMENT, TRIGGER_ATTACHMENT_SIBLINGS, type Timezone, type TriggerAttachment, type TriggerAuthoringSlugInput, type TriggerMetaInput, type TriggerSource, type TriggerSourceAuthoringInput, type WebhookAttachmentSchema, type WebhookMatchIssue, type WebhookPayloadMatch, type WebhookPayloadMatchResult, type WebhookPayloadUnmatched, type WebhookSkipResponse, type WebhookSource, type WorkflowAttachOptions, type WorkflowTriggerAttachment, agentKeyFromAgent, agentSlugFromAgent, attachFromSource, attachmentKeyFrom, attachmentSlugFrom, attachmentSlugFromRecord, cronPayloadSchema, cronScheduleSchema, defineCronSource, definePollSource, defineWebhookSource, formatIssuesDetail, interpolatePrompt, isAgentTriggerAttachment, isTriggerAttachment, isWorkflowTriggerAttachment, matchToJsonSchema, matchWebhookPayload, nextTriggerRunAt, normalizeWebhookEndpoint, parseCronPayload, parseCronSchedule, parsePollSchedule, parseTimezone, parseTriggerSchedule, pollScheduleSchema, resolveAgentPrompt, resolveAttachmentInput, resolveAttachmentTransform, resolveAuthoringSlug, resolveCronSchedule, sourceSlugFrom, timezoneSchema, triggerAttachmentsFromExport, triggerMetaFromAttachment, triggerMetaFromSource, triggerMetaRecordFromAttachment, triggerSourceSlugFromAttachmentSlug, triggerTargetSlugFromAttachmentSlug, workflowKeyFromDefinition, workflowSlugFromDefinition };
+//# sourceMappingURL=trigger.d.cts.map