@genfeedai/workflow-engine 0.2.0

package/dist/src/executors/saas/color-grade-executor.js

@@ -0,0 +1,227 @@
+import { BaseExecutor } from '@workflow-engine/executors/base-executor';
+/**
+ * Preset configurations mapping to FFmpeg filter parameters.
+ * Each preset defines a fixed set of color grading values (0-100 scale).
+ */
+export const COLOR_GRADE_PRESETS = {
+  custom: {
+    contrast: 50,
+    grain: 0,
+    saturation: 50,
+    sharpness: 50,
+    vignette: 0,
+    warmth: 50,
+  },
+  'instagram-bright': {
+    contrast: 40,
+    grain: 5,
+    saturation: 55,
+    sharpness: 45,
+    vignette: 15,
+    warmth: 55,
+  },
+  'instagram-cool': {
+    contrast: 55,
+    grain: 10,
+    saturation: 40,
+    sharpness: 40,
+    vignette: 25,
+    warmth: 30,
+  },
+  'instagram-moody': {
+    contrast: 70,
+    grain: 25,
+    saturation: 35,
+    sharpness: 30,
+    vignette: 50,
+    warmth: 40,
+  },
+  'instagram-warm': {
+    contrast: 55,
+    grain: 15,
+    saturation: 45,
+    sharpness: 40,
+    vignette: 30,
+    warmth: 60,
+  },
+};
+/**
+ * Builds an FFmpeg filter_complex string from color grade parameters.
+ * Parameters are on a 0-100 scale, mapped to FFmpeg-appropriate ranges.
+ */
+export function buildFfmpegFilterChain(params) {
+  const filters = [];
+  // Contrast: map 0-100 to 0.5-1.5 (eq filter)
+  const contrastValue = 0.5 + (params.contrast / 100) * 1.0;
+  // Saturation: map 0-100 to 0.5-1.5
+  const saturationValue = 0.5 + (params.saturation / 100) * 1.0;
+  // Brightness: slight boost based on warmth
+  const brightnessValue = (params.warmth - 50) * 0.0004;
+  filters.push(
+    `eq=contrast=${contrastValue.toFixed(2)}:brightness=${brightnessValue.toFixed(3)}:saturation=${saturationValue.toFixed(2)}`,
+  );
+  // Warmth via color balance (shift reds up, blues down for warmth)
+  const warmthShift = ((params.warmth - 50) / 50) * 0.15;
+  if (Math.abs(warmthShift) > 0.01) {
+    filters.push(
+      `colorbalance=rs=${warmthShift.toFixed(2)}:gs=${(warmthShift * 0.3).toFixed(2)}:bs=${(-warmthShift).toFixed(2)}:rm=${(warmthShift * 0.8).toFixed(2)}:gm=${(warmthShift * 0.3).toFixed(2)}:bm=${(-warmthShift * 0.5).toFixed(2)}`,
+    );
+  }
+  // Vignette: map 0-100 to PI/6 angle
+  if (params.vignette > 0) {
+    const vignetteAngle = (params.vignette / 100) * (Math.PI / 4);
+    filters.push(`vignette=${vignetteAngle.toFixed(3)}`);
+  }
+  // Sharpness via unsharp mask
+  if (params.sharpness > 0) {
+    const sharpAmount = (params.sharpness / 100) * 1.5;
+    filters.push(`unsharp=5:5:${sharpAmount.toFixed(1)}:5:5:0`);
+  }
+  // Film grain via noise filter
+  if (params.grain > 0) {
+    const grainStrength = Math.round((params.grain / 100) * 30);
+    filters.push(`noise=alls=${grainStrength}:allf=t`);
+  }
+  return filters.join(',');
+}
+/**
+ * Color Grade Executor
+ *
+ * Applies Instagram-style color grading to images via FFmpeg filters
+ * or AI style transfer. Supports preset modes (warm, cool, moody, bright)
+ * and custom parameter tuning.
+ *
+ * Node Type: colorGrade
+ * Category: effects
+ */
+export class ColorGradeExecutor extends BaseExecutor {
+  nodeType = 'colorGrade';
+  processor = null;
+  setProcessor(processor) {
+    this.processor = processor;
+  }
+  validate(node) {
+    const baseValidation = super.validate(node);
+    const errors = [...baseValidation.errors];
+    const mode = node.config.mode;
+    if (mode && !['preset', 'custom', 'ai-style'].includes(mode)) {
+      errors.push('Invalid mode. Must be: preset, custom, or ai-style');
+    }
+    const preset = node.config.preset;
+    if (
+      preset &&
+      ![
+        'instagram-warm',
+        'instagram-cool',
+        'instagram-moody',
+        'instagram-bright',
+        'custom',
+      ].includes(preset)
+    ) {
+      errors.push(
+        'Invalid preset. Must be: instagram-warm, instagram-cool, instagram-moody, instagram-bright, or custom',
+      );
+    }
+    const numericFields = [
+      'warmth',
+      'contrast',
+      'saturation',
+      'vignette',
+      'grain',
+      'sharpness',
+    ];
+    for (const field of numericFields) {
+      const value = node.config[field];
+      if (
+        value !== undefined &&
+        (typeof value !== 'number' || value < 0 || value > 100)
+      ) {
+        errors.push(`${field} must be a number between 0 and 100`);
+      }
+    }
+    if (mode === 'ai-style' && !node.config.styleReferenceImage) {
+      errors.push('AI style mode requires a style reference image');
+    }
+    return {
+      errors,
+      valid: errors.length === 0,
+    };
+  }
+  estimateCost(node) {
+    const mode = node.config.mode;
+    // FFmpeg processing is free, AI style transfer costs credits
+    return mode === 'ai-style' ? 5 : 0;
+  }
+  async execute(input) {
+    const { node, inputs, context } = input;
+    if (!this.processor) {
+      throw new Error('Color grade processor not configured');
+    }
+    const imageUrl = this.getRequiredInput(inputs, 'imageUrl');
+    const mode = this.getOptionalConfig(node.config, 'mode', 'preset');
+    const preset = this.getOptionalConfig(
+      node.config,
+      'preset',
+      'instagram-warm',
+    );
+    // Resolve parameters: preset values or custom overrides
+    const baseParams =
+      mode === 'custom'
+        ? COLOR_GRADE_PRESETS.custom
+        : COLOR_GRADE_PRESETS[preset];
+    const params = {
+      contrast: this.getOptionalConfig(
+        node.config,
+        'contrast',
+        baseParams.contrast,
+      ),
+      grain: this.getOptionalConfig(node.config, 'grain', baseParams.grain),
+      saturation: this.getOptionalConfig(
+        node.config,
+        'saturation',
+        baseParams.saturation,
+      ),
+      sharpness: this.getOptionalConfig(
+        node.config,
+        'sharpness',
+        baseParams.sharpness,
+      ),
+      vignette: this.getOptionalConfig(
+        node.config,
+        'vignette',
+        baseParams.vignette,
+      ),
+      warmth: this.getOptionalConfig(node.config, 'warmth', baseParams.warmth),
+    };
+    const filterChain = buildFfmpegFilterChain(params);
+    const styleReferenceImage =
+      mode === 'ai-style'
+        ? this.getOptionalInput(inputs, 'styleReferenceImage', undefined)
+        : undefined;
+    const result = await this.processor({
+      filterChain,
+      imageUrl,
+      mode,
+      organizationId: context.organizationId,
+      preset,
+      styleReferenceImage,
+    });
+    return {
+      data: result.outputImageUrl,
+      metadata: {
+        filterChain,
+        jobId: result.jobId,
+        mode,
+        params,
+        preset,
+      },
+    };
+  }
+}
+export function createColorGradeExecutor(processor) {
+  const executor = new ColorGradeExecutor();
+  if (processor) {
+    executor.setProcessor(processor);
+  }
+  return executor;
+}

