@almadar/ui 5.111.0 → 5.113.0

package/dist/hooks/useAuthContext.d.ts

@@ -1,25 +0,0 @@
-/**
- * Auth Context Hook Stub
- *
- * Provides a placeholder auth context for the design system.
- * Applications should provide their own AuthContext provider
- * that implements this interface.
- */
-export interface AuthUser {
-    uid: string;
-    email: string | null;
-    displayName: string | null;
-    photoURL: string | null;
-}
-export interface AuthContextValue {
-    user: AuthUser | null;
-    loading: boolean;
-    signIn?: () => Promise<void>;
-    signOut?: () => Promise<void>;
-}
-/**
- * Stub hook that returns empty auth context.
- * Applications should wrap their app with an AuthProvider
- * that supplies real auth state.
- */
-export declare function useAuthContext(): AuthContextValue;

package/dist/hooks/useCamera.d.ts

@@ -1,57 +0,0 @@
-import type { CameraState } from '../lib/isometricTypes';
-interface CameraResult {
-    /** Mutable camera state ref (x, y, zoom) */
-    cameraRef: React.MutableRefObject<CameraState>;
-    /** Target camera position for smooth lerp centering. Set to null when reached. */
-    targetCameraRef: React.MutableRefObject<{
-        x: number;
-        y: number;
-    } | null>;
-    /** Whether the user is currently dragging */
-    isDragging: () => boolean;
-    /** Total drag distance — used to distinguish click from pan (threshold: 5px) */
-    dragDistance: () => number;
-    /** Mouse down handler — starts panning */
-    handleMouseDown: (e: React.MouseEvent) => void;
-    /** Mouse up handler — stops panning */
-    handleMouseUp: () => void;
-    /** Mouse move handler — pans camera if dragging, returns true if panning */
-    handleMouseMove: (e: React.MouseEvent, drawFn?: () => void) => boolean;
-    /** Mouse leave handler — cancels drag */
-    handleMouseLeave: () => void;
-    /** Wheel handler — zoom in/out */
-    handleWheel: (e: React.WheelEvent, drawFn?: () => void) => void;
-    /** Pointer down — starts panning (mouse/touch/pen via Pointer Events). */
-    handlePointerDown: (e: React.PointerEvent) => void;
-    /** Pointer up — stops panning. */
-    handlePointerUp: () => void;
-    /** Pointer move — pans camera if dragging, returns true if panning. */
-    handlePointerMove: (e: React.PointerEvent, drawFn?: () => void) => boolean;
-    /** Apply a two-finger pan delta (screen px) directly to the camera. */
-    panBy: (dx: number, dy: number, drawFn?: () => void) => void;
-    /**
-     * Multiplicative zoom by `factor` keeping the world point under (centerX,centerY)
-     * — screen px relative to the canvas — fixed. Used by wheel + pinch.
-     */
-    zoomAtPoint: (factor: number, centerX: number, centerY: number, viewportSize: {
-        width: number;
-        height: number;
-    }, drawFn?: () => void) => void;
-    /** Convert screen coordinates to world coordinates (inverse camera transform) */
-    screenToWorld: (clientX: number, clientY: number, canvas: HTMLCanvasElement, viewportSize: {
-        width: number;
-        height: number;
-    }) => {
-        x: number;
-        y: number;
-    };
-    /** Lerp camera toward target. Call in animation loop. Returns true if still animating. */
-    lerpToTarget: (t?: number) => boolean;
-}
-/**
- * Camera hook for pan/zoom canvas rendering.
- *
- * @returns Camera state, event handlers, and coordinate conversion
- */
-export declare function useCamera(): CameraResult;
-export {};

package/dist/hooks/useCanvasGestures.d.ts

