import { EventEmitter, ViewContainerRef, OnChanges, SimpleChanges, Type, AfterViewInit, DoCheck, ChangeDetectorRef } from '@angular/core'; import { ExecutionStepConfig, AddStepMenuOption, StepMoreMenuOption } from '../execution-step.models'; import * as i0 from "@angular/core"; /** * Component that renders the appropriate step component based on the step type. * Uses dynamic component loading and an injection token to break circular dependencies * between step components in Angular Ivy partial compilation mode. */ export declare class StepRendererComponent implements OnChanges, AfterViewInit, DoCheck { private componentMap; private cdr; step: ExecutionStepConfig; onExpandHandler?: (step: ExecutionStepConfig) => void; getConditionBranchesHandler?: (step: ExecutionStepConfig) => any; isStepLoadingHandler?: (step: ExecutionStepConfig) => boolean; isStepExpandedHandler?: (step: ExecutionStepConfig) => boolean; convertMsToSecondsHandler?: (duration: number) => number; formatFailureDetailsHandler?: (step: ExecutionStepConfig) => any; getSelfHealAnalysisHandler?: (step: ExecutionStepConfig) => any; onMakeCurrentBaselineHandler?: (event: any) => void; onUploadBaselineHandler?: (event: any) => void; onAnalyzeHandler?: () => void; onViewFullLogsHandler?: () => void; onSelfHealActionHandler?: (event: any) => void; getSelfHealLoadingStatesHandler?: () => { isLoadingAccept: { [key: string]: boolean; }; isLoadingModifyAccept: { [key: string]: boolean; }; }; isUploadingBaseline?: any; isMakingCurrentBaseline?: any; selectedIterationId?: any; getLoopIterationsHandler?: (step: ExecutionStepConfig) => any[]; getApiAssertionsHandler?: (step: ExecutionStepConfig) => any[]; formatActionsHandler?: (step: ExecutionStepConfig) => any[]; onViewAllIterationsHandler?: (step: ExecutionStepConfig) => void; onConditionBranchClickHandler?: (step: any, branch: any) => void; onStepClickHandler?: (step: ExecutionStepConfig, event?: Event) => void; onJsonPathCopiedHandler?: (event: { path: string; source: 'requestBody' | 'responseBody' | 'requestHeaders' | 'responseHeaders'; }) => void; onDownloadHandler?: (event: { fileName: string; filePath?: string; fileType: string; testStepResultId: string; }) => void; onFilePathCopiedHandler?: (event: { filePath: string; testStepResultId: string; }) => void; onTextCopiedHandler?: (event: { text: string; testStepResultId: string; }) => void; jumpToTimestampHandler?: (timestamp: number, testStepId?: number | string) => void; downloadingStepId: string | null; container: ViewContainerRef; isLive: boolean; isDebug?: boolean; /** When false, hides the inline edit/add/more action menu and standalone Add-step buttons even if isDebug is true. */ canEditSteps?: boolean; /** When set, used directly for the rendered step's debugPointSet so the icon state propagates when toggled (e.g. in Storybook). */ debugPointSet?: boolean; getDebugPointSetHandler?: (step: ExecutionStepConfig) => boolean; onDebugPointChangeHandler?: (step: ExecutionStepConfig, value: boolean) => void; /** Called when the user clicks the Edit icon on a step (when isDebug is true). Receives the step config so the parent can open an editor. */ onEditStepHandler?: (step: ExecutionStepConfig) => void; /** Add-step menu options (e.g. "Add before", "Add after"). When set, passed to all rendered steps; when unset, steps use their default. Managed like httpMethodOptions in the API edit section. */ addStepMenuOptions?: AddStepMenuOption[]; /** Called when the user selects an option from the Plus menu. Receives the option and the step config. */ onAddStepOptionSelectHandler?: (option: AddStepMenuOption, step?: ExecutionStepConfig) => void; /** More options (three-dot) menu options. When set, passed to all rendered steps. */ stepMoreMenuOptions?: StepMoreMenuOption[]; /** Called when the user selects an option from the More options (three-dot) menu. Receives the option and the step config. */ onStepMoreOptionSelectHandler?: (option: StepMoreMenuOption, step?: ExecutionStepConfig) => void; /** When provided, passed to loop/condition steps so they can supply per-step menu options to their nested step-renderers (supports arbitrary nesting). */ getAddStepMenuOptionsForNested?: (step: ExecutionStepConfig) => AddStepMenuOption[]; /** When provided, passed to loop/condition steps so they can supply per-step menu options to their nested step-renderers (supports arbitrary nesting). */ getStepMoreMenuOptionsForNested?: (step: ExecutionStepConfig) => StepMoreMenuOption[]; /** When provided, passed down to condition-debug-step so "Add ELSE IF" button works inside nested containers (loops, step-groups). */ onAddElseIfBranchAtHandler?: (conditionStep: any, branchIndex: number) => void; /** When provided, passed down to condition-debug-step so "Add ELSE" button works inside nested containers (loops, step-groups). */ onAddElseBranchHandler?: (conditionStep: any) => void; /** When provided, passed down to condition-debug-step so edit icon on IF/ELSE IF branches opens the condition editor. */ onEditBranchConditionHandler?: (conditionStep: any, branch: any, branchStep: any) => void; stepNumber?: string; /** When true, the parent step is skipped — breakpoints on all nested steps are disabled. */ parentSkipped?: boolean; /** Emitted when the user selects an option from the Add (plus) menu. Payload: { option, step }. */ addStepOptionSelect: EventEmitter<{ option: AddStepMenuOption; step?: ExecutionStepConfig; }>; /** Emitted when the user selects an option from the More options (three-dot) menu. Payload: { option, step }. */ stepMoreOptionSelect: EventEmitter<{ option: StepMoreMenuOption; step?: ExecutionStepConfig; }>; /** Emitted when user clicks "+ Add step inside loop" on a (possibly nested) loop step. Payload is the loop step. */ addStepInsideLoop: EventEmitter; componentReady: EventEmitter; /** Effective type for component lookup: 'file-download' when testStepType === 'generateDocument', 'loop' for FOR_LOOP/WHILE_LOOP. */ private getEffectiveStepType; /** Whether the step is a loop step (for, while, or generic loop). */ private isLoopStep; /** Resolve effective debugPointSet so it propagates when toggled (e.g. Storybook Controls). */ private getEffectiveDebugPointSet; private static componentInstances; private static componentRefs; private static subscribedEventEmitters; private static componentInitialized; private lastStepId; private lastStepType; private previousStepKey; private _lastDebugPointDisabled; constructor(componentMap: Map>, cdr: ChangeDetectorRef); /** * Safely trigger change detection on a child component. * Calls detectChanges() only if the child's ngOnInit has already run (i.e. config is built). * Before initialization, falls back to markForCheck() which queues CD for the next cycle * without forcing immediate template evaluation. */ private safeDetectChanges; ngOnChanges(changes: SimpleChanges): void; ngAfterViewInit(): void; private updateComponentInstance; /** * Helper method to update loop-step selectedIteration when selectedIterationId changes * This handles the case where iterations might not be loaded yet */ private updateLoopStepSelectedIteration; /** * Live execution payloads often carry `title` but omit or null out `prompt`. Spreading the * step onto `config` then overwrites `config.prompt` with undefined, while the header still * binds `config.title` — so the PROMPT card appears empty until the view is rebuilt. */ private syncAiAgentPromptInConfig; private hasValueChanged; /** * Deep comparison for branches array to detect changes in nested subSteps */ private hasBranchesChanged; /** * Deep comparison for nestedSteps array to detect content changes * This is important for condition steps when switching between branches */ private hasNestedStepsChanged; private getStepKey; private loadComponent; ngDoCheck(): void; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵcmp: i0.ɵɵComponentDeclaration; }