package/dist/src/executors/saas/condition-executor.d.ts

@@ -0,0 +1,75 @@
+import {
+  BaseExecutor,
+  type ExecutorInput,
+  type ExecutorOutput,
+} from '@workflow-engine/executors/base-executor';
+import type { ExecutableNode } from '@workflow-engine/types';
+export type ConditionOperator =
+  | 'equals'
+  | 'notEquals'
+  | 'greaterThan'
+  | 'lessThan'
+  | 'greaterThanOrEquals'
+  | 'lessThanOrEquals'
+  | 'contains'
+  | 'notContains'
+  | 'startsWith'
+  | 'endsWith'
+  | 'matches'
+  | 'isTrue'
+  | 'isFalse'
+  | 'isEmpty'
+  | 'isNotEmpty'
+  | 'expression';
+export type ConditionField =
+  | 'engagementRate'
+  | 'followerCount'
+  | 'contentType'
+  | 'platform'
+  | 'timeOfDay'
+  | 'dayOfWeek'
+  | 'custom';
+export interface ConditionConfig {
+  /** The field to evaluate */
+  field: ConditionField;
+  /** The comparison operator */
+  operator: ConditionOperator;
+  /** The value to compare against */
+  value?: unknown;
+  /** Custom field path (dot-notation) when field is 'custom' */
+  customField?: string;
+  /** Raw expression string for 'expression' operator */
+  expression?: string;
+  /** Timezone for time-based conditions */
+  timezone?: string;
+}
+export interface ConditionResult {
+  /** Whether the condition evaluated to true */
+  result: boolean;
+  /** The actual value that was evaluated */
+  actualValue: unknown;
+  /** The expected/comparison value */
+  expectedValue: unknown;
+  /** The operator used */
+  operator: ConditionOperator;
+  /** Pass-through data from input */
+  data: unknown;
+}
+export declare function evaluateCondition(
+  operator: ConditionOperator,
+  actual: unknown,
+  expected: unknown,
+  expression?: string,
+): boolean;
+export declare class ConditionExecutor extends BaseExecutor {
+  readonly nodeType = 'condition';
+  execute(input: ExecutorInput): Promise<ExecutorOutput>;
+  validate(node: ExecutableNode): {
+    valid: boolean;
+    errors: string[];
+  };
+  estimateCost(_node: ExecutableNode): number;
+  private resolveConfig;
+}
+export declare function createConditionExecutor(): ConditionExecutor;
+//# sourceMappingURL=condition-executor.d.ts.map