@@ -1,44 +0,0 @@
-/**
- * Unified pointer/touch gesture detection for canvas surfaces (graph, isometric, etc.).
- *
- * It owns the hard part — pointer tracking + two-finger pinch (scale factor + centroid) —
- * and DELEGATES application to the consumer via callbacks, so each canvas applies pan/zoom
- * in its own coordinate convention (screen-offset vs world-camera). A single pointer is
- * passed straight through to the consumer's domain handlers (pan / node-drag / tile-select);
- * a second pointer takes over as a pinch and cancels any in-flight single-pointer action.
- *
- * Pointer Events cover mouse, touch and pen, so this REPLACES mouse handlers — no dual paths.
- */
-export interface CanvasGestureCallbacks {
-    /** Single-pointer down — start the consumer's pan / drag / select (domain-specific). */
-    onPointerDown?: (e: React.PointerEvent<HTMLCanvasElement>) => void;
-    /** Single-pointer move. */
-    onPointerMove?: (e: React.PointerEvent<HTMLCanvasElement>) => void;
-    /** Single-pointer up. */
-    onPointerUp?: (e: React.PointerEvent<HTMLCanvasElement>) => void;
-    /**
-     * Multiplicative zoom around a canvas-local point. Fired by wheel and by pinch.
-     * Consumer applies `newZoom = clamp(oldZoom * factor)` keeping (centerX,centerY) fixed.
-     */
-    onZoom?: (factor: number, centerX: number, centerY: number) => void;
-    /** Two-finger pan delta in canvas-local px (fired alongside pinch). */
-    onPanDelta?: (dx: number, dy: number) => void;
-    /** A second pointer arrived — cancel any single-pointer pan/drag the consumer started. */
-    onMultiTouchStart?: () => void;
-}
-export interface UseCanvasGesturesOptions extends CanvasGestureCallbacks {
-    /** The canvas being gestured on (for coordinate translation). */
-    canvasRef: React.RefObject<HTMLCanvasElement | null>;
-    /** When false, all gestures are inert. Default true. */
-    enabled?: boolean;
-    /** Wheel zoom step per notch (>1). Default 1.1. */
-    wheelStep?: number;
-}
-export interface CanvasGestureHandlers {
-    onPointerDown: (e: React.PointerEvent<HTMLCanvasElement>) => void;
-    onPointerMove: (e: React.PointerEvent<HTMLCanvasElement>) => void;
-    onPointerUp: (e: React.PointerEvent<HTMLCanvasElement>) => void;
-    onPointerCancel: (e: React.PointerEvent<HTMLCanvasElement>) => void;
-    onWheel: (e: React.WheelEvent<HTMLCanvasElement>) => void;
-}
-export declare function useCanvasGestures(options: UseCanvasGesturesOptions): CanvasGestureHandlers;

package/dist/hooks/useClientEffects.d.ts

@@ -1,88 +0,0 @@
-import type { ClientEffect, ClientEffectExecutorConfig } from '../types/renderer-types';
-/**
- * Options for the useClientEffects hook
- */
-export interface UseClientEffectsOptions extends ClientEffectExecutorConfig {
-    /**
-     * Whether to execute effects. Defaults to true.
-     * Set to false to temporarily disable effect execution.
-     */
-    enabled?: boolean;
-    /**
-     * Debug mode - logs effect execution details.
-     */
-    debug?: boolean;
-}
-/**
- * Result of useClientEffects hook
- */
-export interface UseClientEffectsResult {
-    /**
-     * Number of effects executed in the last batch.
-     */
-    executedCount: number;
-    /**
-     * Whether effects are currently being executed.
-     */
-    executing: boolean;
-    /**
-     * Manually trigger effect execution.
-     * Useful for imperative control.
-     */
-    execute: (effects: ClientEffect[]) => void;
-}
-/**
- * Execute client effects from server response.
- *
- * This hook automatically executes effects when they change,
- * tracking which effects have been executed to prevent duplicates.
- *
- * @param effects - Array of client effects to execute (from server response)
- * @param options - Configuration including effect implementations
- * @returns Hook result with execution state and manual trigger
- *
- * @example
- * ```typescript
- * function useMyTrait() {
- *   const [state, setState] = useState({ pendingEffects: [] });
- *   const effectConfig = useClientEffectConfig();
- *
- *   useClientEffects(state.pendingEffects, {
- *     ...effectConfig,
- *     onComplete: () => setState(s => ({ ...s, pendingEffects: [] }))
- *   });
- *
- *   // ...
- * }
- * ```
- */
-export declare function useClientEffects(effects: ClientEffect[] | undefined, options: UseClientEffectsOptions): UseClientEffectsResult;
-declare const ClientEffectConfigContext: import("react").Context<ClientEffectExecutorConfig | null>;
-/**
- * Provider for client effect configuration.
- */
-export declare const ClientEffectConfigProvider: import("react").Provider<ClientEffectExecutorConfig | null>;
-/**
- * Hook to get the client effect configuration from context.
- *
- * @throws Error if used outside of ClientEffectConfigProvider
- *
- * @example
- * ```typescript
- * function MyTraitHook() {
- *   const effectConfig = useClientEffectConfig();
- *
- *   useClientEffects(pendingEffects, {
- *     ...effectConfig,
- *     onComplete: () => clearPendingEffects()
- *   });
- * }
- * ```
- */
-export declare function useClientEffectConfig(): ClientEffectExecutorConfig;
-/**
- * Hook to get client effect configuration, returning null if not available.
- * Use this for optional integration where effects may not be configured.
- */
-export declare function useClientEffectConfigOptional(): ClientEffectExecutorConfig | null;
-export { ClientEffectConfigContext };

