import * as _angular_core from '@angular/core';
import { InjectionToken, AfterViewInit, OnDestroy, ElementRef } from '@angular/core';
import { Terminal, ILinkProvider, ILink, ITerminalAddon } from '@xterm/xterm';
import * as _ng_atomic_core from '@ng-atomic/core';
import { InjectableComponent, NgAtomicComponent } from '@ng-atomic/core';
import * as _ng_atomic_common_services_ui from '@ng-atomic/common/services/ui';

declare enum XtermActionId {
    DATA_INPUT = "xterm:data-input",
    RESIZED = "xterm:resized",
    GITHUB_LINK_CLICK = "xterm:github-link-click",
    FILE_LINK_CLICK = "xterm:file-link-click",
    FOCUS_INPUT_REQUEST = "xterm:focus-input-request"
}
/** DI token for providing serverUUID getter to ProxyLinksAddon */
declare const XTERM_SERVER_UUID: InjectionToken<() => string | undefined>;
/** DI token for providing CLI token getter to ProxyLinksAddon */
declare const XTERM_PROXY_TOKEN: InjectionToken<() => string | undefined>;
/** DI token for providing deploy version getter to ProxyLinksAddon */
declare const XTERM_DEPLOY_VERSION: InjectionToken<() => string | null | undefined>;
/**
 * DI token for providing API endpoints (apiNext / hasura) to ProxyLinksAddon.
 * web-proxy が opener postMessage 経由でこの値を受信して使用する (環境追従)。
 */