package/dist/src/executors/saas/condition-executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"condition-executor.d.ts","sourceRoot":"","sources":["../../../../src/executors/saas/condition-executor.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,KAAK,aAAa,EAClB,KAAK,cAAc,EACpB,MAAM,0CAA0C,CAAC;AAClD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAM7D,MAAM,MAAM,iBAAiB,GACzB,QAAQ,GACR,WAAW,GACX,aAAa,GACb,UAAU,GACV,qBAAqB,GACrB,kBAAkB,GAClB,UAAU,GACV,aAAa,GACb,YAAY,GACZ,UAAU,GACV,SAAS,GACT,QAAQ,GACR,SAAS,GACT,SAAS,GACT,YAAY,GACZ,YAAY,CAAC;AAEjB,MAAM,MAAM,cAAc,GACtB,gBAAgB,GAChB,eAAe,GACf,aAAa,GACb,UAAU,GACV,WAAW,GACX,WAAW,GACX,QAAQ,CAAC;AAEb,MAAM,WAAW,eAAe;IAC9B,4BAA4B;IAC5B,KAAK,EAAE,cAAc,CAAC;IACtB,8BAA8B;IAC9B,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,mCAAmC;IACnC,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,8DAA8D;IAC9D,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,sDAAsD;IACtD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,yCAAyC;IACzC,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,eAAe;IAC9B,8CAA8C;IAC9C,MAAM,EAAE,OAAO,CAAC;IAChB,0CAA0C;IAC1C,WAAW,EAAE,OAAO,CAAC;IACrB,oCAAoC;IACpC,aAAa,EAAE,OAAO,CAAC;IACvB,wBAAwB;IACxB,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,mCAAmC;IACnC,IAAI,EAAE,OAAO,CAAC;CACf;AAiHD,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,iBAAiB,EAC3B,MAAM,EAAE,OAAO,EACf,QAAQ,EAAE,OAAO,EACjB,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAyET;AAsED,qBAAa,iBAAkB,SAAQ,YAAY;IACjD,QAAQ,CAAC,QAAQ,eAAe;IAE1B,OAAO,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,cAAc,CAAC;IAgC5D,QAAQ,CAAC,IAAI,EAAE,cAAc,GAAG;QAAE,KAAK,EAAE,OAAO,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAA;KAAE;IA6CpE,YAAY,CAAC,KAAK,EAAE,cAAc,GAAG,MAAM;IAI3C,OAAO,CAAC,aAAa;CAUtB;AAED,wBAAgB,uBAAuB,IAAI,iBAAiB,CAE3D"}