package/dist/hooks/useCompile.d.ts

@@ -1,18 +0,0 @@
-import type { OrbitalSchema } from '@almadar/core';
-export type CompileStage = 'idle' | 'compiling' | 'done' | 'error';
-export interface CompileResult {
-    success: boolean;
-    files?: Array<{
-        path: string;
-        content: string;
-    }>;
-    errors?: string[];
-}
-export interface UseCompileResult {
-    isCompiling: boolean;
-    stage: CompileStage;
-    lastResult: CompileResult | null;
-    error: string | null;
-    compileSchema: (schema: OrbitalSchema) => Promise<CompileResult | null>;
-}
-export declare function useCompile(): UseCompileResult;

package/dist/hooks/useDeepAgentGeneration.d.ts

@@ -1,46 +0,0 @@
-import type { OrbitalSchema, FieldValue } from '@almadar/core';
-export interface DeepAgentActionRequest {
-    id: string;
-    type: string;
-    tool: string;
-    args: Record<string, FieldValue>;
-    description?: string;
-    allowedDecisions: ('approve' | 'edit' | 'reject')[];
-    status: 'pending' | 'approved' | 'rejected' | 'edited';
-}
-export interface DeepAgentInterrupt {
-    id: string;
-    type: 'tool_calls' | 'confirmation' | 'error';
-    message?: string;
-    actionRequests: DeepAgentActionRequest[];
-    timestamp: number;
-    threadId?: string;
-}
-export interface GenerationRequest {
-    id: string;
-    prompt: string;
-    status: 'pending' | 'running' | 'completed' | 'failed';
-    result?: OrbitalSchema;
-    error?: string;
-}
-export interface GenerationProgress {
-    stage: string;
-    percent: number;
-    message: string;
-}
-export interface UseDeepAgentGenerationResult {
-    requests: GenerationRequest[];
-    currentRequest: GenerationRequest | null;
-    isGenerating: boolean;
-    isLoading: boolean;
-    isComplete: boolean;
-    progress: GenerationProgress;
-    error: string | null;
-    interrupt: DeepAgentInterrupt | null;
-    generate: (prompt: string) => Promise<OrbitalSchema | null>;
-    startGeneration: (skill: string, prompt: string, options?: Record<string, FieldValue>) => Promise<void>;
-    cancelGeneration: () => void;
-    clearRequests: () => void;
-    submitInterruptDecisions: (decisions: FieldValue[]) => void;
-}
-export declare function useDeepAgentGeneration(): UseDeepAgentGenerationResult;

package/dist/hooks/useDragReorder.d.ts

@@ -1,26 +0,0 @@
-import type React from 'react';
-export interface DragReorderResult<T> {
-    /** The reordered items array */
-    items: T[];
-    /** Index of the item currently being dragged (-1 if not dragging) */
-    dragIndex: number;
-    /** Index of the drop target (-1 if not over any target) */
-    dragOverIndex: number;
-    /** Whether a drag is in progress */
-    isDragging: boolean;
-    /** Props to spread on the drag handle element for a given index */
-    getDragHandleProps: (index: number) => {
-        onPointerDown: (e: React.PointerEvent) => void;
-        style: React.CSSProperties;
-        'aria-grabbed': boolean;
-        role: string;
-    };
-    /** Props to spread on each list item for a given index */
-    getItemProps: (index: number) => {
-        onPointerMove: (e: React.PointerEvent) => void;
-        onPointerUp: () => void;
-        'aria-dropeffect': string;
-        style: React.CSSProperties;
-    };
-}
-export declare function useDragReorder<T>(initialItems: T[], onReorder: (fromIndex: number, toIndex: number, item: T) => void): DragReorderResult<T>;

package/dist/hooks/useDraggable.d.ts