declare const XTERM_PROXY_ENDPOINTS: InjectionToken<() => {
    apiNext: string;
    hasura: string;
} | undefined>;
declare class XtermOrganismStore extends InjectableComponent {
    static readonly DI: {
        provide: (typeOrComponent: Parameters<(typeOrFactory: _ng_atomic_core.TypeOrTypeFactory<any>) => {
            provide: any;
            useValue: () => Promise<_angular_core.Type<any>>;
        }>[0]) => (_angular_core.Provider | {
            provide: any;
            useValue: () => Promise<_angular_core.Type<any>>;
        })[];
        provideConfig: (useFactory?: _ng_atomic_common_services_ui.ReducerFactory<{
            data: string;
            interactive: boolean;
            queryResult: string;
            useInteractiveTheme: boolean;
        }> | undefined, label?: string) => _angular_core.Provider;
        injectConfig: () => _angular_core.Signal<{
            data: string;
            interactive: boolean;
            queryResult: string;
            useInteractiveTheme: boolean;
        }>;
        provideInitializer: <SI extends (store: XtermOrganismStore) => Promise<void> | void>(initializer: SI) => {
            provide: InjectionToken<(store: any) => Promise<void> | void>;
            useValue: {
                key: new () => XtermOrganismStore;
                initializer: (store: XtermOrganismStore) => Promise<void> | void;
            };
            multi: boolean;
        }[];
        initialize: (store: XtermOrganismStore) => Promise<void>;
        provideComponent: (typeOrFactory: _ng_atomic_core.TypeOrTypeFactory<any>) => {
            provide: any;
            useValue: () => Promise<_angular_core.Type<any>>;
        };
        Initializer: {
            provide<SI extends (store: XtermOrganismStore) => Promise<void> | void>(initializer: SI): {
                provide: InjectionToken<(store: any) => Promise<void> | void>;
                useValue: {
                    key: new () => XtermOrganismStore;
                    initializer: (store: XtermOrganismStore) => Promise<void> | void;
                };
                multi: boolean;
            }[];
            inject(): ((store: XtermOrganismStore) => Promise<void> | void)[];
            initializeStore(store: XtermOrganismStore): Promise<void>;
        };
        Config: {
            provide(useFactory?: _ng_atomic_common_services_ui.ReducerFactory<{
                data: string;
                interactive: boolean;
                queryResult: string;
                useInteractiveTheme: boolean;
            }> | undefined, label?: string): _angular_core.Provider;
            inject(): _angular_core.Signal<{
                data: string;
                interactive: boolean;
                queryResult: string;
                useInteractiveTheme: boolean;
            }>;
        };
    };
    readonly config: _angular_core.Signal<{
        data: string;
        interactive: boolean;
        queryResult: string;
        useInteractiveTheme: boolean;
    }>;
    readonly data: _angular_core.InputSignal<string | undefined>;
    readonly interactive: _angular_core.InputSignal<boolean>;
    readonly queryResult: _angular_core.InputSignal<string>;
    readonly useInteractiveTheme: _angular_core.InputSignal<boolean>;
    readonly totalWritten: _angular_core.InputSignal<number>;
    /** Injected serverUUID getter for proxy links (optional) */
    readonly getServerUUID: (() => string | undefined) | null;
    /** Injected CLI token getter for proxy link auto-auth (optional) */
    readonly getProxyToken: (() => string | undefined) | null;
    /** Injected deploy version getter for proxy URL host suffix (optional) */
    readonly getDeployVersion: (() => string | null | undefined) | null;
    /** Injected endpoints getter for opener-driven environment switching (optional) */
    readonly getProxyEndpoints: (() => {
        apiNext: string;
        hasura: string;
    } | undefined) | null;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XtermOrganismStore, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<XtermOrganismStore, "organisms-xterm", never, { "data": { "alias": "data"; "required": false; "isSignal": true; }; "interactive": { "alias": "interactive"; "required": false; "isSignal": true; }; "queryResult": { "alias": "queryResult"; "required": false; "isSignal": true; }; "useInteractiveTheme": { "alias": "useInteractiveTheme"; "required": false; "isSignal": true; }; "totalWritten": { "alias": "totalWritten"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

type ImageAddon = any;
declare class XtermOrganism extends NgAtomicComponent implements AfterViewInit, OnDestroy {
    readonly container: _angular_core.Signal<ElementRef<HTMLDivElement>>;
    protected readonly store: XtermOrganismStore;
    private readonly hostElement;
    readonly terminalReady: _angular_core.OutputEmitterRef<Terminal>;
    readonly githubLinkClick: _angular_core.OutputEmitterRef<number>;
    private terminal;
    private fitAddon;
    private imageAddon;
    private githubLinksAddon;
    private fileLinksAddon;
    private resizeObserver?;
    private lastDataLength;
    /** Tracks how many bytes have been processed (for totalWritten-based diff detection) */
    private lastProcessedLength;
    private readonly terminalInitialized;
    /** Tracks if initialization was skipped due to container being too small */
    private initSkippedDueToSize;
    /** IDisposable refs for explicit cleanup (prevents memory leaks on mobile) */
    private readonly disposables;
    /** Timer refs for cleanup in ngOnDestroy */
    private stableTimer;
    private resizeTimer;
    private fallbackTimer;
    constructor();
    private writeDataToTerminal;
    /**
     * Write data using totalWritten for accurate diff detection.
     * This method handles buffer overflow scenarios correctly.
     * When newBytesCount >= data.length, performs a full redraw with terminal.reset()
     * to prevent stale output from previous sessions remaining on screen.
     * @param data The current buffer content
     * @param totalWritten Total bytes written to the buffer (cumulative)
     */
    private writeDataWithTotalWritten;
    ngAfterViewInit(): void;
    private initializeTerminal;
    ngOnDestroy(): void;
    private markInitialized;
    private loadImageAddon;
    write(text: string): void;
    writeln(text: string): void;
    clear(): void;
    scrollToBottom(): void;
    scrollToTop(): void;
    scrollLines(lines: number): void;
    fit(): void;
    get cols(): number;
    get rows(): number;
    getTerminal(): Terminal | undefined;
    /**
     * Display an inline image using iTerm2's Inline Image Protocol
     * @param base64Data Base64 encoded image data (PNG, JPEG, etc.)
     * @param options Image display options
     */
    displayImage(base64Data: string, options?: {
        width?: string | number;
        height?: string | number;
        preserveAspectRatio?: boolean;
        name?: string;
    }): void;
    /**
     * Get the ImageAddon instance for advanced image operations
     */
    getImageAddon(): ImageAddon | undefined;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XtermOrganism, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<XtermOrganism, "organisms-xterm", never, {}, { "terminalReady": "terminalReady"; "githubLinkClick": "githubLinkClick"; }, never, never, true, [{ directive: typeof XtermOrganismStore; inputs: { "data": "data"; "interactive": "interactive"; "useInteractiveTheme": "useInteractiveTheme"; "totalWritten": "totalWritten"; }; outputs: {}; }]>;
}

interface GitHubLinkActivateHandler {
    (event: MouseEvent, issueNumber: number): void;
}
declare class GitHubLinkProvider implements ILinkProvider {
    private readonly _terminal;
    private readonly _handler;
    private readonly GITHUB_ISSUE_REGEX;
    constructor(_terminal: Terminal, _handler: GitHubLinkActivateHandler);
    provideLinks(bufferLineNumber: number, callback: (links: ILink[] | undefined) => void): void;
    private _mapStrIdx;
}

declare class GitHubLinksAddon implements ITerminalAddon {
    private readonly _handler;
    private _terminal?;
    private _linkProvider?;
    constructor(_handler: GitHubLinkActivateHandler);
    activate(terminal: Terminal): void;
    dispose(): void;
}

/**
 * Drop-in replacement for @xterm/addon-web-links that supports
 * URLs spanning wrapped terminal lines.
 * localhost/127.0.0.1 URLs are skipped (handled by ProxyLinksAddon).
 */
declare class WebLinksAddon implements ITerminalAddon {
    private readonly _handler?;
    private _linkProvider?;
    constructor(_handler?: ((event: MouseEvent, uri: string) => void) | undefined);
    activate(terminal: Terminal): void;
    dispose(): void;
}

type ServerUUIDGetter = () => string | undefined;
type TokenGetter = () => string | undefined;
type DeployVersionGetter = () => string | null | undefined;
interface ProxyEndpoints {
    apiNext: string;
    hasura: string;
}
type EndpointsGetter = () => ProxyEndpoints | undefined;
/**
 * deployVersion を proxy.machina.at のサブドメイン suffix に変換。
 *
 * 変換ルール:
 * - null / 'stable'               → '' (suffix なし)
 * - 'pr-{N}'                      → '--pr-{N}'
 * - 'dev' / 'develop'             → '--dev'
 * - 'v{X.Y.Z}' / 'v{X.Y.Z-pre.N}' → '--v{X-Y-Z}[--pre-N]' (dot → dash)
 * - 'X.Y.Z' (v prefix なし)        → 同上
 * - その他                         → '' (fallback)
 */
declare function deployVersionToHostSuffix(version: string | null | undefined): string;
declare class ProxyLinkProvider implements ILinkProvider {
    private readonly _terminal;
    private readonly _getServerUUID;
    private readonly _getToken?;
    private readonly _handler;
    private readonly _getDeployVersion?;
    private readonly _getEndpoints?;
    constructor(_terminal: Terminal, _getServerUUID: ServerUUIDGetter, _getToken?: TokenGetter | undefined, _handler?: (event: MouseEvent, proxyUrl: string) => void, _getDeployVersion?: DeployVersionGetter | undefined, _getEndpoints?: EndpointsGetter | undefined);
    provideLinks(bufferLineNumber: number, callback: (links: ILink[] | undefined) => void): void;
}
declare function toProxyUrl(serverUUID: string, localhostUrl: string, deployVersion?: string | null): string | null;

/**
 * xterm.js addon: localhost URLをmachina web proxyにリダイレクトするリンクを表示。
 *
 * Usage:
 * ```typescript
 * const addon = new ProxyLinksAddon(() => currentServerUUID);
 * terminal.loadAddon(addon);
 * ```
 */
declare class ProxyLinksAddon implements ITerminalAddon {
    private readonly _getServerUUID;
    private readonly _getToken?;
    private readonly _handler?;
    private readonly _getDeployVersion?;
    private readonly _getEndpoints?;
    private _linkProvider?;
    constructor(_getServerUUID: ServerUUIDGetter, _getToken?: TokenGetter | undefined, _handler?: ((event: MouseEvent, proxyUrl: string) => void) | undefined, _getDeployVersion?: DeployVersionGetter | undefined, _getEndpoints?: EndpointsGetter | undefined);
    activate(terminal: Terminal): void;
    dispose(): void;
}

/**
 * Utility functions for displaying images in xterm using SIXEL format
 */
interface SvgToSixelOptions {
    width?: number;
    height?: number;
    backgroundColor?: string;
    textColor?: string;
}
/**
 * Generate ASCII art text using figlet
 * Note: figlet is loaded dynamically as it's not available in browser environments
 */
declare function generateAsciiArt(text: string, font?: string): Promise<string>;
/**
 * Convert ASCII art text to SVG with transparent background
 */
declare function asciiArtToSvg(asciiArt: string, options?: {
    textColor?: string;
    fontSize?: number;
}): string;
/**
 * Convert SVG to SIXEL format for xterm display
 */
declare function svgToSixel(svgString: string, options?: SvgToSixelOptions): Promise<string>;
/**
 * Generate MACHINA ASCII art banner as SIXEL
 */
declare function getMachinaAsciiArtSixel(options?: SvgToSixelOptions): Promise<string>;

export { GitHubLinkProvider, GitHubLinksAddon, ProxyLinkProvider, ProxyLinksAddon, WebLinksAddon, XTERM_DEPLOY_VERSION, XTERM_PROXY_ENDPOINTS, XTERM_PROXY_TOKEN, XTERM_SERVER_UUID, XtermActionId, XtermOrganism, XtermOrganismStore, asciiArtToSvg, deployVersionToHostSuffix, generateAsciiArt, getMachinaAsciiArtSixel, svgToSixel, toProxyUrl };
export type { DeployVersionGetter, EndpointsGetter, GitHubLinkActivateHandler, ProxyEndpoints, ServerUUIDGetter, SvgToSixelOptions, TokenGetter };
//# sourceMappingURL=xxmachina-components-organisms-xterm.d.ts.map