package/dist/src/executors/saas/condition-executor.js

@@ -0,0 +1,298 @@
+import { BaseExecutor } from '@workflow-engine/executors/base-executor';
+
+// =============================================================================
+// FIELD RESOLVERS
+// =============================================================================
+function resolveFieldValue(field, inputs, config) {
+  const inputData = inputs.values().next().value;
+  switch (field) {
+    case 'engagementRate':
+      return (
+        resolveNestedValue(inputData, 'engagementRate') ??
+        resolveNestedValue(inputData, 'analytics.engagementRate') ??
+        resolveNestedValue(inputData, 'data.engagementRate')
+      );
+    case 'followerCount':
+      return (
+        resolveNestedValue(inputData, 'followerCount') ??
+        resolveNestedValue(inputData, 'analytics.followerCount') ??
+        resolveNestedValue(inputData, 'data.followerCount')
+      );
+    case 'contentType':
+      return (
+        resolveNestedValue(inputData, 'contentType') ??
+        resolveNestedValue(inputData, 'type') ??
+        resolveNestedValue(inputData, 'data.contentType')
+      );
+    case 'platform':
+      return (
+        resolveNestedValue(inputData, 'platform') ??
+        resolveNestedValue(inputData, 'data.platform')
+      );
+    case 'timeOfDay': {
+      const tz = config.timezone ?? 'UTC';
+      try {
+        const now = new Date();
+        const formatter = new Intl.DateTimeFormat('en-US', {
+          hour: 'numeric',
+          hour12: false,
+          timeZone: tz,
+        });
+        return parseInt(formatter.format(now), 10);
+      } catch {
+        return new Date().getUTCHours();
+      }
+    }
+    case 'dayOfWeek': {
+      const tz = config.timezone ?? 'UTC';
+      try {
+        const now = new Date();
+        const formatter = new Intl.DateTimeFormat('en-US', {
+          timeZone: tz,
+          weekday: 'long',
+        });
+        return formatter.format(now).toLowerCase();
+      } catch {
+        const days = [
+          'sunday',
+          'monday',
+          'tuesday',
+          'wednesday',
+          'thursday',
+          'friday',
+          'saturday',
+        ];
+        return days[new Date().getUTCDay()];
+      }
+    }
+    case 'custom': {
+      const customPath = config.customField;
+      if (!customPath) {
+        throw new Error('customField is required when field is "custom"');
+      }
+      return resolveNestedValue(inputData, customPath);
+    }
+    default:
+      throw new Error(`Unknown condition field: ${field}`);
+  }
+}
+function resolveNestedValue(obj, path) {
+  if (obj == null || typeof obj !== 'object') {
+    return undefined;
+  }
+  const parts = path.split('.');
+  let current = obj;
+  for (const part of parts) {
+    if (current == null || typeof current !== 'object') {
+      return undefined;
+    }
+    current = current[part];
+  }
+  return current;
+}
+// =============================================================================
+// OPERATOR EVALUATION
+// =============================================================================
+export function evaluateCondition(operator, actual, expected, expression) {
+  switch (operator) {
+    case 'equals':
+      return actual === expected; // eslint-disable-line eqeqeq
+    case 'notEquals':
+      return actual !== expected; // eslint-disable-line eqeqeq
+    case 'greaterThan':
+      return Number(actual) > Number(expected);
+    case 'lessThan':
+      return Number(actual) < Number(expected);
+    case 'greaterThanOrEquals':
+      return Number(actual) >= Number(expected);
+    case 'lessThanOrEquals':
+      return Number(actual) <= Number(expected);
+    case 'contains':
+      return String(actual).includes(String(expected));
+    case 'notContains':
+      return !String(actual).includes(String(expected));
+    case 'startsWith':
+      return String(actual).startsWith(String(expected));
+    case 'endsWith':
+      return String(actual).endsWith(String(expected));
+    case 'matches': {
+      try {
+        const regex = new RegExp(String(expected));
+        return regex.test(String(actual));
+      } catch {
+        return false;
+      }
+    }
+    case 'isTrue':
+      return Boolean(actual) === true;
+    case 'isFalse':
+      return Boolean(actual) === false;
+    case 'isEmpty':
+      return (
+        actual == null ||
+        actual === '' ||
+        (Array.isArray(actual) && actual.length === 0)
+      );
+    case 'isNotEmpty':
+      return (
+        actual != null &&
+        actual !== '' &&
+        !(Array.isArray(actual) && actual.length === 0)
+      );
+    case 'expression': {
+      if (!expression) {
+        throw new Error(
+          'Expression string is required for "expression" operator',
+        );
+      }
+      return evaluateExpression(expression, actual);
+    }
+    default:
+      throw new Error(`Unknown operator: ${operator}`);
+  }
+}
+/**
+ * Evaluates a simple expression string against a value.
+ * Supports: `value > 10`, `value === "foo"`, `value !== "bar"`, etc.
+ * Uses a safe AST-free comparison parser — no code execution.
+ */
+function evaluateExpression(expression, value) {
+  const sanitized = expression.trim();
+  // Match pattern: value <operator> <literal>
+  const match = sanitized.match(/^value\s*(===|!==|==|!=|>=|<=|>|<)\s*(.+)$/);
+  if (!match) {
+    throw new Error(
+      'Expression must be in the form: value <operator> <literal>',
+    );
+  }
+  const operator = match[1];
+  const rawRight = match[2].trim();
+  // Parse the right-hand literal safely (string, number, boolean, null)
+  let right;
+  if (
+    (rawRight.startsWith('"') && rawRight.endsWith('"')) ||
+    (rawRight.startsWith("'") && rawRight.endsWith("'"))
+  ) {
+    right = rawRight.slice(1, -1);
+  } else if (rawRight === 'true') {
+    right = true;
+  } else if (rawRight === 'false') {
+    right = false;
+  } else if (rawRight === 'null') {
+    right = null;
+  } else if (rawRight === 'undefined') {
+    right = undefined;
+  } else if (!Number.isNaN(Number(rawRight))) {
+    right = Number(rawRight);
+  } else {
+    throw new Error(`Unsupported literal in expression: ${rawRight}`);
+  }
+  switch (operator) {
+    case '===':
+      return value === right;
+    case '!==':
+      return value !== right;
+    case '==':
+      // biome-ignore lint/suspicious/noDoubleEquals: intentional loose equality for user expressions
+      return value == right;
+    case '!=':
+      // biome-ignore lint/suspicious/noDoubleEquals: intentional loose inequality for user expressions
+      return value != right;
+    case '>':
+      return value > right;
+    case '<':
+      return value < right;
+    case '>=':
+      return value >= right;
+    case '<=':
+      return value <= right;
+    default:
+      throw new Error(`Unsupported operator: ${operator}`);
+  }
+}
+// =============================================================================
+// EXECUTOR
+// =============================================================================
+export class ConditionExecutor extends BaseExecutor {
+  nodeType = 'condition';
+  async execute(input) {
+    const { node, inputs } = input;
+    const config = this.resolveConfig(node);
+    const actualValue = resolveFieldValue(config.field, inputs, config);
+    const result = evaluateCondition(
+      config.operator,
+      actualValue,
+      config.value,
+      config.expression,
+    );
+    const passthrough = inputs.values().next().value ?? null;
+    const conditionResult = {
+      actualValue,
+      data: passthrough,
+      expectedValue: config.value,
+      operator: config.operator,
+      result,
+    };
+    return {
+      data: conditionResult,
+      metadata: {
+        /** The branch that should be followed: 'true' or 'false' */
+        branch: result ? 'true' : 'false',
+        result,
+      },
+    };
+  }
+  validate(node) {
+    const errors = [];
+    const config = node.config;
+    if (!config.field) {
+      errors.push('Condition field is required');
+    }
+    if (!config.operator) {
+      errors.push('Condition operator is required');
+    }
+    const needsValue = [
+      'equals',
+      'notEquals',
+      'greaterThan',
+      'lessThan',
+      'greaterThanOrEquals',
+      'lessThanOrEquals',
+      'contains',
+      'notContains',
+      'startsWith',
+      'endsWith',
+      'matches',
+    ];
+    if (
+      config.operator &&
+      needsValue.includes(config.operator) &&
+      config.value === undefined
+    ) {
+      errors.push(`Value is required for operator "${config.operator}"`);
+    }
+    if (config.field === 'custom' && !config.customField) {
+      errors.push('customField is required when field is "custom"');
+    }
+    if (config.operator === 'expression' && !config.expression) {
+      errors.push('expression is required for "expression" operator');
+    }
+    return { errors, valid: errors.length === 0 };
+  }
+  estimateCost(_node) {
+    return 0;
+  }
+  resolveConfig(node) {
+    return {
+      customField: node.config.customField,
+      expression: node.config.expression,
+      field: node.config.field ?? 'custom',
+      operator: node.config.operator ?? 'equals',
+      timezone: node.config.timezone,
+      value: node.config.value,
+    };
+  }
+}
+export function createConditionExecutor() {
+  return new ConditionExecutor();
+}