@@ -1,25 +0,0 @@
-import type { EventPayload } from '@almadar/core';
-/** Discriminated payload carried by every drag operation. */
-export interface DraggablePayload {
-    kind: 'pattern' | 'behavior' | 'tree-node' | 'event-wire';
-    data: EventPayload;
-}
-export interface UseDraggableOptions {
-    /** The payload that will be serialised into dataTransfer. */
-    payload: DraggablePayload;
-    /** When true the element cannot be dragged. */
-    disabled?: boolean;
-}
-export interface UseDraggableResult {
-    /** Spread these onto the draggable element. */
-    dragProps: {
-        draggable: boolean;
-        onDragStart: (e: React.DragEvent) => void;
-        onDragEnd: (e: React.DragEvent) => void;
-        'aria-grabbed': boolean;
-    };
-    /** True while the element is being dragged. */
-    isDragging: boolean;
-}
-export declare const ALMADAR_DND_MIME = "application/x-almadar-dnd";
-export declare function useDraggable({ payload, disabled }: UseDraggableOptions): UseDraggableResult;

package/dist/hooks/useDropZone.d.ts

@@ -1,23 +0,0 @@
-import { type DraggablePayload } from './useDraggable';
-export interface UseDropZoneOptions {
-    /** Which payload kinds this zone accepts. */
-    accepts: DraggablePayload['kind'][];
-    /** Called when a valid payload is dropped. */
-    onDrop: (payload: DraggablePayload, position: {
-        x: number;
-        y: number;
-    }) => void;
-    /** When true the zone rejects all drops. */
-    disabled?: boolean;
-}
-export interface UseDropZoneResult {
-    /** Spread these onto the drop-target element. */
-    dropProps: {
-        onDragOver: (e: React.DragEvent) => void;
-        onDragLeave: (e: React.DragEvent) => void;
-        onDrop: (e: React.DragEvent) => void;
-    };
-    /** True while a valid drag payload is hovering over this zone. */
-    isOver: boolean;
-}
-export declare function useDropZone({ accepts, onDrop, disabled }: UseDropZoneOptions): UseDropZoneResult;

package/dist/hooks/useEventBus.d.ts

@@ -1,99 +0,0 @@
-import type { BusEvent, BusEventSource, BusEventListener, Unsubscribe, EventBusContextType } from '../types/event-bus-types';
-import type { EventPayload } from '@almadar/core';
-export type { BusEvent, BusEventSource, BusEventListener, Unsubscribe, EventBusContextType };
-/** @deprecated Use BusEventListener from @almadar/core. */
-export type { BusEventListener as EventListener };
-declare global {
-    interface Window {
-        __kflowEventBus?: EventBusContextType | null;
-    }
-}
-/**
- * Global event bus reference for bridging between packages.
- *
- * Uses window-level global to enable cross-package communication.
- * This allows @almadar/ui components to emit events to the same bus
- * that the consuming app's trait state machine listens to.
- *
- * When the EventBusProvider mounts, it sets window.__kflowEventBus.
- * Components in any package can then use this shared event bus.
- *
- * SSR Safety: All window access is guarded by `typeof window !== 'undefined'`.
- * React Compiler Safety: The global bus reference is set once at provider mount
- * and is stable — no render-path side effects. In practice, the React context
- * path (priority 1) is used in real apps; the window global (priority 2) is
- * only reached when no EventBusProvider is in the tree (e.g., Storybook).
- */
-/**
- * Set the global event bus reference.
- * Called by EventBusProvider when it mounts.
- *
- * @param bus - The event bus context to set as global, or null to clear
- */
-export declare function setGlobalEventBus(bus: EventBusContextType | null): void;
-/**
- * Get the global event bus reference.
- *
- * @returns The global event bus if set, null otherwise
- */
-export declare function getGlobalEventBus(): EventBusContextType | null;
-/**
- * Hook for accessing the event bus.
- *
- * Uses EventBusProvider context if available, otherwise falls back to
- * a simple in-memory event bus (for design system / Storybook).
- *
- * @returns Event bus instance with emit, on, once, and hasListeners methods
- *
- * @example
- * ```tsx
- * const eventBus = useEventBus();
- *
- * // Emit an event
- * eventBus.emit('UI:CLICK', { id: '123' });
- *
- * // Subscribe to an event
- * useEffect(() => {
- *   return eventBus.on('UI:CLICK', (event) => {
- *     console.log('Clicked:', event.payload);
- *   });
- * }, []);
- * ```
- */
-export declare function useEventBus(): EventBusContextType;
-/**
- * Hook for subscribing to a specific event.
- * Automatically cleans up subscription on unmount.
- *
- * @param event - Event name to subscribe to
- * @param handler - Event handler function
- *
- * @example
- * ```tsx
- * useEventListener('UI:CLICK', (event) => {
- *   console.log('Clicked:', event.payload);
- * });
- * ```
- */
-export declare function useEventListener(event: string, handler: BusEventListener): void;
-/**
- * Alias for useEventListener for backward compatibility
- */
-export declare const useEventSubscription: typeof useEventListener;
-/**
- * Hook for emitting events.
- * Returns a memoized emit function.
- *
- * @returns Function to emit events
- *
- * @example
- * ```tsx
- * const emit = useEmitEvent();
- *
- * const handleClick = () => {
- *   emit('UI:CLICK', { id: '123' });
- * };
- * ```
- */
-export declare function useEmitEvent(): (type: string, payload?: EventPayload, source?: BusEventSource) => void;
-export default useEventBus;

