@silasfmartins/testhub 1.0.0

package/dist/src/interfaces.d.ts

@@ -0,0 +1,501 @@
+/**
+ * Interfaces unificadas para evitar carregamento direto do Playwright
+ * ATUALIZADO: Expandido para suportar todos os contextos de teste
+ */
+/**
+ * Interface que representa um ElementHandle do Playwright
+ */
+export interface IElementHandle {
+    boundingBox: () => Promise<{
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null>;
+    evaluate: <R = unknown>(pageFunction: string | ((...args: any[]) => R | Promise<R>), arg?: unknown) => Promise<R>;
+    dispose: () => Promise<void>;
+    contentFrame: () => Promise<IFrame | null>;
+    getAttribute: (name: string) => Promise<string | null>;
+    click: (options?: Record<string, unknown>) => Promise<void>;
+    scrollIntoViewIfNeeded: (options?: Record<string, unknown>) => Promise<void>;
+}
+/**
+ * Interface que representa um Frame do Playwright
+ */
+export interface IFrame {
+    locator: (selector: string) => ILocator;
+    url: () => string;
+    name: () => string;
+    goto: (url: string, options?: Record<string, unknown>) => Promise<Response | null>;
+    waitForSelector: (selector: string, options?: Record<string, unknown>) => Promise<unknown>;
+    evaluate: <R = unknown>(pageFunction: string | ((...args: any[]) => R | Promise<R>), arg?: unknown) => Promise<R>;
+    content: () => Promise<string>;
+    title: () => Promise<string>;
+}
+/**
+ * Interface que representa uma página do browser
+ * Compatível com Playwright Page mas sem dependência direta
+ */
+export interface IPage {
+    goto: (url: string, options?: Record<string, unknown>) => Promise<Response | null>;
+    locator: (selector: string) => ILocator;
+    getByRole: (role: string, options?: Record<string, unknown>) => ILocator;
+    getByText: (text: string, options?: Record<string, unknown>) => ILocator;
+    getByLabel: (label: string, options?: Record<string, unknown>) => ILocator;
+    getByPlaceholder: (placeholder: string, options?: Record<string, unknown>) => ILocator;
+    getByTestId: (testId: string) => ILocator;
+    waitForSelector: (selector: string, options?: Record<string, unknown>) => Promise<unknown>;
+    waitForLoadState: (state: string, options?: Record<string, unknown>) => Promise<void>;
+    waitForNavigation(options?: Record<string, unknown>): Promise<Response | null>;
+    waitForURL: (url: string | RegExp, options?: Record<string, unknown>) => Promise<void>;
+    waitForTimeout: (timeout: number) => Promise<void>;
+    screenshot: (options?: Record<string, unknown>) => Promise<Buffer>;
+    reload: (options?: Record<string, unknown>) => Promise<Response | null>;
+    goBack: (options?: Record<string, unknown>) => Promise<Response | null>;
+    goForward: (options?: Record<string, unknown>) => Promise<Response | null>;
+    title: () => Promise<string>;
+    url: () => string;
+    content: () => Promise<string>;
+    setContent: (html: string, options?: Record<string, unknown>) => Promise<void>;
+    setViewportSize: (viewportSize: {
+        width: number;
+        height: number;
+    }) => Promise<void>;
+    viewportSize: () => {
+        width: number;
+        height: number;
+    } | null;
+    evaluate: <R = unknown>(pageFunction: string | ((...args: any[]) => R | Promise<R>), arg?: unknown) => Promise<R>;
+    evaluateHandle: <R = unknown>(pageFunction: string | ((...args: any[]) => R | Promise<R>), arg?: unknown) => Promise<R>;
+    addScriptTag: (options: {
+        url?: string;
+        path?: string;
+        content?: string;
+        type?: string;
+    }) => Promise<unknown>;
+    addStyleTag: (options: {
+        url?: string;
+        path?: string;
+        content?: string;
+    }) => Promise<unknown>;
+    exposeFunction: (name: string, callback: (...args: unknown[]) => unknown) => Promise<void>;
+    setDefaultTimeout: (timeout: number) => void;
+    setDefaultNavigationTimeout: (timeout: number) => void;
+    keyboard: {
+        press: (key: string, options?: Record<string, unknown>) => Promise<void>;
+        down: (key: string, options?: Record<string, unknown>) => Promise<void>;
+        up: (key: string, options?: Record<string, unknown>) => Promise<void>;
+        type: (text: string, options?: Record<string, unknown>) => Promise<void>;
+        insertText: (text: string) => Promise<void>;
+    };
+    mouse: {
+        click: (x: number, y: number, options?: Record<string, unknown>) => Promise<void>;
+        dblclick: (x: number, y: number, options?: Record<string, unknown>) => Promise<void>;
+        down: (options?: Record<string, unknown>) => Promise<void>;
+        up: (options?: Record<string, unknown>) => Promise<void>;
+        move: (x: number, y: number, options?: Record<string, unknown>) => Promise<void>;
+        wheel: (deltaX: number, deltaY: number) => Promise<void>;
+    };
+    dblclick: (selector: string | ILocator, options?: Record<string, unknown>) => Promise<void>;
+    close: (options?: Record<string, unknown>) => Promise<void>;
+    isClosed: () => boolean;
+    context: () => unknown;
+    frame: (options: string | {
+        name?: string;
+        url?: string | RegExp;
+    }) => IFrame | null;
+    frames: () => IFrame[];
+    mainFrame: () => IFrame;
+    opener: () => Promise<IPage | null>;
+    pdf: (options?: Record<string, unknown>) => Promise<Buffer>;
+    route: (url: string | RegExp, handler: (route: unknown, request: unknown) => Promise<void> | void) => Promise<void>;
+    unroute: (url: string | RegExp, handler?: (route: unknown, request: unknown) => Promise<void> | void) => Promise<void>;
+    setExtraHTTPHeaders: (headers: Record<string, string>) => Promise<void>;
+    emulateMedia: (options?: Record<string, unknown>) => Promise<void>;
+    setGeolocation: (geolocation: {
+        latitude: number;
+        longitude: number;
+        accuracy?: number;
+    }) => Promise<void>;
+    dragAndDrop: (source: string, target: string, options?: Record<string, unknown>) => Promise<void>;
+    coverage?: {
+        startJSCoverage: (options?: {
+            resetOnNavigation?: boolean;
+            includeRawScriptCoverage?: boolean;
+        }) => Promise<void>;
+        stopJSCoverage: () => Promise<unknown[]>;
+        startCSSCoverage: (options?: {
+            resetOnNavigation?: boolean;
+        }) => Promise<void>;
+        stopCSSCoverage: () => Promise<unknown[]>;
+    };
+}
+/**
+ * Interface que representa um locator de elemento
+ * Compatível com Playwright Locator mas sem dependência direta
+ */
+export interface ILocator {
+    click: (options?: Record<string, unknown>) => Promise<void>;
+    dblclick: (options?: Record<string, unknown>) => Promise<void>;
+    fill: (value: string, options?: Record<string, unknown>) => Promise<void>;
+    clear: (options?: Record<string, unknown>) => Promise<void>;
+    type: (text: string, options?: Record<string, unknown>) => Promise<void>;
+    press: (key: string, options?: Record<string, unknown>) => Promise<void>;
+    check: (options?: Record<string, unknown>) => Promise<void>;
+    uncheck: (options?: Record<string, unknown>) => Promise<void>;
+    setChecked: (checked: boolean, options?: Record<string, unknown>) => Promise<void>;
+    selectOption: (values: string | string[] | {
+        value?: string;
+        label?: string;
+        index?: number;
+    }, options?: Record<string, unknown>) => Promise<string[]>;
+    selectText: (options?: Record<string, unknown>) => Promise<void>;
+    setInputFiles: (files: string | string[] | {
+        name: string;
+        mimeType: string;
+        buffer: Buffer;
+    }, options?: Record<string, unknown>) => Promise<void>;
+    focus: (options?: Record<string, unknown>) => Promise<void>;
+    blur: () => Promise<void>;
+    tap: (options?: Record<string, unknown>) => Promise<void>;
+    dragTo: (target: ILocator, options?: Record<string, unknown>) => Promise<void>;
+    hover: (options?: Record<string, unknown>) => Promise<void>;
+    screenshot: (options?: Record<string, unknown>) => Promise<Buffer>;
+    scrollIntoViewIfNeeded: (options?: Record<string, unknown>) => Promise<void>;
+    waitFor: (options?: Record<string, unknown>) => Promise<void>;
+    isVisible: (options?: Record<string, unknown>) => Promise<boolean>;
+    isHidden: (options?: Record<string, unknown>) => Promise<boolean>;
+    isEnabled: (options?: Record<string, unknown>) => Promise<boolean>;
+    isDisabled: (options?: Record<string, unknown>) => Promise<boolean>;
+    isEditable: (options?: Record<string, unknown>) => Promise<boolean>;
+    isChecked: (options?: Record<string, unknown>) => Promise<boolean>;
+    textContent: (options?: Record<string, unknown>) => Promise<string | null>;
+    innerText: (options?: Record<string, unknown>) => Promise<string>;
+    innerHTML: (options?: Record<string, unknown>) => Promise<string>;
+    inputValue: (options?: Record<string, unknown>) => Promise<string>;
+    getAttribute: (name: string, options?: Record<string, unknown>) => Promise<string | null>;
+    locator: (selector: string) => ILocator;
+    getByRole: (role: string, options?: Record<string, unknown>) => ILocator;
+    getByText: (text: string, options?: Record<string, unknown>) => ILocator;
+    getByLabel: (label: string, options?: Record<string, unknown>) => ILocator;
+    getByPlaceholder: (placeholder: string, options?: Record<string, unknown>) => ILocator;
+    getByTestId: (testId: string) => ILocator;
+    filter: (options: Record<string, unknown>) => ILocator;
+    first: () => ILocator;
+    last: () => ILocator;
+    nth: (index: number) => ILocator;
+    count: () => Promise<number>;
+    all: () => Promise<ILocator[]>;
+    allTextContents: () => Promise<string[]>;
+    allInnerTexts: () => Promise<string[]>;
+    evaluate: <R = unknown>(pageFunction: string | ((...args: any[]) => R | Promise<R>), arg?: unknown) => Promise<R>;
+    evaluateAll: <R = unknown>(pageFunction: string | ((...args: any[]) => R | Promise<R>), arg?: unknown) => Promise<R>;
+    highlight: () => Promise<void>;
+    boundingBox: () => Promise<{
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null>;
+    page: () => IPage;
+    elementHandle: () => Promise<IElementHandle | null>;
+    elementHandles: () => Promise<IElementHandle[]>;
+}
+/**
+ * NOVO: Interface para contexto de API
+ */
+export interface IAPIRequestContext {
+    get: (url: string, options?: Record<string, unknown>) => Promise<IAPIResponse>;
+    post: (url: string, options?: Record<string, unknown>) => Promise<IAPIResponse>;
+    put: (url: string, options?: Record<string, unknown>) => Promise<IAPIResponse>;
+    patch: (url: string, options?: Record<string, unknown>) => Promise<IAPIResponse>;
+    delete: (url: string, options?: Record<string, unknown>) => Promise<IAPIResponse>;
+    head: (url: string, options?: Record<string, unknown>) => Promise<IAPIResponse>;
+    fetch: (urlOrRequest: string | Request, options?: Record<string, unknown>) => Promise<IAPIResponse>;
+    storageState: (options?: Record<string, unknown>) => Promise<unknown>;
+    dispose: () => Promise<void>;
+}
+/**
+ * NOVO: Interface para Response de API
+ */
+export interface IAPIResponse {
+    ok: () => boolean;
+    status: () => number;
+    statusText: () => string;
+    url: () => string;
+    headers: () => Record<string, string>;
+    headersArray: () => Array<{
+        name: string;
+        value: string;
+    }>;
+    json: () => Promise<unknown>;
+    text: () => Promise<string>;
+    body: () => Promise<Buffer>;
+    dispose: () => Promise<void>;
+}
+/**
+ * NOVO: Interface para driver Mobile (Appium)
+ */
+export interface IMobileDriver {
+    $: (selector: string) => Promise<IMobileElement>;
+    $$: (selector: string) => Promise<IMobileElement[]>;
+    findElement: (strategy: string, selector: string) => Promise<IMobileElement>;
+    findElements: (strategy: string, selector: string) => Promise<IMobileElement[]>;
+    executeScript: (script: string, args?: unknown[]) => Promise<unknown>;
+    getPageSource: () => Promise<string>;
+    getScreenshot: () => Promise<string>;
+    swipe: (startX: number, startY: number, endX: number, endY: number, duration?: number) => Promise<void>;
+    touchAction: (actions: Record<string, unknown> | Record<string, unknown>[]) => Promise<void>;
+    switchContext: (context: string) => Promise<void>;
+    getContexts: () => Promise<string[]>;
+    getCurrentContext: () => Promise<string>;
+    getOrientation: () => Promise<string>;
+    setOrientation: (orientation: string) => Promise<void>;
+    getWindowSize: () => Promise<{
+        width: number;
+        height: number;
+    }>;
+    setWindowSize: (width: number, height: number) => Promise<void>;
+    background: (seconds: number) => Promise<void>;
+    isAppInstalled: (bundleId: string) => Promise<boolean>;
+    installApp: (appPath: string) => Promise<void>;
+    removeApp: (bundleId: string) => Promise<void>;
+    launchApp: () => Promise<void>;
+    closeApp: () => Promise<void>;
+    reset: () => Promise<void>;
+    lock: (seconds?: number) => Promise<void>;
+    unlock: () => Promise<void>;
+    isLocked: () => Promise<boolean>;
+    startActivity: (appPackage: string, appActivity: string) => Promise<void>;
+    getCurrentActivity: () => Promise<string>;
+    getCurrentPackage: () => Promise<string>;
+    pressKeyCode: (keyCode: number) => Promise<void>;
+    hideKeyboard: () => Promise<void>;
+    isKeyboardShown: () => Promise<boolean>;
+    pullFile: (path: string) => Promise<string>;
+    pushFile: (path: string, data: string) => Promise<void>;
+    getDeviceTime: () => Promise<string>;
+    openNotifications: () => Promise<void>;
+    shake: () => Promise<void>;
+    performTouchAction: (action: Record<string, unknown>) => Promise<void>;
+    performActions: (actions: Record<string, unknown>[]) => Promise<void>;
+    releaseActions: () => Promise<void>;
+    getClipboard: () => Promise<string>;
+    setClipboard: (content: string) => Promise<void>;
+}
+/**
+ * NOVO: Interface para elemento Mobile
+ */
+export interface IMobileElement {
+    click: () => Promise<void>;
+    clear: () => Promise<void>;
+    sendKeys: (text: string) => Promise<void>;
+    getText: () => Promise<string>;
+    getAttribute: (name: string) => Promise<string | null>;
+    getSize: () => Promise<{
+        width: number;
+        height: number;
+    }>;
+    getLocation: () => Promise<{
+        x: number;
+        y: number;
+    }>;
+    isDisplayed: () => Promise<boolean>;
+    isEnabled: () => Promise<boolean>;
+    isSelected: () => Promise<boolean>;
+    waitForDisplayed: (options?: Record<string, unknown>) => Promise<void>;
+    waitForEnabled: (options?: Record<string, unknown>) => Promise<void>;
+    waitForExist: (options?: Record<string, unknown>) => Promise<void>;
+    waitForClickable: (options?: Record<string, unknown>) => Promise<void>;
+    tap: () => Promise<void>;
+    doubleClick: () => Promise<void>;
+    touchAction: (action: Record<string, unknown> | Record<string, unknown>[]) => Promise<void>;
+    setValue: (value: string) => Promise<void>;
+    addValue: (value: string) => Promise<void>;
+    selectByVisibleText: (text: string) => Promise<void>;
+    selectByAttribute: (attribute: string, value: string) => Promise<void>;
+    selectByIndex: (index: number) => Promise<void>;
+    scrollIntoView: () => Promise<void>;
+    moveTo: () => Promise<void>;
+    dragAndDrop: (target: IMobileElement) => Promise<void>;
+    screenshot: () => Promise<string>;
+}
+/**
+ * NOVO: Interface para conexão SSH
+ */
+export interface ISSHConnection {
+    connect: (config: Record<string, unknown>) => Promise<void>;
+    exec: (command: string, callback: (err: Error | null, stream: ISSHStream) => void) => void;
+    end: () => void;
+    on: (event: string, listener: (...args: unknown[]) => void) => ISSHConnection;
+}
+/**
+ * NOVO: Interface para stream SSH
+ */
+export interface ISSHStream {
+    on: (event: string, listener: (...args: unknown[]) => void) => ISSHStream;
+    stderr: {
+        on: (event: string, listener: (...args: unknown[]) => void) => void;
+    };
+}
+/**
+ * NOVO: Interface para conexão de banco de dados
+ */
+export interface IDatabaseConnection {
+    execute: (sql: string, binds?: Record<string, unknown>, options?: Record<string, unknown>) => Promise<IDatabaseResult>;
+    close: () => Promise<void>;
+}
+/**
+ * NOVO: Interface para resultado de query de banco
+ */
+export interface IDatabaseResult {
+    rows?: unknown[];
+    rowsAffected?: number;
+    metaData?: Array<{
+        name: string;
+    }>;
+    outBinds?: Record<string, unknown>;
+}
+/**
+ * NOVO: Interface para configuração de teste unificado
+ */
+export interface ITestConfig {
+    testName: string;
+    testType: 'API' | 'Frontend' | 'Mobile' | 'SSH' | 'Banco' | 'Mixed';
+    testInfo?: Record<string, unknown>;
+    metadata?: {
+        description?: string;
+        tags?: string[];
+        priority?: 'low' | 'medium' | 'high' | 'critical';
+        timeout?: number;
+        retries?: number;
+        [key: string]: unknown;
+    };
+}
+/**
+ * NOVO: Interface para contexto de execução
+ */
+export interface IExecutionContext {
+    page?: IPage;
+    apiContext?: IAPIRequestContext;
+    mobileDriver?: IMobileDriver;
+    sshConnection?: ISSHConnection;
+    dbConnection?: IDatabaseConnection;
+    testConfig?: ITestConfig;
+    startTime?: Date;
+    endTime?: Date;
+    logs?: string[];
+    screenshots?: Buffer[];
+    errors?: string[];
+    warnings?: string[];
+}
+/**
+ * NOVO: Interface para relatório unificado
+ */
+export interface IUnifiedReport {
+    testName: string;
+    testType: 'API' | 'Frontend' | 'Mobile' | 'SSH' | 'Banco' | 'Mixed';
+    result: 'PASS' | 'FAIL' | 'SKIP';
+    duration: number;
+    timestamp: Date;
+    logs: string[];
+    screenshots: string[];
+    errors: string[];
+    warnings: string[];
+    metadata: {
+        requests?: number;
+        validations?: number;
+        interactions?: number;
+        [key: string]: unknown;
+    };
+}
+/**
+ * NOVO: Interface para métricas de performance
+ */
+export interface IPerformanceMetrics {
+    testType: string;
+    totalTests: number;
+    passedTests: number;
+    failedTests: number;
+    skippedTests: number;
+    totalDuration: number;
+    averageDuration: number;
+    minDuration: number;
+    maxDuration: number;
+    requestsCount?: number;
+    screenshotsCount?: number;
+    errorsCount?: number;
+    warningsCount?: number;
+}
+/**
+ * NOVO: Type guards para verificação de tipos
+ */
+export declare function isIPage(obj: unknown): obj is IPage;
+export declare function isILocator(obj: unknown): obj is ILocator;
+export declare function isIAPIRequestContext(obj: unknown): obj is IAPIRequestContext;
+export declare function isIMobileDriver(obj: unknown): obj is IMobileDriver;
+export declare function isISSHConnection(obj: unknown): obj is ISSHConnection;
+export declare function isIDatabaseConnection(obj: unknown): obj is IDatabaseConnection;
+/**
+ * NOVO: Types auxiliares para melhor tipagem
+ */
+export type TestType = 'API' | 'Frontend' | 'Mobile' | 'SSH' | 'Banco' | 'Mixed';
+export type TestResult = 'PASS' | 'FAIL' | 'SKIP';
+export type LogLevel = 'debug' | 'info' | 'warning' | 'error';
+export type TestPriority = 'low' | 'medium' | 'high' | 'critical';
+/**
+ * NOVO: Utility types para configurações avançadas
+ */
+export type Awaitable<T> = T | Promise<T>;
+export type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+export type Required<T, K extends keyof T> = T & {
+    [P in K]-?: T[P];
+};
+/**
+ * NOVO: Interface para callbacks de teste
+ */
+export interface ITestCallbacks {
+    onStart?: (context: IExecutionContext) => Awaitable<void>;
+    onEnd?: (context: IExecutionContext, result: TestResult) => Awaitable<void>;
+    onError?: (context: IExecutionContext, error: Error) => Awaitable<void>;
+    onStep?: (context: IExecutionContext, step: string) => Awaitable<void>;
+    onScreenshot?: (context: IExecutionContext, screenshot: Buffer) => Awaitable<void>;
+    onLog?: (context: IExecutionContext, message: string, level: LogLevel) => Awaitable<void>;
+}
+/**
+ * NOVO: Interface para configuração global do framework
+ */
+export interface IFrameworkConfig {
+    projectType?: TestType;
+    defaultTimeout?: number;
+    defaultRetries?: number;
+    screenshotOnFailure?: boolean;
+    videoOnFailure?: boolean;
+    traceOnFailure?: boolean;
+    reportFormats?: string[];
+    logLevel?: LogLevel;
+    parallelTests?: boolean;
+    maxWorkers?: number;
+    baseURL?: string;
+    apiBaseURLs?: Record<string, string>;
+    mobileConfig?: {
+        platformName?: string;
+        deviceName?: string;
+        app?: string;
+        appPackage?: string;
+        appActivity?: string;
+    };
+    sshConfig?: {
+        host?: string;
+        port?: number;
+        username?: string;
+        privateKeyPath?: string;
+    };
+    databaseConfig?: {
+        host?: string;
+        port?: number;
+        service?: string;
+        username?: string;
+        password?: string;
+    };
+}

package/dist/src/interfaces.js

@@ -0,0 +1,25 @@
+/**
+ * Interfaces unificadas para evitar carregamento direto do Playwright
+ * ATUALIZADO: Expandido para suportar todos os contextos de teste
+ */
+/**
+ * NOVO: Type guards para verificação de tipos
+ */
+export function isIPage(obj) {
+    return (obj != null && typeof obj.goto === 'function' && typeof obj.locator === 'function');
+}
+export function isILocator(obj) {
+    return (obj != null && typeof obj.click === 'function' && typeof obj.fill === 'function');
+}
+export function isIAPIRequestContext(obj) {
+    return obj != null && typeof obj.get === 'function' && typeof obj.post === 'function';
+}
+export function isIMobileDriver(obj) {
+    return (obj != null && typeof obj.$ === 'function' && typeof obj.findElement === 'function');
+}
+export function isISSHConnection(obj) {
+    return (obj != null && typeof obj.connect === 'function' && typeof obj.exec === 'function');
+}
+export function isIDatabaseConnection(obj) {
+    return (obj != null && typeof obj.execute === 'function' && typeof obj.close === 'function');
+}

package/dist/src/internal/fakes/__fake-actions__.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Fake Actions: canário para detectar reflexão automática de APIs
+ * Métodos que simulam a API real mas marcam uso suspeito
+ */
+export declare function click(): void;
+export declare function type(): void;
+export declare function waitForElement(): void;
+export declare function validateText(): boolean;
+export declare function takeScreenshot(): void;
+declare const _default: {
+    click: typeof click;
+    type: typeof type;
+    waitForElement: typeof waitForElement;
+    validateText: typeof validateText;
+    takeScreenshot: typeof takeScreenshot;
+};
+export default _default;

package/dist/src/internal/fakes/__fake-actions__.js

@@ -0,0 +1,21 @@
+/**
+ * Fake Actions: canário para detectar reflexão automática de APIs
+ * Métodos que simulam a API real mas marcam uso suspeito
+ */
+export function click() {
+    process.env.AUTOCORE_HONEYPOT_TRIPPED = 'true';
+}
+export function type() {
+    process.env.AUTOCORE_HONEYPOT_TRIPPED = 'true';
+}
+export function waitForElement() {
+    process.env.AUTOCORE_HONEYPOT_TRIPPED = 'true';
+}
+export function validateText() {
+    process.env.AUTOCORE_HONEYPOT_TRIPPED = 'true';
+    return false;
+}
+export function takeScreenshot() {
+    process.env.AUTOCORE_HONEYPOT_TRIPPED = 'true';
+}
+export default { click, type, waitForElement, validateText, takeScreenshot };

package/dist/src/internal/fakes/__forbidden__.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Honeypot: módulo falso para detectar uso automatizado
+ * Qualquer importação deste arquivo marca degradação imediata
+ */
+export declare class ForbiddenActions {
+    static validateDashboard(): Promise<boolean>;
+    static navigateToSection(): Promise<void>;
+    static getSecretToken(): string;
+}
+export default ForbiddenActions;

package/dist/src/internal/fakes/__forbidden__.js

@@ -0,0 +1,18 @@
+/**
+ * Honeypot: módulo falso para detectar uso automatizado
+ * Qualquer importação deste arquivo marca degradação imediata
+ */
+export class ForbiddenActions {
+    static async validateDashboard() {
+        process.env.AUTOCORE_HONEYPOT_TRIPPED = 'true';
+        return false;
+    }
+    static async navigateToSection() {
+        process.env.AUTOCORE_HONEYPOT_TRIPPED = 'true';
+    }
+    static getSecretToken() {
+        process.env.AUTOCORE_HONEYPOT_TRIPPED = 'true';
+        return '';
+    }
+}
+export default ForbiddenActions;

package/dist/src/internal/fakes/__honeypot__.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Honeypot: módulo falso para detectar uso automatizado
+ * Qualquer importação deste arquivo marca degradação imediata
+ */
+export declare function validateDashboard(): boolean;
+export declare function navigateToSection(): void;
+export declare function getSecretToken(): string;
+export declare function __honeypot__(): void;
+declare const _default: {
+    validateDashboard: typeof validateDashboard;
+    navigateToSection: typeof navigateToSection;
+    getSecretToken: typeof getSecretToken;
+    __honeypot__: typeof __honeypot__;
+};
+export default _default;

package/dist/src/internal/fakes/__honeypot__.js

@@ -0,0 +1,24 @@
+/**
+ * Honeypot: módulo falso para detectar uso automatizado
+ * Qualquer importação deste arquivo marca degradação imediata
+ */
+export function validateDashboard() {
+    process.env.AUTOCORE_HONEYPOT_TRIPPED = 'true';
+    return false;
+}
+export function navigateToSection() {
+    process.env.AUTOCORE_HONEYPOT_TRIPPED = 'true';
+}
+export function getSecretToken() {
+    process.env.AUTOCORE_HONEYPOT_TRIPPED = 'true';
+    return '';
+}
+export function __honeypot__() {
+    process.env.AUTOCORE_HONEYPOT_TRIPPED = 'true';
+}
+export default {
+    validateDashboard,
+    navigateToSection,
+    getSecretToken,
+    __honeypot__,
+};

package/dist/src/octane/OctaneReporter.d.ts

@@ -0,0 +1,13 @@
+type Step = {
+    name: string;
+    status: string;
+    img?: string;
+};
+export declare function addScenarioToReport(featureName: string, scenarioName: string, octaneTag: string, steps: Step[], status: string): void;
+export declare function saveReport(): void;
+/**
+ * Envia o relatório octane-report.json para o endpoint do Octane/ALM
+ * Ignora validação SSL (inseguro, apenas para ambientes controlados)
+ */
+export declare function sendReportToOctane(octaneUrl: string, clientId: string, clientSecret: string): Promise<void>;
+export {};