package/dist/src/executors/saas/delay-executor.d.ts

@@ -0,0 +1,73 @@
+import {
+  BaseExecutor,
+  type ExecutorInput,
+  type ExecutorOutput,
+} from '@workflow-engine/executors/base-executor';
+import type { ExecutableNode } from '@workflow-engine/types';
+export type DelayMode = 'fixed' | 'until' | 'optimal';
+export type DelayUnit =
+  | 'milliseconds'
+  | 'seconds'
+  | 'minutes'
+  | 'hours'
+  | 'days';
+export interface DelayConfig {
+  /** Delay mode: fixed duration, until specific time, or optimal posting time */
+  mode: DelayMode;
+  /** Duration value (used with 'fixed' mode) */
+  duration?: number;
+  /** Duration unit (used with 'fixed' mode) */
+  unit?: DelayUnit;
+  /** ISO 8601 timestamp to wait until (used with 'until' mode) */
+  untilTime?: string;
+  /** Platform for optimal posting time lookup (used with 'optimal' mode) */
+  platform?: string;
+  /** Timezone for optimal time calculation */
+  timezone?: string;
+}
+export interface DelayState {
+  /** When the delay was initiated */
+  startedAt: string;
+  /** When the delay should resume */
+  resumeAt: string;
+  /** Original delay config for auditability */
+  config: DelayConfig;
+  /** Whether this delay has been completed */
+  completed: boolean;
+}
+export interface DelayResult {
+  /** The computed delay in milliseconds */
+  delayMs: number;
+  /** ISO timestamp when execution should resume */
+  resumeAt: string;
+  /** The serialized state for persistence */
+  state: DelayState;
+  /** Pass-through data from input */
+  data: unknown;
+}
+/**
+ * Resolver interface for optimal posting time lookups.
+ * Injected at runtime by the NestJS service layer.
+ */
+export interface OptimalTimeResolver {
+  getOptimalPostingTime(
+    organizationId: string,
+    platform: string,
+    timezone?: string,
+  ): Promise<Date>;
+}
+export declare function durationToMs(duration: number, unit: DelayUnit): number;
+export declare class DelayExecutor extends BaseExecutor {
+  readonly nodeType = 'delay';
+  private optimalTimeResolver?;
+  setOptimalTimeResolver(resolver: OptimalTimeResolver): void;
+  execute(input: ExecutorInput): Promise<ExecutorOutput>;
+  validate(node: ExecutableNode): {
+    valid: boolean;
+    errors: string[];
+  };
+  estimateCost(_node: ExecutableNode): number;
+  private resolveConfig;
+}
+export declare function createDelayExecutor(): DelayExecutor;
+//# sourceMappingURL=delay-executor.d.ts.map