package/dist/hooks/useExtensions.d.ts

@@ -1,32 +0,0 @@
-export interface Extension {
-    id: string;
-    name: string;
-    language?: string;
-    loaded: boolean;
-}
-export interface ExtensionEntry {
-    file: string;
-    language?: string;
-}
-export interface ExtensionManifest {
-    languages: Record<string, {
-        extensions: string[];
-        icon?: string;
-        color?: string;
-    }>;
-    extensions: ExtensionEntry[];
-}
-export interface UseExtensionsOptions {
-    appId: string;
-    loadOnMount?: boolean;
-}
-export interface UseExtensionsResult {
-    extensions: Extension[];
-    manifest: ExtensionManifest;
-    isLoading: boolean;
-    error: string | null;
-    loadExtension: (extensionId: string) => Promise<void>;
-    loadExtensions: () => Promise<void>;
-    getExtensionForFile: (filename: string) => Extension | null;
-}
-export declare function useExtensions(options: UseExtensionsOptions): UseExtensionsResult;

package/dist/hooks/useFileEditor.d.ts

@@ -1,32 +0,0 @@
-import type { UseExtensionsResult } from './useExtensions';
-import type { UseFileSystemResult } from './useFileSystem';
-import type { OrbitalSchema } from '@almadar/core';
-export interface OpenFile {
-    path: string;
-    content: string;
-    isDirty: boolean;
-    language?: string;
-}
-export interface UseFileEditorOptions {
-    extensions: UseExtensionsResult;
-    fileSystem: UseFileSystemResult;
-    onSchemaUpdate?: (schema: OrbitalSchema) => Promise<void>;
-}
-export interface FileEditResult {
-    success: boolean;
-    action?: 'updated_schema' | 'converted_extension' | 'saved_extension' | 'saved';
-    error?: string;
-}
-export interface UseFileEditorResult {
-    openFiles: OpenFile[];
-    activeFile: OpenFile | null;
-    isSaving: boolean;
-    openFile: (path: string) => Promise<void>;
-    closeFile: (path: string) => void;
-    setActiveFile: (path: string) => void;
-    updateFileContent: (path: string, content: string) => void;
-    handleFileEdit: (path: string, content: string) => Promise<FileEditResult>;
-    saveFile: (path: string) => Promise<void>;
-    saveAllFiles: () => Promise<void>;
-}
-export declare function useFileEditor(options: UseFileEditorOptions): UseFileEditorResult;

package/dist/hooks/useFileSystem.d.ts

@@ -1,50 +0,0 @@
-interface FileSystemTree {
-    [name: string]: {
-        file: {
-            contents: string;
-        };
-    } | {
-        directory: FileSystemTree;
-    };
-}
-export interface FileNode {
-    path: string;
-    name: string;
-    type: 'file' | 'directory';
-    children?: FileNode[];
-}
-export type FileSystemStatus = 'idle' | 'booting' | 'ready' | 'running' | 'error';
-export interface FileSystemFile {
-    path: string;
-    content: string;
-}
-export interface SelectedFile {
-    path: string;
-    content: string;
-    language?: string;
-    isDirty?: boolean;
-}
-export interface UseFileSystemResult {
-    status: FileSystemStatus;
-    error: string | null;
-    isLoading: boolean;
-    files: FileNode[];
-    selectedFile: SelectedFile | null;
-    selectedPath: string | null;
-    previewUrl: string | null;
-    boot: () => Promise<void>;
-    mountFiles: (files: FileSystemFile[] | FileSystemTree) => Promise<void>;
-    readFile: (path: string) => Promise<string>;
-    writeFile: (path: string, content: string) => Promise<void>;
-    selectFile: (path: string) => Promise<void>;
-    updateContent: (pathOrContent: string, content?: string) => void;
-    updateSelectedContent: (content: string) => void;
-    refreshTree: () => Promise<void>;
-    runCommand: (command: string) => Promise<{
-        exitCode: number;
-        output: string;
-    }>;
-    startDevServer: () => Promise<void>;
-}
-export declare function useFileSystem(): UseFileSystemResult;
-export {};

