@cqa-lib/cqa-ui 1.1.189 → 1.1.190

package/esm2020/lib/test-case-details/api-edit-step/api-edit-step.component.mjs

@@ -0,0 +1,1122 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output, ViewChild, } from '@angular/core';
+import { FormControl } from '@angular/forms';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+import * as i2 from "../../button/button.component";
+import * as i3 from "../../dynamic-select/dynamic-select-field.component";
+import * as i4 from "../../custom-input/custom-input.component";
+import * as i5 from "../../custom-textarea/custom-textarea.component";
+import * as i6 from "../../segment-control/segment-control.component";
+import * as i7 from "@angular/common";
+export const API_EDIT_STEP_LABELS = {
+    REQUEST_DETAILS: 'Request Details',
+    STORE_RESPONSE: 'Store Response',
+    VALIDATION: 'Validation',
+};
+const METHODS_WITHOUT_BODY = ['GET', 'HEAD', 'DELETE'];
+/** Auto-close pairs for payload JSON editor: opening char -> closing char. */
+const PAYLOAD_AUTO_CLOSE_PAIRS = { '{': '}', '[': ']', '"': '"', "'": "'" };
+export class ApiEditStepComponent {
+    constructor(fb, cdr) {
+        this.fb = fb;
+        this.cdr = cdr;
+        /** Emits the cURL string when user clicks Import (value from the textarea control). */
+        this.importCurl = new EventEmitter();
+        /** Emits when user cancels the Import cURL panel (clicks Cancel). */
+        this.importCurlCancel = new EventEmitter();
+        /** Emits when user clicks Send Request, with environment, method, url, and headers. */
+        this.sendRequest = new EventEmitter();
+        this.back = new EventEmitter();
+        this.next = new EventEmitter();
+        /** Emits when user clicks Create with all entered details: step1 (environment, HTTP method, URL, headers, body), step2 (variable name), step3 (verifications). */
+        this.create = new EventEmitter();
+        /** Emits whenever headers change (add, remove, or edit) so the parent can reflect them in the canvas/controls. */
+        this.headersChange = new EventEmitter();
+        /** Form control for Import cURL textarea; value is emitted when user clicks Import. */
+        this.importCurlControl = new FormControl('');
+        this.variableName = '';
+        this.variableNameError = '';
+        /** Controls which body content is visible: headers (default) or import-curl. */
+        this.bodyView = 'headers';
+        this.stepLabels = [
+            { index: 1, label: API_EDIT_STEP_LABELS.REQUEST_DETAILS },
+            { index: 2, label: API_EDIT_STEP_LABELS.STORE_RESPONSE },
+            { index: 3, label: API_EDIT_STEP_LABELS.VALIDATION },
+        ];
+        this.currentStep = 1;
+        this.minStep = 1;
+        this.maxStep = 3;
+        /** HTTP method options: array of strings or objects with id, name, value, label (passed from parent). */
+        this.httpMethodOptions = [];
+        /** Config for method dropdown (updated when httpMethodOptions changes to avoid new reference every CD) */
+        this.methodSelectConfig = {
+            key: 'method',
+            placeholder: 'Method',
+            searchable: false,
+            options: [],
+        };
+        /** Environment options: array of strings or objects with id, name, value, label (passed from parent). */
+        this.environmentOptions = [];
+        /** Config for environment dropdown (updated when environmentOptions changes to avoid new reference every CD) */
+        this.environmentSelectConfig = {
+            key: 'environment',
+            placeholder: 'Environment',
+            searchable: false,
+            options: [],
+        };
+        /** Cached environment value from last selection (so Create payload has the selected value). */
+        this.currentEnvironmentValue = '';
+        /** Cached HTTP method from last selection (so Create payload has the selected value). */
+        this.currentMethodValue = '';
+        this.url = '';
+        this.payloadTabs = [
+            { value: 'headers', label: 'Headers' },
+            { value: 'body', label: 'Body' },
+            { value: 'params', label: 'Params' },
+            { value: 'scripts', label: 'Scripts' },
+        ];
+        this.activePayloadTab = 'headers';
+        /** Step 3: Response verification tabs */
+        this.responseVerificationTabs = [
+            { value: 'response-body', label: 'Response Body' },
+            { value: 'status', label: 'Status' },
+        ];
+        this.activeResponseVerificationTab = 'response-body';
+        /** Payload type for Body/Params/Scripts: raw, x-www-form-urlencoded, form-data */
+        this.payloadType = 'raw';
+        /** Segment options for payload type (used by cqa-segment-control) */
+        this.payloadTypeSegments = [
+            { label: 'Raw', value: 'raw' },
+            { label: 'x-www-form-urlencoded', value: 'x-www-form-urlencoded' },
+            { label: 'Form Data', value: 'form-data' },
+        ];
+        /** Format options: array of strings or objects (passed from parent). Falls back to JSON, XML, HTML, Text when empty. */
+        this.formatOptions = [];
+        /** Config for Format dropdown (updated when formatOptions changes, like Method dropdown) */
+        this.payloadFormatSelectConfig = {
+            key: 'format',
+            placeholder: 'Select',
+            searchable: false,
+            options: [...ApiEditStepComponent.DEFAULT_FORMAT_OPTIONS],
+        };
+        /** Payload text area value for Body/Params/Scripts */
+        this.payloadText = '';
+        /** JSON parse error when format is JSON and payload is invalid; null when valid or not JSON. */
+        this.payloadJsonError = null;
+        /** Header name options: array of strings or objects with id, name, value, label (passed from parent). Falls back to built-in list when empty. */
+        this.headerNameOptions = [];
+        /** Config for header name dropdown (updated when headerNameOptions changes to avoid new reference every CD) */
+        this.headerNameSelectConfig = {
+            key: 'name',
+            placeholder: 'Select header',
+            searchable: true,
+            allowCustomValue: true,
+            options: [],
+        };
+        this.defaultHeaders = [
+            { name: 'Content-Type', type: 'string', value: 'application/json' },
+        ];
+        /** Config for Type dropdown in key-type-value rows (Text, File) */
+        this.keyTypeValueTypeSelectConfig = {
+            key: 'type',
+            placeholder: 'Text',
+            searchable: false,
+            options: [
+                { id: 'text', value: 'text', name: 'Text', label: 'Text' },
+                { id: 'file', value: 'file', name: 'File', label: 'File' },
+            ],
+        };
+        /** Verification options: array of strings or objects (passed from parent). Falls back to built-in list when empty. */
+        this.verificationOptions = [];
+        /** Config for Verification dropdown (updated when verificationOptions changes, like Method dropdown) */
+        this.verificationSelectConfig = {
+            key: 'verification',
+            placeholder: 'Equals',
+            searchable: false,
+            options: [...ApiEditStepComponent.DEFAULT_VERIFICATION_OPTIONS],
+        };
+        /** Data Type options: array of strings or objects (passed from parent). Falls back to built-in list when empty. */
+        this.verificationDataTypeOptions = [];
+        /** Config for Data Type dropdown (updated when verificationDataTypeOptions changes, like Method dropdown) */
+        this.verificationDataTypeSelectConfig = {
+            key: 'dataType',
+            placeholder: 'String',
+            searchable: false,
+            options: [...ApiEditStepComponent.DEFAULT_DATA_TYPE_OPTIONS],
+        };
+        /** Config for Expected Value when Data Type is Boolean (true/false dropdown) */
+        this.verificationExpectedValueBooleanSelectConfig = {
+            key: 'expectedValue',
+            placeholder: 'Select',
+            searchable: false,
+            options: [
+                { id: 'true', value: 'true', name: 'true', label: 'true' },
+                { id: 'false', value: 'false', name: 'false', label: 'false' },
+            ],
+        };
+        /** Config for Status tab Verification dropdown (Equals, Not equal, Less than, Greater than) */
+        /** Status tab Verification options (Equals, Not equal, etc.). Falls back to built-in list when empty. */
+        this.statusVerificationOptions = [];
+        /** Config for Status tab Verification dropdown (updated when statusVerificationOptions changes). */
+        this.statusVerificationSelectConfig = {
+            key: 'verification',
+            placeholder: 'Equals',
+            searchable: false,
+            options: [...ApiEditStepComponent.DEFAULT_STATUS_VERIFICATION_OPTIONS],
+        };
+        this.responsePreview = ``;
+    }
+    /** The label for the current step only (used when showing a single step in the indicator). */
+    get activeStepLabel() {
+        return this.stepLabels[this.currentStep - 1];
+    }
+    /** Percentage to translate the step strip (0, -33.333, -66.666) for CSS transition. */
+    get stripTranslatePercent() {
+        return (this.currentStep - 1) * -33.333;
+    }
+    setStep(step) {
+        if (step >= this.minStep && step <= this.maxStep) {
+            this.currentStep = step;
+        }
+    }
+    applyInitialStep(value) {
+        if (value == null)
+            return;
+        const clamped = Math.max(this.minStep, Math.min(this.maxStep, Math.floor(value)));
+        this.currentStep = clamped;
+    }
+    updateMethodSelectConfig() {
+        const options = (this.httpMethodOptions ?? []).map((m) => ApiEditStepComponent.toSelectOption(m));
+        this.methodSelectConfig = {
+            ...this.methodSelectConfig,
+            options,
+        };
+    }
+    getMethodValues() {
+        return (this.httpMethodOptions ?? [])
+            .map((m) => ApiEditStepComponent.getOptionValue(m))
+            .filter((v) => v != null);
+    }
+    static toSelectOption(item) {
+        if (typeof item === 'string') {
+            return { id: item, value: item, name: item, label: item };
+        }
+        const o = item;
+        return {
+            id: o.id ?? o.value,
+            value: o.value ?? o.id,
+            name: o.name ?? o.label ?? String(o.value ?? o.id),
+            label: o.label ?? o.name ?? String(o.value ?? o.id),
+        };
+    }
+    static getOptionValue(item) {
+        if (typeof item === 'string')
+            return item;
+        const o = item;
+        const v = o.value ?? o.id;
+        return v != null ? String(v) : undefined;
+    }
+    updateEnvironmentSelectConfig() {
+        const options = (this.environmentOptions ?? []).map((e) => ApiEditStepComponent.toSelectOption(e));
+        this.environmentSelectConfig = {
+            ...this.environmentSelectConfig,
+            options,
+        };
+    }
+    getEnvironmentValues() {
+        return (this.environmentOptions ?? [])
+            .map((e) => ApiEditStepComponent.getOptionValue(e))
+            .filter((v) => v != null);
+    }
+    /** Current HTTP method (from form or default: first of httpMethodOptions). Treats empty string as unset. */
+    get selectedMethod() {
+        const value = this.methodForm?.get('method')?.value;
+        const firstValue = this.httpMethodOptions?.length
+            ? ApiEditStepComponent.getOptionValue(this.httpMethodOptions[0])
+            : undefined;
+        const resolved = value != null && value !== '' ? (typeof value === 'object' ? ApiEditStepComponent.getOptionValue(value) : String(value)) : undefined;
+        return resolved ?? firstValue ?? 'GET';
+    }
+    set selectedMethod(v) {
+        this.methodForm?.patchValue({ method: v });
+    }
+    /** True when the selected HTTP method is GET, HEAD, or DELETE (no request body). */
+    get isMethodWithoutBody() {
+        const method = this.selectedMethod != null ? String(this.selectedMethod).toUpperCase() : '';
+        return METHODS_WITHOUT_BODY.includes(method);
+    }
+    /** Current environment (from form or default: first of environmentOptions). Treats empty string as unset. */
+    get selectedEnvironment() {
+        const value = this.environmentForm?.get('environment')?.value;
+        const firstValue = this.environmentOptions?.length
+            ? ApiEditStepComponent.getOptionValue(this.environmentOptions[0])
+            : undefined;
+        const resolved = value != null && value !== '' ? (typeof value === 'object' ? ApiEditStepComponent.getOptionValue(value) : String(value)) : undefined;
+        return resolved ?? firstValue ?? 'Development';
+    }
+    set selectedEnvironment(v) {
+        this.environmentForm?.patchValue({ environment: v });
+    }
+    /** Called when user selects an environment; keeps currentEnvironmentValue in sync for create payload. */
+    onEnvironmentSelectionChange(event) {
+        const v = event.value;
+        this.currentEnvironmentValue =
+            v != null
+                ? typeof v === 'object'
+                    ? (ApiEditStepComponent.getOptionValue(v) ?? '')
+                    : String(v)
+                : '';
+    }
+    /** Called when user selects an HTTP method; keeps currentMethodValue in sync for create payload. */
+    onMethodSelectionChange(event) {
+        const v = event.value;
+        this.currentMethodValue =
+            v != null
+                ? typeof v === 'object'
+                    ? (ApiEditStepComponent.getOptionValue(v) ?? '')
+                    : String(v)
+                : '';
+    }
+    onPayloadTypeChange(val) {
+        this.payloadType = val;
+    }
+    updatePayloadFormatSelectConfig() {
+        const options = this.formatOptions?.length > 0
+            ? this.formatOptions.map((f) => ApiEditStepComponent.toSelectOption(f))
+            : ApiEditStepComponent.DEFAULT_FORMAT_OPTIONS;
+        this.payloadFormatSelectConfig = {
+            ...this.payloadFormatSelectConfig,
+            options,
+        };
+    }
+    getFormatValues() {
+        const source = this.formatOptions?.length > 0
+            ? this.formatOptions
+            : ApiEditStepComponent.DEFAULT_FORMAT_OPTIONS;
+        return source
+            .map((f) => ApiEditStepComponent.getOptionValue(f))
+            .filter((v) => v != null);
+    }
+    /** Line numbers for payload textarea (1, 2, 3, ...) based on current line count. */
+    get payloadLineNumbers() {
+        const n = Math.max(1, (this.payloadText || '').split(/\r?\n/).length);
+        return Array.from({ length: n }, (_, i) => i + 1);
+    }
+    /** Whether current payload format is JSON (so we validate and show JSON editor behavior). */
+    get isPayloadFormatJson() {
+        const format = this.payloadFormatForm?.get('format')?.value;
+        return format === 'json';
+    }
+    /** Error messages for the payload textarea (red border + bottom line). */
+    get payloadJsonErrors() {
+        return this.payloadJsonError ? ['Invalid JSON format. Please check your syntax.'] : [];
+    }
+    /** Tooltip content for the line-level error icon (parse error on line X, excerpt, caret, message). */
+    get payloadJsonErrorTooltip() {
+        if (!this.payloadJsonError)
+            return '';
+        const e = this.payloadJsonError;
+        const caret = ' '.repeat(e.caretOffset) + '^';
+        return `Parse error on line ${e.line}:\n\n${e.excerpt}\n${caret}\n\n${e.message}`;
+    }
+    onPayloadTextChange(value) {
+        this.payloadText = value;
+        this.validatePayloadJson();
+    }
+    onPayloadInput(event) {
+        const target = event.target;
+        this.onPayloadTextChange(target?.value ?? '');
+    }
+    onPayloadKeydown(event) {
+        if (!this.isPayloadFormatJson)
+            return;
+        const key = event.key;
+        const close = PAYLOAD_AUTO_CLOSE_PAIRS[key];
+        if (!close)
+            return;
+        const target = event.target;
+        if (!target)
+            return;
+        event.preventDefault();
+        const start = target.selectionStart ?? 0;
+        const end = target.selectionEnd ?? start;
+        const before = this.payloadText.slice(0, start);
+        const after = this.payloadText.slice(end);
+        const insertPos = start + 1;
+        const newValue = before + key + close + after;
+        this.payloadText = newValue;
+        this.validatePayloadJson();
+        setTimeout(() => {
+            this.payloadTextareaRef?.nativeElement?.setSelectionRange(insertPos, insertPos);
+        }, 0);
+    }
+    /** Validate payload when format is JSON; sets payloadJsonError or clears it. */
+    validatePayloadJson() {
+        if (!this.isPayloadFormatJson) {
+            this.payloadJsonError = null;
+            return;
+        }
+        const text = this.payloadText ?? '';
+        if (text.trim() === '') {
+            this.payloadJsonError = null;
+            return;
+        }
+        try {
+            JSON.parse(text);
+            this.payloadJsonError = null;
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            const position = this.extractPositionFromJsonError(message);
+            const { line, column } = this.positionToLineColumn(text, position);
+            const lines = text.split(/\r?\n/);
+            const lineIndex = Math.max(0, line - 1);
+            const lineContent = lines[lineIndex] ?? '';
+            const excerpt = lineContent || ' ';
+            const caretOffset = lineIndex === line - 1 ? Math.min(column - 1, lineContent.length) : 0;
+            this.payloadJsonError = {
+                line,
+                column,
+                message: this.normalizeJsonErrorMessage(message),
+                excerpt,
+                caretOffset,
+            };
+        }
+        this.cdr.markForCheck();
+    }
+    extractPositionFromJsonError(message) {
+        const match = message.match(/position\s+(\d+)/i) || message.match(/at\s+position\s+(\d+)/i);
+        return match ? parseInt(match[1], 10) : 0;
+    }
+    positionToLineColumn(text, position) {
+        const before = text.slice(0, Math.min(position, text.length));
+        const lines = before.split(/\r?\n/);
+        const line = lines.length;
+        const lastLine = lines[lines.length - 1] ?? '';
+        return { line, column: lastLine.length + 1 };
+    }
+    normalizeJsonErrorMessage(message) {
+        if (message.includes('Expecting') || message.includes('expecting'))
+            return message;
+        const tokenMatch = message.match(/Unexpected token\s+['"]?([^'"]+)['"]?/i)
+            || message.match(/unexpected character.*?([^\s]+)/i);
+        const token = tokenMatch ? tokenMatch[1].trim() : 'undefined';
+        return `Expecting 'STRING', 'NUMBER', 'NULL', 'TRUE', 'FALSE', '{', '[', got '${token}'`;
+    }
+    /** Typed accessor for template (FormArray.controls is AbstractControl[]) */
+    get headerRows() {
+        return (this.headersFormArray?.controls ?? []);
+    }
+    updateHeaderNameSelectConfig() {
+        const source = this.headerNameOptions?.length > 0
+            ? this.headerNameOptions
+            : ApiEditStepComponent.DEFAULT_HEADER_NAME_OPTIONS;
+        const baseOptions = source.map((h) => ApiEditStepComponent.toSelectOption(h));
+        const baseValues = new Set(baseOptions.map((o) => String(o.value ?? o.id ?? '').trim()).filter(Boolean));
+        const currentNamesFromForm = this.getCurrentHeaderNamesFromForm();
+        const extraOptions = [];
+        for (const name of currentNamesFromForm) {
+            const key = name.trim();
+            if (key && !baseValues.has(key)) {
+                baseValues.add(key);
+                extraOptions.push({ id: key, value: key, name: key, label: key });
+            }
+        }
+        const options = [...baseOptions, ...extraOptions];
+        this.headerNameSelectConfig = {
+            ...this.headerNameSelectConfig,
+            options,
+        };
+    }
+    /** Collects distinct non-empty header names currently in the headers form (for dynamic options). */
+    getCurrentHeaderNamesFromForm() {
+        const names = [];
+        const seen = new Set();
+        if (!this.headersFormArray?.controls?.length)
+            return names;
+        for (const control of this.headersFormArray.controls) {
+            const name = control.get('name')?.value;
+            const str = name != null ? String(name).trim() : '';
+            if (str && !seen.has(str)) {
+                seen.add(str);
+                names.push(str);
+            }
+        }
+        return names;
+    }
+    get keyValueRows() {
+        return (this.keyValueFormArray?.controls ?? []);
+    }
+    get keyTypeValueRows() {
+        return (this.keyTypeValueFormArray?.controls ?? []);
+    }
+    get verificationRows() {
+        return (this.verificationFormArray?.controls ?? []);
+    }
+    updateVerificationSelectConfig() {
+        const options = this.verificationOptions?.length > 0
+            ? this.verificationOptions.map((v) => ApiEditStepComponent.toSelectOption(v))
+            : ApiEditStepComponent.DEFAULT_VERIFICATION_OPTIONS;
+        this.verificationSelectConfig = {
+            ...this.verificationSelectConfig,
+            options,
+        };
+    }
+    getVerificationValues() {
+        const source = this.verificationOptions?.length > 0
+            ? this.verificationOptions
+            : ApiEditStepComponent.DEFAULT_VERIFICATION_OPTIONS;
+        return source
+            .map((v) => ApiEditStepComponent.getOptionValue(v))
+            .filter((v) => v != null);
+    }
+    getDefaultVerification() {
+        const values = this.getVerificationValues();
+        return values.length > 0 ? values[0] : 'equals';
+    }
+    updateVerificationDataTypeSelectConfig() {
+        const options = this.verificationDataTypeOptions?.length > 0
+            ? this.verificationDataTypeOptions.map((d) => ApiEditStepComponent.toSelectOption(d))
+            : ApiEditStepComponent.DEFAULT_DATA_TYPE_OPTIONS;
+        this.verificationDataTypeSelectConfig = {
+            ...this.verificationDataTypeSelectConfig,
+            options,
+        };
+    }
+    getDataTypeValues() {
+        const source = this.verificationDataTypeOptions?.length > 0
+            ? this.verificationDataTypeOptions
+            : ApiEditStepComponent.DEFAULT_DATA_TYPE_OPTIONS;
+        return source
+            .map((d) => ApiEditStepComponent.getOptionValue(d))
+            .filter((v) => v != null);
+    }
+    getDefaultDataType() {
+        const values = this.getDataTypeValues();
+        return values.length > 0 ? values[0] : 'string';
+    }
+    get statusVerificationRows() {
+        return (this.statusVerificationFormArray?.controls ?? []);
+    }
+    updateStatusVerificationSelectConfig() {
+        const options = this.statusVerificationOptions?.length > 0
+            ? this.statusVerificationOptions.map((o) => ApiEditStepComponent.toSelectOption(o))
+            : ApiEditStepComponent.DEFAULT_STATUS_VERIFICATION_OPTIONS;
+        this.statusVerificationSelectConfig = {
+            ...this.statusVerificationSelectConfig,
+            options,
+        };
+    }
+    getStatusVerificationValues() {
+        const source = this.statusVerificationOptions?.length > 0
+            ? this.statusVerificationOptions
+            : ApiEditStepComponent.DEFAULT_STATUS_VERIFICATION_OPTIONS;
+        return source
+            .map((o) => ApiEditStepComponent.getOptionValue(o))
+            .filter((v) => v != null);
+    }
+    getDefaultStatusVerification() {
+        const values = this.getStatusVerificationValues();
+        return values.length > 0 ? values[0] : 'equals';
+    }
+    ngOnInit() {
+        this.applyInitialStep(this.initialStep);
+        this.updateMethodSelectConfig();
+        this.updateHeaderNameSelectConfig();
+        const firstMethodValue = this.httpMethodOptions?.length
+            ? ApiEditStepComponent.getOptionValue(this.httpMethodOptions[0])
+            : undefined;
+        const defaultMethod = this.initialMethod ?? firstMethodValue ?? 'GET';
+        this.currentMethodValue = typeof defaultMethod === 'string' ? defaultMethod : (ApiEditStepComponent.getOptionValue(defaultMethod) ?? '');
+        this.methodForm = this.fb.group({
+            method: [defaultMethod],
+        });
+        const firstValue = this.environmentOptions?.length
+            ? ApiEditStepComponent.getOptionValue(this.environmentOptions[0])
+            : undefined;
+        const defaultEnv = this.initialEnvironment ?? firstValue ?? 'Development';
+        this.currentEnvironmentValue = typeof defaultEnv === 'string' ? defaultEnv : (ApiEditStepComponent.getOptionValue(defaultEnv) ?? '');
+        this.environmentForm = this.fb.group({
+            environment: [defaultEnv],
+        });
+        this.environmentFormChangesSub = this.environmentForm.get('environment')?.valueChanges?.subscribe((v) => {
+            const s = v != null && v !== '' ? (typeof v === 'object' ? ApiEditStepComponent.getOptionValue(v) : String(v)) : '';
+            this.currentEnvironmentValue = s ?? '';
+        });
+        this.methodFormChangesSub = this.methodForm.get('method')?.valueChanges?.subscribe((v) => {
+            const s = v != null && v !== '' ? (typeof v === 'object' ? ApiEditStepComponent.getOptionValue(v) : String(v)) : '';
+            this.currentMethodValue = s ?? '';
+        });
+        this.buildHeadersFormArray(this.initialHeaders ?? [{ name: '', type: 'string', value: '' }]);
+        this.headerNameOptionsChangesSub = this.headersFormArray?.valueChanges?.subscribe(() => {
+            this.updateHeaderNameSelectConfig();
+            this.headersChange.emit(this.headers);
+        });
+        this.updateHeaderNameSelectConfig();
+        this.headersChange.emit(this.headers);
+        this.updateEnvironmentSelectConfig();
+        this.updatePayloadFormatSelectConfig();
+        const firstFormatValue = this.getFormatValues()[0];
+        const defaultFormat = this.initialFormat ?? firstFormatValue ?? 'json';
+        this.payloadFormatForm = this.fb.group({ format: [defaultFormat] });
+        this.buildKeyValueFormArray();
+        this.buildKeyTypeValueFormArray();
+        this.updateVerificationSelectConfig();
+        this.updateVerificationDataTypeSelectConfig();
+        this.buildVerificationFormArray();
+        this.updateStatusVerificationSelectConfig();
+        this.buildStatusVerificationFormArray();
+        this.methodChangesSub = this.methodForm.get('method')?.valueChanges?.subscribe((value) => {
+            const method = value != null ? String(value).toUpperCase() : '';
+            if (METHODS_WITHOUT_BODY.includes(method) && this.activePayloadTab !== 'headers') {
+                this.activePayloadTab = 'headers';
+                this.cdr.detectChanges();
+            }
+        });
+        this.formatChangesSub = this.payloadFormatForm.get('format')?.valueChanges?.subscribe(() => {
+            this.validatePayloadJson();
+        });
+        this.validatePayloadJson();
+    }
+    ngAfterViewInit() {
+        this.setupPayloadTextareaScrollSync();
+    }
+    ngOnDestroy() {
+        this.methodChangesSub?.unsubscribe();
+        this.formatChangesSub?.unsubscribe();
+        this.headerNameOptionsChangesSub?.unsubscribe();
+        this.environmentFormChangesSub?.unsubscribe();
+        this.methodFormChangesSub?.unsubscribe();
+    }
+    /** Sync line numbers column scroll with payload textarea scroll (Postman-style). */
+    setupPayloadTextareaScrollSync() {
+        setTimeout(() => {
+            const host = this.payloadEditorWithLinesRef?.nativeElement;
+            if (!host)
+                return;
+            const lineNumbersEl = host.querySelector('.cqa-api-edit-step-payload-line-numbers');
+            const textarea = host.querySelector('textarea');
+            if (!lineNumbersEl || !textarea)
+                return;
+            textarea.addEventListener('scroll', () => {
+                lineNumbersEl.scrollTop = textarea.scrollTop;
+            });
+        }, 0);
+    }
+    buildKeyValueFormArray(rows) {
+        const initial = rows ?? [{ key: '', value: '' }];
+        const groups = initial.map((r) => this.fb.group({ key: [r.key], value: [r.value] }));
+        this.keyValueFormArray = this.fb.array(groups);
+    }
+    buildKeyTypeValueFormArray(rows) {
+        const initial = rows ?? [{ key: '', type: 'text', value: '' }];
+        const groups = initial.map((r) => this.fb.group({ key: [r.key], type: [r.type], value: [r.value] }));
+        this.keyTypeValueFormArray = this.fb.array(groups);
+    }
+    buildVerificationFormArray(rows) {
+        const defaultVerification = this.getDefaultVerification();
+        const defaultDataType = this.getDefaultDataType();
+        const initial = rows ?? [{ jsonPath: '', verification: defaultVerification, dataType: defaultDataType, expectedValue: '' }];
+        const groups = initial.map((r) => this.fb.group({
+            jsonPath: [r.jsonPath],
+            verification: [r.verification],
+            dataType: [r.dataType],
+            expectedValue: [r.expectedValue],
+        }));
+        this.verificationFormArray = this.fb.array(groups);
+    }
+    buildStatusVerificationFormArray(rows) {
+        const defaultVerification = this.getDefaultStatusVerification();
+        const initial = rows ?? [{ verification: defaultVerification, expectedValue: '' }];
+        const groups = initial.map((r) => this.fb.group({
+            verification: [r.verification],
+            expectedValue: [r.expectedValue],
+        }));
+        this.statusVerificationFormArray = this.fb.array(groups);
+    }
+    buildHeadersFormArray(rows) {
+        const groups = rows.map((h) => this.fb.group({
+            name: [h.name],
+            value: [h.value],
+        }));
+        if (this.headersFormArray) {
+            this.headersFormArray.clear();
+            groups.forEach((g) => this.headersFormArray.push(g));
+        }
+        else {
+            this.headersFormArray = this.fb.array(groups);
+        }
+    }
+    /** Handler: show import cURL panel (called when user clicks "Import API cURL"). */
+    openImportCurlPanel() {
+        this.bodyView = 'import-curl';
+        this.cdr.detectChanges();
+    }
+    /** Handler: emit cURL value from control and close panel. Called when user clicks Import button. */
+    onImportCurlConfirm() {
+        const value = this.importCurlControl.value ?? '';
+        this.importCurl.emit(typeof value === 'string' ? value : '');
+        this.closeImportCurlPanel();
+    }
+    /** Handler: emit cancel and close panel. Called when user clicks Cancel in import cURL panel. */
+    onCancelImportCurl() {
+        this.importCurlCancel.emit();
+        this.closeImportCurlPanel();
+    }
+    /** Handler: show headers section (called from Cancel or after Import in import panel). */
+    closeImportCurlPanel() {
+        this.bodyView = 'headers';
+        this.cdr.detectChanges();
+    }
+    onSendRequest() {
+        const environment = this.selectedEnvironment != null ? String(this.selectedEnvironment) : '';
+        const method = this.selectedMethod != null ? String(this.selectedMethod) : '';
+        this.sendRequest.emit({
+            environment,
+            method,
+            url: this.url ?? '',
+            headers: this.headers,
+        });
+    }
+    onVariableNameChange() {
+        this.variableNameError = '';
+    }
+    onBack() {
+        if (this.currentStep > 1) {
+            this.setStep(this.currentStep - 1);
+        }
+        else {
+            this.back.emit();
+        }
+    }
+    onNext() {
+        if (this.currentStep === 2 && !this.variableName?.trim()) {
+            this.variableNameError = 'Variable Name is required.';
+            return;
+        }
+        this.variableNameError = '';
+        if (this.currentStep < this.stepLabels.length) {
+            this.setStep(this.currentStep + 1);
+        }
+        else {
+            this.next.emit();
+        }
+    }
+    setPayloadTab(value) {
+        this.activePayloadTab = value;
+    }
+    setResponseVerificationTab(value) {
+        this.activeResponseVerificationTab = value;
+    }
+    addHeader() {
+        this.headersFormArray.push(this.fb.group({ name: [''], value: [''] }));
+    }
+    removeHeader(index) {
+        this.headersFormArray.removeAt(index);
+    }
+    /** When user adds a custom header name via the dropdown "Add '…'" option, set the control value. */
+    onHeaderNameAddCustomValue(event, row) {
+        const control = row.get(event.key);
+        if (control && event.value != null) {
+            control.setValue(event.value.trim());
+        }
+    }
+    trackByHeader(index) {
+        return index;
+    }
+    addKeyValueRow() {
+        this.keyValueFormArray.push(this.fb.group({ key: [''], value: [''] }));
+    }
+    removeKeyValueRow(index) {
+        this.keyValueFormArray.removeAt(index);
+    }
+    trackByKeyValue(index) {
+        return index;
+    }
+    addKeyTypeValueRow() {
+        this.keyTypeValueFormArray.push(this.fb.group({ key: [''], type: ['text'], value: [''] }));
+    }
+    removeKeyTypeValueRow(index) {
+        this.keyTypeValueFormArray.removeAt(index);
+    }
+    trackByKeyTypeValue(index) {
+        return index;
+    }
+    addVerificationRow() {
+        this.verificationFormArray.push(this.fb.group({
+            jsonPath: [''],
+            verification: [this.getDefaultVerification()],
+            dataType: [this.getDefaultDataType()],
+            expectedValue: [''],
+        }));
+    }
+    removeVerificationRow(index) {
+        this.verificationFormArray.removeAt(index);
+    }
+    trackByVerification(index) {
+        return index;
+    }
+    /** When Data Type changes in Response Body verification, reset Expected Value for that row. */
+    onVerificationDataTypeChange(row, event) {
+        if (event.key === 'dataType') {
+            row.get('expectedValue')?.setValue('', { emitEvent: false });
+        }
+    }
+    addStatusVerificationRow() {
+        this.statusVerificationFormArray.push(this.fb.group({ verification: [this.getDefaultStatusVerification()], expectedValue: [''] }));
+    }
+    removeStatusVerificationRow(index) {
+        this.statusVerificationFormArray.removeAt(index);
+    }
+    trackByStatusVerification(index) {
+        return index;
+    }
+    /** Emit all entered details (environment, HTTP method, URL, headers, body, step2 variable, step3 verifications) when user clicks Create. */
+    onCreate() {
+        console.log('9999999');
+        try {
+            const payload = this.getCreatePayload();
+            console.log('9999999 payload', payload);
+            this.create.emit(payload);
+        }
+        catch (err) {
+            console.error('ApiEditStep getCreatePayload error:', err);
+            this.create.emit(this.getCreatePayloadFallback());
+        }
+    }
+    /** Minimal payload when getCreatePayload throws (so create always emits). */
+    getCreatePayloadFallback() {
+        return {
+            step1: {
+                environment: '',
+                method: '',
+                url: this.url ?? '',
+                headers: [],
+                activePayloadTab: this.activePayloadTab,
+                payloadType: this.payloadType,
+                payloadFormat: '',
+                payloadText: this.payloadText ?? '',
+                keyValueRows: [],
+                keyTypeValueRows: [],
+            },
+            step2: { variableName: this.variableName ?? '' },
+            step3: {
+                activeResponseVerificationTab: this.activeResponseVerificationTab,
+                responseBodyVerifications: [],
+                statusVerifications: [],
+            },
+        };
+    }
+    /** Normalize form control value to string (handles object or string). */
+    static getControlValue(control) {
+        const v = control?.value;
+        if (v == null || v === '')
+            return '';
+        return typeof v === 'object' ? (ApiEditStepComponent.getOptionValue(v) ?? '') : String(v);
+    }
+    /** Build full create payload: environment, HTTP method, URL, headers, body (step1), variable name (step2), verifications (step3). */
+    getCreatePayload() {
+        const envFromForm = ApiEditStepComponent.getControlValue(this.environmentForm?.get('environment'));
+        const environment = envFromForm !== '' ? envFromForm : (this.currentEnvironmentValue !== '' ? this.currentEnvironmentValue : this.selectedEnvironment);
+        const methodFromForm = ApiEditStepComponent.getControlValue(this.methodForm?.get('method'));
+        const method = methodFromForm !== '' ? methodFromForm : (this.currentMethodValue !== '' ? this.currentMethodValue : this.selectedMethod);
+        const format = this.payloadFormatForm?.get('format')?.value ?? '';
+        const keyValueFormArray = this.keyValueFormArray;
+        const keyValueRows = (keyValueFormArray?.controls ?? []).map((c) => ({
+            key: c.get('key')?.value ?? '',
+            value: c.get('value')?.value ?? '',
+        }));
+        const keyTypeValueFormArray = this.keyTypeValueFormArray;
+        const keyTypeValueRows = (keyTypeValueFormArray?.controls ?? []).map((c) => ({
+            key: c.get('key')?.value ?? '',
+            type: c.get('type')?.value ?? 'text',
+            value: c.get('value')?.value ?? '',
+        }));
+        const verificationFormArray = this.verificationFormArray;
+        const responseBodyVerifications = (verificationFormArray?.controls ?? []).map((c) => ({
+            jsonPath: c.get('jsonPath')?.value ?? '',
+            verification: c.get('verification')?.value ?? '',
+            dataType: c.get('dataType')?.value ?? '',
+            expectedValue: c.get('expectedValue')?.value ?? '',
+        }));
+        const statusVerificationFormArray = this.statusVerificationFormArray;
+        const statusVerifications = (statusVerificationFormArray?.controls ?? []).map((c) => ({
+            verification: c.get('verification')?.value ?? '',
+            expectedValue: c.get('expectedValue')?.value ?? '',
+        }));
+        return {
+            step1: {
+                environment,
+                method,
+                url: this.url ?? '',
+                headers: this.headers,
+                activePayloadTab: this.activePayloadTab,
+                payloadType: this.payloadType,
+                payloadFormat: format,
+                payloadText: this.payloadText ?? '',
+                keyValueRows,
+                keyTypeValueRows,
+            },
+            step2: {
+                variableName: this.variableName ?? '',
+            },
+            step3: {
+                activeResponseVerificationTab: this.activeResponseVerificationTab,
+                responseBodyVerifications,
+                statusVerifications,
+            },
+        };
+    }
+    /** Current header rows from form (for consumers that read headers) */
+    get headers() {
+        if (!this.headersFormArray)
+            return [];
+        return this.headersFormArray.controls.map((c) => ({
+            name: c.get('name')?.value ?? '',
+            type: 'string',
+            value: c.get('value')?.value ?? '',
+        }));
+    }
+    ngOnChanges(changes) {
+        if (changes['initialMethod']?.currentValue != null && this.methodForm) {
+            const v = changes['initialMethod'].currentValue;
+            this.currentMethodValue = typeof v === 'string' ? v : (ApiEditStepComponent.getOptionValue(v) ?? '');
+            this.methodForm.patchValue({ method: v });
+        }
+        if (changes['httpMethodOptions']) {
+            this.updateMethodSelectConfig();
+            if (this.methodForm && this.httpMethodOptions?.length) {
+                const current = this.methodForm.get('method')?.value;
+                const values = this.getMethodValues();
+                const valid = values.includes(current);
+                if (!valid) {
+                    const firstValue = ApiEditStepComponent.getOptionValue(this.httpMethodOptions[0]);
+                    if (firstValue != null) {
+                        this.currentMethodValue = firstValue;
+                        this.methodForm.patchValue({ method: firstValue });
+                    }
+                }
+            }
+        }
+        if (changes['initialEnvironment']?.currentValue != null && this.environmentForm) {
+            const v = changes['initialEnvironment'].currentValue;
+            this.currentEnvironmentValue = typeof v === 'string' ? v : (ApiEditStepComponent.getOptionValue(v) ?? '');
+            this.environmentForm.patchValue({ environment: v });
+        }
+        if (changes['environmentOptions']) {
+            this.updateEnvironmentSelectConfig();
+            if (this.environmentForm && this.environmentOptions?.length) {
+                const current = this.environmentForm.get('environment')?.value;
+                const values = this.getEnvironmentValues();
+                const valid = values.includes(current);
+                if (!valid) {
+                    const firstValue = ApiEditStepComponent.getOptionValue(this.environmentOptions[0]);
+                    if (firstValue != null) {
+                        this.currentEnvironmentValue = firstValue;
+                        this.environmentForm.patchValue({ environment: firstValue });
+                    }
+                }
+            }
+        }
+        if (changes['initialStep']) {
+            this.applyInitialStep(changes['initialStep'].currentValue);
+        }
+        if (changes['initialUrl']?.currentValue != null) {
+            this.url = changes['initialUrl'].currentValue;
+        }
+        if (changes['initialPayloadTab']?.currentValue != null) {
+            this.activePayloadTab = changes['initialPayloadTab'].currentValue;
+        }
+        if (changes['headerNameOptions']) {
+            this.updateHeaderNameSelectConfig();
+        }
+        if (changes['initialHeaders']?.currentValue != null) {
+            this.buildHeadersFormArray(changes['initialHeaders'].currentValue);
+            this.updateHeaderNameSelectConfig();
+        }
+        if (changes['initialResponsePreview']?.currentValue != null) {
+            this.responsePreview = changes['initialResponsePreview'].currentValue;
+        }
+        if (changes['initialFormat']?.currentValue != null && this.payloadFormatForm) {
+            this.payloadFormatForm.patchValue({ format: changes['initialFormat'].currentValue });
+        }
+        if (changes['formatOptions']) {
+            this.updatePayloadFormatSelectConfig();
+            if (this.payloadFormatForm) {
+                const current = this.payloadFormatForm.get('format')?.value;
+                const values = this.getFormatValues();
+                const valid = values.includes(current);
+                if (!valid && values.length > 0) {
+                    const firstValue = values[0];
+                    this.payloadFormatForm.patchValue({ format: firstValue });
+                }
+            }
+        }
+        if (changes['verificationOptions']) {
+            this.updateVerificationSelectConfig();
+            const values = this.getVerificationValues();
+            const defaultVerification = this.getDefaultVerification();
+            if (this.verificationFormArray && values.length > 0) {
+                this.verificationFormArray.controls.forEach((control) => {
+                    const current = control.get('verification')?.value;
+                    if (current && !values.includes(current)) {
+                        control.patchValue({ verification: defaultVerification });
+                    }
+                });
+            }
+        }
+        if (changes['verificationDataTypeOptions']) {
+            this.updateVerificationDataTypeSelectConfig();
+            const values = this.getDataTypeValues();
+            const defaultDataType = this.getDefaultDataType();
+            if (this.verificationFormArray && values.length > 0) {
+                this.verificationFormArray.controls.forEach((control) => {
+                    const current = control.get('dataType')?.value;
+                    if (current && !values.includes(current)) {
+                        control.patchValue({ dataType: defaultDataType });
+                    }
+                });
+            }
+        }
+        if (changes['statusVerificationOptions']) {
+            this.updateStatusVerificationSelectConfig();
+            const values = this.getStatusVerificationValues();
+            const defaultVerification = this.getDefaultStatusVerification();
+            if (this.statusVerificationFormArray && values.length > 0) {
+                this.statusVerificationFormArray.controls.forEach((control) => {
+                    const current = control.get('verification')?.value;
+                    if (current && !values.includes(current)) {
+                        control.patchValue({ verification: defaultVerification });
+                    }
+                });
+            }
+        }
+    }
+}
+ApiEditStepComponent.DEFAULT_FORMAT_OPTIONS = [
+    { id: 'json', value: 'json', name: 'JSON', label: 'JSON' },
+    { id: 'xml', value: 'xml', name: 'XML', label: 'XML' },
+    { id: 'html', value: 'html', name: 'HTML', label: 'HTML' },
+    { id: 'text', value: 'text', name: 'Text', label: 'Text' },
+];
+ApiEditStepComponent.DEFAULT_HEADER_NAME_OPTIONS = [
+    'Accept',
+    'Accept-Charset',
+    'Accept-Encoding',
+    'Accept-Language',
+    'Access-Control-Request-Headers',
+    'Access-Control-Request-Method',
+    'Authorization',
+    'Cache-Control',
+    'Content-MD5',
+    'Content-Length',
+    'Content-Transfer-Encoding',
+    'Content-Type',
+    'Cookie',
+    'Date',
+    'Expect',
+    'From',
+    'Host',
+    'If-Match',
+    'If-Modified-Since',
+    'If-None-Match',
+    'If-Unmodified-Since',
+    'If-Range',
+    'Keep-Alive',
+    'Max-Forwards',
+    'Origin',
+    'Pragma',
+    'Proxy-Authorization',
+    'Range',
+    'Referer',
+    'TE',
+    'Trailer',
+    'Transfer-Encoding',
+    'Upgrade',
+    'User-Agent',
+    'Via',
+    'Warning',
+    'X-Requested-With',
+    'X-Do-Not-Track',
+    'DNT',
+    'x-api-key',
+    'Connection',
+];
+ApiEditStepComponent.DEFAULT_VERIFICATION_OPTIONS = [
+    { id: 'equals', value: 'equals', name: 'Equals', label: 'Equals' },
+    { id: 'not-equal', value: 'not-equal', name: 'Not equal', label: 'Not equal' },
+    { id: 'less-than', value: 'less-than', name: 'Less than', label: 'Less than' },
+    { id: 'greater-than', value: 'greater-than', name: 'Greater than', label: 'Greater than' },
+    { id: 'is-null', value: 'is-null', name: 'Is null', label: 'Is null' },
+    { id: 'is-not-null', value: 'is-not-null', name: 'Is not null', label: 'Is not null' },
+];
+ApiEditStepComponent.DEFAULT_DATA_TYPE_OPTIONS = [
+    { id: 'string', value: 'string', name: 'String', label: 'String' },
+    { id: 'number', value: 'number', name: 'Number', label: 'Number' },
+    { id: 'boolean', value: 'boolean', name: 'Boolean', label: 'Boolean' },
+    { id: 'array', value: 'array', name: 'Array', label: 'Array' },
+    { id: 'object', value: 'object', name: 'Object', label: 'Object' },
+];
+ApiEditStepComponent.DEFAULT_STATUS_VERIFICATION_OPTIONS = [
+    { id: 'equals', value: 'equals', name: 'Equals', label: 'Equals' },
+    { id: 'not-equal', value: 'not-equal', name: 'Not equal', label: 'Not equal' },
+    { id: 'less-than', value: 'less-than', name: 'Less than', label: 'Less than' },
+    { id: 'greater-than', value: 'greater-than', name: 'Greater than', label: 'Greater than' },
+];
+ApiEditStepComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: ApiEditStepComponent, deps: [{ token: i1.FormBuilder }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+ApiEditStepComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.4.0", type: ApiEditStepComponent, selector: "cqa-api-edit-step", inputs: { initialMethod: "initialMethod", initialEnvironment: "initialEnvironment", initialStep: "initialStep", initialUrl: "initialUrl", initialPayloadTab: "initialPayloadTab", initialHeaders: "initialHeaders", initialResponsePreview: "initialResponsePreview", httpMethodOptions: "httpMethodOptions", environmentOptions: "environmentOptions", formatOptions: "formatOptions", initialFormat: "initialFormat", headerNameOptions: "headerNameOptions", verificationOptions: "verificationOptions", verificationDataTypeOptions: "verificationDataTypeOptions", statusVerificationOptions: "statusVerificationOptions" }, outputs: { importCurl: "importCurl", importCurlCancel: "importCurlCancel", sendRequest: "sendRequest", back: "back", next: "next", create: "create", headersChange: "headersChange" }, host: { classAttribute: "cqa-ui-root" }, viewQueries: [{ propertyName: "payloadEditorWithLinesRef", first: true, predicate: ["payloadEditorWithLinesRef"], descendants: true }, { propertyName: "payloadTextareaRef", first: true, predicate: ["payloadTextareaRef"], descendants: true }], usesOnChanges: true, ngImport: i0, template: "<div class=\"cqa-api-edit-step-container\">\n  <!-- Title -->\n  <h2\n    class=\"cqa-api-edit-step-title cqa-font-inter cqa-text-[12px] cqa-font-semibold cqa-leading-[100%] cqa-tracking-normal cqa-text-[#000000]\">\n    Create API Test Step</h2>\n\n  <!-- Step indicator: all three steps visible, active step highlighted (Postman-style) -->\n  <div class=\"cqa-api-edit-step-indicator\">\n    <ng-container *ngFor=\"let step of stepLabels; let i = index\">\n      <cqa-button type=\"button\" variant=\"text\"\n        customClass=\"cqa-api-edit-step-indicator-item cqa-api-edit-step-indicator-item--clickable\"\n        [attr.aria-label]=\"'Step ' + step.index + ': ' + step.label\" [attr.aria-pressed]=\"step.index === currentStep\"\n        (clicked)=\"setStep(step.index)\">\n        <span class=\"cqa-api-edit-step-indicator-circle\"\n          [class.cqa-api-edit-step-indicator-circle--active]=\"step.index === currentStep\">\n          {{ step.index }}\n        </span>\n        <span class=\"cqa-api-edit-step-indicator-label\"\n          [class.cqa-api-edit-step-indicator-label--active]=\"step.index === currentStep\">\n          {{ step.label }}\n        </span>\n        <div *ngIf=\"i < stepLabels.length - 1\" class=\"cqa-api-edit-step-indicator-line\" aria-hidden=\"true\"></div>\n      </cqa-button>\n    </ng-container>\n  </div>\n\n  <!-- Step content viewport: smooth slide between steps -->\n  <div class=\"cqa-api-edit-step-viewport\">\n    <div class=\"cqa-api-edit-step-strip\" [style.transform]=\"'translateX(' + stripTranslatePercent + '%)'\">\n      <!-- Step 1: Environment, request, body, response -->\n      <div class=\"cqa-api-edit-step-panel\">\n        <!-- Environment row: new line, select aligned right -->\n        <div class=\"cqa-api-edit-step-environment-row\">\n          <cqa-dynamic-select *ngIf=\"environmentForm\" [form]=\"environmentForm\" [config]=\"environmentSelectConfig\"\n            class=\"cqa-api-edit-step-environment-select\" aria-label=\"Environment\"\n            (selectionChange)=\"onEnvironmentSelectionChange($event)\">\n          </cqa-dynamic-select>\n        </div>\n\n        <!-- Request row: method, URL, buttons -->\n        <div class=\"cqa-api-edit-step-request-row\">\n          <cqa-dynamic-select *ngIf=\"methodForm\" [form]=\"methodForm\" [config]=\"methodSelectConfig\"\n            class=\"cqa-api-edit-step-method-select\" aria-label=\"HTTP method\"\n            (selectionChange)=\"onMethodSelectionChange($event)\">\n          </cqa-dynamic-select>\n          <div class=\"cqa-api-edit-step-url-wrap\">\n            <cqa-custom-input [(value)]=\"url\" [label]=\"''\" placeholder=\"\" [fullWidth]=\"true\" size=\"md\">\n            </cqa-custom-input>\n          </div>\n          <div class=\"cqa-api-edit-step-import-curl-trigger\" style=\"display: contents\" (click)=\"openImportCurlPanel()\">\n            <cqa-button type=\"button\" variant=\"outlined\" btnSize=\"lg\" text=\"Import API cURL\"\n              customClass=\"cqa-api-edit-step-btn-outline cqa-font-inter cqa-text-[14px] cqa-font-semibold cqa-leading-[100%] cqa-tracking-normal cqa-text-[#414146]\">\n            </cqa-button>\n          </div>\n          <cqa-button variant=\"filled\" btnSize=\"lg\" text=\"Send Request\" (clicked)=\"onSendRequest()\"\n            customClass=\"cqa-api-edit-step-btn-primary cqa-font-inter cqa-text-[14px] cqa-font-semibold cqa-leading-[100%] cqa-tracking-normal cqa-text-[#FBFCFF]\">\n          </cqa-button>\n        </div>\n\n\n\n        <!-- Body content: header section (default) OR import cURL section -->\n        <ng-container *ngIf=\"bodyView === 'import-curl'\">\n          <div class=\"cqa-api-edit-step-import-curl-panel\">\n            <div class=\"cqa-api-edit-step-import-curl-header\">\n              <h3 class=\"cqa-api-edit-step-import-curl-title\">Import API cURL</h3>\n            </div>\n            <div class=\"cqa-api-edit-step-import-curl-separator\"></div>\n            <div class=\"cqa-api-edit-step-import-curl-body\">\n              <cqa-custom-textarea [value]=\"importCurlControl.value\"\n                (valueChange)=\"importCurlControl.setValue($event)\"\n                placeholder=\"Paste your cURL command here (e.g., curl -X POST https://api.example.com/users)\"\n                [fullWidth]=\"true\" [rows]=\"8\" resize=\"vertical\" size=\"md\"\n                class=\"cqa-api-edit-step-import-curl-textarea\">\n              </cqa-custom-textarea>\n            </div>\n            <div class=\"cqa-api-edit-step-import-curl-footer\">\n              <cqa-button type=\"button\" variant=\"outlined\" btnSize=\"lg\" text=\"Cancel\"\n                customClass=\"cqa-api-edit-step-import-curl-btn-cancel\" (clicked)=\"onCancelImportCurl()\"></cqa-button>\n              <cqa-button type=\"button\" variant=\"filled\" btnSize=\"lg\" text=\"Import\"\n                customClass=\"cqa-api-edit-step-import-curl-btn-import\" (clicked)=\"onImportCurlConfirm()\"></cqa-button>\n            </div>\n          </div>\n        </ng-container>\n\n        <ng-container *ngIf=\"bodyView === 'headers'\">\n          <div class=\"cqa-api-edit-step-tabs-wrapper\">\n            <div class=\"cqa-api-edit-step-tabs\">\n              <cqa-button *ngFor=\"let tab of payloadTabs\" type=\"button\" variant=\"text\" [text]=\"tab.label\"\n                [customClass]=\"'cqa-api-edit-step-tab' + (activePayloadTab === tab.value ? ' cqa-api-edit-step-tab--active' : '') + (isMethodWithoutBody && tab.value !== 'headers' ? ' cqa-api-edit-step-tab--disabled' : '')\"\n                [disabled]=\"isMethodWithoutBody && tab.value !== 'headers'\"\n                (clicked)=\"setPayloadTab(tab.value)\">\n              </cqa-button>\n            </div>\n\n            <!-- Payload content (Headers) -->\n            <div *ngIf=\"activePayloadTab === 'headers'\" class=\"cqa-api-edit-step-payload\">\n              <div class=\"cqa-api-edit-step-headers-grid\">\n                <span class=\"cqa-api-edit-step-headers-label\">Header Name</span>\n                <span class=\"cqa-api-edit-step-headers-label\">Header Value</span>\n                <span class=\"cqa-api-edit-step-headers-label cqa-api-edit-step-headers-label--empty\"\n                  aria-hidden=\"true\"></span>\n              </div>\n              <div *ngFor=\"let row of headerRows; let i = index; trackBy: trackByHeader\" [formGroup]=\"row\"\n                class=\"cqa-api-edit-step-header-row\">\n                <cqa-dynamic-select [form]=\"row\" [config]=\"headerNameSelectConfig\"\n                  (addCustomValue)=\"onHeaderNameAddCustomValue($event, row)\"\n                  class=\"cqa-api-edit-step-header-type-select cqa-w-full\">\n                </cqa-dynamic-select>\n                <cqa-custom-input [value]=\"row.get('value')?.value ?? ''\"\n                  (valueChange)=\"row.get('value')?.setValue($event)\" placeholder=\"Value\" [fullWidth]=\"true\" size=\"sm\"\n                  class=\"cqa-api-edit-step-header-value-input\" ariaLabel=\"Header value\">\n                </cqa-custom-input>\n                <cqa-button type=\"button\" variant=\"text\" [customClass]=\"'cqa-api-edit-step-header-delete'\"\n                  [tooltip]=\"'Remove header'\" (clicked)=\"removeHeader(i)\">\n                  <svg class=\"cqa-api-edit-step-header-delete-icon\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\"\n                    fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\" aria-hidden=\"true\">\n                    <path\n                      d=\"M10.6663 6V12.6667H5.33301V6H10.6663ZM9.66634 2H6.33301L5.66634 2.66667H3.33301V4H12.6663V2.66667H10.333L9.66634 2ZM11.9997 4.66667H3.99967V12.6667C3.99967 13.4 4.59967 14 5.33301 14H10.6663C11.3997 14 11.9997 13.4 11.9997 12.6667V4.66667Z\"\n                      fill=\"#F9BFBF\" />\n                  </svg>\n                </cqa-button>\n              </div>\n              <div class=\"cqa-api-edit-step-add-header-wrap\">\n                <cqa-button type=\"button\" variant=\"text\" text=\"+ Add Header\"\n                  [customClass]=\"'cqa-api-edit-step-add-header-link'\" (clicked)=\"addHeader()\">\n                </cqa-button>\n              </div>\n            </div>\n\n            <!-- Payload content (Body only): type, format, text area, Back/Next -->\n            <div *ngIf=\"activePayloadTab === 'body'\"\n              class=\"cqa-api-edit-step-payload cqa-api-edit-step-payload-editor\">\n              <div class=\"cqa-api-edit-step-payload-type-row\">\n                <span class=\"cqa-api-edit-step-payload-type-label\">Type</span>\n                <div class=\"cqa-api-edit-step-payload-type-radios\">\n                  <cqa-segment-control [value]=\"payloadType\" [segments]=\"payloadTypeSegments\"\n                    (valueChange)=\"onPayloadTypeChange($event)\"\n                    class=\"cqa-api-edit-step-payload-type-segment\">\n                  </cqa-segment-control>\n                </div>\n                <div *ngIf=\"payloadType === 'raw'\" class=\"cqa-api-edit-step-payload-format-wrap\">\n                  <span class=\"cqa-api-edit-step-payload-format-label\">Format:</span>\n                  <cqa-dynamic-select *ngIf=\"payloadFormatForm\" [form]=\"payloadFormatForm\"\n                    [config]=\"payloadFormatSelectConfig\" class=\"cqa-api-edit-step-payload-format-select\"\n                    aria-label=\"Format\">\n                  </cqa-dynamic-select>\n                </div>\n              </div>\n              <!-- Raw: text area with line numbers (Postman-style payload body) -->\n              <div *ngIf=\"payloadType === 'raw'\" class=\"cqa-api-edit-step-payload-body\" #payloadEditorWithLinesRef>\n                <div class=\"cqa-api-edit-step-payload-editor-with-lines\">\n                  <div class=\"cqa-api-edit-step-payload-line-numbers\" aria-hidden=\"true\">\n                    <span *ngFor=\"let n of payloadLineNumbers\" class=\"cqa-api-edit-step-payload-line-num\">\n                      <span *ngIf=\"payloadJsonError && payloadJsonError.line === n\"\n                        class=\"cqa-api-edit-step-payload-line-error-icon\" [title]=\"payloadJsonErrorTooltip\"\n                        aria-label=\"Parse error on this line\">\n                        <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"14\" height=\"14\" viewBox=\"0 0 14 14\" fill=\"none\" aria-hidden=\"true\">\n                          <circle cx=\"7\" cy=\"7\" r=\"6\" fill=\"#EF4444\"/>\n                          <path d=\"M4 4l6 6M10 4l-6 6\" stroke=\"white\" stroke-width=\"1.5\" stroke-linecap=\"round\"/>\n                        </svg>\n                      </span>\n                      <span class=\"cqa-api-edit-step-payload-line-num-text\">{{ n }}</span>\n                    </span>\n                  </div>\n                  <div class=\"cqa-api-edit-step-payload-textarea-cell\">\n                    <div class=\"cqa-api-edit-step-payload-textarea cqa-w-full cqa-flex cqa-flex-col cqa-min-h-0\"\n                      [ngClass]=\"{'cqa-api-edit-step-payload-textarea--error': payloadJsonError}\">\n                      <textarea #payloadTextareaRef\n                        class=\"cqa-api-edit-step-payload-textarea-input cqa-w-full cqa-resize-y cqa-outline-none cqa-box-border\"\n                        [ngClass]=\"{'cqa-api-edit-step-payload-textarea-input--error': payloadJsonError}\"\n                        [value]=\"payloadText\"\n                        [attr.rows]=\"10\"\n                        placeholder=\"\"\n                        [attr.aria-label]=\"'Payload'\"\n                        [attr.aria-invalid]=\"!!payloadJsonError\"\n                        (input)=\"onPayloadInput($event)\"\n                        (keydown)=\"onPayloadKeydown($event)\">\n                      </textarea>\n                    </div>\n                  </div>\n                </div>\n                <p *ngIf=\"payloadJsonError\" class=\"cqa-api-edit-step-payload-json-error-msg\">\n                  Invalid JSON format. Please check your syntax.\n                </p>\n              </div>\n\n              <!-- x-www-form-urlencoded: Key\u2013Value rows, add/remove dynamically -->\n              <div *ngIf=\"payloadType === 'x-www-form-urlencoded'\" class=\"cqa-api-edit-step-key-value\">\n                <div class=\"cqa-api-edit-step-key-value-grid cqa-api-edit-step-key-value-header\">\n                  <span class=\"cqa-api-edit-step-key-value-label\">Key</span>\n                  <span class=\"cqa-api-edit-step-key-value-label\">Value</span>\n                  <span class=\"cqa-api-edit-step-key-value-label cqa-api-edit-step-key-value-label--empty\"\n                    aria-hidden=\"true\"></span>\n                </div>\n                <div *ngFor=\"let row of keyValueRows; let i = index; trackBy: trackByKeyValue\" [formGroup]=\"row\"\n                  class=\"cqa-api-edit-step-key-value-row\">\n                  <cqa-custom-input [value]=\"row.get('key')?.value ?? ''\"\n                    (valueChange)=\"row.get('key')?.setValue($event)\" placeholder=\"Key\" [fullWidth]=\"true\" size=\"sm\"\n                    class=\"cqa-api-edit-step-key-value-input\" ariaLabel=\"Key\">\n                  </cqa-custom-input>\n                  <cqa-custom-input [value]=\"row.get('value')?.value ?? ''\"\n                    (valueChange)=\"row.get('value')?.setValue($event)\" placeholder=\"Value\" [fullWidth]=\"true\" size=\"sm\"\n                    class=\"cqa-api-edit-step-key-value-input\" ariaLabel=\"Value\">\n                  </cqa-custom-input>\n                  <cqa-button type=\"button\" variant=\"text\" [customClass]=\"'cqa-api-edit-step-key-value-delete'\"\n                    [tooltip]=\"'Remove row'\" (clicked)=\"removeKeyValueRow(i)\">\n                    <svg class=\"cqa-api-edit-step-key-value-delete-icon\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\"\n                      fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\" aria-hidden=\"true\">\n                      <path\n                        d=\"M10.6663 6V12.6667H5.33301V6H10.6663ZM9.66634 2H6.33301L5.66634 2.66667H3.33301V4H12.6663V2.66667H10.333L9.66634 2ZM11.9997 4.66667H3.99967V12.6667C3.99967 13.4 4.59967 14 5.33301 14H10.6663C11.3997 14 11.9997 13.4 11.9997 12.6667V4.66667Z\"\n                        fill=\"#F9BFBF\" />\n                    </svg>\n                  </cqa-button>\n                </div>\n                <div class=\"cqa-api-edit-step-key-value-add-wrap\">\n                  <cqa-button type=\"button\" variant=\"filled\" btnSize=\"lg\" text=\"+ Add Row\"\n                    customClass=\"cqa-api-edit-step-key-value-add-btn\" (clicked)=\"addKeyValueRow()\">\n                  </cqa-button>\n                </div>\n              </div>\n\n              <!-- Form Data: Key\u2013Type\u2013Value rows; Type is a dropdown (Text/File), add/remove dynamically -->\n              <div *ngIf=\"payloadType === 'form-data'\" class=\"cqa-api-edit-step-key-type-value\">\n                <div class=\"cqa-api-edit-step-key-type-value-header\">\n                  <span class=\"cqa-api-edit-step-key-type-value-label\">Key</span>\n                  <span class=\"cqa-api-edit-step-key-type-value-label\">Type</span>\n                  <span class=\"cqa-api-edit-step-key-type-value-label\">Value</span>\n                  <span class=\"cqa-api-edit-step-key-type-value-label cqa-api-edit-step-key-type-value-label--empty\"\n                    aria-hidden=\"true\"></span>\n                </div>\n                <div *ngFor=\"let row of keyTypeValueRows; let i = index; trackBy: trackByKeyTypeValue\" [formGroup]=\"row\"\n                  class=\"cqa-api-edit-step-key-type-value-row\">\n                  <cqa-custom-input [value]=\"row.get('key')?.value ?? ''\"\n                    (valueChange)=\"row.get('key')?.setValue($event)\" placeholder=\"Key\" [fullWidth]=\"true\" size=\"sm\"\n                    class=\"cqa-api-edit-step-key-type-value-input\" ariaLabel=\"Key\">\n                  </cqa-custom-input>\n                  <cqa-dynamic-select [form]=\"row\" [config]=\"keyTypeValueTypeSelectConfig\"\n                    class=\"cqa-api-edit-step-key-type-value-type-select cqa-w-full\">\n                  </cqa-dynamic-select>\n                  <cqa-custom-input [value]=\"row.get('value')?.value ?? ''\"\n                    (valueChange)=\"row.get('value')?.setValue($event)\" placeholder=\"Value\" [fullWidth]=\"true\" size=\"sm\"\n                    class=\"cqa-api-edit-step-key-type-value-input\" ariaLabel=\"Value\">\n                  </cqa-custom-input>\n                  <cqa-button type=\"button\" variant=\"text\" [customClass]=\"'cqa-api-edit-step-key-type-value-delete'\"\n                    [tooltip]=\"'Remove row'\" (clicked)=\"removeKeyTypeValueRow(i)\">\n                    <svg class=\"cqa-api-edit-step-key-type-value-delete-icon\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\"\n                      fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\" aria-hidden=\"true\">\n                      <path\n                        d=\"M10.6663 6V12.6667H5.33301V6H10.6663ZM9.66634 2H6.33301L5.66634 2.66667H3.33301V4H12.6663V2.66667H10.333L9.66634 2ZM11.9997 4.66667H3.99967V12.6667C3.99967 13.4 4.59967 14 5.33301 14H10.6663C11.3997 14 11.9997 13.4 11.9997 12.6667V4.66667Z\"\n                        fill=\"#F9BFBF\" />\n                    </svg>\n                  </cqa-button>\n                </div>\n                <div class=\"cqa-api-edit-step-key-type-value-add-wrap\">\n                  <cqa-button type=\"button\" variant=\"filled\" btnSize=\"lg\" text=\"+ Add Row\"\n                    customClass=\"cqa-api-edit-step-key-type-value-add-btn\" (clicked)=\"addKeyTypeValueRow()\">\n                  </cqa-button>\n                </div>\n              </div>\n            </div>\n          </div>\n        </ng-container>\n\n      </div>\n      <!-- Step 2: Variable Name: input, validation, Back / Next -->\n      <div class=\"cqa-api-edit-step-panel\">\n        <div class=\"cqa-api-edit-step-variable-section\">\n          <div class=\"cqa-api-edit-step-variable-input-wrap\">\n            <cqa-custom-input [(value)]=\"variableName\" [label]=\"''\" placeholder=\"Variable Name\" [fullWidth]=\"true\"\n              size=\"md\" (valueChange)=\"onVariableNameChange()\" aria-label=\"Variable Name\">\n            </cqa-custom-input>\n          </div>\n          <p *ngIf=\"variableNameError\" class=\"cqa-api-edit-step-variable-error\" role=\"alert\">{{ variableNameError }}</p>\n        </div>\n      </div>\n      <!-- Step 3: Response Body / Status tabs -->\n      <div class=\"cqa-api-edit-step-panel\">\n        <div class=\"cqa-api-edit-step-tabs-wrapper\">\n          <div class=\"cqa-api-edit-step-tabs\">\n            <cqa-button *ngFor=\"let tab of responseVerificationTabs\" type=\"button\" variant=\"text\" [text]=\"tab.label\"\n              [customClass]=\"'cqa-api-edit-step-tab' + (activeResponseVerificationTab === tab.value ? ' cqa-api-edit-step-tab--active' : '')\"\n              (clicked)=\"setResponseVerificationTab(tab.value)\">\n            </cqa-button>\n          </div>\n\n          <!-- Response Body tab content: verification grid -->\n          <div *ngIf=\"activeResponseVerificationTab === 'response-body'\" class=\"cqa-api-edit-step-step3-content\">\n            <div class=\"cqa-api-edit-step-verification-header-row\">\n              <span></span>\n              <cqa-button type=\"button\" variant=\"text\" text=\"Add Verification\"\n                customClass=\"cqa-api-edit-step-verification-add-link\" (clicked)=\"addVerificationRow()\">\n              </cqa-button>\n            </div>\n            <div class=\"cqa-api-edit-step-verification\">\n              <div class=\"cqa-api-edit-step-verification-grid cqa-api-edit-step-verification-grid-header\">\n                <span class=\"cqa-api-edit-step-verification-label\">S.no</span>\n                <span class=\"cqa-api-edit-step-verification-label\">JSON Path</span>\n                <span class=\"cqa-api-edit-step-verification-label\">Verification</span>\n                <span class=\"cqa-api-edit-step-verification-label\">Data Type</span>\n                <span class=\"cqa-api-edit-step-verification-label\">Expected Value</span>\n                <span class=\"cqa-api-edit-step-verification-label cqa-api-edit-step-verification-label--empty\"\n                  aria-hidden=\"true\"></span>\n              </div>\n              <div *ngFor=\"let row of verificationRows; let i = index; trackBy: trackByVerification\" [formGroup]=\"row\"\n                class=\"cqa-api-edit-step-verification-row\">\n                <span class=\"cqa-api-edit-step-verification-sno\">{{ i + 1 }}</span>\n                <cqa-custom-input [value]=\"row.get('jsonPath')?.value ?? ''\"\n                  (valueChange)=\"row.get('jsonPath')?.setValue($event)\" placeholder=\"Json Path\" [fullWidth]=\"true\"\n                  size=\"sm\" class=\"cqa-api-edit-step-verification-input\" ariaLabel=\"JSON Path\">\n                </cqa-custom-input>\n                <cqa-dynamic-select [form]=\"row\" [config]=\"verificationSelectConfig\"\n                  class=\"cqa-api-edit-step-verification-select cqa-w-full\">\n                </cqa-dynamic-select>\n                <cqa-dynamic-select [form]=\"row\" [config]=\"verificationDataTypeSelectConfig\"\n                  class=\"cqa-api-edit-step-verification-select cqa-w-full\"\n                  (selectionChange)=\"onVerificationDataTypeChange(row, $event)\">\n                </cqa-dynamic-select>\n                <!-- Expected Value: text for String/Array/Object, number for Number, dropdown for Boolean -->\n                <ng-container [ngSwitch]=\"row.get('dataType')?.value\">\n                  <cqa-dynamic-select *ngSwitchCase=\"'boolean'\" [form]=\"row\"\n                    [config]=\"verificationExpectedValueBooleanSelectConfig\"\n                    class=\"cqa-api-edit-step-verification-select cqa-api-edit-step-verification-expected-select cqa-w-full\">\n                  </cqa-dynamic-select>\n                  <cqa-custom-input *ngSwitchCase=\"'number'\" [value]=\"row.get('expectedValue')?.value ?? ''\"\n                    (valueChange)=\"row.get('expectedValue')?.setValue($event)\" placeholder=\"Expected Value (number)\"\n                    type=\"number\" [fullWidth]=\"true\" size=\"sm\"\n                    class=\"cqa-api-edit-step-verification-input cqa-api-edit-step-verification-expected-number\"\n                    ariaLabel=\"Expected Value\">\n                  </cqa-custom-input>\n                  <cqa-custom-input *ngSwitchDefault [value]=\"row.get('expectedValue')?.value ?? ''\"\n                    (valueChange)=\"row.get('expectedValue')?.setValue($event)\"\n                    placeholder=\"Expected Value in String\" [fullWidth]=\"true\" size=\"sm\"\n                    class=\"cqa-api-edit-step-verification-input\" ariaLabel=\"Expected Value\">\n                  </cqa-custom-input>\n                </ng-container>\n                <cqa-button type=\"button\" variant=\"text\" [customClass]=\"'cqa-api-edit-step-verification-delete'\"\n                  [tooltip]=\"'Remove row'\" (clicked)=\"removeVerificationRow(i)\">\n                  <svg class=\"cqa-api-edit-step-verification-delete-icon\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\"\n                    fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\" aria-hidden=\"true\">\n                    <path\n                      d=\"M10.6663 6V12.6667H5.33301V6H10.6663ZM9.66634 2H6.33301L5.66634 2.66667H3.33301V4H12.6663V2.66667H10.333L9.66634 2ZM11.9997 4.66667H3.99967V12.6667C3.99967 13.4 4.59967 14 5.33301 14H10.6663C11.3997 14 11.9997 13.4 11.9997 12.6667V4.66667Z\"\n                      fill=\"#F9BFBF\" />\n                  </svg>\n                </cqa-button>\n              </div>\n            </div>\n          </div>\n\n          <!-- Status tab content: S.no, Verification dropdown, Expected Value, add/remove rows -->\n          <div *ngIf=\"activeResponseVerificationTab === 'status'\" class=\"cqa-api-edit-step-step3-content\">\n            <div class=\"cqa-api-edit-step-verification-header-row\">\n              <span></span>\n              <cqa-button type=\"button\" variant=\"text\" text=\"Add Verification\"\n                customClass=\"cqa-api-edit-step-verification-add-link\" (clicked)=\"addStatusVerificationRow()\">\n              </cqa-button>\n            </div>\n            <div class=\"cqa-api-edit-step-status-verification\">\n              <div class=\"cqa-api-edit-step-status-verification-header\">\n                <span class=\"cqa-api-edit-step-verification-label\">S.no</span>\n                <span class=\"cqa-api-edit-step-verification-label\">Verification</span>\n                <span class=\"cqa-api-edit-step-verification-label\">Expected Value</span>\n                <span class=\"cqa-api-edit-step-verification-label cqa-api-edit-step-verification-label--empty\"\n                  aria-hidden=\"true\"></span>\n              </div>\n              <div *ngFor=\"let row of statusVerificationRows; let i = index; trackBy: trackByStatusVerification\"\n                [formGroup]=\"row\" class=\"cqa-api-edit-step-status-verification-row\">\n                <span class=\"cqa-api-edit-step-verification-sno\">{{ i + 1 }}</span>\n                <cqa-dynamic-select [form]=\"row\" [config]=\"statusVerificationSelectConfig\"\n                  class=\"cqa-api-edit-step-status-verification-select cqa-w-full\">\n                </cqa-dynamic-select>\n                <cqa-custom-input [value]=\"row.get('expectedValue')?.value ?? ''\"\n                  (valueChange)=\"row.get('expectedValue')?.setValue($event)\" placeholder=\"Expected Value\"\n                  type=\"number\" [fullWidth]=\"true\" size=\"sm\" class=\"cqa-api-edit-step-verification-input\"\n                  ariaLabel=\"Expected Value\">\n                </cqa-custom-input>\n                <cqa-button type=\"button\" variant=\"text\" [customClass]=\"'cqa-api-edit-step-verification-delete'\"\n                  [tooltip]=\"'Remove row'\" (clicked)=\"removeStatusVerificationRow(i)\">\n                  <svg class=\"cqa-api-edit-step-verification-delete-icon\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\"\n                    fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\" aria-hidden=\"true\">\n                    <path\n                      d=\"M10.6663 6V12.6667H5.33301V6H10.6663ZM9.66634 2H6.33301L5.66634 2.66667H3.33301V4H12.6663V2.66667H10.333L9.66634 2ZM11.9997 4.66667H3.99967V12.6667C3.99967 13.4 4.59967 14 5.33301 14H10.6663C11.3997 14 11.9997 13.4 11.9997 12.6667V4.66667Z\"\n                      fill=\"#F9BFBF\" />\n                  </svg>\n                </cqa-button>\n              </div>\n            </div>\n          </div>\n        </div>\n      </div>\n    </div>\n  </div>\n\n  <!-- Response Preview -->\n  <div class=\"cqa-api-edit-step-response\">\n    <h3 class=\"cqa-api-edit-step-response-title\">Response Preview</h3>\n    <pre class=\"cqa-api-edit-step-response-content\">{{ responsePreview }}</pre>\n  </div>\n\n  <!-- Step actions: one row, full width. Step 1: Cancel + Next; Step 2: Back + Next; Step 3: Back + Create -->\n  <div class=\"cqa-api-edit-step-actions\">\n    <ng-container [ngSwitch]=\"currentStep\">\n      <ng-container *ngSwitchCase=\"1\">\n        <cqa-button type=\"button\" variant=\"outlined\" btnSize=\"lg\" text=\"Cancel\"\n          customClass=\"cqa-api-edit-step-actions-btn-cancel\" (clicked)=\"onBack()\">\n        </cqa-button>\n        <cqa-button type=\"button\" variant=\"filled\" btnSize=\"lg\" text=\"Next\"\n          customClass=\"cqa-api-edit-step-actions-btn-next\" (clicked)=\"onNext()\">\n        </cqa-button>\n      </ng-container>\n      <ng-container *ngSwitchCase=\"2\">\n        <cqa-button type=\"button\" variant=\"outlined\" btnSize=\"lg\" text=\"Back\"\n          customClass=\"cqa-api-edit-step-actions-btn-back\" (clicked)=\"onBack()\">\n        </cqa-button>\n        <cqa-button type=\"button\" variant=\"filled\" btnSize=\"lg\" text=\"Next\"\n          customClass=\"cqa-api-edit-step-actions-btn-next\" (clicked)=\"onNext()\">\n        </cqa-button>\n      </ng-container>\n      <ng-container *ngSwitchCase=\"3\">\n        <cqa-button type=\"button\" variant=\"outlined\" btnSize=\"lg\" text=\"Back\"\n          customClass=\"cqa-api-edit-step-actions-btn-back\" (clicked)=\"onBack()\">\n        </cqa-button>\n        <cqa-button type=\"button\" variant=\"filled\" btnSize=\"lg\" text=\"Create\"\n          customClass=\"cqa-api-edit-step-actions-btn-create\" (clicked)=\"onCreate()\">\n        </cqa-button>\n      </ng-container>\n    </ng-container>\n  </div>\n</div>", components: [{ type: i2.ButtonComponent, selector: "cqa-button", inputs: ["variant", "btnSize", "disabled", "icon", "iconPosition", "fullWidth", "iconColor", "type", "text", "customClass", "inlineStyles", "tooltip", "tooltipPosition"], outputs: ["clicked"] }, { type: i3.DynamicSelectFieldComponent, selector: "cqa-dynamic-select", inputs: ["form", "config"], outputs: ["selectionChange", "selectClick", "searchChange", "loadMore", "addCustomValue"] }, { type: i4.CustomInputComponent, selector: "cqa-custom-input", inputs: ["label", "type", "placeholder", "value", "disabled", "errors", "required", "ariaLabel", "size", "fullWidth", "maxLength", "showCharCount", "inputInlineStyle", "labelInlineStyle"], outputs: ["valueChange", "blurred", "focused", "enterPressed"] }, { type: i5.CustomTextareaComponent, selector: "cqa-custom-textarea", inputs: ["label", "placeholder", "value", "disabled", "errors", "required", "ariaLabel", "size", "fullWidth", "maxLength", "showCharCount", "rows", "cols", "resize", "textareaInlineStyle", "labelInlineStyle"], outputs: ["valueChange", "blurred", "focused"] }, { type: i6.SegmentControlComponent, selector: "cqa-segment-control", inputs: ["segments", "value", "disabled", "containerBgColor"], outputs: ["valueChange"] }], directives: [{ type: i7.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i7.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i1.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { type: i1.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { type: i7.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { type: i7.NgSwitch, selector: "[ngSwitch]", inputs: ["ngSwitch"] }, { type: i7.NgSwitchCase, selector: "[ngSwitchCase]", inputs: ["ngSwitchCase"] }, { type: i7.NgSwitchDefault, selector: "[ngSwitchDefault]" }], changeDetection: i0.ChangeDetectionStrategy.Default });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: ApiEditStepComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'cqa-api-edit-step', host: { class: 'cqa-ui-root' }, changeDetection: ChangeDetectionStrategy.Default, template: "<div class=\"cqa-api-edit-step-container\">\n  <!-- Title -->\n  <h2\n    class=\"cqa-api-edit-step-title cqa-font-inter cqa-text-[12px] cqa-font-semibold cqa-leading-[100%] cqa-tracking-normal cqa-text-[#000000]\">\n    Create API Test Step</h2>\n\n  <!-- Step indicator: all three steps visible, active step highlighted (Postman-style) -->\n  <div class=\"cqa-api-edit-step-indicator\">\n    <ng-container *ngFor=\"let step of stepLabels; let i = index\">\n      <cqa-button type=\"button\" variant=\"text\"\n        customClass=\"cqa-api-edit-step-indicator-item cqa-api-edit-step-indicator-item--clickable\"\n        [attr.aria-label]=\"'Step ' + step.index + ': ' + step.label\" [attr.aria-pressed]=\"step.index === currentStep\"\n        (clicked)=\"setStep(step.index)\">\n        <span class=\"cqa-api-edit-step-indicator-circle\"\n          [class.cqa-api-edit-step-indicator-circle--active]=\"step.index === currentStep\">\n          {{ step.index }}\n        </span>\n        <span class=\"cqa-api-edit-step-indicator-label\"\n          [class.cqa-api-edit-step-indicator-label--active]=\"step.index === currentStep\">\n          {{ step.label }}\n        </span>\n        <div *ngIf=\"i < stepLabels.length - 1\" class=\"cqa-api-edit-step-indicator-line\" aria-hidden=\"true\"></div>\n      </cqa-button>\n    </ng-container>\n  </div>\n\n  <!-- Step content viewport: smooth slide between steps -->\n  <div class=\"cqa-api-edit-step-viewport\">\n    <div class=\"cqa-api-edit-step-strip\" [style.transform]=\"'translateX(' + stripTranslatePercent + '%)'\">\n      <!-- Step 1: Environment, request, body, response -->\n      <div class=\"cqa-api-edit-step-panel\">\n        <!-- Environment row: new line, select aligned right -->\n        <div class=\"cqa-api-edit-step-environment-row\">\n          <cqa-dynamic-select *ngIf=\"environmentForm\" [form]=\"environmentForm\" [config]=\"environmentSelectConfig\"\n            class=\"cqa-api-edit-step-environment-select\" aria-label=\"Environment\"\n            (selectionChange)=\"onEnvironmentSelectionChange($event)\">\n          </cqa-dynamic-select>\n        </div>\n\n        <!-- Request row: method, URL, buttons -->\n        <div class=\"cqa-api-edit-step-request-row\">\n          <cqa-dynamic-select *ngIf=\"methodForm\" [form]=\"methodForm\" [config]=\"methodSelectConfig\"\n            class=\"cqa-api-edit-step-method-select\" aria-label=\"HTTP method\"\n            (selectionChange)=\"onMethodSelectionChange($event)\">\n          </cqa-dynamic-select>\n          <div class=\"cqa-api-edit-step-url-wrap\">\n            <cqa-custom-input [(value)]=\"url\" [label]=\"''\" placeholder=\"\" [fullWidth]=\"true\" size=\"md\">\n            </cqa-custom-input>\n          </div>\n          <div class=\"cqa-api-edit-step-import-curl-trigger\" style=\"display: contents\" (click)=\"openImportCurlPanel()\">\n            <cqa-button type=\"button\" variant=\"outlined\" btnSize=\"lg\" text=\"Import API cURL\"\n              customClass=\"cqa-api-edit-step-btn-outline cqa-font-inter cqa-text-[14px] cqa-font-semibold cqa-leading-[100%] cqa-tracking-normal cqa-text-[#414146]\">\n            </cqa-button>\n          </div>\n          <cqa-button variant=\"filled\" btnSize=\"lg\" text=\"Send Request\" (clicked)=\"onSendRequest()\"\n            customClass=\"cqa-api-edit-step-btn-primary cqa-font-inter cqa-text-[14px] cqa-font-semibold cqa-leading-[100%] cqa-tracking-normal cqa-text-[#FBFCFF]\">\n          </cqa-button>\n        </div>\n\n\n\n        <!-- Body content: header section (default) OR import cURL section -->\n        <ng-container *ngIf=\"bodyView === 'import-curl'\">\n          <div class=\"cqa-api-edit-step-import-curl-panel\">\n            <div class=\"cqa-api-edit-step-import-curl-header\">\n              <h3 class=\"cqa-api-edit-step-import-curl-title\">Import API cURL</h3>\n            </div>\n            <div class=\"cqa-api-edit-step-import-curl-separator\"></div>\n            <div class=\"cqa-api-edit-step-import-curl-body\">\n              <cqa-custom-textarea [value]=\"importCurlControl.value\"\n                (valueChange)=\"importCurlControl.setValue($event)\"\n                placeholder=\"Paste your cURL command here (e.g., curl -X POST https://api.example.com/users)\"\n                [fullWidth]=\"true\" [rows]=\"8\" resize=\"vertical\" size=\"md\"\n                class=\"cqa-api-edit-step-import-curl-textarea\">\n              </cqa-custom-textarea>\n            </div>\n            <div class=\"cqa-api-edit-step-import-curl-footer\">\n              <cqa-button type=\"button\" variant=\"outlined\" btnSize=\"lg\" text=\"Cancel\"\n                customClass=\"cqa-api-edit-step-import-curl-btn-cancel\" (clicked)=\"onCancelImportCurl()\"></cqa-button>\n              <cqa-button type=\"button\" variant=\"filled\" btnSize=\"lg\" text=\"Import\"\n                customClass=\"cqa-api-edit-step-import-curl-btn-import\" (clicked)=\"onImportCurlConfirm()\"></cqa-button>\n            </div>\n          </div>\n        </ng-container>\n\n        <ng-container *ngIf=\"bodyView === 'headers'\">\n          <div class=\"cqa-api-edit-step-tabs-wrapper\">\n            <div class=\"cqa-api-edit-step-tabs\">\n              <cqa-button *ngFor=\"let tab of payloadTabs\" type=\"button\" variant=\"text\" [text]=\"tab.label\"\n                [customClass]=\"'cqa-api-edit-step-tab' + (activePayloadTab === tab.value ? ' cqa-api-edit-step-tab--active' : '') + (isMethodWithoutBody && tab.value !== 'headers' ? ' cqa-api-edit-step-tab--disabled' : '')\"\n                [disabled]=\"isMethodWithoutBody && tab.value !== 'headers'\"\n                (clicked)=\"setPayloadTab(tab.value)\">\n              </cqa-button>\n            </div>\n\n            <!-- Payload content (Headers) -->\n            <div *ngIf=\"activePayloadTab === 'headers'\" class=\"cqa-api-edit-step-payload\">\n              <div class=\"cqa-api-edit-step-headers-grid\">\n                <span class=\"cqa-api-edit-step-headers-label\">Header Name</span>\n                <span class=\"cqa-api-edit-step-headers-label\">Header Value</span>\n                <span class=\"cqa-api-edit-step-headers-label cqa-api-edit-step-headers-label--empty\"\n                  aria-hidden=\"true\"></span>\n              </div>\n              <div *ngFor=\"let row of headerRows; let i = index; trackBy: trackByHeader\" [formGroup]=\"row\"\n                class=\"cqa-api-edit-step-header-row\">\n                <cqa-dynamic-select [form]=\"row\" [config]=\"headerNameSelectConfig\"\n                  (addCustomValue)=\"onHeaderNameAddCustomValue($event, row)\"\n                  class=\"cqa-api-edit-step-header-type-select cqa-w-full\">\n                </cqa-dynamic-select>\n                <cqa-custom-input [value]=\"row.get('value')?.value ?? ''\"\n                  (valueChange)=\"row.get('value')?.setValue($event)\" placeholder=\"Value\" [fullWidth]=\"true\" size=\"sm\"\n                  class=\"cqa-api-edit-step-header-value-input\" ariaLabel=\"Header value\">\n                </cqa-custom-input>\n                <cqa-button type=\"button\" variant=\"text\" [customClass]=\"'cqa-api-edit-step-header-delete'\"\n                  [tooltip]=\"'Remove header'\" (clicked)=\"removeHeader(i)\">\n                  <svg class=\"cqa-api-edit-step-header-delete-icon\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\"\n                    fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\" aria-hidden=\"true\">\n                    <path\n                      d=\"M10.6663 6V12.6667H5.33301V6H10.6663ZM9.66634 2H6.33301L5.66634 2.66667H3.33301V4H12.6663V2.66667H10.333L9.66634 2ZM11.9997 4.66667H3.99967V12.6667C3.99967 13.4 4.59967 14 5.33301 14H10.6663C11.3997 14 11.9997 13.4 11.9997 12.6667V4.66667Z\"\n                      fill=\"#F9BFBF\" />\n                  </svg>\n                </cqa-button>\n              </div>\n              <div class=\"cqa-api-edit-step-add-header-wrap\">\n                <cqa-button type=\"button\" variant=\"text\" text=\"+ Add Header\"\n                  [customClass]=\"'cqa-api-edit-step-add-header-link'\" (clicked)=\"addHeader()\">\n                </cqa-button>\n              </div>\n            </div>\n\n            <!-- Payload content (Body only): type, format, text area, Back/Next -->\n            <div *ngIf=\"activePayloadTab === 'body'\"\n              class=\"cqa-api-edit-step-payload cqa-api-edit-step-payload-editor\">\n              <div class=\"cqa-api-edit-step-payload-type-row\">\n                <span class=\"cqa-api-edit-step-payload-type-label\">Type</span>\n                <div class=\"cqa-api-edit-step-payload-type-radios\">\n                  <cqa-segment-control [value]=\"payloadType\" [segments]=\"payloadTypeSegments\"\n                    (valueChange)=\"onPayloadTypeChange($event)\"\n                    class=\"cqa-api-edit-step-payload-type-segment\">\n                  </cqa-segment-control>\n                </div>\n                <div *ngIf=\"payloadType === 'raw'\" class=\"cqa-api-edit-step-payload-format-wrap\">\n                  <span class=\"cqa-api-edit-step-payload-format-label\">Format:</span>\n                  <cqa-dynamic-select *ngIf=\"payloadFormatForm\" [form]=\"payloadFormatForm\"\n                    [config]=\"payloadFormatSelectConfig\" class=\"cqa-api-edit-step-payload-format-select\"\n                    aria-label=\"Format\">\n                  </cqa-dynamic-select>\n                </div>\n              </div>\n              <!-- Raw: text area with line numbers (Postman-style payload body) -->\n              <div *ngIf=\"payloadType === 'raw'\" class=\"cqa-api-edit-step-payload-body\" #payloadEditorWithLinesRef>\n                <div class=\"cqa-api-edit-step-payload-editor-with-lines\">\n                  <div class=\"cqa-api-edit-step-payload-line-numbers\" aria-hidden=\"true\">\n                    <span *ngFor=\"let n of payloadLineNumbers\" class=\"cqa-api-edit-step-payload-line-num\">\n                      <span *ngIf=\"payloadJsonError && payloadJsonError.line === n\"\n                        class=\"cqa-api-edit-step-payload-line-error-icon\" [title]=\"payloadJsonErrorTooltip\"\n                        aria-label=\"Parse error on this line\">\n                        <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"14\" height=\"14\" viewBox=\"0 0 14 14\" fill=\"none\" aria-hidden=\"true\">\n                          <circle cx=\"7\" cy=\"7\" r=\"6\" fill=\"#EF4444\"/>\n                          <path d=\"M4 4l6 6M10 4l-6 6\" stroke=\"white\" stroke-width=\"1.5\" stroke-linecap=\"round\"/>\n                        </svg>\n                      </span>\n                      <span class=\"cqa-api-edit-step-payload-line-num-text\">{{ n }}</span>\n                    </span>\n                  </div>\n                  <div class=\"cqa-api-edit-step-payload-textarea-cell\">\n                    <div class=\"cqa-api-edit-step-payload-textarea cqa-w-full cqa-flex cqa-flex-col cqa-min-h-0\"\n                      [ngClass]=\"{'cqa-api-edit-step-payload-textarea--error': payloadJsonError}\">\n                      <textarea #payloadTextareaRef\n                        class=\"cqa-api-edit-step-payload-textarea-input cqa-w-full cqa-resize-y cqa-outline-none cqa-box-border\"\n                        [ngClass]=\"{'cqa-api-edit-step-payload-textarea-input--error': payloadJsonError}\"\n                        [value]=\"payloadText\"\n                        [attr.rows]=\"10\"\n                        placeholder=\"\"\n                        [attr.aria-label]=\"'Payload'\"\n                        [attr.aria-invalid]=\"!!payloadJsonError\"\n                        (input)=\"onPayloadInput($event)\"\n                        (keydown)=\"onPayloadKeydown($event)\">\n                      </textarea>\n                    </div>\n                  </div>\n                </div>\n                <p *ngIf=\"payloadJsonError\" class=\"cqa-api-edit-step-payload-json-error-msg\">\n                  Invalid JSON format. Please check your syntax.\n                </p>\n              </div>\n\n              <!-- x-www-form-urlencoded: Key\u2013Value rows, add/remove dynamically -->\n              <div *ngIf=\"payloadType === 'x-www-form-urlencoded'\" class=\"cqa-api-edit-step-key-value\">\n                <div class=\"cqa-api-edit-step-key-value-grid cqa-api-edit-step-key-value-header\">\n                  <span class=\"cqa-api-edit-step-key-value-label\">Key</span>\n                  <span class=\"cqa-api-edit-step-key-value-label\">Value</span>\n                  <span class=\"cqa-api-edit-step-key-value-label cqa-api-edit-step-key-value-label--empty\"\n                    aria-hidden=\"true\"></span>\n                </div>\n                <div *ngFor=\"let row of keyValueRows; let i = index; trackBy: trackByKeyValue\" [formGroup]=\"row\"\n                  class=\"cqa-api-edit-step-key-value-row\">\n                  <cqa-custom-input [value]=\"row.get('key')?.value ?? ''\"\n                    (valueChange)=\"row.get('key')?.setValue($event)\" placeholder=\"Key\" [fullWidth]=\"true\" size=\"sm\"\n                    class=\"cqa-api-edit-step-key-value-input\" ariaLabel=\"Key\">\n                  </cqa-custom-input>\n                  <cqa-custom-input [value]=\"row.get('value')?.value ?? ''\"\n                    (valueChange)=\"row.get('value')?.setValue($event)\" placeholder=\"Value\" [fullWidth]=\"true\" size=\"sm\"\n                    class=\"cqa-api-edit-step-key-value-input\" ariaLabel=\"Value\">\n                  </cqa-custom-input>\n                  <cqa-button type=\"button\" variant=\"text\" [customClass]=\"'cqa-api-edit-step-key-value-delete'\"\n                    [tooltip]=\"'Remove row'\" (clicked)=\"removeKeyValueRow(i)\">\n                    <svg class=\"cqa-api-edit-step-key-value-delete-icon\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\"\n                      fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\" aria-hidden=\"true\">\n                      <path\n                        d=\"M10.6663 6V12.6667H5.33301V6H10.6663ZM9.66634 2H6.33301L5.66634 2.66667H3.33301V4H12.6663V2.66667H10.333L9.66634 2ZM11.9997 4.66667H3.99967V12.6667C3.99967 13.4 4.59967 14 5.33301 14H10.6663C11.3997 14 11.9997 13.4 11.9997 12.6667V4.66667Z\"\n                        fill=\"#F9BFBF\" />\n                    </svg>\n                  </cqa-button>\n                </div>\n                <div class=\"cqa-api-edit-step-key-value-add-wrap\">\n                  <cqa-button type=\"button\" variant=\"filled\" btnSize=\"lg\" text=\"+ Add Row\"\n                    customClass=\"cqa-api-edit-step-key-value-add-btn\" (clicked)=\"addKeyValueRow()\">\n                  </cqa-button>\n                </div>\n              </div>\n\n              <!-- Form Data: Key\u2013Type\u2013Value rows; Type is a dropdown (Text/File), add/remove dynamically -->\n              <div *ngIf=\"payloadType === 'form-data'\" class=\"cqa-api-edit-step-key-type-value\">\n                <div class=\"cqa-api-edit-step-key-type-value-header\">\n                  <span class=\"cqa-api-edit-step-key-type-value-label\">Key</span>\n                  <span class=\"cqa-api-edit-step-key-type-value-label\">Type</span>\n                  <span class=\"cqa-api-edit-step-key-type-value-label\">Value</span>\n                  <span class=\"cqa-api-edit-step-key-type-value-label cqa-api-edit-step-key-type-value-label--empty\"\n                    aria-hidden=\"true\"></span>\n                </div>\n                <div *ngFor=\"let row of keyTypeValueRows; let i = index; trackBy: trackByKeyTypeValue\" [formGroup]=\"row\"\n                  class=\"cqa-api-edit-step-key-type-value-row\">\n                  <cqa-custom-input [value]=\"row.get('key')?.value ?? ''\"\n                    (valueChange)=\"row.get('key')?.setValue($event)\" placeholder=\"Key\" [fullWidth]=\"true\" size=\"sm\"\n                    class=\"cqa-api-edit-step-key-type-value-input\" ariaLabel=\"Key\">\n                  </cqa-custom-input>\n                  <cqa-dynamic-select [form]=\"row\" [config]=\"keyTypeValueTypeSelectConfig\"\n                    class=\"cqa-api-edit-step-key-type-value-type-select cqa-w-full\">\n                  </cqa-dynamic-select>\n                  <cqa-custom-input [value]=\"row.get('value')?.value ?? ''\"\n                    (valueChange)=\"row.get('value')?.setValue($event)\" placeholder=\"Value\" [fullWidth]=\"true\" size=\"sm\"\n                    class=\"cqa-api-edit-step-key-type-value-input\" ariaLabel=\"Value\">\n                  </cqa-custom-input>\n                  <cqa-button type=\"button\" variant=\"text\" [customClass]=\"'cqa-api-edit-step-key-type-value-delete'\"\n                    [tooltip]=\"'Remove row'\" (clicked)=\"removeKeyTypeValueRow(i)\">\n                    <svg class=\"cqa-api-edit-step-key-type-value-delete-icon\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\"\n                      fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\" aria-hidden=\"true\">\n                      <path\n                        d=\"M10.6663 6V12.6667H5.33301V6H10.6663ZM9.66634 2H6.33301L5.66634 2.66667H3.33301V4H12.6663V2.66667H10.333L9.66634 2ZM11.9997 4.66667H3.99967V12.6667C3.99967 13.4 4.59967 14 5.33301 14H10.6663C11.3997 14 11.9997 13.4 11.9997 12.6667V4.66667Z\"\n                        fill=\"#F9BFBF\" />\n                    </svg>\n                  </cqa-button>\n                </div>\n                <div class=\"cqa-api-edit-step-key-type-value-add-wrap\">\n                  <cqa-button type=\"button\" variant=\"filled\" btnSize=\"lg\" text=\"+ Add Row\"\n                    customClass=\"cqa-api-edit-step-key-type-value-add-btn\" (clicked)=\"addKeyTypeValueRow()\">\n                  </cqa-button>\n                </div>\n              </div>\n            </div>\n          </div>\n        </ng-container>\n\n      </div>\n      <!-- Step 2: Variable Name: input, validation, Back / Next -->\n      <div class=\"cqa-api-edit-step-panel\">\n        <div class=\"cqa-api-edit-step-variable-section\">\n          <div class=\"cqa-api-edit-step-variable-input-wrap\">\n            <cqa-custom-input [(value)]=\"variableName\" [label]=\"''\" placeholder=\"Variable Name\" [fullWidth]=\"true\"\n              size=\"md\" (valueChange)=\"onVariableNameChange()\" aria-label=\"Variable Name\">\n            </cqa-custom-input>\n          </div>\n          <p *ngIf=\"variableNameError\" class=\"cqa-api-edit-step-variable-error\" role=\"alert\">{{ variableNameError }}</p>\n        </div>\n      </div>\n      <!-- Step 3: Response Body / Status tabs -->\n      <div class=\"cqa-api-edit-step-panel\">\n        <div class=\"cqa-api-edit-step-tabs-wrapper\">\n          <div class=\"cqa-api-edit-step-tabs\">\n            <cqa-button *ngFor=\"let tab of responseVerificationTabs\" type=\"button\" variant=\"text\" [text]=\"tab.label\"\n              [customClass]=\"'cqa-api-edit-step-tab' + (activeResponseVerificationTab === tab.value ? ' cqa-api-edit-step-tab--active' : '')\"\n              (clicked)=\"setResponseVerificationTab(tab.value)\">\n            </cqa-button>\n          </div>\n\n          <!-- Response Body tab content: verification grid -->\n          <div *ngIf=\"activeResponseVerificationTab === 'response-body'\" class=\"cqa-api-edit-step-step3-content\">\n            <div class=\"cqa-api-edit-step-verification-header-row\">\n              <span></span>\n              <cqa-button type=\"button\" variant=\"text\" text=\"Add Verification\"\n                customClass=\"cqa-api-edit-step-verification-add-link\" (clicked)=\"addVerificationRow()\">\n              </cqa-button>\n            </div>\n            <div class=\"cqa-api-edit-step-verification\">\n              <div class=\"cqa-api-edit-step-verification-grid cqa-api-edit-step-verification-grid-header\">\n                <span class=\"cqa-api-edit-step-verification-label\">S.no</span>\n                <span class=\"cqa-api-edit-step-verification-label\">JSON Path</span>\n                <span class=\"cqa-api-edit-step-verification-label\">Verification</span>\n                <span class=\"cqa-api-edit-step-verification-label\">Data Type</span>\n                <span class=\"cqa-api-edit-step-verification-label\">Expected Value</span>\n                <span class=\"cqa-api-edit-step-verification-label cqa-api-edit-step-verification-label--empty\"\n                  aria-hidden=\"true\"></span>\n              </div>\n              <div *ngFor=\"let row of verificationRows; let i = index; trackBy: trackByVerification\" [formGroup]=\"row\"\n                class=\"cqa-api-edit-step-verification-row\">\n                <span class=\"cqa-api-edit-step-verification-sno\">{{ i + 1 }}</span>\n                <cqa-custom-input [value]=\"row.get('jsonPath')?.value ?? ''\"\n                  (valueChange)=\"row.get('jsonPath')?.setValue($event)\" placeholder=\"Json Path\" [fullWidth]=\"true\"\n                  size=\"sm\" class=\"cqa-api-edit-step-verification-input\" ariaLabel=\"JSON Path\">\n                </cqa-custom-input>\n                <cqa-dynamic-select [form]=\"row\" [config]=\"verificationSelectConfig\"\n                  class=\"cqa-api-edit-step-verification-select cqa-w-full\">\n                </cqa-dynamic-select>\n                <cqa-dynamic-select [form]=\"row\" [config]=\"verificationDataTypeSelectConfig\"\n                  class=\"cqa-api-edit-step-verification-select cqa-w-full\"\n                  (selectionChange)=\"onVerificationDataTypeChange(row, $event)\">\n                </cqa-dynamic-select>\n                <!-- Expected Value: text for String/Array/Object, number for Number, dropdown for Boolean -->\n                <ng-container [ngSwitch]=\"row.get('dataType')?.value\">\n                  <cqa-dynamic-select *ngSwitchCase=\"'boolean'\" [form]=\"row\"\n                    [config]=\"verificationExpectedValueBooleanSelectConfig\"\n                    class=\"cqa-api-edit-step-verification-select cqa-api-edit-step-verification-expected-select cqa-w-full\">\n                  </cqa-dynamic-select>\n                  <cqa-custom-input *ngSwitchCase=\"'number'\" [value]=\"row.get('expectedValue')?.value ?? ''\"\n                    (valueChange)=\"row.get('expectedValue')?.setValue($event)\" placeholder=\"Expected Value (number)\"\n                    type=\"number\" [fullWidth]=\"true\" size=\"sm\"\n                    class=\"cqa-api-edit-step-verification-input cqa-api-edit-step-verification-expected-number\"\n                    ariaLabel=\"Expected Value\">\n                  </cqa-custom-input>\n                  <cqa-custom-input *ngSwitchDefault [value]=\"row.get('expectedValue')?.value ?? ''\"\n                    (valueChange)=\"row.get('expectedValue')?.setValue($event)\"\n                    placeholder=\"Expected Value in String\" [fullWidth]=\"true\" size=\"sm\"\n                    class=\"cqa-api-edit-step-verification-input\" ariaLabel=\"Expected Value\">\n                  </cqa-custom-input>\n                </ng-container>\n                <cqa-button type=\"button\" variant=\"text\" [customClass]=\"'cqa-api-edit-step-verification-delete'\"\n                  [tooltip]=\"'Remove row'\" (clicked)=\"removeVerificationRow(i)\">\n                  <svg class=\"cqa-api-edit-step-verification-delete-icon\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\"\n                    fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\" aria-hidden=\"true\">\n                    <path\n                      d=\"M10.6663 6V12.6667H5.33301V6H10.6663ZM9.66634 2H6.33301L5.66634 2.66667H3.33301V4H12.6663V2.66667H10.333L9.66634 2ZM11.9997 4.66667H3.99967V12.6667C3.99967 13.4 4.59967 14 5.33301 14H10.6663C11.3997 14 11.9997 13.4 11.9997 12.6667V4.66667Z\"\n                      fill=\"#F9BFBF\" />\n                  </svg>\n                </cqa-button>\n              </div>\n            </div>\n          </div>\n\n          <!-- Status tab content: S.no, Verification dropdown, Expected Value, add/remove rows -->\n          <div *ngIf=\"activeResponseVerificationTab === 'status'\" class=\"cqa-api-edit-step-step3-content\">\n            <div class=\"cqa-api-edit-step-verification-header-row\">\n              <span></span>\n              <cqa-button type=\"button\" variant=\"text\" text=\"Add Verification\"\n                customClass=\"cqa-api-edit-step-verification-add-link\" (clicked)=\"addStatusVerificationRow()\">\n              </cqa-button>\n            </div>\n            <div class=\"cqa-api-edit-step-status-verification\">\n              <div class=\"cqa-api-edit-step-status-verification-header\">\n                <span class=\"cqa-api-edit-step-verification-label\">S.no</span>\n                <span class=\"cqa-api-edit-step-verification-label\">Verification</span>\n                <span class=\"cqa-api-edit-step-verification-label\">Expected Value</span>\n                <span class=\"cqa-api-edit-step-verification-label cqa-api-edit-step-verification-label--empty\"\n                  aria-hidden=\"true\"></span>\n              </div>\n              <div *ngFor=\"let row of statusVerificationRows; let i = index; trackBy: trackByStatusVerification\"\n                [formGroup]=\"row\" class=\"cqa-api-edit-step-status-verification-row\">\n                <span class=\"cqa-api-edit-step-verification-sno\">{{ i + 1 }}</span>\n                <cqa-dynamic-select [form]=\"row\" [config]=\"statusVerificationSelectConfig\"\n                  class=\"cqa-api-edit-step-status-verification-select cqa-w-full\">\n                </cqa-dynamic-select>\n                <cqa-custom-input [value]=\"row.get('expectedValue')?.value ?? ''\"\n                  (valueChange)=\"row.get('expectedValue')?.setValue($event)\" placeholder=\"Expected Value\"\n                  type=\"number\" [fullWidth]=\"true\" size=\"sm\" class=\"cqa-api-edit-step-verification-input\"\n                  ariaLabel=\"Expected Value\">\n                </cqa-custom-input>\n                <cqa-button type=\"button\" variant=\"text\" [customClass]=\"'cqa-api-edit-step-verification-delete'\"\n                  [tooltip]=\"'Remove row'\" (clicked)=\"removeStatusVerificationRow(i)\">\n                  <svg class=\"cqa-api-edit-step-verification-delete-icon\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\"\n                    fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\" aria-hidden=\"true\">\n                    <path\n                      d=\"M10.6663 6V12.6667H5.33301V6H10.6663ZM9.66634 2H6.33301L5.66634 2.66667H3.33301V4H12.6663V2.66667H10.333L9.66634 2ZM11.9997 4.66667H3.99967V12.6667C3.99967 13.4 4.59967 14 5.33301 14H10.6663C11.3997 14 11.9997 13.4 11.9997 12.6667V4.66667Z\"\n                      fill=\"#F9BFBF\" />\n                  </svg>\n                </cqa-button>\n              </div>\n            </div>\n          </div>\n        </div>\n      </div>\n    </div>\n  </div>\n\n  <!-- Response Preview -->\n  <div class=\"cqa-api-edit-step-response\">\n    <h3 class=\"cqa-api-edit-step-response-title\">Response Preview</h3>\n    <pre class=\"cqa-api-edit-step-response-content\">{{ responsePreview }}</pre>\n  </div>\n\n  <!-- Step actions: one row, full width. Step 1: Cancel + Next; Step 2: Back + Next; Step 3: Back + Create -->\n  <div class=\"cqa-api-edit-step-actions\">\n    <ng-container [ngSwitch]=\"currentStep\">\n      <ng-container *ngSwitchCase=\"1\">\n        <cqa-button type=\"button\" variant=\"outlined\" btnSize=\"lg\" text=\"Cancel\"\n          customClass=\"cqa-api-edit-step-actions-btn-cancel\" (clicked)=\"onBack()\">\n        </cqa-button>\n        <cqa-button type=\"button\" variant=\"filled\" btnSize=\"lg\" text=\"Next\"\n          customClass=\"cqa-api-edit-step-actions-btn-next\" (clicked)=\"onNext()\">\n        </cqa-button>\n      </ng-container>\n      <ng-container *ngSwitchCase=\"2\">\n        <cqa-button type=\"button\" variant=\"outlined\" btnSize=\"lg\" text=\"Back\"\n          customClass=\"cqa-api-edit-step-actions-btn-back\" (clicked)=\"onBack()\">\n        </cqa-button>\n        <cqa-button type=\"button\" variant=\"filled\" btnSize=\"lg\" text=\"Next\"\n          customClass=\"cqa-api-edit-step-actions-btn-next\" (clicked)=\"onNext()\">\n        </cqa-button>\n      </ng-container>\n      <ng-container *ngSwitchCase=\"3\">\n        <cqa-button type=\"button\" variant=\"outlined\" btnSize=\"lg\" text=\"Back\"\n          customClass=\"cqa-api-edit-step-actions-btn-back\" (clicked)=\"onBack()\">\n        </cqa-button>\n        <cqa-button type=\"button\" variant=\"filled\" btnSize=\"lg\" text=\"Create\"\n          customClass=\"cqa-api-edit-step-actions-btn-create\" (clicked)=\"onCreate()\">\n        </cqa-button>\n      </ng-container>\n    </ng-container>\n  </div>\n</div>" }]
+        }], ctorParameters: function () { return [{ type: i1.FormBuilder }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { initialMethod: [{
+                type: Input
+            }], initialEnvironment: [{
+                type: Input
+            }], initialStep: [{
+                type: Input
+            }], initialUrl: [{
+                type: Input
+            }], initialPayloadTab: [{
+                type: Input
+            }], initialHeaders: [{
+                type: Input
+            }], initialResponsePreview: [{
+                type: Input
+            }], importCurl: [{
+                type: Output
+            }], importCurlCancel: [{
+                type: Output
+            }], sendRequest: [{
+                type: Output
+            }], back: [{
+                type: Output
+            }], next: [{
+                type: Output
+            }], create: [{
+                type: Output
+            }], headersChange: [{
+                type: Output
+            }], httpMethodOptions: [{
+                type: Input
+            }], environmentOptions: [{
+                type: Input
+            }], formatOptions: [{
+                type: Input
+            }], initialFormat: [{
+                type: Input
+            }], payloadEditorWithLinesRef: [{
+                type: ViewChild,
+                args: ['payloadEditorWithLinesRef']
+            }], payloadTextareaRef: [{
+                type: ViewChild,
+                args: ['payloadTextareaRef']
+            }], headerNameOptions: [{
+                type: Input
+            }], verificationOptions: [{
+                type: Input
+            }], verificationDataTypeOptions: [{
+                type: Input
+            }], statusVerificationOptions: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-edit-step.component.js","sourceRoot":"","sources":["../../../../../../src/lib/test-case-details/api-edit-step/api-edit-step.component.ts","../../../../../../src/lib/test-case-details/api-edit-step/api-edit-step.component.html"],"names":[],"mappings":"AAAA,OAAO,EAEL,uBAAuB,EAEvB,SAAS,EAET,YAAY,EACZ,KAAK,EAIL,MAAM,EAEN,SAAS,GACV,MAAM,eAAe,CAAC;AACvB,OAAO,EAA0B,WAAW,EAAa,MAAM,gBAAgB,CAAC;;;;;;;;;AAIhF,MAAM,CAAC,MAAM,oBAAoB,GAAG;IAClC,eAAe,EAAE,iBAAiB;IAClC,cAAc,EAAE,gBAAgB;IAChC,UAAU,EAAE,YAAY;CAChB,CAAC;AAuEX,MAAM,oBAAoB,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC;AAEvD,8EAA8E;AAC9E,MAAM,wBAAwB,GAA2B,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC;AAQpG,MAAM,OAAO,oBAAoB;IA6rB/B,YACmB,EAAe,EACf,GAAsB;QADtB,OAAE,GAAF,EAAE,CAAa;QACf,QAAG,GAAH,GAAG,CAAmB;QAtrBzC,uFAAuF;QAC7E,eAAU,GAAG,IAAI,YAAY,EAAU,CAAC;QAClD,qEAAqE;QAC3D,qBAAgB,GAAG,IAAI,YAAY,EAAQ,CAAC;QACtD,uFAAuF;QAC7E,gBAAW,GAAG,IAAI,YAAY,EAA6B,CAAC;QAC5D,SAAI,GAAG,IAAI,YAAY,EAAQ,CAAC;QAChC,SAAI,GAAG,IAAI,YAAY,EAAQ,CAAC;QAC1C,kKAAkK;QACxJ,WAAM,GAAG,IAAI,YAAY,EAAwB,CAAC;QAC5D,kHAAkH;QACxG,kBAAa,GAAG,IAAI,YAAY,EAAsB,CAAC;QAEjE,uFAAuF;QAC9E,sBAAiB,GAAG,IAAI,WAAW,CAAC,EAAE,CAAC,CAAC;QAEjD,iBAAY,GAAG,EAAE,CAAC;QAClB,sBAAiB,GAAG,EAAE,CAAC;QAEvB,gFAAgF;QAChF,aAAQ,GAAoB,SAAS,CAAC;QAE7B,eAAU,GAAG;YACpB,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,oBAAoB,CAAC,eAAe,EAAE;YACzD,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,oBAAoB,CAAC,cAAc,EAAE;YACxD,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,oBAAoB,CAAC,UAAU,EAAE;SACrD,CAAC;QACF,gBAAW,GAAG,CAAC,CAAC;QAOC,YAAO,GAAG,CAAC,CAAC;QACZ,YAAO,GAAG,CAAC,CAAC;QAmB7B,yGAAyG;QAChG,sBAAiB,GAA6B,EAAE,CAAC;QAK1D,0GAA0G;QAC1G,uBAAkB,GAA6B;YAC7C,GAAG,EAAE,QAAQ;YACb,WAAW,EAAE,QAAQ;YACrB,UAAU,EAAE,KAAK;YACjB,OAAO,EAAE,EAAE;SACZ,CAAC;QAmBF,yGAAyG;QAChG,uBAAkB,GAA6B,EAAE,CAAC;QAE3D,gHAAgH;QAChH,4BAAuB,GAA6B;YAClD,GAAG,EAAE,aAAa;YAClB,WAAW,EAAE,aAAa;YAC1B,UAAU,EAAE,KAAK;YACjB,OAAO,EAAE,EAAE;SACZ,CAAC;QAuDF,+FAA+F;QACvF,4BAAuB,GAAG,EAAE,CAAC;QAErC,yFAAyF;QACjF,uBAAkB,GAAG,EAAE,CAAC;QAqChC,QAAG,GAAG,EAAE,CAAC;QAEA,gBAAW,GAAkD;YACpE,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,EAAE;YACtC,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE;YAChC,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,QAAQ,EAAE;YACpC,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,EAAE;SACvC,CAAC;QACF,qBAAgB,GAAsB,SAAS,CAAC;QAEhD,yCAAyC;QAChC,6BAAwB,GAA2D;YAC1F,EAAE,KAAK,EAAE,eAAe,EAAE,KAAK,EAAE,eAAe,EAAE;YAClD,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,QAAQ,EAAE;SACrC,CAAC;QACF,kCAA6B,GAA+B,eAAe,CAAC;QAE5E,kFAAkF;QAClF,gBAAW,GAAkD,KAAK,CAAC;QAEnE,qEAAqE;QAC5D,wBAAmB,GAAG;YAC7B,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE;YAC9B,EAAE,KAAK,EAAE,uBAAuB,EAAE,KAAK,EAAE,uBAAuB,EAAE;YAClE,EAAE,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,WAAW,EAAE;SAC3C,CAAC;QASF,wHAAwH;QAC/G,kBAAa,GAA6B,EAAE,CAAC;QAWtD,4FAA4F;QAC5F,8BAAyB,GAA6B;YACpD,GAAG,EAAE,QAAQ;YACb,WAAW,EAAE,QAAQ;YACrB,UAAU,EAAE,KAAK;YACjB,OAAO,EAAE,CAAC,GAAG,oBAAoB,CAAC,sBAAsB,CAAC;SAC1D,CAAC;QAuBF,sDAAsD;QACtD,gBAAW,GAAG,EAAE,CAAC;QAEjB,gGAAgG;QAChG,qBAAgB,GAML,IAAI,CAAC;QAgKhB,iJAAiJ;QACxI,sBAAiB,GAA6B,EAAE,CAAC;QAU1D,+GAA+G;QAC/G,2BAAsB,GAA6B;YACjD,GAAG,EAAE,MAAM;YACX,WAAW,EAAE,eAAe;YAC5B,UAAU,EAAE,IAAI;YAChB,gBAAgB,EAAE,IAAI;YACtB,OAAO,EAAE,EAAE;SACZ,CAAC;QAyCe,mBAAc,GAAuB;YACpD,EAAE,IAAI,EAAE,cAAc,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,kBAAkB,EAAE;SACpE,CAAC;QAgBF,mEAAmE;QAC1D,iCAA4B,GAA6B;YAChE,GAAG,EAAE,MAAM;YACX,WAAW,EAAE,MAAM;YACnB,UAAU,EAAE,KAAK;YACjB,OAAO,EAAE;gBACP,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE;gBAC1D,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE;aAC3D;SACF,CAAC;QASF,sHAAsH;QAC7G,wBAAmB,GAA6B,EAAE,CAAC;QAW5D,wGAAwG;QACxG,6BAAwB,GAA6B;YACnD,GAAG,EAAE,cAAc;YACnB,WAAW,EAAE,QAAQ;YACrB,UAAU,EAAE,KAAK;YACjB,OAAO,EAAE,CAAC,GAAG,oBAAoB,CAAC,4BAA4B,CAAC;SAChE,CAAC;QA4BF,mHAAmH;QAC1G,gCAA2B,GAA6B,EAAE,CAAC;QAUpE,6GAA6G;QAC7G,qCAAgC,GAA6B;YAC3D,GAAG,EAAE,UAAU;YACf,WAAW,EAAE,QAAQ;YACrB,UAAU,EAAE,KAAK;YACjB,OAAO,EAAE,CAAC,GAAG,oBAAoB,CAAC,yBAAyB,CAAC;SAC7D,CAAC;QA4BF,gFAAgF;QACvE,iDAA4C,GAA6B;YAChF,GAAG,EAAE,eAAe;YACpB,WAAW,EAAE,QAAQ;YACrB,UAAU,EAAE,KAAK;YACjB,OAAO,EAAE;gBACP,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE;gBAC1D,EAAE,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE;aAC/D;SACF,CAAC;QASF,+FAA+F;QAC/F,yGAAyG;QAChG,8BAAyB,GAA6B,EAAE,CAAC;QASlE,oGAAoG;QACpG,mCAA8B,GAA6B;YACzD,GAAG,EAAE,cAAc;YACnB,WAAW,EAAE,QAAQ;YACrB,UAAU,EAAE,KAAK;YACjB,OAAO,EAAE,CAAC,GAAG,oBAAoB,CAAC,mCAAmC,CAAC;SACvE,CAAC;QA4BF,oBAAe,GAAG,EAAE,CAAC;IAWlB,CAAC;IA1pBJ,8FAA8F;IAC9F,IAAI,eAAe;QACjB,OAAO,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,WAAW,GAAG,CAAC,CAAC,CAAC;IAC/C,CAAC;IAKD,uFAAuF;IACvF,IAAI,qBAAqB;QACvB,OAAO,CAAC,IAAI,CAAC,WAAW,GAAG,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC;IAC1C,CAAC;IAED,OAAO,CAAC,IAAY;QAClB,IAAI,IAAI,IAAI,IAAI,CAAC,OAAO,IAAI,IAAI,IAAI,IAAI,CAAC,OAAO,EAAE;YAChD,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;SACzB;IACH,CAAC;IAEO,gBAAgB,CAAC,KAAyB;QAChD,IAAI,KAAK,IAAI,IAAI;YAAE,OAAO;QAC1B,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAClF,IAAI,CAAC,WAAW,GAAG,OAAO,CAAC;IAC7B,CAAC;IAgBO,wBAAwB;QAC9B,MAAM,OAAO,GAAG,CAAC,IAAI,CAAC,iBAAiB,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,oBAAoB,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC;QAClG,IAAI,CAAC,kBAAkB,GAAG;YACxB,GAAG,IAAI,CAAC,kBAAkB;YAC1B,OAAO;SACR,CAAC;IACJ,CAAC;IAEO,eAAe;QACrB,OAAO,CAAC,IAAI,CAAC,iBAAiB,IAAI,EAAE,CAAC;aAClC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,oBAAoB,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;aAClD,MAAM,CAAC,CAAC,CAAC,EAAe,EAAE,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC;IAC3C,CAAC;IAgBO,MAAM,CAAC,cAAc,CAAC,IAA4B;QACxD,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE;YAC5B,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;SAC3D;QACD,MAAM,CAAC,GAAG,IAAoB,CAAC;QAC/B,OAAO;YACL,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,KAAK;YACnB,KAAK,EAAE,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,EAAE;YACtB,IAAI,EAAE,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,KAAK,IAAI,MAAM,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,EAAE,CAAC;YAClD,KAAK,EAAE,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,IAAI,IAAI,MAAM,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,EAAE,CAAC;SACpD,CAAC;IACJ,CAAC;IAEO,MAAM,CAAC,cAAc,CAAC,IAA4B;QACxD,IAAI,OAAO,IAAI,KAAK,QAAQ;YAAE,OAAO,IAAI,CAAC;QAC1C,MAAM,CAAC,GAAG,IAAoB,CAAC;QAC/B,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,EAAE,CAAC;QAC1B,OAAO,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IAC3C,CAAC;IAEO,6BAA6B;QACnC,MAAM,OAAO,GAAG,CAAC,IAAI,CAAC,kBAAkB,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,oBAAoB,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC;QACnG,IAAI,CAAC,uBAAuB,GAAG;YAC7B,GAAG,IAAI,CAAC,uBAAuB;YAC/B,OAAO;SACR,CAAC;IACJ,CAAC;IAEO,oBAAoB;QAC1B,OAAO,CAAC,IAAI,CAAC,kBAAkB,IAAI,EAAE,CAAC;aACnC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,oBAAoB,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;aAClD,MAAM,CAAC,CAAC,CAAC,EAAe,EAAE,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC;IAC3C,CAAC;IAED,4GAA4G;IAC5G,IAAI,cAAc;QAChB,MAAM,KAAK,GAAG,IAAI,CAAC,UAAU,EAAE,GAAG,CAAC,QAAQ,CAAC,EAAE,KAAK,CAAC;QACpD,MAAM,UAAU,GAAG,IAAI,CAAC,iBAAiB,EAAE,MAAM;YAC/C,CAAC,CAAC,oBAAoB,CAAC,cAAc,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC;YAChE,CAAC,CAAC,SAAS,CAAC;QACd,MAAM,QAAQ,GAAG,KAAK,IAAI,IAAI,IAAI,KAAK,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,oBAAoB,CAAC,cAAc,CAAC,KAA+B,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QAChL,OAAO,QAAQ,IAAI,UAAU,IAAI,KAAK,CAAC;IACzC,CAAC;IACD,IAAI,cAAc,CAAC,CAAS;QAC1B,IAAI,CAAC,UAAU,EAAE,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC,CAAC;IAC7C,CAAC;IAED,oFAAoF;IACpF,IAAI,mBAAmB;QACrB,MAAM,MAAM,GAAG,IAAI,CAAC,cAAc,IAAI,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAC5F,OAAO,oBAAoB,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;IAC/C,CAAC;IAQD,6GAA6G;IAC7G,IAAI,mBAAmB;QACrB,MAAM,KAAK,GAAG,IAAI,CAAC,eAAe,EAAE,GAAG,CAAC,aAAa,CAAC,EAAE,KAAK,CAAC;QAC9D,MAAM,UAAU,GAAG,IAAI,CAAC,kBAAkB,EAAE,MAAM;YAChD,CAAC,CAAC,oBAAoB,CAAC,cAAc,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC;YACjE,CAAC,CAAC,SAAS,CAAC;QACd,MAAM,QAAQ,GAAG,KAAK,IAAI,IAAI,IAAI,KAAK,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,oBAAoB,CAAC,cAAc,CAAC,KAA+B,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QAChL,OAAO,QAAQ,IAAI,UAAU,IAAI,aAAa,CAAC;IACjD,CAAC;IACD,IAAI,mBAAmB,CAAC,CAAS;QAC/B,IAAI,CAAC,eAAe,EAAE,UAAU,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,CAAC,CAAC;IACvD,CAAC;IAED,yGAAyG;IACzG,4BAA4B,CAAC,KAAsC;QACjE,MAAM,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC;QACtB,IAAI,CAAC,uBAAuB;YAC1B,CAAC,IAAI,IAAI;gBACP,CAAC,CAAC,OAAO,CAAC,KAAK,QAAQ;oBACrB,CAAC,CAAC,CAAC,oBAAoB,CAAC,cAAc,CAAC,CAA2B,CAAC,IAAI,EAAE,CAAC;oBAC1E,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;gBACb,CAAC,CAAC,EAAE,CAAC;IACX,CAAC;IAED,oGAAoG;IACpG,uBAAuB,CAAC,KAAsC;QAC5D,MAAM,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC;QACtB,IAAI,CAAC,kBAAkB;YACrB,CAAC,IAAI,IAAI;gBACP,CAAC,CAAC,OAAO,CAAC,KAAK,QAAQ;oBACrB,CAAC,CAAC,CAAC,oBAAoB,CAAC,cAAc,CAAC,CAA2B,CAAC,IAAI,EAAE,CAAC;oBAC1E,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;gBACb,CAAC,CAAC,EAAE,CAAC;IACX,CAAC;IA6BD,mBAAmB,CAAC,GAAW;QAC7B,IAAI,CAAC,WAAW,GAAG,GAAoD,CAAC;IAC1E,CAAC;IAyBO,+BAA+B;QACrC,MAAM,OAAO,GACX,IAAI,CAAC,aAAa,EAAE,MAAM,GAAG,CAAC;YAC5B,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,oBAAoB,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;YACvE,CAAC,CAAC,oBAAoB,CAAC,sBAAsB,CAAC;QAClD,IAAI,CAAC,yBAAyB,GAAG;YAC/B,GAAG,IAAI,CAAC,yBAAyB;YACjC,OAAO;SACR,CAAC;IACJ,CAAC;IAEO,eAAe;QACrB,MAAM,MAAM,GACV,IAAI,CAAC,aAAa,EAAE,MAAM,GAAG,CAAC;YAC5B,CAAC,CAAC,IAAI,CAAC,aAAa;YACpB,CAAC,CAAE,oBAAoB,CAAC,sBAAmD,CAAC;QAChF,OAAO,MAAM;aACV,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,oBAAoB,CAAC,cAAc,CAAC,CAA2B,CAAC,CAAC;aAC5E,MAAM,CAAC,CAAC,CAAC,EAAe,EAAE,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC;IAC3C,CAAC;IAcD,oFAAoF;IACpF,IAAI,kBAAkB;QACpB,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,WAAW,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC;QACtE,OAAO,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IACpD,CAAC;IAED,6FAA6F;IAC7F,IAAI,mBAAmB;QACrB,MAAM,MAAM,GAAG,IAAI,CAAC,iBAAiB,EAAE,GAAG,CAAC,QAAQ,CAAC,EAAE,KAAK,CAAC;QAC5D,OAAO,MAAM,KAAK,MAAM,CAAC;IAC3B,CAAC;IAED,0EAA0E;IAC1E,IAAI,iBAAiB;QACnB,OAAO,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,gDAAgD,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;IACzF,CAAC;IAED,sGAAsG;IACtG,IAAI,uBAAuB;QACzB,IAAI,CAAC,IAAI,CAAC,gBAAgB;YAAE,OAAO,EAAE,CAAC;QACtC,MAAM,CAAC,GAAG,IAAI,CAAC,gBAAgB,CAAC;QAChC,MAAM,KAAK,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,WAAW,CAAC,GAAG,GAAG,CAAC;QAC9C,OAAO,uBAAuB,CAAC,CAAC,IAAI,QAAQ,CAAC,CAAC,OAAO,KAAK,KAAK,OAAO,CAAC,CAAC,OAAO,EAAE,CAAC;IACpF,CAAC;IAED,mBAAmB,CAAC,KAAa;QAC/B,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC;QACzB,IAAI,CAAC,mBAAmB,EAAE,CAAC;IAC7B,CAAC;IAED,cAAc,CAAC,KAAY;QACzB,MAAM,MAAM,GAAG,KAAK,CAAC,MAAoC,CAAC;QAC1D,IAAI,CAAC,mBAAmB,CAAC,MAAM,EAAE,KAAK,IAAI,EAAE,CAAC,CAAC;IAChD,CAAC;IAED,gBAAgB,CAAC,KAAoB;QACnC,IAAI,CAAC,IAAI,CAAC,mBAAmB;YAAE,OAAO;QACtC,MAAM,GAAG,GAAG,KAAK,CAAC,GAAG,CAAC;QACtB,MAAM,KAAK,GAAG,wBAAwB,CAAC,GAAG,CAAC,CAAC;QAC5C,IAAI,CAAC,KAAK;YAAE,OAAO;QACnB,MAAM,MAAM,GAAG,KAAK,CAAC,MAAoC,CAAC;QAC1D,IAAI,CAAC,MAAM;YAAE,OAAO;QACpB,KAAK,CAAC,cAAc,EAAE,CAAC;QACvB,MAAM,KAAK,GAAG,MAAM,CAAC,cAAc,IAAI,CAAC,CAAC;QACzC,MAAM,GAAG,GAAG,MAAM,CAAC,YAAY,IAAI,KAAK,CAAC;QACzC,MAAM,MAAM,GAAG,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;QAChD,MAAM,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAC1C,MAAM,SAAS,GAAG,KAAK,GAAG,CAAC,CAAC;QAC5B,MAAM,QAAQ,GAAG,MAAM,GAAG,GAAG,GAAG,KAAK,GAAG,KAAK,CAAC;QAC9C,IAAI,CAAC,WAAW,GAAG,QAAQ,CAAC;QAC5B,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAC3B,UAAU,CAAC,GAAG,EAAE;YACd,IAAI,CAAC,kBAAkB,EAAE,aAAa,EAAE,iBAAiB,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;QAClF,CAAC,EAAE,CAAC,CAAC,CAAC;IACR,CAAC;IAED,gFAAgF;IAChF,mBAAmB;QACjB,IAAI,CAAC,IAAI,CAAC,mBAAmB,EAAE;YAC7B,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC;YAC7B,OAAO;SACR;QACD,MAAM,IAAI,GAAG,IAAI,CAAC,WAAW,IAAI,EAAE,CAAC;QACpC,IAAI,IAAI,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE;YACtB,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC;YAC7B,OAAO;SACR;QACD,IAAI;YACF,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YACjB,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC;SAC9B;QAAC,OAAO,GAAG,EAAE;YACZ,MAAM,OAAO,GAAG,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;YACjE,MAAM,QAAQ,GAAG,IAAI,CAAC,4BAA4B,CAAC,OAAO,CAAC,CAAC;YAC5D,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC,oBAAoB,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;YACnE,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;YAClC,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,CAAC,CAAC;YACxC,MAAM,WAAW,GAAG,KAAK,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC;YAC3C,MAAM,OAAO,GAAG,WAAW,IAAI,GAAG,CAAC;YACnC,MAAM,WAAW,GAAG,SAAS,KAAK,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,GAAG,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YAC1F,IAAI,CAAC,gBAAgB,GAAG;gBACtB,IAAI;gBACJ,MAAM;gBACN,OAAO,EAAE,IAAI,CAAC,yBAAyB,CAAC,OAAO,CAAC;gBAChD,OAAO;gBACP,WAAW;aACZ,CAAC;SACH;QACD,IAAI,CAAC,GAAG,CAAC,YAAY,EAAE,CAAC;IAC1B,CAAC;IAEO,4BAA4B,CAAC,OAAe;QAClD,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,mBAAmB,CAAC,IAAI,OAAO,CAAC,KAAK,CAAC,wBAAwB,CAAC,CAAC;QAC5F,OAAO,KAAK,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAC5C,CAAC;IAEO,oBAAoB,CAAC,IAAY,EAAE,QAAgB;QACzD,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,QAAQ,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;QAC9D,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QACpC,MAAM,IAAI,GAAG,KAAK,CAAC,MAAM,CAAC;QAC1B,MAAM,QAAQ,GAAG,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC;QAC/C,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;IAC/C,CAAC;IAEO,yBAAyB,CAAC,OAAe;QAC/C,IAAI,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAC;YAAE,OAAO,OAAO,CAAC;QACnF,MAAM,UAAU,GAAG,OAAO,CAAC,KAAK,CAAC,wCAAwC,CAAC;eACrE,OAAO,CAAC,KAAK,CAAC,kCAAkC,CAAC,CAAC;QACvD,MAAM,KAAK,GAAG,UAAU,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,WAAW,CAAC;QAC9D,OAAO,yEAAyE,KAAK,GAAG,CAAC;IAC3F,CAAC;IAuDD,4EAA4E;IAC5E,IAAI,UAAU;QACZ,OAAO,CAAC,IAAI,CAAC,gBAAgB,EAAE,QAAQ,IAAI,EAAE,CAAgB,CAAC;IAChE,CAAC;IAWO,4BAA4B;QAClC,MAAM,MAAM,GACV,IAAI,CAAC,iBAAiB,EAAE,MAAM,GAAG,CAAC;YAChC,CAAC,CAAC,IAAI,CAAC,iBAAiB;YACxB,CAAC,CAAE,oBAAoB,CAAC,2BAAwD,CAAC;QACrF,MAAM,WAAW,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,oBAAoB,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC;QAC9E,MAAM,UAAU,GAAG,IAAI,GAAG,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC;QACzG,MAAM,oBAAoB,GAAG,IAAI,CAAC,6BAA6B,EAAE,CAAC;QAClE,MAAM,YAAY,GAAmB,EAAE,CAAC;QACxC,KAAK,MAAM,IAAI,IAAI,oBAAoB,EAAE;YACvC,MAAM,GAAG,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC;YACxB,IAAI,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;gBAC/B,UAAU,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;gBACpB,YAAY,CAAC,IAAI,CAAC,EAAE,EAAE,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,CAAC;aACnE;SACF;QACD,MAAM,OAAO,GAAG,CAAC,GAAG,WAAW,EAAE,GAAG,YAAY,CAAC,CAAC;QAClD,IAAI,CAAC,sBAAsB,GAAG;YAC5B,GAAG,IAAI,CAAC,sBAAsB;YAC9B,OAAO;SACR,CAAC;IACJ,CAAC;IAED,oGAAoG;IAC5F,6BAA6B;QACnC,MAAM,KAAK,GAAa,EAAE,CAAC;QAC3B,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAC;QAC/B,IAAI,CAAC,IAAI,CAAC,gBAAgB,EAAE,QAAQ,EAAE,MAAM;YAAE,OAAO,KAAK,CAAC;QAC3D,KAAK,MAAM,OAAO,IAAI,IAAI,CAAC,gBAAgB,CAAC,QAAQ,EAAE;YACpD,MAAM,IAAI,GAAI,OAAqB,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,KAAK,CAAC;YACvD,MAAM,GAAG,GAAG,IAAI,IAAI,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YACpD,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;gBACzB,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;gBACd,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;aACjB;SACF;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IASD,IAAI,YAAY;QACd,OAAO,CAAC,IAAI,CAAC,iBAAiB,EAAE,QAAQ,IAAI,EAAE,CAAgB,CAAC;IACjE,CAAC;IAKD,IAAI,gBAAgB;QAClB,OAAO,CAAC,IAAI,CAAC,qBAAqB,EAAE,QAAQ,IAAI,EAAE,CAAgB,CAAC;IACrE,CAAC;IAgBD,IAAI,gBAAgB;QAClB,OAAO,CAAC,IAAI,CAAC,qBAAqB,EAAE,QAAQ,IAAI,EAAE,CAAgB,CAAC;IACrE,CAAC;IAsBO,8BAA8B;QACpC,MAAM,OAAO,GACX,IAAI,CAAC,mBAAmB,EAAE,MAAM,GAAG,CAAC;YAClC,CAAC,CAAC,IAAI,CAAC,mBAAmB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,oBAAoB,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;YAC7E,CAAC,CAAC,oBAAoB,CAAC,4BAA4B,CAAC;QACxD,IAAI,CAAC,wBAAwB,GAAG;YAC9B,GAAG,IAAI,CAAC,wBAAwB;YAChC,OAAO;SACR,CAAC;IACJ,CAAC;IAEO,qBAAqB;QAC3B,MAAM,MAAM,GACV,IAAI,CAAC,mBAAmB,EAAE,MAAM,GAAG,CAAC;YAClC,CAAC,CAAC,IAAI,CAAC,mBAAmB;YAC1B,CAAC,CAAE,oBAAoB,CAAC,4BAAyD,CAAC;QACtF,OAAO,MAAM;aACV,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,oBAAoB,CAAC,cAAc,CAAC,CAA2B,CAAC,CAAC;aAC5E,MAAM,CAAC,CAAC,CAAC,EAAe,EAAE,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC;IAC3C,CAAC;IAEO,sBAAsB;QAC5B,MAAM,MAAM,GAAG,IAAI,CAAC,qBAAqB,EAAE,CAAC;QAC5C,OAAO,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC;IAClD,CAAC;IAqBO,sCAAsC;QAC5C,MAAM,OAAO,GACX,IAAI,CAAC,2BAA2B,EAAE,MAAM,GAAG,CAAC;YAC1C,CAAC,CAAC,IAAI,CAAC,2BAA2B,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,oBAAoB,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;YACrF,CAAC,CAAC,oBAAoB,CAAC,yBAAyB,CAAC;QACrD,IAAI,CAAC,gCAAgC,GAAG;YACtC,GAAG,IAAI,CAAC,gCAAgC;YACxC,OAAO;SACR,CAAC;IACJ,CAAC;IAEO,iBAAiB;QACvB,MAAM,MAAM,GACV,IAAI,CAAC,2BAA2B,EAAE,MAAM,GAAG,CAAC;YAC1C,CAAC,CAAC,IAAI,CAAC,2BAA2B;YAClC,CAAC,CAAE,oBAAoB,CAAC,yBAAsD,CAAC;QACnF,OAAO,MAAM;aACV,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,oBAAoB,CAAC,cAAc,CAAC,CAA2B,CAAC,CAAC;aAC5E,MAAM,CAAC,CAAC,CAAC,EAAe,EAAE,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC;IAC3C,CAAC;IAEO,kBAAkB;QACxB,MAAM,MAAM,GAAG,IAAI,CAAC,iBAAiB,EAAE,CAAC;QACxC,OAAO,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC;IAClD,CAAC;IAgBD,IAAI,sBAAsB;QACxB,OAAO,CAAC,IAAI,CAAC,2BAA2B,EAAE,QAAQ,IAAI,EAAE,CAAgB,CAAC;IAC3E,CAAC;IAqBO,oCAAoC;QAC1C,MAAM,OAAO,GACX,IAAI,CAAC,yBAAyB,EAAE,MAAM,GAAG,CAAC;YACxC,CAAC,CAAC,IAAI,CAAC,yBAAyB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,oBAAoB,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;YACnF,CAAC,CAAC,oBAAoB,CAAC,mCAAmC,CAAC;QAC/D,IAAI,CAAC,8BAA8B,GAAG;YACpC,GAAG,IAAI,CAAC,8BAA8B;YACtC,OAAO;SACR,CAAC;IACJ,CAAC;IAEO,2BAA2B;QACjC,MAAM,MAAM,GACV,IAAI,CAAC,yBAAyB,EAAE,MAAM,GAAG,CAAC;YACxC,CAAC,CAAC,IAAI,CAAC,yBAAyB;YAChC,CAAC,CAAE,oBAAoB,CAAC,mCAAgE,CAAC;QAC7F,OAAO,MAAM;aACV,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,oBAAoB,CAAC,cAAc,CAAC,CAA2B,CAAC,CAAC;aAC5E,MAAM,CAAC,CAAC,CAAC,EAAe,EAAE,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC;IAC3C,CAAC;IAEO,4BAA4B;QAClC,MAAM,MAAM,GAAG,IAAI,CAAC,2BAA2B,EAAE,CAAC;QAClD,OAAO,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC;IAClD,CAAC;IAeD,QAAQ;QACN,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QACxC,IAAI,CAAC,wBAAwB,EAAE,CAAC;QAChC,IAAI,CAAC,4BAA4B,EAAE,CAAC;QACpC,MAAM,gBAAgB,GAAG,IAAI,CAAC,iBAAiB,EAAE,MAAM;YACrD,CAAC,CAAC,oBAAoB,CAAC,cAAc,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC;YAChE,CAAC,CAAC,SAAS,CAAC;QACd,MAAM,aAAa,GAAG,IAAI,CAAC,aAAa,IAAI,gBAAgB,IAAI,KAAK,CAAC;QACtE,IAAI,CAAC,kBAAkB,GAAG,OAAO,aAAa,KAAK,QAAQ,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,oBAAoB,CAAC,cAAc,CAAC,aAAuC,CAAC,IAAI,EAAE,CAAC,CAAC;QACnK,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC;YAC9B,MAAM,EAAE,CAAC,aAAa,CAAC;SACxB,CAAC,CAAC;QACH,MAAM,UAAU,GAAG,IAAI,CAAC,kBAAkB,EAAE,MAAM;YAChD,CAAC,CAAC,oBAAoB,CAAC,cAAc,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC;YACjE,CAAC,CAAC,SAAS,CAAC;QACd,MAAM,UAAU,GAAG,IAAI,CAAC,kBAAkB,IAAI,UAAU,IAAI,aAAa,CAAC;QAC1E,IAAI,CAAC,uBAAuB,GAAG,OAAO,UAAU,KAAK,QAAQ,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,oBAAoB,CAAC,cAAc,CAAC,UAAoC,CAAC,IAAI,EAAE,CAAC,CAAC;QAC/J,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC;YACnC,WAAW,EAAE,CAAC,UAAU,CAAC;SAC1B,CAAC,CAAC;QACH,IAAI,CAAC,yBAAyB,GAAG,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,aAAa,CAAC,EAAE,YAAY,EAAE,SAAS,CAAC,CAAC,CAAU,EAAE,EAAE;YAC/G,MAAM,CAAC,GAAG,CAAC,IAAI,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,oBAAoB,CAAC,cAAc,CAAC,CAA2B,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;YAC9I,IAAI,CAAC,uBAAuB,GAAG,CAAC,IAAI,EAAE,CAAC;QACzC,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,YAAY,EAAE,SAAS,CAAC,CAAC,CAAU,EAAE,EAAE;YAChG,MAAM,CAAC,GAAG,CAAC,IAAI,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,oBAAoB,CAAC,cAAc,CAAC,CAA2B,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;YAC9I,IAAI,CAAC,kBAAkB,GAAG,CAAC,IAAI,EAAE,CAAC;QACpC,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,qBAAqB,CACxB,IAAI,CAAC,cAAc,IAAI,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,CACjE,CAAC;QACF,IAAI,CAAC,2BAA2B,GAAG,IAAI,CAAC,gBAAgB,EAAE,YAAY,EAAE,SAAS,CAAC,GAAG,EAAE;YACrF,IAAI,CAAC,4BAA4B,EAAE,CAAC;YACpC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACxC,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,4BAA4B,EAAE,CAAC;QACpC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACtC,IAAI,CAAC,6BAA6B,EAAE,CAAC;QACrC,IAAI,CAAC,+BAA+B,EAAE,CAAC;QACvC,MAAM,gBAAgB,GAAG,IAAI,CAAC,eAAe,EAAE,CAAC,CAAC,CAAC,CAAC;QACnD,MAAM,aAAa,GAAG,IAAI,CAAC,aAAa,IAAI,gBAAgB,IAAI,MAAM,CAAC;QACvE,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC,aAAa,CAAC,EAAE,CAAC,CAAC;QACpE,IAAI,CAAC,sBAAsB,EAAE,CAAC;QAC9B,IAAI,CAAC,0BAA0B,EAAE,CAAC;QAClC,IAAI,CAAC,8BAA8B,EAAE,CAAC;QACtC,IAAI,CAAC,sCAAsC,EAAE,CAAC;QAC9C,IAAI,CAAC,0BAA0B,EAAE,CAAC;QAClC,IAAI,CAAC,oCAAoC,EAAE,CAAC;QAC5C,IAAI,CAAC,gCAAgC,EAAE,CAAC;QACxC,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,YAAY,EAAE,SAAS,CAAC,CAAC,KAAa,EAAE,EAAE;YAC/F,MAAM,MAAM,GAAG,KAAK,IAAI,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YAChE,IAAI,oBAAoB,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,IAAI,CAAC,gBAAgB,KAAK,SAAS,EAAE;gBAChF,IAAI,CAAC,gBAAgB,GAAG,SAAS,CAAC;gBAClC,IAAI,CAAC,GAAG,CAAC,aAAa,EAAE,CAAC;aAC1B;QACH,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,YAAY,EAAE,SAAS,CAAC,GAAG,EAAE;YACzF,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAC7B,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,mBAAmB,EAAE,CAAC;IAC7B,CAAC;IAED,eAAe;QACb,IAAI,CAAC,8BAA8B,EAAE,CAAC;IACxC,CAAC;IAED,WAAW;QACT,IAAI,CAAC,gBAAgB,EAAE,WAAW,EAAE,CAAC;QACrC,IAAI,CAAC,gBAAgB,EAAE,WAAW,EAAE,CAAC;QACrC,IAAI,CAAC,2BAA2B,EAAE,WAAW,EAAE,CAAC;QAChD,IAAI,CAAC,yBAAyB,EAAE,WAAW,EAAE,CAAC;QAC9C,IAAI,CAAC,oBAAoB,EAAE,WAAW,EAAE,CAAC;IAC3C,CAAC;IAED,oFAAoF;IAC5E,8BAA8B;QACpC,UAAU,CAAC,GAAG,EAAE;YACd,MAAM,IAAI,GAAG,IAAI,CAAC,yBAAyB,EAAE,aAAa,CAAC;YAC3D,IAAI,CAAC,IAAI;gBAAE,OAAO;YAClB,MAAM,aAAa,GAAG,IAAI,CAAC,aAAa,CAAC,yCAAyC,CAAuB,CAAC;YAC1G,MAAM,QAAQ,GAAG,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC;YAChD,IAAI,CAAC,aAAa,IAAI,CAAC,QAAQ;gBAAE,OAAO;YACxC,QAAQ,CAAC,gBAAgB,CAAC,QAAQ,EAAE,GAAG,EAAE;gBACvC,aAAa,CAAC,SAAS,GAAG,QAAQ,CAAC,SAAS,CAAC;YAC/C,CAAC,CAAC,CAAC;QACL,CAAC,EAAE,CAAC,CAAC,CAAC;IACR,CAAC;IAEO,sBAAsB,CAAC,IAAuC;QACpE,MAAM,OAAO,GAAG,IAAI,IAAI,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,CAAC;QACjD,MAAM,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC;QACrF,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;IACjD,CAAC;IAEO,0BAA0B,CAAC,IAAqD;QACtF,MAAM,OAAO,GAAG,IAAI,IAAI,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,CAAC;QAC/D,MAAM,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC;QACrG,IAAI,CAAC,qBAAqB,GAAG,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;IACrD,CAAC;IAEO,0BAA0B,CAAC,IAA4F;QAC7H,MAAM,mBAAmB,GAAG,IAAI,CAAC,sBAAsB,EAAE,CAAC;QAC1D,MAAM,eAAe,GAAG,IAAI,CAAC,kBAAkB,EAAE,CAAC;QAClD,MAAM,OAAO,GAAG,IAAI,IAAI,CAAC,EAAE,QAAQ,EAAE,EAAE,EAAE,YAAY,EAAE,mBAAmB,EAAE,QAAQ,EAAE,eAAe,EAAE,aAAa,EAAE,EAAE,EAAE,CAAC,CAAC;QAC5H,MAAM,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAC/B,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC;YACZ,QAAQ,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC;YACtB,YAAY,EAAE,CAAC,CAAC,CAAC,YAAY,CAAC;YAC9B,QAAQ,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC;YACtB,aAAa,EAAE,CAAC,CAAC,CAAC,aAAa,CAAC;SACjC,CAAC,CACH,CAAC;QACF,IAAI,CAAC,qBAAqB,GAAG,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;IACrD,CAAC;IAEO,gCAAgC,CAAC,IAAwD;QAC/F,MAAM,mBAAmB,GAAG,IAAI,CAAC,4BAA4B,EAAE,CAAC;QAChE,MAAM,OAAO,GAAG,IAAI,IAAI,CAAC,EAAE,YAAY,EAAE,mBAAmB,EAAE,aAAa,EAAE,EAAE,EAAE,CAAC,CAAC;QACnF,MAAM,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAC/B,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC;YACZ,YAAY,EAAE,CAAC,CAAC,CAAC,YAAY,CAAC;YAC9B,aAAa,EAAE,CAAC,CAAC,CAAC,aAAa,CAAC;SACjC,CAAC,CACH,CAAC;QACF,IAAI,CAAC,2BAA2B,GAAG,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;IAC3D,CAAC;IAEO,qBAAqB,CAAC,IAAwB;QACpD,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAC5B,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC;YACZ,IAAI,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;YACd,KAAK,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC;SACjB,CAAC,CACH,CAAC;QACF,IAAI,IAAI,CAAC,gBAAgB,EAAE;YACzB,IAAI,CAAC,gBAAgB,CAAC,KAAK,EAAE,CAAC;YAC9B,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;SACtD;aAAM;YACL,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;SAC/C;IACH,CAAC;IAED,mFAAmF;IACnF,mBAAmB;QACjB,IAAI,CAAC,QAAQ,GAAG,aAAa,CAAC;QAC9B,IAAI,CAAC,GAAG,CAAC,aAAa,EAAE,CAAC;IAC3B,CAAC;IAED,oGAAoG;IACpG,mBAAmB;QACjB,MAAM,KAAK,GAAG,IAAI,CAAC,iBAAiB,CAAC,KAAK,IAAI,EAAE,CAAC;QACjD,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;QAC7D,IAAI,CAAC,oBAAoB,EAAE,CAAC;IAC9B,CAAC;IAED,iGAAiG;IACjG,kBAAkB;QAChB,IAAI,CAAC,gBAAgB,CAAC,IAAI,EAAE,CAAC;QAC7B,IAAI,CAAC,oBAAoB,EAAE,CAAC;IAC9B,CAAC;IAED,0FAA0F;IAC1F,oBAAoB;QAClB,IAAI,CAAC,QAAQ,GAAG,SAAS,CAAC;QAC1B,IAAI,CAAC,GAAG,CAAC,aAAa,EAAE,CAAC;IAC3B,CAAC;IAED,aAAa;QACX,MAAM,WAAW,GAAG,IAAI,CAAC,mBAAmB,IAAI,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QAC7F,MAAM,MAAM,GAAG,IAAI,CAAC,cAAc,IAAI,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QAC9E,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC;YACpB,WAAW;YACX,MAAM;YACN,GAAG,EAAE,IAAI,CAAC,GAAG,IAAI,EAAE;YACnB,OAAO,EAAE,IAAI,CAAC,OAAO;SACtB,CAAC,CAAC;IACL,CAAC;IAED,oBAAoB;QAClB,IAAI,CAAC,iBAAiB,GAAG,EAAE,CAAC;IAC9B,CAAC;IAED,MAAM;QACJ,IAAI,IAAI,CAAC,WAAW,GAAG,CAAC,EAAE;YACxB,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,WAAW,GAAG,CAAC,CAAC,CAAC;SACpC;aAAM;YACL,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;SAClB;IACH,CAAC;IAED,MAAM;QACJ,IAAI,IAAI,CAAC,WAAW,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,IAAI,EAAE,EAAE;YACxD,IAAI,CAAC,iBAAiB,GAAG,4BAA4B,CAAC;YACtD,OAAO;SACR;QACD,IAAI,CAAC,iBAAiB,GAAG,EAAE,CAAC;QAC5B,IAAI,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE;YAC7C,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,WAAW,GAAG,CAAC,CAAC,CAAC;SACpC;aAAM;YACL,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;SAClB;IACH,CAAC;IAED,aAAa,CAAC,KAAwB;QACpC,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC;IAChC,CAAC;IAED,0BAA0B,CAAC,KAAiC;QAC1D,IAAI,CAAC,6BAA6B,GAAG,KAAK,CAAC;IAC7C,CAAC;IAED,SAAS;QACP,IAAI,CAAC,gBAAgB,CAAC,IAAI,CACxB,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAC3C,CAAC;IACJ,CAAC;IAED,YAAY,CAAC,KAAa;QACxB,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IACxC,CAAC;IAED,oGAAoG;IACpG,0BAA0B,CAAC,KAAqC,EAAE,GAAc;QAC9E,MAAM,OAAO,GAAG,GAAG,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QACnC,IAAI,OAAO,IAAI,KAAK,CAAC,KAAK,IAAI,IAAI,EAAE;YAClC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC;SACtC;IACH,CAAC;IAED,aAAa,CAAC,KAAa;QACzB,OAAO,KAAK,CAAC;IACf,CAAC;IAED,cAAc;QACZ,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IACzE,CAAC;IAED,iBAAiB,CAAC,KAAa;QAC7B,IAAI,CAAC,iBAAiB,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IACzC,CAAC;IAED,eAAe,CAAC,KAAa;QAC3B,OAAO,KAAK,CAAC;IACf,CAAC;IAED,kBAAkB;QAChB,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAC7F,CAAC;IAED,qBAAqB,CAAC,KAAa;QACjC,IAAI,CAAC,qBAAqB,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IAC7C,CAAC;IAED,mBAAmB,CAAC,KAAa;QAC/B,OAAO,KAAK,CAAC;IACf,CAAC;IAED,kBAAkB;QAChB,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAC7B,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC;YACZ,QAAQ,EAAE,CAAC,EAAE,CAAC;YACd,YAAY,EAAE,CAAC,IAAI,CAAC,sBAAsB,EAAE,CAAC;YAC7C,QAAQ,EAAE,CAAC,IAAI,CAAC,kBAAkB,EAAE,CAAC;YACrC,aAAa,EAAE,CAAC,EAAE,CAAC;SACpB,CAAC,CACH,CAAC;IACJ,CAAC;IAED,qBAAqB,CAAC,KAAa;QACjC,IAAI,CAAC,qBAAqB,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IAC7C,CAAC;IAED,mBAAmB,CAAC,KAAa;QAC/B,OAAO,KAAK,CAAC;IACf,CAAC;IAED,+FAA+F;IAC/F,4BAA4B,CAAC,GAAc,EAAE,KAAsC;QACjF,IAAI,KAAK,CAAC,GAAG,KAAK,UAAU,EAAE;YAC5B,GAAG,CAAC,GAAG,CAAC,eAAe,CAAC,EAAE,QAAQ,CAAC,EAAE,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,CAAC;SAC9D;IACH,CAAC;IAED,wBAAwB;QACtB,IAAI,CAAC,2BAA2B,CAAC,IAAI,CACnC,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE,YAAY,EAAE,CAAC,IAAI,CAAC,4BAA4B,EAAE,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAC5F,CAAC;IACJ,CAAC;IAED,2BAA2B,CAAC,KAAa;QACvC,IAAI,CAAC,2BAA2B,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IACnD,CAAC;IAED,yBAAyB,CAAC,KAAa;QACrC,OAAO,KAAK,CAAC;IACf,CAAC;IAED,4IAA4I;IAC5I,QAAQ;QACN,OAAO,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QAEvB,IAAI;YACF,MAAM,OAAO,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAC;YACxC,OAAO,CAAC,GAAG,CAAC,iBAAiB,EAAE,OAAO,CAAC,CAAC;YACxC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;SAC3B;QAAC,OAAO,GAAG,EAAE;YACZ,OAAO,CAAC,KAAK,CAAC,qCAAqC,EAAE,GAAG,CAAC,CAAC;YAC1D,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,wBAAwB,EAAE,CAAC,CAAC;SACnD;IACH,CAAC;IAED,6EAA6E;IACrE,wBAAwB;QAC9B,OAAO;YACL,KAAK,EAAE;gBACL,WAAW,EAAE,EAAE;gBACf,MAAM,EAAE,EAAE;gBACV,GAAG,EAAE,IAAI,CAAC,GAAG,IAAI,EAAE;gBACnB,OAAO,EAAE,EAAE;gBACX,gBAAgB,EAAE,IAAI,CAAC,gBAAgB;gBACvC,WAAW,EAAE,IAAI,CAAC,WAAW;gBAC7B,aAAa,EAAE,EAAE;gBACjB,WAAW,EAAE,IAAI,CAAC,WAAW,IAAI,EAAE;gBACnC,YAAY,EAAE,EAAE;gBAChB,gBAAgB,EAAE,EAAE;aACrB;YACD,KAAK,EAAE,EAAE,YAAY,EAAE,IAAI,CAAC,YAAY,IAAI,EAAE,EAAE;YAChD,KAAK,EAAE;gBACL,6BAA6B,EAAE,IAAI,CAAC,6BAA6B;gBACjE,yBAAyB,EAAE,EAAE;gBAC7B,mBAAmB,EAAE,EAAE;aACxB;SACF,CAAC;IACJ,CAAC;IAED,yEAAyE;IACjE,MAAM,CAAC,eAAe,CAAC,OAA8C;QAC3E,MAAM,CAAC,GAAG,OAAO,EAAE,KAAK,CAAC;QACzB,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,KAAK,EAAE;YAAE,OAAO,EAAE,CAAC;QACrC,OAAO,OAAO,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,oBAAoB,CAAC,cAAc,CAAC,CAA2B,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;IACtH,CAAC;IAED,qIAAqI;IAC7H,gBAAgB;QACtB,MAAM,WAAW,GAAG,oBAAoB,CAAC,eAAe,CAAC,IAAI,CAAC,eAAe,EAAE,GAAG,CAAC,aAAa,CAA8B,CAAC,CAAC;QAChI,MAAM,WAAW,GACf,WAAW,KAAK,EAAE,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,uBAAuB,KAAK,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,uBAAuB,CAAC,CAAC,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;QACrI,MAAM,cAAc,GAAG,oBAAoB,CAAC,eAAe,CAAC,IAAI,CAAC,UAAU,EAAE,GAAG,CAAC,QAAQ,CAA8B,CAAC,CAAC;QACzH,MAAM,MAAM,GACV,cAAc,KAAK,EAAE,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,kBAAkB,KAAK,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;QAC5H,MAAM,MAAM,GAAG,IAAI,CAAC,iBAAiB,EAAE,GAAG,CAAC,QAAQ,CAAC,EAAE,KAAK,IAAI,EAAE,CAAC;QAClE,MAAM,iBAAiB,GAAG,IAAI,CAAC,iBAAiB,CAAC;QACjD,MAAM,YAAY,GAAG,CAAC,iBAAiB,EAAE,QAAQ,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;YACnE,GAAG,EAAG,CAAe,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,KAAK,IAAI,EAAE;YAC7C,KAAK,EAAG,CAAe,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,KAAK,IAAI,EAAE;SAClD,CAAC,CAAC,CAAC;QACJ,MAAM,qBAAqB,GAAG,IAAI,CAAC,qBAAqB,CAAC;QACzD,MAAM,gBAAgB,GAAG,CAAC,qBAAqB,EAAE,QAAQ,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;YAC3E,GAAG,EAAG,CAAe,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,KAAK,IAAI,EAAE;YAC7C,IAAI,EAAG,CAAe,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,KAAK,IAAI,MAAM;YACnD,KAAK,EAAG,CAAe,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,KAAK,IAAI,EAAE;SAClD,CAAC,CAAC,CAAC;QACJ,MAAM,qBAAqB,GAAG,IAAI,CAAC,qBAAqB,CAAC;QACzD,MAAM,yBAAyB,GAAG,CAAC,qBAAqB,EAAE,QAAQ,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;YACpF,QAAQ,EAAG,CAAe,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,KAAK,IAAI,EAAE;YACvD,YAAY,EAAG,CAAe,CAAC,GAAG,CAAC,cAAc,CAAC,EAAE,KAAK,IAAI,EAAE;YAC/D,QAAQ,EAAG,CAAe,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,KAAK,IAAI,EAAE;YACvD,aAAa,EAAG,CAAe,CAAC,GAAG,CAAC,eAAe,CAAC,EAAE,KAAK,IAAI,EAAE;SAClE,CAAC,CAAC,CAAC;QACJ,MAAM,2BAA2B,GAAG,IAAI,CAAC,2BAA2B,CAAC;QACrE,MAAM,mBAAmB,GAAG,CAAC,2BAA2B,EAAE,QAAQ,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;YACpF,YAAY,EAAG,CAAe,CAAC,GAAG,CAAC,cAAc,CAAC,EAAE,KAAK,IAAI,EAAE;YAC/D,aAAa,EAAG,CAAe,CAAC,GAAG,CAAC,eAAe,CAAC,EAAE,KAAK,IAAI,EAAE;SAClE,CAAC,CAAC,CAAC;QACJ,OAAO;YACL,KAAK,EAAE;gBACL,WAAW;gBACX,MAAM;gBACN,GAAG,EAAE,IAAI,CAAC,GAAG,IAAI,EAAE;gBACnB,OAAO,EAAE,IAAI,CAAC,OAAO;gBACrB,gBAAgB,EAAE,IAAI,CAAC,gBAAgB;gBACvC,WAAW,EAAE,IAAI,CAAC,WAAW;gBAC7B,aAAa,EAAE,MAAM;gBACrB,WAAW,EAAE,IAAI,CAAC,WAAW,IAAI,EAAE;gBACnC,YAAY;gBACZ,gBAAgB;aACjB;YACD,KAAK,EAAE;gBACL,YAAY,EAAE,IAAI,CAAC,YAAY,IAAI,EAAE;aACtC;YACD,KAAK,EAAE;gBACL,6BAA6B,EAAE,IAAI,CAAC,6BAA6B;gBACjE,yBAAyB;gBACzB,mBAAmB;aACpB;SACF,CAAC;IACJ,CAAC;IAED,sEAAsE;IACtE,IAAI,OAAO;QACT,IAAI,CAAC,IAAI,CAAC,gBAAgB;YAAE,OAAO,EAAE,CAAC;QACtC,OAAO,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;YAChD,IAAI,EAAG,CAAe,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,KAAK,IAAI,EAAE;YAC/C,IAAI,EAAE,QAAQ;YACd,KAAK,EAAG,CAAe,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,KAAK,IAAI,EAAE;SAClD,CAAC,CAAC,CAAC;IACN,CAAC;IAED,WAAW,CAAC,OAAsB;QAChC,IAAI,OAAO,CAAC,eAAe,CAAC,EAAE,YAAY,IAAI,IAAI,IAAI,IAAI,CAAC,UAAU,EAAE;YACrE,MAAM,CAAC,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC,YAAY,CAAC;YAChD,IAAI,CAAC,kBAAkB,GAAG,OAAO,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,oBAAoB,CAAC,cAAc,CAAC,CAA2B,CAAC,IAAI,EAAE,CAAC,CAAC;YAC/H,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC,CAAC;SAC3C;QACD,IAAI,OAAO,CAAC,mBAAmB,CAAC,EAAE;YAChC,IAAI,CAAC,wBAAwB,EAAE,CAAC;YAChC,IAAI,IAAI,CAAC,UAAU,IAAI,IAAI,CAAC,iBAAiB,EAAE,MAAM,EAAE;gBACrD,MAAM,OAAO,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,KAAK,CAAC;gBACrD,MAAM,MAAM,GAAG,IAAI,CAAC,eAAe,EAAE,CAAC;gBACtC,MAAM,KAAK,GAAG,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;gBACvC,IAAI,CAAC,KAAK,EAAE;oBACV,MAAM,UAAU,GAAG,oBAAoB,CAAC,cAAc,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,CAAC;oBAClF,IAAI,UAAU,IAAI,IAAI,EAAE;wBACtB,IAAI,CAAC,kBAAkB,GAAG,UAAU,CAAC;wBACrC,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC,EAAE,MAAM,EAAE,UAAU,EAAE,CAAC,CAAC;qBACpD;iBACF;aACF;SACF;QACD,IAAI,OAAO,CAAC,oBAAoB,CAAC,EAAE,YAAY,IAAI,IAAI,IAAI,IAAI,CAAC,eAAe,EAAE;YAC/E,MAAM,CAAC,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAAC,YAAY,CAAC;YACrD,IAAI,CAAC,uBAAuB,GAAG,OAAO,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,oBAAoB,CAAC,cAAc,CAAC,CAA2B,CAAC,IAAI,EAAE,CAAC,CAAC;YACpI,IAAI,CAAC,eAAe,CAAC,UAAU,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,CAAC,CAAC;SACrD;QACD,IAAI,OAAO,CAAC,oBAAoB,CAAC,EAAE;YACjC,IAAI,CAAC,6BAA6B,EAAE,CAAC;YACrC,IAAI,IAAI,CAAC,eAAe,IAAI,IAAI,CAAC,kBAAkB,EAAE,MAAM,EAAE;gBAC3D,MAAM,OAAO,GAAG,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,aAAa,CAAC,EAAE,KAAK,CAAC;gBAC/D,MAAM,MAAM,GAAG,IAAI,CAAC,oBAAoB,EAAE,CAAC;gBAC3C,MAAM,KAAK,GAAG,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;gBACvC,IAAI,CAAC,KAAK,EAAE;oBACV,MAAM,UAAU,GAAG,oBAAoB,CAAC,cAAc,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,CAAC;oBACnF,IAAI,UAAU,IAAI,IAAI,EAAE;wBACtB,IAAI,CAAC,uBAAuB,GAAG,UAAU,CAAC;wBAC1C,IAAI,CAAC,eAAe,CAAC,UAAU,CAAC,EAAE,WAAW,EAAE,UAAU,EAAE,CAAC,CAAC;qBAC9D;iBACF;aACF;SACF;QACD,IAAI,OAAO,CAAC,aAAa,CAAC,EAAE;YAC1B,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC,YAAY,CAAC,CAAC;SAC5D;QACD,IAAI,OAAO,CAAC,YAAY,CAAC,EAAE,YAAY,IAAI,IAAI,EAAE;YAC/C,IAAI,CAAC,GAAG,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC,YAAY,CAAC;SAC/C;QACD,IAAI,OAAO,CAAC,mBAAmB,CAAC,EAAE,YAAY,IAAI,IAAI,EAAE;YACtD,IAAI,CAAC,gBAAgB,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAAC,YAAY,CAAC;SACnE;QACD,IAAI,OAAO,CAAC,mBAAmB,CAAC,EAAE;YAChC,IAAI,CAAC,4BAA4B,EAAE,CAAC;SACrC;QACD,IAAI,OAAO,CAAC,gBAAgB,CAAC,EAAE,YAAY,IAAI,IAAI,EAAE;YACnD,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAAC,gBAAgB,CAAC,CAAC,YAAkC,CAAC,CAAC;YACzF,IAAI,CAAC,4BAA4B,EAAE,CAAC;SACrC;QACD,IAAI,OAAO,CAAC,wBAAwB,CAAC,EAAE,YAAY,IAAI,IAAI,EAAE;YAC3D,IAAI,CAAC,eAAe,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAAC,YAAY,CAAC;SACvE;QACD,IAAI,OAAO,CAAC,eAAe,CAAC,EAAE,YAAY,IAAI,IAAI,IAAI,IAAI,CAAC,iBAAiB,EAAE;YAC5E,IAAI,CAAC,iBAAiB,CAAC,UAAU,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,eAAe,CAAC,CAAC,YAAY,EAAE,CAAC,CAAC;SACtF;QACD,IAAI,OAAO,CAAC,eAAe,CAAC,EAAE;YAC5B,IAAI,CAAC,+BAA+B,EAAE,CAAC;YACvC,IAAI,IAAI,CAAC,iBAAiB,EAAE;gBAC1B,MAAM,OAAO,GAAG,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,KAAK,CAAC;gBAC5D,MAAM,MAAM,GAAG,IAAI,CAAC,eAAe,EAAE,CAAC;gBACtC,MAAM,KAAK,GAAG,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;gBACvC,IAAI,CAAC,KAAK,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE;oBAC/B,MAAM,UAAU,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;oBAC7B,IAAI,CAAC,iBAAiB,CAAC,UAAU,CAAC,EAAE,MAAM,EAAE,UAAU,EAAE,CAAC,CAAC;iBAC3D;aACF;SACF;QACD,IAAI,OAAO,CAAC,qBAAqB,CAAC,EAAE;YAClC,IAAI,CAAC,8BAA8B,EAAE,CAAC;YACtC,MAAM,MAAM,GAAG,IAAI,CAAC,qBAAqB,EAAE,CAAC;YAC5C,MAAM,mBAAmB,GAAG,IAAI,CAAC,sBAAsB,EAAE,CAAC;YAC1D,IAAI,IAAI,CAAC,qBAAqB,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE;gBACnD,IAAI,CAAC,qBAAqB,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;oBACtD,MAAM,OAAO,GAAI,OAAqB,CAAC,GAAG,CAAC,cAAc,CAAC,EAAE,KAAK,CAAC;oBAClE,IAAI,OAAO,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE;wBACvC,OAAqB,CAAC,UAAU,CAAC,EAAE,YAAY,EAAE,mBAAmB,EAAE,CAAC,CAAC;qBAC1E;gBACH,CAAC,CAAC,CAAC;aACJ;SACF;QACD,IAAI,OAAO,CAAC,6BAA6B,CAAC,EAAE;YAC1C,IAAI,CAAC,sCAAsC,EAAE,CAAC;YAC9C,MAAM,MAAM,GAAG,IAAI,CAAC,iBAAiB,EAAE,CAAC;YACxC,MAAM,eAAe,GAAG,IAAI,CAAC,kBAAkB,EAAE,CAAC;YAClD,IAAI,IAAI,CAAC,qBAAqB,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE;gBACnD,IAAI,CAAC,qBAAqB,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;oBACtD,MAAM,OAAO,GAAI,OAAqB,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,KAAK,CAAC;oBAC9D,IAAI,OAAO,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE;wBACvC,OAAqB,CAAC,UAAU,CAAC,EAAE,QAAQ,EAAE,eAAe,EAAE,CAAC,CAAC;qBAClE;gBACH,CAAC,CAAC,CAAC;aACJ;SACF;QACD,IAAI,OAAO,CAAC,2BAA2B,CAAC,EAAE;YACxC,IAAI,CAAC,oCAAoC,EAAE,CAAC;YAC5C,MAAM,MAAM,GAAG,IAAI,CAAC,2BAA2B,EAAE,CAAC;YAClD,MAAM,mBAAmB,GAAG,IAAI,CAAC,4BAA4B,EAAE,CAAC;YAChE,IAAI,IAAI,CAAC,2BAA2B,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE;gBACzD,IAAI,CAAC,2BAA2B,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;oBAC5D,MAAM,OAAO,GAAI,OAAqB,CAAC,GAAG,CAAC,cAAc,CAAC,EAAE,KAAK,CAAC;oBAClE,IAAI,OAAO,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE;wBACvC,OAAqB,CAAC,UAAU,CAAC,EAAE,YAAY,EAAE,mBAAmB,EAAE,CAAC,CAAC;qBAC1E;gBACH,CAAC,CAAC,CAAC;aACJ;SACF;IACH,CAAC;;AA99BuB,2CAAsB,GAAmB;IAC/D,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE;IAC1D,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE;IACtD,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE;IAC1D,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE;CAC1D,CAAA;AA6JsB,gDAA2B,GAAa;IAC9D,QAAQ;IACR,gBAAgB;IAChB,iBAAiB;IACjB,iBAAiB;IACjB,gCAAgC;IAChC,+BAA+B;IAC/B,eAAe;IACf,eAAe;IACf,aAAa;IACb,gBAAgB;IAChB,2BAA2B;IAC3B,cAAc;IACd,QAAQ;IACR,MAAM;IACN,QAAQ;IACR,MAAM;IACN,MAAM;IACN,UAAU;IACV,mBAAmB;IACnB,eAAe;IACf,qBAAqB;IACrB,UAAU;IACV,YAAY;IACZ,cAAc;IACd,QAAQ;IACR,QAAQ;IACR,qBAAqB;IACrB,OAAO;IACP,SAAS;IACT,IAAI;IACJ,SAAS;IACT,mBAAmB;IACnB,SAAS;IACT,YAAY;IACZ,KAAK;IACL,SAAS;IACT,kBAAkB;IAClB,gBAAgB;IAChB,KAAK;IACL,WAAW;IACX,YAAY;CACZ,CAAA;AAoGsB,iDAA4B,GAAmB;IACrE,EAAE,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,QAAQ,EAAE;IAClE,EAAE,EAAE,EAAE,WAAW,EAAE,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,WAAW,EAAE;IAC9E,EAAE,EAAE,EAAE,WAAW,EAAE,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,WAAW,EAAE;IAC9E,EAAE,EAAE,EAAE,cAAc,EAAE,KAAK,EAAE,cAAc,EAAE,IAAI,EAAE,cAAc,EAAE,KAAK,EAAE,cAAc,EAAE;IAC1F,EAAE,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,EAAE;IACtE,EAAE,EAAE,EAAE,aAAa,EAAE,KAAK,EAAE,aAAa,EAAE,IAAI,EAAE,aAAa,EAAE,KAAK,EAAE,aAAa,EAAE;CACtF,CAAA;AAuCsB,8CAAyB,GAAmB;IAClE,EAAE,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,QAAQ,EAAE;IAClE,EAAE,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,QAAQ,EAAE;IAClE,EAAE,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,EAAE;IACtE,EAAE,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE;IAC9D,EAAE,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,QAAQ,EAAE;CAClE,CAAA;AA0DsB,wDAAmC,GAAmB;IAC5E,EAAE,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,QAAQ,EAAE;IAClE,EAAE,EAAE,EAAE,WAAW,EAAE,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,WAAW,EAAE;IAC9E,EAAE,EAAE,EAAE,WAAW,EAAE,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,WAAW,EAAE;IAC9E,EAAE,EAAE,EAAE,cAAc,EAAE,KAAK,EAAE,cAAc,EAAE,IAAI,EAAE,cAAc,EAAE,KAAK,EAAE,cAAc,EAAE;CAC1F,CAAA;iHAjpBS,oBAAoB;qGAApB,oBAAoB,moCCzGjC,+v4BA4aM;2FDnUO,oBAAoB;kBANhC,SAAS;+BACE,mBAAmB,QAEvB,EAAE,KAAK,EAAE,aAAa,EAAE,mBACb,uBAAuB,CAAC,OAAO;kIAGvC,aAAa;sBAArB,KAAK;gBACG,kBAAkB;sBAA1B,KAAK;gBACG,WAAW;sBAAnB,KAAK;gBACG,UAAU;sBAAlB,KAAK;gBACG,iBAAiB;sBAAzB,KAAK;gBACG,cAAc;sBAAtB,KAAK;gBACG,sBAAsB;sBAA9B,KAAK;gBAGI,UAAU;sBAAnB,MAAM;gBAEG,gBAAgB;sBAAzB,MAAM;gBAEG,WAAW;sBAApB,MAAM;gBACG,IAAI;sBAAb,MAAM;gBACG,IAAI;sBAAb,MAAM;gBAEG,MAAM;sBAAf,MAAM;gBAEG,aAAa;sBAAtB,MAAM;gBA4CE,iBAAiB;sBAAzB,KAAK;gBA+BG,kBAAkB;sBAA1B,KAAK;gBA2IG,aAAa;sBAArB,KAAK;gBAEG,aAAa;sBAArB,KAAK;gBAiKkC,yBAAyB;sBAAhE,SAAS;uBAAC,2BAA2B;gBACL,kBAAkB;sBAAlD,SAAS;uBAAC,oBAAoB;gBA+CtB,iBAAiB;sBAAzB,KAAK;gBA+FG,mBAAmB;sBAA3B,KAAK;gBA8CG,2BAA2B;sBAAnC,KAAK;gBAgEG,yBAAyB;sBAAjC,KAAK","sourcesContent":["import {\n  AfterViewInit,\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  ElementRef,\n  EventEmitter,\n  Input,\n  OnChanges,\n  OnDestroy,\n  OnInit,\n  Output,\n  SimpleChanges,\n  ViewChild,\n} from '@angular/core';\nimport { FormArray, FormBuilder, FormControl, FormGroup } from '@angular/forms';\nimport { Subscription } from 'rxjs';\nimport { DynamicSelectFieldConfig, SelectOption } from '../../dynamic-select/dynamic-select-field.component';\n\nexport const API_EDIT_STEP_LABELS = {\n  REQUEST_DETAILS: 'Request Details',\n  STORE_RESPONSE: 'Store Response',\n  VALIDATION: 'Validation',\n} as const;\n\nexport type ApiEditPayloadTab = 'headers' | 'body' | 'params' | 'scripts';\n\n/** Which body content block is visible: headers (tabs) or import cURL textarea. */\nexport type ApiEditBodyView = 'headers' | 'import-curl';\n\nexport interface ApiEditHeaderRow {\n  name: string;\n  type: string;\n  value: string;\n}\n\n/** Payload emitted when user clicks Send Request (environment, method, url, headers). */\nexport interface ApiEditSendRequestPayload {\n  environment: string;\n  method: string;\n  url: string;\n  headers: ApiEditHeaderRow[];\n}\n\n/** Step 1 request + body payload. */\nexport interface ApiEditStep1Payload {\n  environment: string;\n  method: string;\n  url: string;\n  headers: ApiEditHeaderRow[];\n  activePayloadTab: ApiEditPayloadTab;\n  payloadType: 'raw' | 'x-www-form-urlencoded' | 'form-data';\n  payloadFormat: string;\n  payloadText: string;\n  keyValueRows: { key: string; value: string }[];\n  keyTypeValueRows: { key: string; type: string; value: string }[];\n}\n\n/** Step 2 store-response payload. */\nexport interface ApiEditStep2Payload {\n  variableName: string;\n}\n\n/** Response body verification row. */\nexport interface ApiEditResponseBodyVerificationRow {\n  jsonPath: string;\n  verification: string;\n  dataType: string;\n  expectedValue: string;\n}\n\n/** Status verification row. */\nexport interface ApiEditStatusVerificationRow {\n  verification: string;\n  expectedValue: string;\n}\n\n/** Step 3 validation payload. */\nexport interface ApiEditStep3Payload {\n  activeResponseVerificationTab: 'response-body' | 'status';\n  responseBodyVerifications: ApiEditResponseBodyVerificationRow[];\n  statusVerifications: ApiEditStatusVerificationRow[];\n}\n\n/** Full payload emitted when user clicks Create (all steps’ data). */\nexport interface ApiEditCreatePayload {\n  step1: ApiEditStep1Payload;\n  step2: ApiEditStep2Payload;\n  step3: ApiEditStep3Payload;\n}\n\n/** Environment option: either a string (display = value) or an object with id, name, value, label. */\nexport type EnvironmentOptionInput = string | SelectOption;\n\nconst METHODS_WITHOUT_BODY = ['GET', 'HEAD', 'DELETE'];\n\n/** Auto-close pairs for payload JSON editor: opening char -> closing char. */\nconst PAYLOAD_AUTO_CLOSE_PAIRS: Record<string, string> = { '{': '}', '[': ']', '\"': '\"', \"'\": \"'\" };\n\n@Component({\n  selector: 'cqa-api-edit-step',\n  templateUrl: './api-edit-step.component.html',\n  host: { class: 'cqa-ui-root' },\n  changeDetection: ChangeDetectionStrategy.Default,\n})\nexport class ApiEditStepComponent implements OnChanges, OnInit, AfterViewInit, OnDestroy {\n  @Input() initialMethod?: string;\n  @Input() initialEnvironment?: string;\n  @Input() initialStep?: number;\n  @Input() initialUrl?: string;\n  @Input() initialPayloadTab?: ApiEditPayloadTab;\n  @Input() initialHeaders?: ApiEditHeaderRow[];\n  @Input() initialResponsePreview?: string;\n\n  /** Emits the cURL string when user clicks Import (value from the textarea control). */\n  @Output() importCurl = new EventEmitter<string>();\n  /** Emits when user cancels the Import cURL panel (clicks Cancel). */\n  @Output() importCurlCancel = new EventEmitter<void>();\n  /** Emits when user clicks Send Request, with environment, method, url, and headers. */\n  @Output() sendRequest = new EventEmitter<ApiEditSendRequestPayload>();\n  @Output() back = new EventEmitter<void>();\n  @Output() next = new EventEmitter<void>();\n  /** Emits when user clicks Create with all entered details: step1 (environment, HTTP method, URL, headers, body), step2 (variable name), step3 (verifications). */\n  @Output() create = new EventEmitter<ApiEditCreatePayload>();\n  /** Emits whenever headers change (add, remove, or edit) so the parent can reflect them in the canvas/controls. */\n  @Output() headersChange = new EventEmitter<ApiEditHeaderRow[]>();\n\n  /** Form control for Import cURL textarea; value is emitted when user clicks Import. */\n  readonly importCurlControl = new FormControl('');\n\n  variableName = '';\n  variableNameError = '';\n\n  /** Controls which body content is visible: headers (default) or import-curl. */\n  bodyView: ApiEditBodyView = 'headers';\n\n  readonly stepLabels = [\n    { index: 1, label: API_EDIT_STEP_LABELS.REQUEST_DETAILS },\n    { index: 2, label: API_EDIT_STEP_LABELS.STORE_RESPONSE },\n    { index: 3, label: API_EDIT_STEP_LABELS.VALIDATION },\n  ];\n  currentStep = 1;\n\n  /** The label for the current step only (used when showing a single step in the indicator). */\n  get activeStepLabel(): { index: number; label: string } | undefined {\n    return this.stepLabels[this.currentStep - 1];\n  }\n\n  private readonly minStep = 1;\n  private readonly maxStep = 3;\n\n  /** Percentage to translate the step strip (0, -33.333, -66.666) for CSS transition. */\n  get stripTranslatePercent(): number {\n    return (this.currentStep - 1) * -33.333;\n  }\n\n  setStep(step: number): void {\n    if (step >= this.minStep && step <= this.maxStep) {\n      this.currentStep = step;\n    }\n  }\n\n  private applyInitialStep(value: number | undefined): void {\n    if (value == null) return;\n    const clamped = Math.max(this.minStep, Math.min(this.maxStep, Math.floor(value)));\n    this.currentStep = clamped;\n  }\n\n  /** HTTP method options: array of strings or objects with id, name, value, label (passed from parent). */\n  @Input() httpMethodOptions: EnvironmentOptionInput[] = [];\n\n  /** Form for HTTP method select (cqa-dynamic-select) */\n  methodForm!: FormGroup;\n\n  /** Config for method dropdown (updated when httpMethodOptions changes to avoid new reference every CD) */\n  methodSelectConfig: DynamicSelectFieldConfig = {\n    key: 'method',\n    placeholder: 'Method',\n    searchable: false,\n    options: [],\n  };\n\n  private updateMethodSelectConfig(): void {\n    const options = (this.httpMethodOptions ?? []).map((m) => ApiEditStepComponent.toSelectOption(m));\n    this.methodSelectConfig = {\n      ...this.methodSelectConfig,\n      options,\n    };\n  }\n\n  private getMethodValues(): string[] {\n    return (this.httpMethodOptions ?? [])\n      .map((m) => ApiEditStepComponent.getOptionValue(m))\n      .filter((v): v is string => v != null);\n  }\n\n  /** Form for environment select (cqa-dynamic-select) */\n  environmentForm!: FormGroup;\n\n  /** Environment options: array of strings or objects with id, name, value, label (passed from parent). */\n  @Input() environmentOptions: EnvironmentOptionInput[] = [];\n\n  /** Config for environment dropdown (updated when environmentOptions changes to avoid new reference every CD) */\n  environmentSelectConfig: DynamicSelectFieldConfig = {\n    key: 'environment',\n    placeholder: 'Environment',\n    searchable: false,\n    options: [],\n  };\n\n  private static toSelectOption(item: EnvironmentOptionInput): SelectOption {\n    if (typeof item === 'string') {\n      return { id: item, value: item, name: item, label: item };\n    }\n    const o = item as SelectOption;\n    return {\n      id: o.id ?? o.value,\n      value: o.value ?? o.id,\n      name: o.name ?? o.label ?? String(o.value ?? o.id),\n      label: o.label ?? o.name ?? String(o.value ?? o.id),\n    };\n  }\n\n  private static getOptionValue(item: EnvironmentOptionInput): string | undefined {\n    if (typeof item === 'string') return item;\n    const o = item as SelectOption;\n    const v = o.value ?? o.id;\n    return v != null ? String(v) : undefined;\n  }\n\n  private updateEnvironmentSelectConfig(): void {\n    const options = (this.environmentOptions ?? []).map((e) => ApiEditStepComponent.toSelectOption(e));\n    this.environmentSelectConfig = {\n      ...this.environmentSelectConfig,\n      options,\n    };\n  }\n\n  private getEnvironmentValues(): string[] {\n    return (this.environmentOptions ?? [])\n      .map((e) => ApiEditStepComponent.getOptionValue(e))\n      .filter((v): v is string => v != null);\n  }\n\n  /** Current HTTP method (from form or default: first of httpMethodOptions). Treats empty string as unset. */\n  get selectedMethod(): string {\n    const value = this.methodForm?.get('method')?.value;\n    const firstValue = this.httpMethodOptions?.length\n      ? ApiEditStepComponent.getOptionValue(this.httpMethodOptions[0])\n      : undefined;\n    const resolved = value != null && value !== '' ? (typeof value === 'object' ? ApiEditStepComponent.getOptionValue(value as EnvironmentOptionInput) : String(value)) : undefined;\n    return resolved ?? firstValue ?? 'GET';\n  }\n  set selectedMethod(v: string) {\n    this.methodForm?.patchValue({ method: v });\n  }\n\n  /** True when the selected HTTP method is GET, HEAD, or DELETE (no request body). */\n  get isMethodWithoutBody(): boolean {\n    const method = this.selectedMethod != null ? String(this.selectedMethod).toUpperCase() : '';\n    return METHODS_WITHOUT_BODY.includes(method);\n  }\n\n  /** Cached environment value from last selection (so Create payload has the selected value). */\n  private currentEnvironmentValue = '';\n\n  /** Cached HTTP method from last selection (so Create payload has the selected value). */\n  private currentMethodValue = '';\n\n  /** Current environment (from form or default: first of environmentOptions). Treats empty string as unset. */\n  get selectedEnvironment(): string {\n    const value = this.environmentForm?.get('environment')?.value;\n    const firstValue = this.environmentOptions?.length\n      ? ApiEditStepComponent.getOptionValue(this.environmentOptions[0])\n      : undefined;\n    const resolved = value != null && value !== '' ? (typeof value === 'object' ? ApiEditStepComponent.getOptionValue(value as EnvironmentOptionInput) : String(value)) : undefined;\n    return resolved ?? firstValue ?? 'Development';\n  }\n  set selectedEnvironment(v: string) {\n    this.environmentForm?.patchValue({ environment: v });\n  }\n\n  /** Called when user selects an environment; keeps currentEnvironmentValue in sync for create payload. */\n  onEnvironmentSelectionChange(event: { key: string; value: unknown }): void {\n    const v = event.value;\n    this.currentEnvironmentValue =\n      v != null\n        ? typeof v === 'object'\n          ? (ApiEditStepComponent.getOptionValue(v as EnvironmentOptionInput) ?? '')\n          : String(v)\n        : '';\n  }\n\n  /** Called when user selects an HTTP method; keeps currentMethodValue in sync for create payload. */\n  onMethodSelectionChange(event: { key: string; value: unknown }): void {\n    const v = event.value;\n    this.currentMethodValue =\n      v != null\n        ? typeof v === 'object'\n          ? (ApiEditStepComponent.getOptionValue(v as EnvironmentOptionInput) ?? '')\n          : String(v)\n        : '';\n  }\n\n  url = '';\n\n  readonly payloadTabs: { value: ApiEditPayloadTab; label: string }[] = [\n    { value: 'headers', label: 'Headers' },\n    { value: 'body', label: 'Body' },\n    { value: 'params', label: 'Params' },\n    { value: 'scripts', label: 'Scripts' },\n  ];\n  activePayloadTab: ApiEditPayloadTab = 'headers';\n\n  /** Step 3: Response verification tabs */\n  readonly responseVerificationTabs: { value: 'response-body' | 'status'; label: string }[] = [\n    { value: 'response-body', label: 'Response Body' },\n    { value: 'status', label: 'Status' },\n  ];\n  activeResponseVerificationTab: 'response-body' | 'status' = 'response-body';\n\n  /** Payload type for Body/Params/Scripts: raw, x-www-form-urlencoded, form-data */\n  payloadType: 'raw' | 'x-www-form-urlencoded' | 'form-data' = 'raw';\n\n  /** Segment options for payload type (used by cqa-segment-control) */\n  readonly payloadTypeSegments = [\n    { label: 'Raw', value: 'raw' },\n    { label: 'x-www-form-urlencoded', value: 'x-www-form-urlencoded' },\n    { label: 'Form Data', value: 'form-data' },\n  ];\n\n  onPayloadTypeChange(val: string): void {\n    this.payloadType = val as 'raw' | 'x-www-form-urlencoded' | 'form-data';\n  }\n\n  /** Form for Format select (Body/Params/Scripts) */\n  payloadFormatForm!: FormGroup;\n\n  /** Format options: array of strings or objects (passed from parent). Falls back to JSON, XML, HTML, Text when empty. */\n  @Input() formatOptions: EnvironmentOptionInput[] = [];\n\n  @Input() initialFormat?: string;\n\n  private static readonly DEFAULT_FORMAT_OPTIONS: SelectOption[] = [\n    { id: 'json', value: 'json', name: 'JSON', label: 'JSON' },\n    { id: 'xml', value: 'xml', name: 'XML', label: 'XML' },\n    { id: 'html', value: 'html', name: 'HTML', label: 'HTML' },\n    { id: 'text', value: 'text', name: 'Text', label: 'Text' },\n  ];\n\n  /** Config for Format dropdown (updated when formatOptions changes, like Method dropdown) */\n  payloadFormatSelectConfig: DynamicSelectFieldConfig = {\n    key: 'format',\n    placeholder: 'Select',\n    searchable: false,\n    options: [...ApiEditStepComponent.DEFAULT_FORMAT_OPTIONS],\n  };\n\n  private updatePayloadFormatSelectConfig(): void {\n    const options =\n      this.formatOptions?.length > 0\n        ? this.formatOptions.map((f) => ApiEditStepComponent.toSelectOption(f))\n        : ApiEditStepComponent.DEFAULT_FORMAT_OPTIONS;\n    this.payloadFormatSelectConfig = {\n      ...this.payloadFormatSelectConfig,\n      options,\n    };\n  }\n\n  private getFormatValues(): string[] {\n    const source =\n      this.formatOptions?.length > 0\n        ? this.formatOptions\n        : (ApiEditStepComponent.DEFAULT_FORMAT_OPTIONS as EnvironmentOptionInput[]);\n    return source\n      .map((f) => ApiEditStepComponent.getOptionValue(f as EnvironmentOptionInput))\n      .filter((v): v is string => v != null);\n  }\n\n  /** Payload text area value for Body/Params/Scripts */\n  payloadText = '';\n\n  /** JSON parse error when format is JSON and payload is invalid; null when valid or not JSON. */\n  payloadJsonError: {\n    line: number;\n    column: number;\n    message: string;\n    excerpt: string;\n    caretOffset: number;\n  } | null = null;\n\n  /** Line numbers for payload textarea (1, 2, 3, ...) based on current line count. */\n  get payloadLineNumbers(): number[] {\n    const n = Math.max(1, (this.payloadText || '').split(/\\r?\\n/).length);\n    return Array.from({ length: n }, (_, i) => i + 1);\n  }\n\n  /** Whether current payload format is JSON (so we validate and show JSON editor behavior). */\n  get isPayloadFormatJson(): boolean {\n    const format = this.payloadFormatForm?.get('format')?.value;\n    return format === 'json';\n  }\n\n  /** Error messages for the payload textarea (red border + bottom line). */\n  get payloadJsonErrors(): string[] {\n    return this.payloadJsonError ? ['Invalid JSON format. Please check your syntax.'] : [];\n  }\n\n  /** Tooltip content for the line-level error icon (parse error on line X, excerpt, caret, message). */\n  get payloadJsonErrorTooltip(): string {\n    if (!this.payloadJsonError) return '';\n    const e = this.payloadJsonError;\n    const caret = ' '.repeat(e.caretOffset) + '^';\n    return `Parse error on line ${e.line}:\\n\\n${e.excerpt}\\n${caret}\\n\\n${e.message}`;\n  }\n\n  onPayloadTextChange(value: string): void {\n    this.payloadText = value;\n    this.validatePayloadJson();\n  }\n\n  onPayloadInput(event: Event): void {\n    const target = event.target as HTMLTextAreaElement | null;\n    this.onPayloadTextChange(target?.value ?? '');\n  }\n\n  onPayloadKeydown(event: KeyboardEvent): void {\n    if (!this.isPayloadFormatJson) return;\n    const key = event.key;\n    const close = PAYLOAD_AUTO_CLOSE_PAIRS[key];\n    if (!close) return;\n    const target = event.target as HTMLTextAreaElement | null;\n    if (!target) return;\n    event.preventDefault();\n    const start = target.selectionStart ?? 0;\n    const end = target.selectionEnd ?? start;\n    const before = this.payloadText.slice(0, start);\n    const after = this.payloadText.slice(end);\n    const insertPos = start + 1;\n    const newValue = before + key + close + after;\n    this.payloadText = newValue;\n    this.validatePayloadJson();\n    setTimeout(() => {\n      this.payloadTextareaRef?.nativeElement?.setSelectionRange(insertPos, insertPos);\n    }, 0);\n  }\n\n  /** Validate payload when format is JSON; sets payloadJsonError or clears it. */\n  validatePayloadJson(): void {\n    if (!this.isPayloadFormatJson) {\n      this.payloadJsonError = null;\n      return;\n    }\n    const text = this.payloadText ?? '';\n    if (text.trim() === '') {\n      this.payloadJsonError = null;\n      return;\n    }\n    try {\n      JSON.parse(text);\n      this.payloadJsonError = null;\n    } catch (err) {\n      const message = err instanceof Error ? err.message : String(err);\n      const position = this.extractPositionFromJsonError(message);\n      const { line, column } = this.positionToLineColumn(text, position);\n      const lines = text.split(/\\r?\\n/);\n      const lineIndex = Math.max(0, line - 1);\n      const lineContent = lines[lineIndex] ?? '';\n      const excerpt = lineContent || ' ';\n      const caretOffset = lineIndex === line - 1 ? Math.min(column - 1, lineContent.length) : 0;\n      this.payloadJsonError = {\n        line,\n        column,\n        message: this.normalizeJsonErrorMessage(message),\n        excerpt,\n        caretOffset,\n      };\n    }\n    this.cdr.markForCheck();\n  }\n\n  private extractPositionFromJsonError(message: string): number {\n    const match = message.match(/position\\s+(\\d+)/i) || message.match(/at\\s+position\\s+(\\d+)/i);\n    return match ? parseInt(match[1], 10) : 0;\n  }\n\n  private positionToLineColumn(text: string, position: number): { line: number; column: number } {\n    const before = text.slice(0, Math.min(position, text.length));\n    const lines = before.split(/\\r?\\n/);\n    const line = lines.length;\n    const lastLine = lines[lines.length - 1] ?? '';\n    return { line, column: lastLine.length + 1 };\n  }\n\n  private normalizeJsonErrorMessage(message: string): string {\n    if (message.includes('Expecting') || message.includes('expecting')) return message;\n    const tokenMatch = message.match(/Unexpected token\\s+['\"]?([^'\"]+)['\"]?/i)\n      || message.match(/unexpected character.*?([^\\s]+)/i);\n    const token = tokenMatch ? tokenMatch[1].trim() : 'undefined';\n    return `Expecting 'STRING', 'NUMBER', 'NULL', 'TRUE', 'FALSE', '{', '[', got '${token}'`;\n  }\n\n  @ViewChild('payloadEditorWithLinesRef') payloadEditorWithLinesRef?: ElementRef<HTMLElement>;\n  @ViewChild('payloadTextareaRef') payloadTextareaRef?: ElementRef<HTMLTextAreaElement>;\n\n  private static readonly DEFAULT_HEADER_NAME_OPTIONS: string[] = [\n    'Accept',\n    'Accept-Charset',\n    'Accept-Encoding',\n    'Accept-Language',\n    'Access-Control-Request-Headers',\n    'Access-Control-Request-Method',\n    'Authorization',\n    'Cache-Control',\n    'Content-MD5',\n    'Content-Length',\n    'Content-Transfer-Encoding',\n    'Content-Type',\n    'Cookie',\n    'Date',\n    'Expect',\n    'From',\n    'Host',\n    'If-Match',\n    'If-Modified-Since',\n    'If-None-Match',\n    'If-Unmodified-Since',\n    'If-Range',\n    'Keep-Alive',\n    'Max-Forwards',\n    'Origin',\n    'Pragma',\n    'Proxy-Authorization',\n    'Range',\n    'Referer',\n    'TE',\n    'Trailer',\n    'Transfer-Encoding',\n    'Upgrade',\n    'User-Agent',\n    'Via',\n    'Warning',\n    'X-Requested-With',\n    'X-Do-Not-Track',\n    'DNT',\n    'x-api-key',\n    'Connection',\n  ];\n\n  /** Header name options: array of strings or objects with id, name, value, label (passed from parent). Falls back to built-in list when empty. */\n  @Input() headerNameOptions: EnvironmentOptionInput[] = [];\n\n  /** Form array for header rows; each item is FormGroup({ name, value }) for cqa-dynamic-select and value input */\n  headersFormArray!: FormArray;\n\n  /** Typed accessor for template (FormArray.controls is AbstractControl[]) */\n  get headerRows(): FormGroup[] {\n    return (this.headersFormArray?.controls ?? []) as FormGroup[];\n  }\n\n  /** Config for header name dropdown (updated when headerNameOptions changes to avoid new reference every CD) */\n  headerNameSelectConfig: DynamicSelectFieldConfig = {\n    key: 'name',\n    placeholder: 'Select header',\n    searchable: true,\n    allowCustomValue: true,\n    options: [],\n  };\n\n  private updateHeaderNameSelectConfig(): void {\n    const source =\n      this.headerNameOptions?.length > 0\n        ? this.headerNameOptions\n        : (ApiEditStepComponent.DEFAULT_HEADER_NAME_OPTIONS as EnvironmentOptionInput[]);\n    const baseOptions = source.map((h) => ApiEditStepComponent.toSelectOption(h));\n    const baseValues = new Set(baseOptions.map((o) => String(o.value ?? o.id ?? '').trim()).filter(Boolean));\n    const currentNamesFromForm = this.getCurrentHeaderNamesFromForm();\n    const extraOptions: SelectOption[] = [];\n    for (const name of currentNamesFromForm) {\n      const key = name.trim();\n      if (key && !baseValues.has(key)) {\n        baseValues.add(key);\n        extraOptions.push({ id: key, value: key, name: key, label: key });\n      }\n    }\n    const options = [...baseOptions, ...extraOptions];\n    this.headerNameSelectConfig = {\n      ...this.headerNameSelectConfig,\n      options,\n    };\n  }\n\n  /** Collects distinct non-empty header names currently in the headers form (for dynamic options). */\n  private getCurrentHeaderNamesFromForm(): string[] {\n    const names: string[] = [];\n    const seen = new Set<string>();\n    if (!this.headersFormArray?.controls?.length) return names;\n    for (const control of this.headersFormArray.controls) {\n      const name = (control as FormGroup).get('name')?.value;\n      const str = name != null ? String(name).trim() : '';\n      if (str && !seen.has(str)) {\n        seen.add(str);\n        names.push(str);\n      }\n    }\n    return names;\n  }\n\n  private readonly defaultHeaders: ApiEditHeaderRow[] = [\n    { name: 'Content-Type', type: 'string', value: 'application/json' },\n  ];\n\n  /** Form array for key-value rows (Body payload); each item is FormGroup({ key, value }) */\n  keyValueFormArray!: FormArray;\n\n  get keyValueRows(): FormGroup[] {\n    return (this.keyValueFormArray?.controls ?? []) as FormGroup[];\n  }\n\n  /** Form array for key-type-value rows; each item is FormGroup({ key, type, value }) */\n  keyTypeValueFormArray!: FormArray;\n\n  get keyTypeValueRows(): FormGroup[] {\n    return (this.keyTypeValueFormArray?.controls ?? []) as FormGroup[];\n  }\n\n  /** Config for Type dropdown in key-type-value rows (Text, File) */\n  readonly keyTypeValueTypeSelectConfig: DynamicSelectFieldConfig = {\n    key: 'type',\n    placeholder: 'Text',\n    searchable: false,\n    options: [\n      { id: 'text', value: 'text', name: 'Text', label: 'Text' },\n      { id: 'file', value: 'file', name: 'File', label: 'File' },\n    ],\n  };\n\n  /** Form array for response body verification rows; each item is FormGroup({ jsonPath, verification, dataType, expectedValue }) */\n  verificationFormArray!: FormArray;\n\n  get verificationRows(): FormGroup[] {\n    return (this.verificationFormArray?.controls ?? []) as FormGroup[];\n  }\n\n  /** Verification options: array of strings or objects (passed from parent). Falls back to built-in list when empty. */\n  @Input() verificationOptions: EnvironmentOptionInput[] = [];\n\n  private static readonly DEFAULT_VERIFICATION_OPTIONS: SelectOption[] = [\n    { id: 'equals', value: 'equals', name: 'Equals', label: 'Equals' },\n    { id: 'not-equal', value: 'not-equal', name: 'Not equal', label: 'Not equal' },\n    { id: 'less-than', value: 'less-than', name: 'Less than', label: 'Less than' },\n    { id: 'greater-than', value: 'greater-than', name: 'Greater than', label: 'Greater than' },\n    { id: 'is-null', value: 'is-null', name: 'Is null', label: 'Is null' },\n    { id: 'is-not-null', value: 'is-not-null', name: 'Is not null', label: 'Is not null' },\n  ];\n\n  /** Config for Verification dropdown (updated when verificationOptions changes, like Method dropdown) */\n  verificationSelectConfig: DynamicSelectFieldConfig = {\n    key: 'verification',\n    placeholder: 'Equals',\n    searchable: false,\n    options: [...ApiEditStepComponent.DEFAULT_VERIFICATION_OPTIONS],\n  };\n\n  private updateVerificationSelectConfig(): void {\n    const options =\n      this.verificationOptions?.length > 0\n        ? this.verificationOptions.map((v) => ApiEditStepComponent.toSelectOption(v))\n        : ApiEditStepComponent.DEFAULT_VERIFICATION_OPTIONS;\n    this.verificationSelectConfig = {\n      ...this.verificationSelectConfig,\n      options,\n    };\n  }\n\n  private getVerificationValues(): string[] {\n    const source =\n      this.verificationOptions?.length > 0\n        ? this.verificationOptions\n        : (ApiEditStepComponent.DEFAULT_VERIFICATION_OPTIONS as EnvironmentOptionInput[]);\n    return source\n      .map((v) => ApiEditStepComponent.getOptionValue(v as EnvironmentOptionInput))\n      .filter((v): v is string => v != null);\n  }\n\n  private getDefaultVerification(): string {\n    const values = this.getVerificationValues();\n    return values.length > 0 ? values[0] : 'equals';\n  }\n\n  /** Data Type options: array of strings or objects (passed from parent). Falls back to built-in list when empty. */\n  @Input() verificationDataTypeOptions: EnvironmentOptionInput[] = [];\n\n  private static readonly DEFAULT_DATA_TYPE_OPTIONS: SelectOption[] = [\n    { id: 'string', value: 'string', name: 'String', label: 'String' },\n    { id: 'number', value: 'number', name: 'Number', label: 'Number' },\n    { id: 'boolean', value: 'boolean', name: 'Boolean', label: 'Boolean' },\n    { id: 'array', value: 'array', name: 'Array', label: 'Array' },\n    { id: 'object', value: 'object', name: 'Object', label: 'Object' },\n  ];\n\n  /** Config for Data Type dropdown (updated when verificationDataTypeOptions changes, like Method dropdown) */\n  verificationDataTypeSelectConfig: DynamicSelectFieldConfig = {\n    key: 'dataType',\n    placeholder: 'String',\n    searchable: false,\n    options: [...ApiEditStepComponent.DEFAULT_DATA_TYPE_OPTIONS],\n  };\n\n  private updateVerificationDataTypeSelectConfig(): void {\n    const options =\n      this.verificationDataTypeOptions?.length > 0\n        ? this.verificationDataTypeOptions.map((d) => ApiEditStepComponent.toSelectOption(d))\n        : ApiEditStepComponent.DEFAULT_DATA_TYPE_OPTIONS;\n    this.verificationDataTypeSelectConfig = {\n      ...this.verificationDataTypeSelectConfig,\n      options,\n    };\n  }\n\n  private getDataTypeValues(): string[] {\n    const source =\n      this.verificationDataTypeOptions?.length > 0\n        ? this.verificationDataTypeOptions\n        : (ApiEditStepComponent.DEFAULT_DATA_TYPE_OPTIONS as EnvironmentOptionInput[]);\n    return source\n      .map((d) => ApiEditStepComponent.getOptionValue(d as EnvironmentOptionInput))\n      .filter((v): v is string => v != null);\n  }\n\n  private getDefaultDataType(): string {\n    const values = this.getDataTypeValues();\n    return values.length > 0 ? values[0] : 'string';\n  }\n\n  /** Config for Expected Value when Data Type is Boolean (true/false dropdown) */\n  readonly verificationExpectedValueBooleanSelectConfig: DynamicSelectFieldConfig = {\n    key: 'expectedValue',\n    placeholder: 'Select',\n    searchable: false,\n    options: [\n      { id: 'true', value: 'true', name: 'true', label: 'true' },\n      { id: 'false', value: 'false', name: 'false', label: 'false' },\n    ],\n  };\n\n  /** Form array for Status tab verification rows; each item is FormGroup({ verification, expectedValue }) */\n  statusVerificationFormArray!: FormArray;\n\n  get statusVerificationRows(): FormGroup[] {\n    return (this.statusVerificationFormArray?.controls ?? []) as FormGroup[];\n  }\n\n  /** Config for Status tab Verification dropdown (Equals, Not equal, Less than, Greater than) */\n  /** Status tab Verification options (Equals, Not equal, etc.). Falls back to built-in list when empty. */\n  @Input() statusVerificationOptions: EnvironmentOptionInput[] = [];\n\n  private static readonly DEFAULT_STATUS_VERIFICATION_OPTIONS: SelectOption[] = [\n    { id: 'equals', value: 'equals', name: 'Equals', label: 'Equals' },\n    { id: 'not-equal', value: 'not-equal', name: 'Not equal', label: 'Not equal' },\n    { id: 'less-than', value: 'less-than', name: 'Less than', label: 'Less than' },\n    { id: 'greater-than', value: 'greater-than', name: 'Greater than', label: 'Greater than' },\n  ];\n\n  /** Config for Status tab Verification dropdown (updated when statusVerificationOptions changes). */\n  statusVerificationSelectConfig: DynamicSelectFieldConfig = {\n    key: 'verification',\n    placeholder: 'Equals',\n    searchable: false,\n    options: [...ApiEditStepComponent.DEFAULT_STATUS_VERIFICATION_OPTIONS],\n  };\n\n  private updateStatusVerificationSelectConfig(): void {\n    const options =\n      this.statusVerificationOptions?.length > 0\n        ? this.statusVerificationOptions.map((o) => ApiEditStepComponent.toSelectOption(o))\n        : ApiEditStepComponent.DEFAULT_STATUS_VERIFICATION_OPTIONS;\n    this.statusVerificationSelectConfig = {\n      ...this.statusVerificationSelectConfig,\n      options,\n    };\n  }\n\n  private getStatusVerificationValues(): string[] {\n    const source =\n      this.statusVerificationOptions?.length > 0\n        ? this.statusVerificationOptions\n        : (ApiEditStepComponent.DEFAULT_STATUS_VERIFICATION_OPTIONS as EnvironmentOptionInput[]);\n    return source\n      .map((o) => ApiEditStepComponent.getOptionValue(o as EnvironmentOptionInput))\n      .filter((v): v is string => v != null);\n  }\n\n  private getDefaultStatusVerification(): string {\n    const values = this.getStatusVerificationValues();\n    return values.length > 0 ? values[0] : 'equals';\n  }\n\n  responsePreview = ``;\n\n  private methodChangesSub?: Subscription;\n  private formatChangesSub?: Subscription;\n  private headerNameOptionsChangesSub?: Subscription;\n  private environmentFormChangesSub?: Subscription;\n  private methodFormChangesSub?: Subscription;\n\n  constructor(\n    private readonly fb: FormBuilder,\n    private readonly cdr: ChangeDetectorRef,\n  ) {}\n\n  ngOnInit(): void {\n    this.applyInitialStep(this.initialStep);\n    this.updateMethodSelectConfig();\n    this.updateHeaderNameSelectConfig();\n    const firstMethodValue = this.httpMethodOptions?.length\n      ? ApiEditStepComponent.getOptionValue(this.httpMethodOptions[0])\n      : undefined;\n    const defaultMethod = this.initialMethod ?? firstMethodValue ?? 'GET';\n    this.currentMethodValue = typeof defaultMethod === 'string' ? defaultMethod : (ApiEditStepComponent.getOptionValue(defaultMethod as EnvironmentOptionInput) ?? '');\n    this.methodForm = this.fb.group({\n      method: [defaultMethod],\n    });\n    const firstValue = this.environmentOptions?.length\n      ? ApiEditStepComponent.getOptionValue(this.environmentOptions[0])\n      : undefined;\n    const defaultEnv = this.initialEnvironment ?? firstValue ?? 'Development';\n    this.currentEnvironmentValue = typeof defaultEnv === 'string' ? defaultEnv : (ApiEditStepComponent.getOptionValue(defaultEnv as EnvironmentOptionInput) ?? '');\n    this.environmentForm = this.fb.group({\n      environment: [defaultEnv],\n    });\n    this.environmentFormChangesSub = this.environmentForm.get('environment')?.valueChanges?.subscribe((v: unknown) => {\n      const s = v != null && v !== '' ? (typeof v === 'object' ? ApiEditStepComponent.getOptionValue(v as EnvironmentOptionInput) : String(v)) : '';\n      this.currentEnvironmentValue = s ?? '';\n    });\n    this.methodFormChangesSub = this.methodForm.get('method')?.valueChanges?.subscribe((v: unknown) => {\n      const s = v != null && v !== '' ? (typeof v === 'object' ? ApiEditStepComponent.getOptionValue(v as EnvironmentOptionInput) : String(v)) : '';\n      this.currentMethodValue = s ?? '';\n    });\n    this.buildHeadersFormArray(\n      this.initialHeaders ?? [{ name: '', type: 'string', value: '' }]\n    );\n    this.headerNameOptionsChangesSub = this.headersFormArray?.valueChanges?.subscribe(() => {\n      this.updateHeaderNameSelectConfig();\n      this.headersChange.emit(this.headers);\n    });\n    this.updateHeaderNameSelectConfig();\n    this.headersChange.emit(this.headers);\n    this.updateEnvironmentSelectConfig();\n    this.updatePayloadFormatSelectConfig();\n    const firstFormatValue = this.getFormatValues()[0];\n    const defaultFormat = this.initialFormat ?? firstFormatValue ?? 'json';\n    this.payloadFormatForm = this.fb.group({ format: [defaultFormat] });\n    this.buildKeyValueFormArray();\n    this.buildKeyTypeValueFormArray();\n    this.updateVerificationSelectConfig();\n    this.updateVerificationDataTypeSelectConfig();\n    this.buildVerificationFormArray();\n    this.updateStatusVerificationSelectConfig();\n    this.buildStatusVerificationFormArray();\n    this.methodChangesSub = this.methodForm.get('method')?.valueChanges?.subscribe((value: string) => {\n      const method = value != null ? String(value).toUpperCase() : '';\n      if (METHODS_WITHOUT_BODY.includes(method) && this.activePayloadTab !== 'headers') {\n        this.activePayloadTab = 'headers';\n        this.cdr.detectChanges();\n      }\n    });\n    this.formatChangesSub = this.payloadFormatForm.get('format')?.valueChanges?.subscribe(() => {\n      this.validatePayloadJson();\n    });\n    this.validatePayloadJson();\n  }\n\n  ngAfterViewInit(): void {\n    this.setupPayloadTextareaScrollSync();\n  }\n\n  ngOnDestroy(): void {\n    this.methodChangesSub?.unsubscribe();\n    this.formatChangesSub?.unsubscribe();\n    this.headerNameOptionsChangesSub?.unsubscribe();\n    this.environmentFormChangesSub?.unsubscribe();\n    this.methodFormChangesSub?.unsubscribe();\n  }\n\n  /** Sync line numbers column scroll with payload textarea scroll (Postman-style). */\n  private setupPayloadTextareaScrollSync(): void {\n    setTimeout(() => {\n      const host = this.payloadEditorWithLinesRef?.nativeElement;\n      if (!host) return;\n      const lineNumbersEl = host.querySelector('.cqa-api-edit-step-payload-line-numbers') as HTMLElement | null;\n      const textarea = host.querySelector('textarea');\n      if (!lineNumbersEl || !textarea) return;\n      textarea.addEventListener('scroll', () => {\n        lineNumbersEl.scrollTop = textarea.scrollTop;\n      });\n    }, 0);\n  }\n\n  private buildKeyValueFormArray(rows?: { key: string; value: string }[]): void {\n    const initial = rows ?? [{ key: '', value: '' }];\n    const groups = initial.map((r) => this.fb.group({ key: [r.key], value: [r.value] }));\n    this.keyValueFormArray = this.fb.array(groups);\n  }\n\n  private buildKeyTypeValueFormArray(rows?: { key: string; type: string; value: string }[]): void {\n    const initial = rows ?? [{ key: '', type: 'text', value: '' }];\n    const groups = initial.map((r) => this.fb.group({ key: [r.key], type: [r.type], value: [r.value] }));\n    this.keyTypeValueFormArray = this.fb.array(groups);\n  }\n\n  private buildVerificationFormArray(rows?: { jsonPath: string; verification: string; dataType: string; expectedValue: string }[]): void {\n    const defaultVerification = this.getDefaultVerification();\n    const defaultDataType = this.getDefaultDataType();\n    const initial = rows ?? [{ jsonPath: '', verification: defaultVerification, dataType: defaultDataType, expectedValue: '' }];\n    const groups = initial.map((r) =>\n      this.fb.group({\n        jsonPath: [r.jsonPath],\n        verification: [r.verification],\n        dataType: [r.dataType],\n        expectedValue: [r.expectedValue],\n      })\n    );\n    this.verificationFormArray = this.fb.array(groups);\n  }\n\n  private buildStatusVerificationFormArray(rows?: { verification: string; expectedValue: string }[]): void {\n    const defaultVerification = this.getDefaultStatusVerification();\n    const initial = rows ?? [{ verification: defaultVerification, expectedValue: '' }];\n    const groups = initial.map((r) =>\n      this.fb.group({\n        verification: [r.verification],\n        expectedValue: [r.expectedValue],\n      })\n    );\n    this.statusVerificationFormArray = this.fb.array(groups);\n  }\n\n  private buildHeadersFormArray(rows: ApiEditHeaderRow[]): void {\n    const groups = rows.map((h) =>\n      this.fb.group({\n        name: [h.name],\n        value: [h.value],\n      })\n    );\n    if (this.headersFormArray) {\n      this.headersFormArray.clear();\n      groups.forEach((g) => this.headersFormArray.push(g));\n    } else {\n      this.headersFormArray = this.fb.array(groups);\n    }\n  }\n\n  /** Handler: show import cURL panel (called when user clicks \"Import API cURL\"). */\n  openImportCurlPanel(): void {\n    this.bodyView = 'import-curl';\n    this.cdr.detectChanges();\n  }\n\n  /** Handler: emit cURL value from control and close panel. Called when user clicks Import button. */\n  onImportCurlConfirm(): void {\n    const value = this.importCurlControl.value ?? '';\n    this.importCurl.emit(typeof value === 'string' ? value : '');\n    this.closeImportCurlPanel();\n  }\n\n  /** Handler: emit cancel and close panel. Called when user clicks Cancel in import cURL panel. */\n  onCancelImportCurl(): void {\n    this.importCurlCancel.emit();\n    this.closeImportCurlPanel();\n  }\n\n  /** Handler: show headers section (called from Cancel or after Import in import panel). */\n  closeImportCurlPanel(): void {\n    this.bodyView = 'headers';\n    this.cdr.detectChanges();\n  }\n\n  onSendRequest(): void {\n    const environment = this.selectedEnvironment != null ? String(this.selectedEnvironment) : '';\n    const method = this.selectedMethod != null ? String(this.selectedMethod) : '';\n    this.sendRequest.emit({\n      environment,\n      method,\n      url: this.url ?? '',\n      headers: this.headers,\n    });\n  }\n\n  onVariableNameChange(): void {\n    this.variableNameError = '';\n  }\n\n  onBack(): void {\n    if (this.currentStep > 1) {\n      this.setStep(this.currentStep - 1);\n    } else {\n      this.back.emit();\n    }\n  }\n\n  onNext(): void {\n    if (this.currentStep === 2 && !this.variableName?.trim()) {\n      this.variableNameError = 'Variable Name is required.';\n      return;\n    }\n    this.variableNameError = '';\n    if (this.currentStep < this.stepLabels.length) {\n      this.setStep(this.currentStep + 1);\n    } else {\n      this.next.emit();\n    }\n  }\n\n  setPayloadTab(value: ApiEditPayloadTab): void {\n    this.activePayloadTab = value;\n  }\n\n  setResponseVerificationTab(value: 'response-body' | 'status'): void {\n    this.activeResponseVerificationTab = value;\n  }\n\n  addHeader(): void {\n    this.headersFormArray.push(\n      this.fb.group({ name: [''], value: [''] })\n    );\n  }\n\n  removeHeader(index: number): void {\n    this.headersFormArray.removeAt(index);\n  }\n\n  /** When user adds a custom header name via the dropdown \"Add '…'\" option, set the control value. */\n  onHeaderNameAddCustomValue(event: { key: string; value: string }, row: FormGroup): void {\n    const control = row.get(event.key);\n    if (control && event.value != null) {\n      control.setValue(event.value.trim());\n    }\n  }\n\n  trackByHeader(index: number): number {\n    return index;\n  }\n\n  addKeyValueRow(): void {\n    this.keyValueFormArray.push(this.fb.group({ key: [''], value: [''] }));\n  }\n\n  removeKeyValueRow(index: number): void {\n    this.keyValueFormArray.removeAt(index);\n  }\n\n  trackByKeyValue(index: number): number {\n    return index;\n  }\n\n  addKeyTypeValueRow(): void {\n    this.keyTypeValueFormArray.push(this.fb.group({ key: [''], type: ['text'], value: [''] }));\n  }\n\n  removeKeyTypeValueRow(index: number): void {\n    this.keyTypeValueFormArray.removeAt(index);\n  }\n\n  trackByKeyTypeValue(index: number): number {\n    return index;\n  }\n\n  addVerificationRow(): void {\n    this.verificationFormArray.push(\n      this.fb.group({\n        jsonPath: [''],\n        verification: [this.getDefaultVerification()],\n        dataType: [this.getDefaultDataType()],\n        expectedValue: [''],\n      })\n    );\n  }\n\n  removeVerificationRow(index: number): void {\n    this.verificationFormArray.removeAt(index);\n  }\n\n  trackByVerification(index: number): number {\n    return index;\n  }\n\n  /** When Data Type changes in Response Body verification, reset Expected Value for that row. */\n  onVerificationDataTypeChange(row: FormGroup, event: { key: string; value: unknown }): void {\n    if (event.key === 'dataType') {\n      row.get('expectedValue')?.setValue('', { emitEvent: false });\n    }\n  }\n\n  addStatusVerificationRow(): void {\n    this.statusVerificationFormArray.push(\n      this.fb.group({ verification: [this.getDefaultStatusVerification()], expectedValue: [''] })\n    );\n  }\n\n  removeStatusVerificationRow(index: number): void {\n    this.statusVerificationFormArray.removeAt(index);\n  }\n\n  trackByStatusVerification(index: number): number {\n    return index;\n  }\n\n  /** Emit all entered details (environment, HTTP method, URL, headers, body, step2 variable, step3 verifications) when user clicks Create. */\n  onCreate(): void {\n    console.log('9999999');\n    \n    try {\n      const payload = this.getCreatePayload();\n      console.log('9999999 payload', payload);\n      this.create.emit(payload);\n    } catch (err) {\n      console.error('ApiEditStep getCreatePayload error:', err);\n      this.create.emit(this.getCreatePayloadFallback());\n    }\n  }\n\n  /** Minimal payload when getCreatePayload throws (so create always emits). */\n  private getCreatePayloadFallback(): ApiEditCreatePayload {\n    return {\n      step1: {\n        environment: '',\n        method: '',\n        url: this.url ?? '',\n        headers: [],\n        activePayloadTab: this.activePayloadTab,\n        payloadType: this.payloadType,\n        payloadFormat: '',\n        payloadText: this.payloadText ?? '',\n        keyValueRows: [],\n        keyTypeValueRows: [],\n      },\n      step2: { variableName: this.variableName ?? '' },\n      step3: {\n        activeResponseVerificationTab: this.activeResponseVerificationTab,\n        responseBodyVerifications: [],\n        statusVerifications: [],\n      },\n    };\n  }\n\n  /** Normalize form control value to string (handles object or string). */\n  private static getControlValue(control: { value: unknown } | null | undefined): string {\n    const v = control?.value;\n    if (v == null || v === '') return '';\n    return typeof v === 'object' ? (ApiEditStepComponent.getOptionValue(v as EnvironmentOptionInput) ?? '') : String(v);\n  }\n\n  /** Build full create payload: environment, HTTP method, URL, headers, body (step1), variable name (step2), verifications (step3). */\n  private getCreatePayload(): ApiEditCreatePayload {\n    const envFromForm = ApiEditStepComponent.getControlValue(this.environmentForm?.get('environment') as { value: unknown } | null);\n    const environment =\n      envFromForm !== '' ? envFromForm : (this.currentEnvironmentValue !== '' ? this.currentEnvironmentValue : this.selectedEnvironment);\n    const methodFromForm = ApiEditStepComponent.getControlValue(this.methodForm?.get('method') as { value: unknown } | null);\n    const method =\n      methodFromForm !== '' ? methodFromForm : (this.currentMethodValue !== '' ? this.currentMethodValue : this.selectedMethod);\n    const format = this.payloadFormatForm?.get('format')?.value ?? '';\n    const keyValueFormArray = this.keyValueFormArray;\n    const keyValueRows = (keyValueFormArray?.controls ?? []).map((c) => ({\n      key: (c as FormGroup).get('key')?.value ?? '',\n      value: (c as FormGroup).get('value')?.value ?? '',\n    }));\n    const keyTypeValueFormArray = this.keyTypeValueFormArray;\n    const keyTypeValueRows = (keyTypeValueFormArray?.controls ?? []).map((c) => ({\n      key: (c as FormGroup).get('key')?.value ?? '',\n      type: (c as FormGroup).get('type')?.value ?? 'text',\n      value: (c as FormGroup).get('value')?.value ?? '',\n    }));\n    const verificationFormArray = this.verificationFormArray;\n    const responseBodyVerifications = (verificationFormArray?.controls ?? []).map((c) => ({\n      jsonPath: (c as FormGroup).get('jsonPath')?.value ?? '',\n      verification: (c as FormGroup).get('verification')?.value ?? '',\n      dataType: (c as FormGroup).get('dataType')?.value ?? '',\n      expectedValue: (c as FormGroup).get('expectedValue')?.value ?? '',\n    }));\n    const statusVerificationFormArray = this.statusVerificationFormArray;\n    const statusVerifications = (statusVerificationFormArray?.controls ?? []).map((c) => ({\n      verification: (c as FormGroup).get('verification')?.value ?? '',\n      expectedValue: (c as FormGroup).get('expectedValue')?.value ?? '',\n    }));\n    return {\n      step1: {\n        environment,\n        method,\n        url: this.url ?? '',\n        headers: this.headers,\n        activePayloadTab: this.activePayloadTab,\n        payloadType: this.payloadType,\n        payloadFormat: format,\n        payloadText: this.payloadText ?? '',\n        keyValueRows,\n        keyTypeValueRows,\n      },\n      step2: {\n        variableName: this.variableName ?? '',\n      },\n      step3: {\n        activeResponseVerificationTab: this.activeResponseVerificationTab,\n        responseBodyVerifications,\n        statusVerifications,\n      },\n    };\n  }\n\n  /** Current header rows from form (for consumers that read headers) */\n  get headers(): ApiEditHeaderRow[] {\n    if (!this.headersFormArray) return [];\n    return this.headersFormArray.controls.map((c) => ({\n      name: (c as FormGroup).get('name')?.value ?? '',\n      type: 'string',\n      value: (c as FormGroup).get('value')?.value ?? '',\n    }));\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (changes['initialMethod']?.currentValue != null && this.methodForm) {\n      const v = changes['initialMethod'].currentValue;\n      this.currentMethodValue = typeof v === 'string' ? v : (ApiEditStepComponent.getOptionValue(v as EnvironmentOptionInput) ?? '');\n      this.methodForm.patchValue({ method: v });\n    }\n    if (changes['httpMethodOptions']) {\n      this.updateMethodSelectConfig();\n      if (this.methodForm && this.httpMethodOptions?.length) {\n        const current = this.methodForm.get('method')?.value;\n        const values = this.getMethodValues();\n        const valid = values.includes(current);\n        if (!valid) {\n          const firstValue = ApiEditStepComponent.getOptionValue(this.httpMethodOptions[0]);\n          if (firstValue != null) {\n            this.currentMethodValue = firstValue;\n            this.methodForm.patchValue({ method: firstValue });\n          }\n        }\n      }\n    }\n    if (changes['initialEnvironment']?.currentValue != null && this.environmentForm) {\n      const v = changes['initialEnvironment'].currentValue;\n      this.currentEnvironmentValue = typeof v === 'string' ? v : (ApiEditStepComponent.getOptionValue(v as EnvironmentOptionInput) ?? '');\n      this.environmentForm.patchValue({ environment: v });\n    }\n    if (changes['environmentOptions']) {\n      this.updateEnvironmentSelectConfig();\n      if (this.environmentForm && this.environmentOptions?.length) {\n        const current = this.environmentForm.get('environment')?.value;\n        const values = this.getEnvironmentValues();\n        const valid = values.includes(current);\n        if (!valid) {\n          const firstValue = ApiEditStepComponent.getOptionValue(this.environmentOptions[0]);\n          if (firstValue != null) {\n            this.currentEnvironmentValue = firstValue;\n            this.environmentForm.patchValue({ environment: firstValue });\n          }\n        }\n      }\n    }\n    if (changes['initialStep']) {\n      this.applyInitialStep(changes['initialStep'].currentValue);\n    }\n    if (changes['initialUrl']?.currentValue != null) {\n      this.url = changes['initialUrl'].currentValue;\n    }\n    if (changes['initialPayloadTab']?.currentValue != null) {\n      this.activePayloadTab = changes['initialPayloadTab'].currentValue;\n    }\n    if (changes['headerNameOptions']) {\n      this.updateHeaderNameSelectConfig();\n    }\n    if (changes['initialHeaders']?.currentValue != null) {\n      this.buildHeadersFormArray(changes['initialHeaders'].currentValue as ApiEditHeaderRow[]);\n      this.updateHeaderNameSelectConfig();\n    }\n    if (changes['initialResponsePreview']?.currentValue != null) {\n      this.responsePreview = changes['initialResponsePreview'].currentValue;\n    }\n    if (changes['initialFormat']?.currentValue != null && this.payloadFormatForm) {\n      this.payloadFormatForm.patchValue({ format: changes['initialFormat'].currentValue });\n    }\n    if (changes['formatOptions']) {\n      this.updatePayloadFormatSelectConfig();\n      if (this.payloadFormatForm) {\n        const current = this.payloadFormatForm.get('format')?.value;\n        const values = this.getFormatValues();\n        const valid = values.includes(current);\n        if (!valid && values.length > 0) {\n          const firstValue = values[0];\n          this.payloadFormatForm.patchValue({ format: firstValue });\n        }\n      }\n    }\n    if (changes['verificationOptions']) {\n      this.updateVerificationSelectConfig();\n      const values = this.getVerificationValues();\n      const defaultVerification = this.getDefaultVerification();\n      if (this.verificationFormArray && values.length > 0) {\n        this.verificationFormArray.controls.forEach((control) => {\n          const current = (control as FormGroup).get('verification')?.value;\n          if (current && !values.includes(current)) {\n            (control as FormGroup).patchValue({ verification: defaultVerification });\n          }\n        });\n      }\n    }\n    if (changes['verificationDataTypeOptions']) {\n      this.updateVerificationDataTypeSelectConfig();\n      const values = this.getDataTypeValues();\n      const defaultDataType = this.getDefaultDataType();\n      if (this.verificationFormArray && values.length > 0) {\n        this.verificationFormArray.controls.forEach((control) => {\n          const current = (control as FormGroup).get('dataType')?.value;\n          if (current && !values.includes(current)) {\n            (control as FormGroup).patchValue({ dataType: defaultDataType });\n          }\n        });\n      }\n    }\n    if (changes['statusVerificationOptions']) {\n      this.updateStatusVerificationSelectConfig();\n      const values = this.getStatusVerificationValues();\n      const defaultVerification = this.getDefaultStatusVerification();\n      if (this.statusVerificationFormArray && values.length > 0) {\n        this.statusVerificationFormArray.controls.forEach((control) => {\n          const current = (control as FormGroup).get('verification')?.value;\n          if (current && !values.includes(current)) {\n            (control as FormGroup).patchValue({ verification: defaultVerification });\n          }\n        });\n      }\n    }\n  }\n}\n","<div class=\"cqa-api-edit-step-container\">\n  <!-- Title -->\n  <h2\n    class=\"cqa-api-edit-step-title cqa-font-inter cqa-text-[12px] cqa-font-semibold cqa-leading-[100%] cqa-tracking-normal cqa-text-[#000000]\">\n    Create API Test Step</h2>\n\n  <!-- Step indicator: all three steps visible, active step highlighted (Postman-style) -->\n  <div class=\"cqa-api-edit-step-indicator\">\n    <ng-container *ngFor=\"let step of stepLabels; let i = index\">\n      <cqa-button type=\"button\" variant=\"text\"\n        customClass=\"cqa-api-edit-step-indicator-item cqa-api-edit-step-indicator-item--clickable\"\n        [attr.aria-label]=\"'Step ' + step.index + ': ' + step.label\" [attr.aria-pressed]=\"step.index === currentStep\"\n        (clicked)=\"setStep(step.index)\">\n        <span class=\"cqa-api-edit-step-indicator-circle\"\n          [class.cqa-api-edit-step-indicator-circle--active]=\"step.index === currentStep\">\n          {{ step.index }}\n        </span>\n        <span class=\"cqa-api-edit-step-indicator-label\"\n          [class.cqa-api-edit-step-indicator-label--active]=\"step.index === currentStep\">\n          {{ step.label }}\n        </span>\n        <div *ngIf=\"i < stepLabels.length - 1\" class=\"cqa-api-edit-step-indicator-line\" aria-hidden=\"true\"></div>\n      </cqa-button>\n    </ng-container>\n  </div>\n\n  <!-- Step content viewport: smooth slide between steps -->\n  <div class=\"cqa-api-edit-step-viewport\">\n    <div class=\"cqa-api-edit-step-strip\" [style.transform]=\"'translateX(' + stripTranslatePercent + '%)'\">\n      <!-- Step 1: Environment, request, body, response -->\n      <div class=\"cqa-api-edit-step-panel\">\n        <!-- Environment row: new line, select aligned right -->\n        <div class=\"cqa-api-edit-step-environment-row\">\n          <cqa-dynamic-select *ngIf=\"environmentForm\" [form]=\"environmentForm\" [config]=\"environmentSelectConfig\"\n            class=\"cqa-api-edit-step-environment-select\" aria-label=\"Environment\"\n            (selectionChange)=\"onEnvironmentSelectionChange($event)\">\n          </cqa-dynamic-select>\n        </div>\n\n        <!-- Request row: method, URL, buttons -->\n        <div class=\"cqa-api-edit-step-request-row\">\n          <cqa-dynamic-select *ngIf=\"methodForm\" [form]=\"methodForm\" [config]=\"methodSelectConfig\"\n            class=\"cqa-api-edit-step-method-select\" aria-label=\"HTTP method\"\n            (selectionChange)=\"onMethodSelectionChange($event)\">\n          </cqa-dynamic-select>\n          <div class=\"cqa-api-edit-step-url-wrap\">\n            <cqa-custom-input [(value)]=\"url\" [label]=\"''\" placeholder=\"\" [fullWidth]=\"true\" size=\"md\">\n            </cqa-custom-input>\n          </div>\n          <div class=\"cqa-api-edit-step-import-curl-trigger\" style=\"display: contents\" (click)=\"openImportCurlPanel()\">\n            <cqa-button type=\"button\" variant=\"outlined\" btnSize=\"lg\" text=\"Import API cURL\"\n              customClass=\"cqa-api-edit-step-btn-outline cqa-font-inter cqa-text-[14px] cqa-font-semibold cqa-leading-[100%] cqa-tracking-normal cqa-text-[#414146]\">\n            </cqa-button>\n          </div>\n          <cqa-button variant=\"filled\" btnSize=\"lg\" text=\"Send Request\" (clicked)=\"onSendRequest()\"\n            customClass=\"cqa-api-edit-step-btn-primary cqa-font-inter cqa-text-[14px] cqa-font-semibold cqa-leading-[100%] cqa-tracking-normal cqa-text-[#FBFCFF]\">\n          </cqa-button>\n        </div>\n\n\n\n        <!-- Body content: header section (default) OR import cURL section -->\n        <ng-container *ngIf=\"bodyView === 'import-curl'\">\n          <div class=\"cqa-api-edit-step-import-curl-panel\">\n            <div class=\"cqa-api-edit-step-import-curl-header\">\n              <h3 class=\"cqa-api-edit-step-import-curl-title\">Import API cURL</h3>\n            </div>\n            <div class=\"cqa-api-edit-step-import-curl-separator\"></div>\n            <div class=\"cqa-api-edit-step-import-curl-body\">\n              <cqa-custom-textarea [value]=\"importCurlControl.value\"\n                (valueChange)=\"importCurlControl.setValue($event)\"\n                placeholder=\"Paste your cURL command here (e.g., curl -X POST https://api.example.com/users)\"\n                [fullWidth]=\"true\" [rows]=\"8\" resize=\"vertical\" size=\"md\"\n                class=\"cqa-api-edit-step-import-curl-textarea\">\n              </cqa-custom-textarea>\n            </div>\n            <div class=\"cqa-api-edit-step-import-curl-footer\">\n              <cqa-button type=\"button\" variant=\"outlined\" btnSize=\"lg\" text=\"Cancel\"\n                customClass=\"cqa-api-edit-step-import-curl-btn-cancel\" (clicked)=\"onCancelImportCurl()\"></cqa-button>\n              <cqa-button type=\"button\" variant=\"filled\" btnSize=\"lg\" text=\"Import\"\n                customClass=\"cqa-api-edit-step-import-curl-btn-import\" (clicked)=\"onImportCurlConfirm()\"></cqa-button>\n            </div>\n          </div>\n        </ng-container>\n\n        <ng-container *ngIf=\"bodyView === 'headers'\">\n          <div class=\"cqa-api-edit-step-tabs-wrapper\">\n            <div class=\"cqa-api-edit-step-tabs\">\n              <cqa-button *ngFor=\"let tab of payloadTabs\" type=\"button\" variant=\"text\" [text]=\"tab.label\"\n                [customClass]=\"'cqa-api-edit-step-tab' + (activePayloadTab === tab.value ? ' cqa-api-edit-step-tab--active' : '') + (isMethodWithoutBody && tab.value !== 'headers' ? ' cqa-api-edit-step-tab--disabled' : '')\"\n                [disabled]=\"isMethodWithoutBody && tab.value !== 'headers'\"\n                (clicked)=\"setPayloadTab(tab.value)\">\n              </cqa-button>\n            </div>\n\n            <!-- Payload content (Headers) -->\n            <div *ngIf=\"activePayloadTab === 'headers'\" class=\"cqa-api-edit-step-payload\">\n              <div class=\"cqa-api-edit-step-headers-grid\">\n                <span class=\"cqa-api-edit-step-headers-label\">Header Name</span>\n                <span class=\"cqa-api-edit-step-headers-label\">Header Value</span>\n                <span class=\"cqa-api-edit-step-headers-label cqa-api-edit-step-headers-label--empty\"\n                  aria-hidden=\"true\"></span>\n              </div>\n              <div *ngFor=\"let row of headerRows; let i = index; trackBy: trackByHeader\" [formGroup]=\"row\"\n                class=\"cqa-api-edit-step-header-row\">\n                <cqa-dynamic-select [form]=\"row\" [config]=\"headerNameSelectConfig\"\n                  (addCustomValue)=\"onHeaderNameAddCustomValue($event, row)\"\n                  class=\"cqa-api-edit-step-header-type-select cqa-w-full\">\n                </cqa-dynamic-select>\n                <cqa-custom-input [value]=\"row.get('value')?.value ?? ''\"\n                  (valueChange)=\"row.get('value')?.setValue($event)\" placeholder=\"Value\" [fullWidth]=\"true\" size=\"sm\"\n                  class=\"cqa-api-edit-step-header-value-input\" ariaLabel=\"Header value\">\n                </cqa-custom-input>\n                <cqa-button type=\"button\" variant=\"text\" [customClass]=\"'cqa-api-edit-step-header-delete'\"\n                  [tooltip]=\"'Remove header'\" (clicked)=\"removeHeader(i)\">\n                  <svg class=\"cqa-api-edit-step-header-delete-icon\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\"\n                    fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\" aria-hidden=\"true\">\n                    <path\n                      d=\"M10.6663 6V12.6667H5.33301V6H10.6663ZM9.66634 2H6.33301L5.66634 2.66667H3.33301V4H12.6663V2.66667H10.333L9.66634 2ZM11.9997 4.66667H3.99967V12.6667C3.99967 13.4 4.59967 14 5.33301 14H10.6663C11.3997 14 11.9997 13.4 11.9997 12.6667V4.66667Z\"\n                      fill=\"#F9BFBF\" />\n                  </svg>\n                </cqa-button>\n              </div>\n              <div class=\"cqa-api-edit-step-add-header-wrap\">\n                <cqa-button type=\"button\" variant=\"text\" text=\"+ Add Header\"\n                  [customClass]=\"'cqa-api-edit-step-add-header-link'\" (clicked)=\"addHeader()\">\n                </cqa-button>\n              </div>\n            </div>\n\n            <!-- Payload content (Body only): type, format, text area, Back/Next -->\n            <div *ngIf=\"activePayloadTab === 'body'\"\n              class=\"cqa-api-edit-step-payload cqa-api-edit-step-payload-editor\">\n              <div class=\"cqa-api-edit-step-payload-type-row\">\n                <span class=\"cqa-api-edit-step-payload-type-label\">Type</span>\n                <div class=\"cqa-api-edit-step-payload-type-radios\">\n                  <cqa-segment-control [value]=\"payloadType\" [segments]=\"payloadTypeSegments\"\n                    (valueChange)=\"onPayloadTypeChange($event)\"\n                    class=\"cqa-api-edit-step-payload-type-segment\">\n                  </cqa-segment-control>\n                </div>\n                <div *ngIf=\"payloadType === 'raw'\" class=\"cqa-api-edit-step-payload-format-wrap\">\n                  <span class=\"cqa-api-edit-step-payload-format-label\">Format:</span>\n                  <cqa-dynamic-select *ngIf=\"payloadFormatForm\" [form]=\"payloadFormatForm\"\n                    [config]=\"payloadFormatSelectConfig\" class=\"cqa-api-edit-step-payload-format-select\"\n                    aria-label=\"Format\">\n                  </cqa-dynamic-select>\n                </div>\n              </div>\n              <!-- Raw: text area with line numbers (Postman-style payload body) -->\n              <div *ngIf=\"payloadType === 'raw'\" class=\"cqa-api-edit-step-payload-body\" #payloadEditorWithLinesRef>\n                <div class=\"cqa-api-edit-step-payload-editor-with-lines\">\n                  <div class=\"cqa-api-edit-step-payload-line-numbers\" aria-hidden=\"true\">\n                    <span *ngFor=\"let n of payloadLineNumbers\" class=\"cqa-api-edit-step-payload-line-num\">\n                      <span *ngIf=\"payloadJsonError && payloadJsonError.line === n\"\n                        class=\"cqa-api-edit-step-payload-line-error-icon\" [title]=\"payloadJsonErrorTooltip\"\n                        aria-label=\"Parse error on this line\">\n                        <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"14\" height=\"14\" viewBox=\"0 0 14 14\" fill=\"none\" aria-hidden=\"true\">\n                          <circle cx=\"7\" cy=\"7\" r=\"6\" fill=\"#EF4444\"/>\n                          <path d=\"M4 4l6 6M10 4l-6 6\" stroke=\"white\" stroke-width=\"1.5\" stroke-linecap=\"round\"/>\n                        </svg>\n                      </span>\n                      <span class=\"cqa-api-edit-step-payload-line-num-text\">{{ n }}</span>\n                    </span>\n                  </div>\n                  <div class=\"cqa-api-edit-step-payload-textarea-cell\">\n                    <div class=\"cqa-api-edit-step-payload-textarea cqa-w-full cqa-flex cqa-flex-col cqa-min-h-0\"\n                      [ngClass]=\"{'cqa-api-edit-step-payload-textarea--error': payloadJsonError}\">\n                      <textarea #payloadTextareaRef\n                        class=\"cqa-api-edit-step-payload-textarea-input cqa-w-full cqa-resize-y cqa-outline-none cqa-box-border\"\n                        [ngClass]=\"{'cqa-api-edit-step-payload-textarea-input--error': payloadJsonError}\"\n                        [value]=\"payloadText\"\n                        [attr.rows]=\"10\"\n                        placeholder=\"\"\n                        [attr.aria-label]=\"'Payload'\"\n                        [attr.aria-invalid]=\"!!payloadJsonError\"\n                        (input)=\"onPayloadInput($event)\"\n                        (keydown)=\"onPayloadKeydown($event)\">\n                      </textarea>\n                    </div>\n                  </div>\n                </div>\n                <p *ngIf=\"payloadJsonError\" class=\"cqa-api-edit-step-payload-json-error-msg\">\n                  Invalid JSON format. Please check your syntax.\n                </p>\n              </div>\n\n              <!-- x-www-form-urlencoded: Key–Value rows, add/remove dynamically -->\n              <div *ngIf=\"payloadType === 'x-www-form-urlencoded'\" class=\"cqa-api-edit-step-key-value\">\n                <div class=\"cqa-api-edit-step-key-value-grid cqa-api-edit-step-key-value-header\">\n                  <span class=\"cqa-api-edit-step-key-value-label\">Key</span>\n                  <span class=\"cqa-api-edit-step-key-value-label\">Value</span>\n                  <span class=\"cqa-api-edit-step-key-value-label cqa-api-edit-step-key-value-label--empty\"\n                    aria-hidden=\"true\"></span>\n                </div>\n                <div *ngFor=\"let row of keyValueRows; let i = index; trackBy: trackByKeyValue\" [formGroup]=\"row\"\n                  class=\"cqa-api-edit-step-key-value-row\">\n                  <cqa-custom-input [value]=\"row.get('key')?.value ?? ''\"\n                    (valueChange)=\"row.get('key')?.setValue($event)\" placeholder=\"Key\" [fullWidth]=\"true\" size=\"sm\"\n                    class=\"cqa-api-edit-step-key-value-input\" ariaLabel=\"Key\">\n                  </cqa-custom-input>\n                  <cqa-custom-input [value]=\"row.get('value')?.value ?? ''\"\n                    (valueChange)=\"row.get('value')?.setValue($event)\" placeholder=\"Value\" [fullWidth]=\"true\" size=\"sm\"\n                    class=\"cqa-api-edit-step-key-value-input\" ariaLabel=\"Value\">\n                  </cqa-custom-input>\n                  <cqa-button type=\"button\" variant=\"text\" [customClass]=\"'cqa-api-edit-step-key-value-delete'\"\n                    [tooltip]=\"'Remove row'\" (clicked)=\"removeKeyValueRow(i)\">\n                    <svg class=\"cqa-api-edit-step-key-value-delete-icon\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\"\n                      fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\" aria-hidden=\"true\">\n                      <path\n                        d=\"M10.6663 6V12.6667H5.33301V6H10.6663ZM9.66634 2H6.33301L5.66634 2.66667H3.33301V4H12.6663V2.66667H10.333L9.66634 2ZM11.9997 4.66667H3.99967V12.6667C3.99967 13.4 4.59967 14 5.33301 14H10.6663C11.3997 14 11.9997 13.4 11.9997 12.6667V4.66667Z\"\n                        fill=\"#F9BFBF\" />\n                    </svg>\n                  </cqa-button>\n                </div>\n                <div class=\"cqa-api-edit-step-key-value-add-wrap\">\n                  <cqa-button type=\"button\" variant=\"filled\" btnSize=\"lg\" text=\"+ Add Row\"\n                    customClass=\"cqa-api-edit-step-key-value-add-btn\" (clicked)=\"addKeyValueRow()\">\n                  </cqa-button>\n                </div>\n              </div>\n\n              <!-- Form Data: Key–Type–Value rows; Type is a dropdown (Text/File), add/remove dynamically -->\n              <div *ngIf=\"payloadType === 'form-data'\" class=\"cqa-api-edit-step-key-type-value\">\n                <div class=\"cqa-api-edit-step-key-type-value-header\">\n                  <span class=\"cqa-api-edit-step-key-type-value-label\">Key</span>\n                  <span class=\"cqa-api-edit-step-key-type-value-label\">Type</span>\n                  <span class=\"cqa-api-edit-step-key-type-value-label\">Value</span>\n                  <span class=\"cqa-api-edit-step-key-type-value-label cqa-api-edit-step-key-type-value-label--empty\"\n                    aria-hidden=\"true\"></span>\n                </div>\n                <div *ngFor=\"let row of keyTypeValueRows; let i = index; trackBy: trackByKeyTypeValue\" [formGroup]=\"row\"\n                  class=\"cqa-api-edit-step-key-type-value-row\">\n                  <cqa-custom-input [value]=\"row.get('key')?.value ?? ''\"\n                    (valueChange)=\"row.get('key')?.setValue($event)\" placeholder=\"Key\" [fullWidth]=\"true\" size=\"sm\"\n                    class=\"cqa-api-edit-step-key-type-value-input\" ariaLabel=\"Key\">\n                  </cqa-custom-input>\n                  <cqa-dynamic-select [form]=\"row\" [config]=\"keyTypeValueTypeSelectConfig\"\n                    class=\"cqa-api-edit-step-key-type-value-type-select cqa-w-full\">\n                  </cqa-dynamic-select>\n                  <cqa-custom-input [value]=\"row.get('value')?.value ?? ''\"\n                    (valueChange)=\"row.get('value')?.setValue($event)\" placeholder=\"Value\" [fullWidth]=\"true\" size=\"sm\"\n                    class=\"cqa-api-edit-step-key-type-value-input\" ariaLabel=\"Value\">\n                  </cqa-custom-input>\n                  <cqa-button type=\"button\" variant=\"text\" [customClass]=\"'cqa-api-edit-step-key-type-value-delete'\"\n                    [tooltip]=\"'Remove row'\" (clicked)=\"removeKeyTypeValueRow(i)\">\n                    <svg class=\"cqa-api-edit-step-key-type-value-delete-icon\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\"\n                      fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\" aria-hidden=\"true\">\n                      <path\n                        d=\"M10.6663 6V12.6667H5.33301V6H10.6663ZM9.66634 2H6.33301L5.66634 2.66667H3.33301V4H12.6663V2.66667H10.333L9.66634 2ZM11.9997 4.66667H3.99967V12.6667C3.99967 13.4 4.59967 14 5.33301 14H10.6663C11.3997 14 11.9997 13.4 11.9997 12.6667V4.66667Z\"\n                        fill=\"#F9BFBF\" />\n                    </svg>\n                  </cqa-button>\n                </div>\n                <div class=\"cqa-api-edit-step-key-type-value-add-wrap\">\n                  <cqa-button type=\"button\" variant=\"filled\" btnSize=\"lg\" text=\"+ Add Row\"\n                    customClass=\"cqa-api-edit-step-key-type-value-add-btn\" (clicked)=\"addKeyTypeValueRow()\">\n                  </cqa-button>\n                </div>\n              </div>\n            </div>\n          </div>\n        </ng-container>\n\n      </div>\n      <!-- Step 2: Variable Name: input, validation, Back / Next -->\n      <div class=\"cqa-api-edit-step-panel\">\n        <div class=\"cqa-api-edit-step-variable-section\">\n          <div class=\"cqa-api-edit-step-variable-input-wrap\">\n            <cqa-custom-input [(value)]=\"variableName\" [label]=\"''\" placeholder=\"Variable Name\" [fullWidth]=\"true\"\n              size=\"md\" (valueChange)=\"onVariableNameChange()\" aria-label=\"Variable Name\">\n            </cqa-custom-input>\n          </div>\n          <p *ngIf=\"variableNameError\" class=\"cqa-api-edit-step-variable-error\" role=\"alert\">{{ variableNameError }}</p>\n        </div>\n      </div>\n      <!-- Step 3: Response Body / Status tabs -->\n      <div class=\"cqa-api-edit-step-panel\">\n        <div class=\"cqa-api-edit-step-tabs-wrapper\">\n          <div class=\"cqa-api-edit-step-tabs\">\n            <cqa-button *ngFor=\"let tab of responseVerificationTabs\" type=\"button\" variant=\"text\" [text]=\"tab.label\"\n              [customClass]=\"'cqa-api-edit-step-tab' + (activeResponseVerificationTab === tab.value ? ' cqa-api-edit-step-tab--active' : '')\"\n              (clicked)=\"setResponseVerificationTab(tab.value)\">\n            </cqa-button>\n          </div>\n\n          <!-- Response Body tab content: verification grid -->\n          <div *ngIf=\"activeResponseVerificationTab === 'response-body'\" class=\"cqa-api-edit-step-step3-content\">\n            <div class=\"cqa-api-edit-step-verification-header-row\">\n              <span></span>\n              <cqa-button type=\"button\" variant=\"text\" text=\"Add Verification\"\n                customClass=\"cqa-api-edit-step-verification-add-link\" (clicked)=\"addVerificationRow()\">\n              </cqa-button>\n            </div>\n            <div class=\"cqa-api-edit-step-verification\">\n              <div class=\"cqa-api-edit-step-verification-grid cqa-api-edit-step-verification-grid-header\">\n                <span class=\"cqa-api-edit-step-verification-label\">S.no</span>\n                <span class=\"cqa-api-edit-step-verification-label\">JSON Path</span>\n                <span class=\"cqa-api-edit-step-verification-label\">Verification</span>\n                <span class=\"cqa-api-edit-step-verification-label\">Data Type</span>\n                <span class=\"cqa-api-edit-step-verification-label\">Expected Value</span>\n                <span class=\"cqa-api-edit-step-verification-label cqa-api-edit-step-verification-label--empty\"\n                  aria-hidden=\"true\"></span>\n              </div>\n              <div *ngFor=\"let row of verificationRows; let i = index; trackBy: trackByVerification\" [formGroup]=\"row\"\n                class=\"cqa-api-edit-step-verification-row\">\n                <span class=\"cqa-api-edit-step-verification-sno\">{{ i + 1 }}</span>\n                <cqa-custom-input [value]=\"row.get('jsonPath')?.value ?? ''\"\n                  (valueChange)=\"row.get('jsonPath')?.setValue($event)\" placeholder=\"Json Path\" [fullWidth]=\"true\"\n                  size=\"sm\" class=\"cqa-api-edit-step-verification-input\" ariaLabel=\"JSON Path\">\n                </cqa-custom-input>\n                <cqa-dynamic-select [form]=\"row\" [config]=\"verificationSelectConfig\"\n                  class=\"cqa-api-edit-step-verification-select cqa-w-full\">\n                </cqa-dynamic-select>\n                <cqa-dynamic-select [form]=\"row\" [config]=\"verificationDataTypeSelectConfig\"\n                  class=\"cqa-api-edit-step-verification-select cqa-w-full\"\n                  (selectionChange)=\"onVerificationDataTypeChange(row, $event)\">\n                </cqa-dynamic-select>\n                <!-- Expected Value: text for String/Array/Object, number for Number, dropdown for Boolean -->\n                <ng-container [ngSwitch]=\"row.get('dataType')?.value\">\n                  <cqa-dynamic-select *ngSwitchCase=\"'boolean'\" [form]=\"row\"\n                    [config]=\"verificationExpectedValueBooleanSelectConfig\"\n                    class=\"cqa-api-edit-step-verification-select cqa-api-edit-step-verification-expected-select cqa-w-full\">\n                  </cqa-dynamic-select>\n                  <cqa-custom-input *ngSwitchCase=\"'number'\" [value]=\"row.get('expectedValue')?.value ?? ''\"\n                    (valueChange)=\"row.get('expectedValue')?.setValue($event)\" placeholder=\"Expected Value (number)\"\n                    type=\"number\" [fullWidth]=\"true\" size=\"sm\"\n                    class=\"cqa-api-edit-step-verification-input cqa-api-edit-step-verification-expected-number\"\n                    ariaLabel=\"Expected Value\">\n                  </cqa-custom-input>\n                  <cqa-custom-input *ngSwitchDefault [value]=\"row.get('expectedValue')?.value ?? ''\"\n                    (valueChange)=\"row.get('expectedValue')?.setValue($event)\"\n                    placeholder=\"Expected Value in String\" [fullWidth]=\"true\" size=\"sm\"\n                    class=\"cqa-api-edit-step-verification-input\" ariaLabel=\"Expected Value\">\n                  </cqa-custom-input>\n                </ng-container>\n                <cqa-button type=\"button\" variant=\"text\" [customClass]=\"'cqa-api-edit-step-verification-delete'\"\n                  [tooltip]=\"'Remove row'\" (clicked)=\"removeVerificationRow(i)\">\n                  <svg class=\"cqa-api-edit-step-verification-delete-icon\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\"\n                    fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\" aria-hidden=\"true\">\n                    <path\n                      d=\"M10.6663 6V12.6667H5.33301V6H10.6663ZM9.66634 2H6.33301L5.66634 2.66667H3.33301V4H12.6663V2.66667H10.333L9.66634 2ZM11.9997 4.66667H3.99967V12.6667C3.99967 13.4 4.59967 14 5.33301 14H10.6663C11.3997 14 11.9997 13.4 11.9997 12.6667V4.66667Z\"\n                      fill=\"#F9BFBF\" />\n                  </svg>\n                </cqa-button>\n              </div>\n            </div>\n          </div>\n\n          <!-- Status tab content: S.no, Verification dropdown, Expected Value, add/remove rows -->\n          <div *ngIf=\"activeResponseVerificationTab === 'status'\" class=\"cqa-api-edit-step-step3-content\">\n            <div class=\"cqa-api-edit-step-verification-header-row\">\n              <span></span>\n              <cqa-button type=\"button\" variant=\"text\" text=\"Add Verification\"\n                customClass=\"cqa-api-edit-step-verification-add-link\" (clicked)=\"addStatusVerificationRow()\">\n              </cqa-button>\n            </div>\n            <div class=\"cqa-api-edit-step-status-verification\">\n              <div class=\"cqa-api-edit-step-status-verification-header\">\n                <span class=\"cqa-api-edit-step-verification-label\">S.no</span>\n                <span class=\"cqa-api-edit-step-verification-label\">Verification</span>\n                <span class=\"cqa-api-edit-step-verification-label\">Expected Value</span>\n                <span class=\"cqa-api-edit-step-verification-label cqa-api-edit-step-verification-label--empty\"\n                  aria-hidden=\"true\"></span>\n              </div>\n              <div *ngFor=\"let row of statusVerificationRows; let i = index; trackBy: trackByStatusVerification\"\n                [formGroup]=\"row\" class=\"cqa-api-edit-step-status-verification-row\">\n                <span class=\"cqa-api-edit-step-verification-sno\">{{ i + 1 }}</span>\n                <cqa-dynamic-select [form]=\"row\" [config]=\"statusVerificationSelectConfig\"\n                  class=\"cqa-api-edit-step-status-verification-select cqa-w-full\">\n                </cqa-dynamic-select>\n                <cqa-custom-input [value]=\"row.get('expectedValue')?.value ?? ''\"\n                  (valueChange)=\"row.get('expectedValue')?.setValue($event)\" placeholder=\"Expected Value\"\n                  type=\"number\" [fullWidth]=\"true\" size=\"sm\" class=\"cqa-api-edit-step-verification-input\"\n                  ariaLabel=\"Expected Value\">\n                </cqa-custom-input>\n                <cqa-button type=\"button\" variant=\"text\" [customClass]=\"'cqa-api-edit-step-verification-delete'\"\n                  [tooltip]=\"'Remove row'\" (clicked)=\"removeStatusVerificationRow(i)\">\n                  <svg class=\"cqa-api-edit-step-verification-delete-icon\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\"\n                    fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\" aria-hidden=\"true\">\n                    <path\n                      d=\"M10.6663 6V12.6667H5.33301V6H10.6663ZM9.66634 2H6.33301L5.66634 2.66667H3.33301V4H12.6663V2.66667H10.333L9.66634 2ZM11.9997 4.66667H3.99967V12.6667C3.99967 13.4 4.59967 14 5.33301 14H10.6663C11.3997 14 11.9997 13.4 11.9997 12.6667V4.66667Z\"\n                      fill=\"#F9BFBF\" />\n                  </svg>\n                </cqa-button>\n              </div>\n            </div>\n          </div>\n        </div>\n      </div>\n    </div>\n  </div>\n\n  <!-- Response Preview -->\n  <div class=\"cqa-api-edit-step-response\">\n    <h3 class=\"cqa-api-edit-step-response-title\">Response Preview</h3>\n    <pre class=\"cqa-api-edit-step-response-content\">{{ responsePreview }}</pre>\n  </div>\n\n  <!-- Step actions: one row, full width. Step 1: Cancel + Next; Step 2: Back + Next; Step 3: Back + Create -->\n  <div class=\"cqa-api-edit-step-actions\">\n    <ng-container [ngSwitch]=\"currentStep\">\n      <ng-container *ngSwitchCase=\"1\">\n        <cqa-button type=\"button\" variant=\"outlined\" btnSize=\"lg\" text=\"Cancel\"\n          customClass=\"cqa-api-edit-step-actions-btn-cancel\" (clicked)=\"onBack()\">\n        </cqa-button>\n        <cqa-button type=\"button\" variant=\"filled\" btnSize=\"lg\" text=\"Next\"\n          customClass=\"cqa-api-edit-step-actions-btn-next\" (clicked)=\"onNext()\">\n        </cqa-button>\n      </ng-container>\n      <ng-container *ngSwitchCase=\"2\">\n        <cqa-button type=\"button\" variant=\"outlined\" btnSize=\"lg\" text=\"Back\"\n          customClass=\"cqa-api-edit-step-actions-btn-back\" (clicked)=\"onBack()\">\n        </cqa-button>\n        <cqa-button type=\"button\" variant=\"filled\" btnSize=\"lg\" text=\"Next\"\n          customClass=\"cqa-api-edit-step-actions-btn-next\" (clicked)=\"onNext()\">\n        </cqa-button>\n      </ng-container>\n      <ng-container *ngSwitchCase=\"3\">\n        <cqa-button type=\"button\" variant=\"outlined\" btnSize=\"lg\" text=\"Back\"\n          customClass=\"cqa-api-edit-step-actions-btn-back\" (clicked)=\"onBack()\">\n        </cqa-button>\n        <cqa-button type=\"button\" variant=\"filled\" btnSize=\"lg\" text=\"Create\"\n          customClass=\"cqa-api-edit-step-actions-btn-create\" (clicked)=\"onCreate()\">\n        </cqa-button>\n      </ng-container>\n    </ng-container>\n  </div>\n</div>"]}