package/dist/src/executors/saas/delay-executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delay-executor.d.ts","sourceRoot":"","sources":["../../../../src/executors/saas/delay-executor.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,KAAK,aAAa,EAClB,KAAK,cAAc,EACpB,MAAM,0CAA0C,CAAC;AAClD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAM7D,MAAM,MAAM,SAAS,GAAG,OAAO,GAAG,OAAO,GAAG,SAAS,CAAC;AAEtD,MAAM,MAAM,SAAS,GACjB,cAAc,GACd,SAAS,GACT,SAAS,GACT,OAAO,GACP,MAAM,CAAC;AAEX,MAAM,WAAW,WAAW;IAC1B,+EAA+E;IAC/E,IAAI,EAAE,SAAS,CAAC;IAChB,8CAA8C;IAC9C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,6CAA6C;IAC7C,IAAI,CAAC,EAAE,SAAS,CAAC;IACjB,gEAAgE;IAChE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,0EAA0E;IAC1E,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,4CAA4C;IAC5C,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,UAAU;IACzB,mCAAmC;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB,mCAAmC;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB,6CAA6C;IAC7C,MAAM,EAAE,WAAW,CAAC;IACpB,4CAA4C;IAC5C,SAAS,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,WAAW;IAC1B,yCAAyC;IACzC,OAAO,EAAE,MAAM,CAAC;IAChB,iDAAiD;IACjD,QAAQ,EAAE,MAAM,CAAC;IACjB,2CAA2C;IAC3C,KAAK,EAAE,UAAU,CAAC;IAClB,mCAAmC;IACnC,IAAI,EAAE,OAAO,CAAC;CACf;AAED;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IAClC,qBAAqB,CACnB,cAAc,EAAE,MAAM,EACtB,QAAQ,EAAE,MAAM,EAChB,QAAQ,CAAC,EAAE,MAAM,GAChB,OAAO,CAAC,IAAI,CAAC,CAAC;CAClB;AAcD,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,GAAG,MAAM,CAMtE;AAMD,qBAAa,aAAc,SAAQ,YAAY;IAC7C,QAAQ,CAAC,QAAQ,WAAW;IAE5B,OAAO,CAAC,mBAAmB,CAAC,CAAsB;IAElD,sBAAsB,CAAC,QAAQ,EAAE,mBAAmB,GAAG,IAAI;IAIrD,OAAO,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,cAAc,CAAC;IAmF5D,QAAQ,CAAC,IAAI,EAAE,cAAc,GAAG;QAAE,KAAK,EAAE,OAAO,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAA;KAAE;IA6BpE,YAAY,CAAC,KAAK,EAAE,cAAc,GAAG,MAAM;IAI3C,OAAO,CAAC,aAAa;CAUtB;AAED,wBAAgB,mBAAmB,IAAI,aAAa,CAEnD"}