package/dist/hooks/useGameAudio.d.ts

@@ -1,47 +0,0 @@
-export interface SoundEntry {
-    /** Single path or array of paths — array picks randomly on each play */
-    path: string | string[];
-    /** Volume 0–1 (multiplied by masterVolume; default 1) */
-    volume?: number;
-    /** Whether this sound loops (background music) */
-    loop?: boolean;
-    /** Number of concurrent Audio instances in the pool (default 1) */
-    poolSize?: number;
-    /** Start automatically on first user interaction */
-    autostart?: boolean;
-    /** Use crossfade transitions when played via playMusic() */
-    crossfade?: boolean;
-    /** Crossfade duration in ms (default 1500) */
-    crossfadeDurationMs?: number;
-}
-export type AudioManifest = Record<string, SoundEntry>;
-export interface GameAudioControls {
-    /** Play a sound effect (instant, pooled) */
-    play: (key: string) => void;
-    /** Stop all instances of a sound effect */
-    stop: (key: string) => void;
-    /** Stop all sounds including music */
-    stopAll: () => void;
-    /** Crossfade to a new music track */
-    playMusic: (key: string) => void;
-    /** Fade out and stop the current music */
-    stopMusic: (fadeDurationMs?: number) => void;
-    muted: boolean;
-    setMuted: (muted: boolean) => void;
-    masterVolume: number;
-    setMasterVolume: (volume: number) => void;
-}
-export interface UseGameAudioOptions {
-    /** Sound definitions keyed by logical name */
-    manifest: AudioManifest;
-    /** Prefix prepended to all `path` values (default '') */
-    baseUrl?: string;
-    /** Start muted (default false) */
-    initialMuted?: boolean;
-    /** Master volume 0–1 (default 1) */
-    initialVolume?: number;
-}
-export declare function useGameAudio({ manifest, baseUrl, initialMuted, initialVolume, }: UseGameAudioOptions): GameAudioControls;
-export declare namespace useGameAudio {
-    var displayName: string;
-}

package/dist/hooks/useGitHub.d.ts

@@ -1,58 +0,0 @@
-/**
- * GitHub connection status
- */
-export interface GitHubStatus {
-    connected: boolean;
-    username?: string;
-    avatarUrl?: string;
-    scopes?: string[];
-    connectedAt?: number;
-    lastUsedAt?: number;
-}
-/**
- * GitHub repository
- */
-export interface GitHubRepo {
-    id: number;
-    name: string;
-    fullName: string;
-    owner: string;
-    isPrivate: boolean;
-    description: string | null;
-    defaultBranch: string;
-    url: string;
-}
-/**
- * Hook to get GitHub connection status
- */
-export declare function useGitHubStatus(): import("@tanstack/react-query").UseQueryResult<NoInfer<GitHubStatus>, Error>;
-/**
- * Hook to connect GitHub (initiate OAuth flow)
- */
-export declare function useConnectGitHub(): {
-    connectGitHub: () => void;
-};
-/**
- * Hook to disconnect GitHub
- */
-export declare function useDisconnectGitHub(): import("@tanstack/react-query").UseMutationResult<unknown, Error, void, unknown>;
-/**
- * Hook to list GitHub repositories
- */
-export declare function useGitHubRepos(page?: number, perPage?: number): import("@tanstack/react-query").UseQueryResult<NoInfer<{
-    repos: GitHubRepo[];
-    page: number;
-    perPage: number;
-}>, Error>;
-/**
- * Hook to get repository details
- */
-export declare function useGitHubRepo(owner: string, repo: string, enabled?: boolean): import("@tanstack/react-query").UseQueryResult<NoInfer<{
-    repo: GitHubRepo;
-}>, Error>;
-/**
- * Hook to list repository branches
- */
-export declare function useGitHubBranches(owner: string, repo: string, enabled?: boolean): import("@tanstack/react-query").UseQueryResult<NoInfer<{
-    branches: string[];
-}>, Error>;