@nice2dev/ui-tools 1.0.10

package/dist/integration-platform.d.ts

@@ -0,0 +1,857 @@
+/**
+ * @file integration-platform.ts
+ * @module @nice2dev/ui-tools
+ * @description PRO-13.3 — Integration Platform (iPaaS)
+ *
+ * Types for integration workflows: visual flow builder, connectors,
+ * data mapping, transformations, triggers, error handling, and monitoring.
+ */
+/** Flow execution status */
+export type FlowStatus = 'draft' | 'active' | 'paused' | 'error' | 'archived';
+/** Step execution status */
+export type StepStatus = 'pending' | 'running' | 'completed' | 'failed' | 'skipped' | 'cancelled';
+/** Data type for mapping */
+export type DataType = 'string' | 'number' | 'boolean' | 'date' | 'datetime' | 'array' | 'object' | 'binary' | 'null' | 'any';
+/** Integration flow definition */
+export interface IntegrationFlow {
+    id: string;
+    name: string;
+    description?: string;
+    version: string;
+    status: FlowStatus;
+    trigger: FlowTrigger;
+    steps: FlowStep[];
+    errorHandler?: ErrorHandler;
+    settings: FlowSettings;
+    variables?: FlowVariable[];
+    tags?: string[];
+    folder?: string;
+    createdAt: Date;
+    updatedAt: Date;
+    createdBy?: string;
+    updatedBy?: string;
+}
+/** Flow settings */
+export interface FlowSettings {
+    /** Timeout in seconds */
+    timeout?: number;
+    /** Maximum retries */
+    maxRetries?: number;
+    /** Retry delay in seconds */
+    retryDelay?: number;
+    /** Retry backoff multiplier */
+    retryBackoff?: number;
+    /** Maximum concurrent executions */
+    maxConcurrency?: number;
+    /** Log level */
+    logLevel?: 'debug' | 'info' | 'warn' | 'error';
+    /** Store execution data */
+    storeData?: boolean;
+    /** Data retention days */
+    dataRetentionDays?: number;
+    /** Notifications */
+    notifications?: FlowNotification[];
+}
+/** Flow notification */
+export interface FlowNotification {
+    event: 'success' | 'failure' | 'timeout' | 'warning';
+    channels: NotificationChannel[];
+}
+/** Notification channel */
+export interface NotificationChannel {
+    type: 'email' | 'slack' | 'teams' | 'webhook' | 'sms' | 'pagerduty';
+    target: string;
+    template?: string;
+}
+/** Flow variable */
+export interface FlowVariable {
+    name: string;
+    type: DataType;
+    description?: string;
+    defaultValue?: unknown;
+    required?: boolean;
+    secret?: boolean;
+}
+/** Flow trigger */
+export type FlowTrigger = ScheduleTrigger | WebhookTrigger | EventTrigger | ManualTrigger | FileTrigger | EmailTrigger | DatabaseTrigger;
+/** Schedule trigger (cron) */
+export interface ScheduleTrigger {
+    type: 'schedule';
+    schedule: CronSchedule;
+    timezone?: string;
+    enabled: boolean;
+    nextRunAt?: Date;
+    lastRunAt?: Date;
+}
+/** Cron schedule */
+export interface CronSchedule {
+    expression: string;
+    description?: string;
+}
+/** Webhook trigger */
+export interface WebhookTrigger {
+    type: 'webhook';
+    path: string;
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'ANY';
+    authentication?: WebhookAuth;
+    responseMode?: 'immediate' | 'deferred';
+    responseMapping?: DataMapping;
+    url?: string;
+}
+/** Webhook authentication */
+export interface WebhookAuth {
+    type: 'none' | 'basic' | 'bearer' | 'api-key' | 'hmac' | 'oauth2';
+    config?: Record<string, unknown>;
+}
+/** Event trigger (message queue) */
+export interface EventTrigger {
+    type: 'event';
+    source: EventSource;
+    filter?: EventFilter;
+    batchSize?: number;
+    batchTimeout?: number;
+}
+/** Event source */
+export interface EventSource {
+    connector: string;
+    connectionId: string;
+    topic?: string;
+    queue?: string;
+    subscription?: string;
+}
+/** Event filter */
+export interface EventFilter {
+    conditions: FilterCondition[];
+    logic: 'and' | 'or';
+}
+/** Filter condition */
+export interface FilterCondition {
+    field: string;
+    operator: FilterOperator;
+    value: unknown;
+}
+/** Filter operator */
+export type FilterOperator = 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'starts_with' | 'ends_with' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'is_null' | 'is_not_null' | 'matches_regex';
+/** Manual trigger */
+export interface ManualTrigger {
+    type: 'manual';
+    inputSchema?: DataSchema;
+}
+/** File trigger */
+export interface FileTrigger {
+    type: 'file';
+    connector: string;
+    connectionId: string;
+    path: string;
+    events: FileEvent[];
+    pattern?: string;
+    recursive?: boolean;
+    pollInterval?: number;
+}
+/** File event type */
+export type FileEvent = 'created' | 'modified' | 'deleted' | 'renamed';
+/** Email trigger */
+export interface EmailTrigger {
+    type: 'email';
+    connectionId: string;
+    folder?: string;
+    filter?: EmailFilter;
+    markAsRead?: boolean;
+    pollInterval?: number;
+}
+/** Email filter */
+export interface EmailFilter {
+    from?: string;
+    subject?: string;
+    hasAttachment?: boolean;
+    isUnread?: boolean;
+}
+/** Database trigger */
+export interface DatabaseTrigger {
+    type: 'database';
+    connectionId: string;
+    table: string;
+    events: DatabaseEvent[];
+    columns?: string[];
+    pollInterval?: number;
+    watermarkColumn?: string;
+}
+/** Database event type */
+export type DatabaseEvent = 'insert' | 'update' | 'delete';
+/** Flow step */
+export type FlowStep = ConnectorStep | TransformStep | ConditionStep | LoopStep | ParallelStep | DelayStep | SubflowStep | CodeStep | HttpStep | VariableStep | LogStep | ErrorStep;
+/** Base step properties */
+export interface BaseStep {
+    id: string;
+    name: string;
+    description?: string;
+    enabled?: boolean;
+    condition?: StepCondition;
+    errorBehavior?: StepErrorBehavior;
+    timeout?: number;
+    retries?: number;
+}
+/** Step condition */
+export interface StepCondition {
+    expression: string;
+    language?: 'javascript' | 'jsonata' | 'jmespath';
+}
+/** Step error behavior */
+export interface StepErrorBehavior {
+    action: 'fail' | 'continue' | 'retry' | 'goto';
+    gotoStepId?: string;
+    retryAttempts?: number;
+    retryDelay?: number;
+}
+/** Connector step (action) */
+export interface ConnectorStep extends BaseStep {
+    type: 'connector';
+    connector: string;
+    connectionId: string;
+    action: string;
+    inputMapping: DataMapping;
+    outputMapping?: DataMapping;
+    pagination?: PaginationConfig;
+}
+/** Pagination configuration */
+export interface PaginationConfig {
+    enabled: boolean;
+    type: 'offset' | 'cursor' | 'page';
+    pageSize: number;
+    maxPages?: number;
+    pageSizeParam?: string;
+    pageParam?: string;
+    cursorParam?: string;
+    cursorPath?: string;
+    hasMorePath?: string;
+    aggregateResults?: boolean;
+}
+/** Transform step */
+export interface TransformStep extends BaseStep {
+    type: 'transform';
+    transformType: 'map' | 'filter' | 'aggregate' | 'sort' | 'flatten' | 'group' | 'custom';
+    config: TransformConfig;
+}
+/** Transform configuration */
+export type TransformConfig = MapTransformConfig | FilterTransformConfig | AggregateTransformConfig | SortTransformConfig | FlattenTransformConfig | GroupTransformConfig | CustomTransformConfig;
+/** Map transform */
+export interface MapTransformConfig {
+    type: 'map';
+    mapping: DataMapping;
+}
+/** Filter transform */
+export interface FilterTransformConfig {
+    type: 'filter';
+    condition: string;
+    language?: 'javascript' | 'jsonata' | 'jmespath';
+}
+/** Aggregate transform */
+export interface AggregateTransformConfig {
+    type: 'aggregate';
+    groupBy?: string[];
+    aggregations: Aggregation[];
+}
+/** Aggregation */
+export interface Aggregation {
+    field: string;
+    operation: 'sum' | 'avg' | 'min' | 'max' | 'count' | 'first' | 'last' | 'concat';
+    alias: string;
+}
+/** Sort transform */
+export interface SortTransformConfig {
+    type: 'sort';
+    sortBy: SortField[];
+}
+/** Sort field */
+export interface SortField {
+    field: string;
+    direction: 'asc' | 'desc';
+    nullsFirst?: boolean;
+}
+/** Flatten transform */
+export interface FlattenTransformConfig {
+    type: 'flatten';
+    path: string;
+    depth?: number;
+}
+/** Group transform */
+export interface GroupTransformConfig {
+    type: 'group';
+    groupBy: string[];
+    outputField?: string;
+}
+/** Custom transform */
+export interface CustomTransformConfig {
+    type: 'custom';
+    code: string;
+    language: 'javascript' | 'python';
+    inputSchema?: DataSchema;
+    outputSchema?: DataSchema;
+}
+/** Condition step (branching) */
+export interface ConditionStep extends BaseStep {
+    type: 'condition';
+    branches: ConditionalBranch[];
+    defaultBranch?: FlowStep[];
+}
+/** Conditional branch */
+export interface ConditionalBranch {
+    name: string;
+    condition: string;
+    steps: FlowStep[];
+}
+/** Loop step */
+export interface LoopStep extends BaseStep {
+    type: 'loop';
+    loopType: 'foreach' | 'while' | 'until' | 'times';
+    collection?: string;
+    /** Loop termination condition (for while/until loops) */
+    loopCondition?: string;
+    times?: number;
+    itemVariable?: string;
+    indexVariable?: string;
+    steps: FlowStep[];
+    maxIterations?: number;
+    batchSize?: number;
+    parallelism?: number;
+}
+/** Parallel step */
+export interface ParallelStep extends BaseStep {
+    type: 'parallel';
+    branches: ParallelBranch[];
+    waitForAll?: boolean;
+    failFast?: boolean;
+    maxParallel?: number;
+}
+/** Parallel branch */
+export interface ParallelBranch {
+    name: string;
+    steps: FlowStep[];
+}
+/** Delay step */
+export interface DelayStep extends BaseStep {
+    type: 'delay';
+    duration: number;
+    unit: 'seconds' | 'minutes' | 'hours' | 'days';
+    until?: string;
+}
+/** Subflow step */
+export interface SubflowStep extends BaseStep {
+    type: 'subflow';
+    flowId: string;
+    inputMapping: DataMapping;
+    outputMapping?: DataMapping;
+    waitForCompletion?: boolean;
+}
+/** Code step */
+export interface CodeStep extends BaseStep {
+    type: 'code';
+    language: 'javascript' | 'python' | 'sql';
+    code: string;
+    inputVariables?: string[];
+    outputVariable?: string;
+}
+/** HTTP step */
+export interface HttpStep extends BaseStep {
+    type: 'http';
+    url: string;
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS';
+    headers?: Record<string, string>;
+    queryParams?: Record<string, string>;
+    body?: unknown;
+    bodyType?: 'json' | 'form' | 'xml' | 'text' | 'binary';
+    authentication?: HttpAuthentication;
+    followRedirects?: boolean;
+    validateCertificate?: boolean;
+    timeout?: number;
+    responseMapping?: DataMapping;
+}
+/** HTTP authentication */
+export interface HttpAuthentication {
+    type: 'none' | 'basic' | 'bearer' | 'api-key' | 'oauth2' | 'aws-signature';
+    config: Record<string, unknown>;
+}
+/** Variable step */
+export interface VariableStep extends BaseStep {
+    type: 'variable';
+    operation: 'set' | 'increment' | 'append' | 'clear';
+    variable: string;
+    value?: unknown;
+    expression?: string;
+}
+/** Log step */
+export interface LogStep extends BaseStep {
+    type: 'log';
+    level: 'debug' | 'info' | 'warn' | 'error';
+    message: string;
+    data?: unknown;
+}
+/** Error step (throw) */
+export interface ErrorStep extends BaseStep {
+    type: 'error';
+    errorCode: string;
+    message: string;
+    data?: unknown;
+}
+/** Data mapping */
+export interface DataMapping {
+    fields: FieldMapping[];
+    defaultBehavior?: 'passthrough' | 'drop';
+    validation?: MappingValidation;
+}
+/** Field mapping */
+export interface FieldMapping {
+    target: string;
+    source?: string;
+    expression?: string;
+    type?: DataType;
+    defaultValue?: unknown;
+    transform?: FieldTransform[];
+    condition?: string;
+}
+/** Field transform */
+export interface FieldTransform {
+    type: FieldTransformType;
+    config?: Record<string, unknown>;
+}
+/** Field transform type */
+export type FieldTransformType = 'uppercase' | 'lowercase' | 'trim' | 'truncate' | 'pad' | 'replace' | 'split' | 'join' | 'substring' | 'concat' | 'format_date' | 'parse_date' | 'format_number' | 'parse_number' | 'round' | 'floor' | 'ceil' | 'abs' | 'base64_encode' | 'base64_decode' | 'url_encode' | 'url_decode' | 'json_stringify' | 'json_parse' | 'hash' | 'encrypt' | 'decrypt' | 'custom';
+/** Mapping validation */
+export interface MappingValidation {
+    enabled: boolean;
+    rules: ValidationRule[];
+    onError: 'fail' | 'warn' | 'skip';
+}
+/** Validation rule */
+export interface ValidationRule {
+    field: string;
+    rule: ValidationType;
+    config?: Record<string, unknown>;
+    message?: string;
+}
+/** Validation type */
+export type ValidationType = 'required' | 'type' | 'min_length' | 'max_length' | 'pattern' | 'email' | 'url' | 'uuid' | 'date' | 'min' | 'max' | 'enum' | 'custom';
+/** Data schema */
+export interface DataSchema {
+    type: 'object' | 'array';
+    properties?: Record<string, SchemaProperty>;
+    items?: SchemaProperty;
+    required?: string[];
+    additionalProperties?: boolean;
+}
+/** Schema property */
+export interface SchemaProperty {
+    type: DataType;
+    format?: string;
+    description?: string;
+    enum?: unknown[];
+    default?: unknown;
+    properties?: Record<string, SchemaProperty>;
+    items?: SchemaProperty;
+    required?: string[];
+}
+/** Connector definition */
+export interface ConnectorDefinition {
+    id: string;
+    name: string;
+    description?: string;
+    category: ConnectorCategory;
+    icon?: string;
+    authTypes: AuthType[];
+    connectionFields: ConnectionField[];
+    triggers: TriggerDefinition[];
+    actions: ActionDefinition[];
+    version: string;
+    status: 'stable' | 'beta' | 'deprecated';
+}
+/** Connector category */
+export type ConnectorCategory = 'crm' | 'erp' | 'marketing' | 'sales' | 'support' | 'communication' | 'collaboration' | 'database' | 'file-storage' | 'analytics' | 'payment' | 'ecommerce' | 'hr' | 'productivity' | 'developer-tools' | 'infrastructure' | 'iot' | 'social' | 'custom';
+/** Authentication type */
+export type AuthType = 'none' | 'api_key' | 'basic' | 'oauth2' | 'oauth2_client_credentials' | 'jwt' | 'session' | 'custom';
+/** Connection field */
+export interface ConnectionField {
+    name: string;
+    label: string;
+    type: 'string' | 'number' | 'boolean' | 'select' | 'password' | 'textarea' | 'file';
+    required: boolean;
+    description?: string;
+    placeholder?: string;
+    defaultValue?: unknown;
+    options?: SelectOption[];
+    validation?: FieldValidation;
+    dependsOn?: FieldDependency;
+}
+/** Select option */
+export interface SelectOption {
+    label: string;
+    value: string | number;
+}
+/** Field validation */
+export interface FieldValidation {
+    pattern?: string;
+    minLength?: number;
+    maxLength?: number;
+    min?: number;
+    max?: number;
+}
+/** Field dependency */
+export interface FieldDependency {
+    field: string;
+    value: unknown;
+    condition?: 'equals' | 'not_equals' | 'in' | 'not_in';
+}
+/** Trigger definition */
+export interface TriggerDefinition {
+    id: string;
+    name: string;
+    description?: string;
+    type: 'polling' | 'webhook' | 'realtime';
+    inputFields?: ConnectionField[];
+    outputSchema: DataSchema;
+    pollInterval?: number;
+}
+/** Action definition */
+export interface ActionDefinition {
+    id: string;
+    name: string;
+    description?: string;
+    inputFields: ConnectionField[];
+    inputSchema?: DataSchema;
+    outputSchema: DataSchema;
+    dynamicInputFields?: boolean;
+    dynamicOutputFields?: boolean;
+    bulkSupport?: boolean;
+    pagination?: boolean;
+}
+/** Connection instance */
+export interface ConnectionInstance {
+    id: string;
+    connectorId: string;
+    name: string;
+    description?: string;
+    status: 'active' | 'error' | 'expired' | 'pending';
+    authType: AuthType;
+    credentials: Record<string, unknown>;
+    settings?: Record<string, unknown>;
+    metadata?: ConnectionMetadata;
+    createdAt: Date;
+    updatedAt: Date;
+    lastUsedAt?: Date;
+    error?: string;
+}
+/** Connection metadata */
+export interface ConnectionMetadata {
+    accountId?: string;
+    accountName?: string;
+    environment?: string;
+    region?: string;
+    apiVersion?: string;
+}
+/** Error handler */
+export interface ErrorHandler {
+    type: 'global' | 'step';
+    strategies: ErrorStrategy[];
+    fallbackSteps?: FlowStep[];
+    notifications?: ErrorNotification[];
+}
+/** Error strategy */
+export interface ErrorStrategy {
+    errorTypes: ErrorType[];
+    action: ErrorAction;
+    config?: Record<string, unknown>;
+}
+/** Error type */
+export type ErrorType = 'timeout' | 'connection' | 'authentication' | 'rate_limit' | 'validation' | 'not_found' | 'permission' | 'server_error' | 'unknown';
+/** Error action */
+export type ErrorAction = 'retry' | 'retry_exponential' | 'skip' | 'fail' | 'goto' | 'callback' | 'dead_letter';
+/** Error notification */
+export interface ErrorNotification {
+    channels: NotificationChannel[];
+    includeDetails?: boolean;
+    throttle?: number;
+}
+/** Dead letter queue config */
+export interface DeadLetterConfig {
+    enabled: boolean;
+    queueName: string;
+    retentionDays: number;
+    maxRetries?: number;
+}
+/** Flow execution */
+export interface FlowExecution {
+    id: string;
+    flowId: string;
+    flowVersion: string;
+    status: ExecutionStatus;
+    trigger: TriggerExecution;
+    steps: StepExecution[];
+    variables: Record<string, unknown>;
+    input?: unknown;
+    output?: unknown;
+    error?: ExecutionError;
+    startTime: Date;
+    endTime?: Date;
+    duration?: number;
+    retryCount?: number;
+    parentExecutionId?: string;
+}
+/** Execution status */
+export type ExecutionStatus = 'pending' | 'running' | 'completed' | 'failed' | 'cancelled' | 'timeout' | 'waiting';
+/** Trigger execution */
+export interface TriggerExecution {
+    type: string;
+    timestamp: Date;
+    input: unknown;
+    source?: string;
+}
+/** Step execution */
+export interface StepExecution {
+    id: string;
+    stepId: string;
+    stepName: string;
+    type: string;
+    status: StepStatus;
+    input?: unknown;
+    output?: unknown;
+    error?: ExecutionError;
+    startTime?: Date;
+    endTime?: Date;
+    duration?: number;
+    retryCount?: number;
+    logs?: ExecutionLog[];
+}
+/** Execution error */
+export interface ExecutionError {
+    code: string;
+    message: string;
+    type: ErrorType;
+    details?: unknown;
+    stack?: string;
+    stepId?: string;
+    retryable?: boolean;
+}
+/** Execution log */
+export interface ExecutionLog {
+    timestamp: Date;
+    level: 'debug' | 'info' | 'warn' | 'error';
+    message: string;
+    data?: unknown;
+}
+/** Flow version */
+export interface FlowVersion {
+    id: string;
+    flowId: string;
+    version: string;
+    status: 'draft' | 'published' | 'archived';
+    changelog?: string;
+    definition: IntegrationFlow;
+    createdAt: Date;
+    createdBy?: string;
+    publishedAt?: Date;
+    publishedBy?: string;
+}
+/** Version comparison */
+export interface VersionComparison {
+    oldVersion: string;
+    newVersion: string;
+    changes: VersionChange[];
+    compatible: boolean;
+}
+/** Version change */
+export interface VersionChange {
+    type: 'added' | 'removed' | 'modified';
+    path: string;
+    description: string;
+    breaking?: boolean;
+    oldValue?: unknown;
+    newValue?: unknown;
+}
+/** Flow test case */
+export interface FlowTestCase {
+    id: string;
+    flowId: string;
+    name: string;
+    description?: string;
+    trigger: TestTrigger;
+    mockResponses?: MockResponse[];
+    assertions: TestAssertion[];
+    enabled: boolean;
+}
+/** Test trigger */
+export interface TestTrigger {
+    type: string;
+    input: unknown;
+}
+/** Mock response */
+export interface MockResponse {
+    stepId: string;
+    response: unknown;
+    error?: ExecutionError;
+    delay?: number;
+}
+/** Test assertion */
+export interface TestAssertion {
+    type: 'status' | 'output' | 'step_status' | 'variable' | 'duration' | 'error' | 'custom';
+    config: AssertionConfig;
+}
+/** Assertion config */
+export interface AssertionConfig {
+    path?: string;
+    operator?: 'equals' | 'not_equals' | 'contains' | 'matches' | 'greater_than' | 'less_than';
+    value?: unknown;
+    stepId?: string;
+    expression?: string;
+}
+/** Test result */
+export interface FlowTestResult {
+    id: string;
+    testCaseId: string;
+    flowId: string;
+    status: 'passed' | 'failed' | 'error';
+    execution: FlowExecution;
+    assertionResults: AssertionResult[];
+    duration: number;
+    timestamp: Date;
+}
+/** Assertion result */
+export interface AssertionResult {
+    assertion: TestAssertion;
+    passed: boolean;
+    message?: string;
+    actual?: unknown;
+    expected?: unknown;
+}
+/** Flow statistics */
+export interface FlowStatistics {
+    flowId: string;
+    period: StatisticsPeriod;
+    executions: ExecutionStats;
+    steps: StepStats[];
+    errors: ErrorStats;
+    performance: PerformanceStats;
+}
+/** Statistics period */
+export interface StatisticsPeriod {
+    start: Date;
+    end: Date;
+    granularity: 'minute' | 'hour' | 'day' | 'week' | 'month';
+}
+/** Execution statistics */
+export interface ExecutionStats {
+    total: number;
+    completed: number;
+    failed: number;
+    cancelled: number;
+    running: number;
+    successRate: number;
+    timeSeries: TimeSeriesPoint[];
+}
+/** Time series point */
+export interface TimeSeriesPoint {
+    timestamp: Date;
+    value: number;
+}
+/** Step statistics */
+export interface StepStats {
+    stepId: string;
+    stepName: string;
+    executions: number;
+    failures: number;
+    avgDuration: number;
+    p50Duration: number;
+    p95Duration: number;
+    p99Duration: number;
+}
+/** Error statistics */
+export interface ErrorStats {
+    total: number;
+    byType: Record<ErrorType, number>;
+    byStep: Record<string, number>;
+    topErrors: TopError[];
+}
+/** Top error */
+export interface TopError {
+    code: string;
+    message: string;
+    count: number;
+    lastOccurrence: Date;
+}
+/** Performance statistics */
+export interface PerformanceStats {
+    avgDuration: number;
+    p50Duration: number;
+    p95Duration: number;
+    p99Duration: number;
+    maxDuration: number;
+    minDuration: number;
+    throughput: number;
+}
+/** Flow canvas configuration */
+export interface FlowCanvasConfig {
+    zoom: number;
+    panX: number;
+    panY: number;
+    gridSize: number;
+    snapToGrid: boolean;
+    showMinimap: boolean;
+    showGrid: boolean;
+    layout: 'auto' | 'manual';
+    theme: 'light' | 'dark';
+}
+/** Flow node (visual) */
+export interface FlowNode {
+    id: string;
+    type: string;
+    position: NodePosition;
+    data: FlowStep;
+    selected?: boolean;
+    dragging?: boolean;
+    width?: number;
+    height?: number;
+}
+/** Node position */
+export interface NodePosition {
+    x: number;
+    y: number;
+}
+/** Flow edge (connection) */
+export interface FlowEdge {
+    id: string;
+    source: string;
+    target: string;
+    sourceHandle?: string;
+    targetHandle?: string;
+    label?: string;
+    type?: 'default' | 'success' | 'error' | 'loop';
+    animated?: boolean;
+}
+/** Flow builder state */
+export interface FlowBuilderState {
+    flow: IntegrationFlow;
+    nodes: FlowNode[];
+    edges: FlowEdge[];
+    canvas: FlowCanvasConfig;
+    selectedNodes: string[];
+    selectedEdges: string[];
+    clipboard?: FlowNode[];
+    history: FlowHistoryEntry[];
+    historyIndex: number;
+    isDirty: boolean;
+    validationErrors: FlowValidationError[];
+}
+/** Flow history entry */
+export interface FlowHistoryEntry {
+    timestamp: Date;
+    action: string;
+    nodes: FlowNode[];
+    edges: FlowEdge[];
+}
+/** Flow validation error */
+export interface FlowValidationError {
+    nodeId?: string;
+    edgeId?: string;
+    field?: string;
+    message: string;
+    severity: 'error' | 'warning';
+}
+//# sourceMappingURL=integration-platform.d.ts.map