import * as react_jsx_runtime from 'react/jsx-runtime';
import * as React$1 from 'react';
import React__default, { KeyboardEvent, ElementType } from 'react';

type BlockType = "SCENE_HEADING" | "ACTION" | "CHARACTER" | "PARENTHETICAL" | "DIALOGUE" | "TRANSITION";
type TimeOfDay = "DAY" | "NIGHT";
declare const timeOfDayOptions: TimeOfDay[];
interface Block$1 {
    id: string;
    type: BlockType;
    text: string;
    position?: string;
    sceneNumber?: string;
    sceneType?: "INT." | "EXT." | "INT/EXT.";
    timeOfDay?: TimeOfDay;
}
declare const blockTypes: BlockType[];
declare const uuid: () => string;
declare const icons: Record<BlockType, React__default.ReactNode>;
declare const blockStyles: Record<BlockType, {
    label: string;
    className: string;
    inputStyle: React__default.CSSProperties;
}>;

/**
 * Multilingual Input Service
 * Implements a Deterministic Finite State Machine (DFSM) for real-time
 * keyboard layout mapping. Supports Indic (InScript), Arabic, French, and Spanish.
 */
type LanguageType = "English" | "Hindi Phonetic" | "Gujarati Phonetic";

interface UseScreenplayEditorOptions {
    script_id?: string;
    blocks?: Block$1[];
    initialUrl?: string;
    fetchOptions?: RequestInit;
    onSave?: (blocks: Block$1[]) => void;
    onSaveBlob?: (content?: Blob) => void;
    onSyncWithCloud?: (blocks: Block$1[], sceneNumbers: Record<string, string>) => void;
    enhanceContentUrl?: string | URL | Request;
    isLocked?: boolean;
}
declare function useScreenplayEditor(options?: UseScreenplayEditorOptions): {
    blocks: Block$1[];
    refs: React__default.RefObject<Record<string, HTMLDivElement | null>>;
    focusedBlockId: string;
    showSuggestions: boolean;
    showExtensionSuggestions: boolean;
    characterExtensions: string[];
    locations: string[];
    characters: string[];
    sceneNumbers: Record<string, string>;
    isLoading: boolean;
    handleBlockTextChange: (id: string, text: string) => void;
    handleSceneTypeChange: (id: string, sceneType: "INT." | "EXT." | "INT/EXT.") => void;
    handleTimeOfDayChange: (id: string, time: TimeOfDay) => void;
    handleBlockTypeChange: (newType: BlockType) => void;
    handleSelectCharacterExtension: (extension: string) => void;
    handleKeyDown: (e: KeyboardEvent<HTMLDivElement>, id: string, text: string) => void;
    handleScriptImport: (title: string, content: string, preParsedBlocks?: Partial<Block$1>[], isInitialLoad?: boolean) => void;
    handleSceneNumberChange: (id: string, newNumber: string) => void;
    handleFocus: (id: string) => void;
    handleBlur: (id: string) => void;
    handleEnhance: (block: Block$1) => Promise<void>;
    handleApproveEnhance: () => void;
    handleRejectEnhance: () => void;
    enhancingBlockId: string | null;
    enhancementSuggestion: string | null;
    isEnhancing: boolean;
    hasUnsavedChanges: boolean;
    showUnsavedPopover: boolean;
    syncScreenplay: () => void;
    ignoreChanges: () => void;
    loadFromUrl: (url: string, fetchOptions?: RequestInit, isInitialLoad?: boolean) => Promise<void>;
    currentLanguage: LanguageType;
    setCurrentLanguage: React__default.Dispatch<React__default.SetStateAction<LanguageType>>;
    phoneticSuggestions: string[];
    handleSelectPhoneticSuggestion: (suggestion: string) => void;
    isLocked: boolean;
    autosaveStatus: "idle" | "typing" | "saving" | "saved" | "error";
};

type ScreenplayEditorViewProps = ReturnType<typeof useScreenplayEditor> & {
    showPdfImport?: boolean;
    showSaveButton?: boolean;
    showSyncButton?: boolean;
    isLocked?: boolean;
    onToggleLock?: () => void;
    onSave?: () => void;
    onSaveAsPdf?: () => void;
    onSaveAsSbx?: () => void;
    onSyncWithCloud?: () => void;
    handleSceneNumberChange: (blockId: string, value: string) => void;
    handleEnhance: (block: Block$1) => void;
    handleApproveEnhance: () => void;
    handleRejectEnhance: () => void;
    enhancingBlockId: string | null;
    enhancementSuggestion: string | null;
    isEnhancing: boolean;
    savePopOverLeft?: string;
    currentLanguage: LanguageType;
    setCurrentLanguage: (lang: LanguageType) => void;
    phoneticSuggestions: string[];
    handleSelectPhoneticSuggestion: (suggestion: string) => void;
};
declare function ScreenplayEditorView({ blocks, refs, focusedBlockId, showSuggestions, showExtensionSuggestions, characterExtensions, locations, characters, showPdfImport, showSaveButton, showSyncButton, isLocked, onToggleLock, handleBlockTextChange, handleSceneTypeChange, handleTimeOfDayChange, handleBlockTypeChange, handleSelectCharacterExtension, handleKeyDown, handleFocus, handleBlur, handleScriptImport, onSave, onSaveAsPdf, onSyncWithCloud, handleSceneNumberChange, handleEnhance, handleApproveEnhance, handleRejectEnhance, enhancingBlockId, enhancementSuggestion, isEnhancing, showUnsavedPopover, syncScreenplay, ignoreChanges, isLoading, savePopOverLeft, currentLanguage, setCurrentLanguage, phoneticSuggestions, handleSelectPhoneticSuggestion, autosaveStatus, }: ScreenplayEditorViewProps): react_jsx_runtime.JSX.Element;

declare const handleSaveAsPdf: (blocks: Block$1[], sceneNumbers: Record<string, string>, project_name?: string) => Promise<void>;
declare const convertBlocksToSbx: (blocks: Block$1[], sceneNumbers: Record<string, string>) => string;
declare const handleSyncWithCloud: (blocks: Block$1[], sceneNumbers: Record<string, string>, onSaveAsSbx?: (file: File) => void, project_name?: string) => void;

interface ScriptBreakdown {
    scene_number: string;
    content: string;
}
type ElementCategory = "CAST" | "PROP" | "COSTUME" | "VEHICLE" | "SET_PROP" | "EXTRA" | "LOCATION" | "SUBLOCATION" | "OTHER";
interface Tag {
    id?: string;
    scene_id?: string | number;
    block_id: string;
    category_id: ElementCategory;
    name: string;
    start_index: number;
    end_index: number;
    quantity?: number;
    look?: string;
    age?: string;
    age_range?: {
        name: string;
    }[];
    crowd_type?: {
        name: string;
    }[];
    created_at?: string;
    updated_at?: string;
}
declare const CATEGORIES: {
    id: ElementCategory;
    label: string;
    color: string;
    hex: string;
    icon: ElementType;
}[];

declare function ScriptBreakdownSceneView({ blocks, characters, isLoading, sceneNumber, tags, selectionMenu, handleMouseUp, addTag, updateTag, removeTag, clearSelection, menuPlacement, menuRef, sceneBrief, setSceneBrief, onSummarize, isSummarizing, aiSummarized, onUpdateBrief, headerChildren, }: {
    blocks: Block$1[];
    characters: string[];
    isLoading: boolean;
    sceneNumber: string;
    tags: Tag[];
    selectionMenu: {
        blockId: string;
        startIndex: number;
        endIndex: number;
        text: string;
        top: number;
        left: number;
    } | null;
    handleMouseUp: () => void;
    addTag: (c: ElementCategory) => void;
    updateTag?: (id: string, categoryId?: ElementCategory | null, details?: Partial<Tag>) => void;
    removeTag: (e: React__default.MouseEvent, id?: string) => void;
    clearSelection: () => void;
    menuPlacement: "top" | "bottom";
    menuRef: React__default.RefObject<HTMLDivElement | null>;
    sceneBrief: string;
    setSceneBrief: (brief: string) => void;
    onSummarize?: () => void;
    isSummarizing?: boolean;
    aiSummarized?: boolean;
    onUpdateBrief?: () => void;
    headerChildren?: React__default.ReactNode;
}): react_jsx_runtime.JSX.Element;

interface UseScriptBreakdownSceneOptions {
    scene_url: string;
    fetchOptions?: RequestInit;
    onAISummarize?: (scene: any) => void;
    onTagAdded?: (tag: Tag) => void;
    onTagsBulkAdded?: (tags: Tag[], summary?: string) => Promise<void>;
    onTagRemoved?: (tagId: string) => void;
    onTagUpdated?: (tagId: string, categoryId: ElementCategory | null, details?: Partial<Tag>) => void;
    preLoadedTags?: Tag[];
    preLoadedTagsLoading?: boolean;
}
declare function useScriptBreakdownScene(options: UseScriptBreakdownSceneOptions): {
    scene: any;
    blocks: Block$1[];
    characters: string[];
    isLoading: boolean;
    error: boolean;
    tags: Tag[];
    selectionMenu: {
        blockId: string;
        startIndex: number;
        endIndex: number;
        text: string;
        top: number;
        left: number;
    } | null;
    handleMouseUp: () => void;
    addTag: (categoryId: ElementCategory) => Promise<void>;
    updateTag: (id: string, categoryId?: ElementCategory | null, details?: Partial<Tag>) => Promise<void>;
    removeTag: (e: React.MouseEvent, id?: string) => Promise<void>;
    clearSelection: () => void;
    menuPlacement: "top" | "bottom";
    menuRef: React$1.RefObject<HTMLDivElement | null>;
    sceneBrief: string;
    setSceneBrief: React$1.Dispatch<React$1.SetStateAction<string>>;
    handleAISummarize: () => Promise<any>;
    isSummarizing: boolean;
};

interface Camera {
    name: string;
}
interface ShotPart {
    block_id: string;
    start_index: number;
    end_index: number;
    text: string;
    type?: string;
}
interface ShotCharacter {
    id: string;
    name: string;
}
interface Shot {
    id?: number | string;
    shot_number: number;
    priority: string;
    shot_type: string;
    framing: string;
    camera_angle: {
        name: string;
    }[];
    camera_movement: string;
    camera_support: string;
    lens_mm: string;
    lens_feel: string;
    aperture: string;
    depth_of_field: string;
    fps?: number;
    subject: string;
    action_blocking: string;
    emotional_purpose: string;
    lighting: {
        name: string;
    }[];
    sound: {
        name: string;
    }[];
    duration_seconds: number;
    edit_purpose: string;
    reason: string;
    vfx: string;
    camera_name: string;
    parts: ShotPart[];
    props?: {
        name: string;
        quantity: string;
    }[];
    set_props?: {
        name: string;
        quantity: string;
    }[];
    vehicles?: {
        name: string;
        quantity: string;
    }[];
    costumes?: {
        name: string;
    }[];
    characters?: ShotCharacter[];
    crowd?: {
        id?: string;
        name: string;
        gender: string;
        ageGroup: string;
    }[];
}
interface ShotBreakdown {
    scene_id?: number;
    scene_type: string;
    no_of_camera: number;
    cameras: Camera[];
    shots: Shot[];
}

declare function ShotBreakdownView({ blocks, isLoading, shots, selectionMenu, handleMouseUp, addShot, updateShot, clearSelection, menuRef, cameras, sceneType, initializeProduction, handleAISummarize, isSummarizing, aiSummarized, headerChildren, }: {
    blocks: Block$1[];
    isLoading: boolean;
    shots: Shot[];
    sceneType: string;
    selectionMenu: {
        top: number;
        left: number;
        parts: ShotPart[];
    } | null;
    handleMouseUp: () => void;
    addShot: (shotDetails: Omit<Shot, "id" | "shot_number" | "parts">) => any;
    updateShot: (shotId: string | number, updatedDetails: Omit<Shot, "id" | "shot_number" | "parts">) => any;
    clearSelection: () => void;
    menuRef: React__default.RefObject<HTMLDivElement | null>;
    cameras: Camera[];
    initializeProduction: (count: number, type: string, dance_choreographer_required?: boolean, action_sequence_required?: boolean) => any;
    handleAISummarize: () => void;
    isSummarizing: boolean;
    aiSummarized?: boolean;
    headerChildren?: React__default.ReactNode;
}): react_jsx_runtime.JSX.Element;

interface UseShotBreakdownOptions {
    scene_url: string;
    fetchOptions?: RequestInit;
    onAISummarize?: (scene: any) => void;
    onShotAdded?: (shot: Shot) => any;
    onShotsBulkAdded?: (shots: Shot[], scene_type: string) => Promise<void>;
    onShotRemoved?: (shotId: string) => any;
    onShotUpdated?: (shotId: string, detail: Shot) => any;
    onProductionInitialized?: (cameras: Camera[], type: string, dance_choreographer_required?: boolean, action_sequence_required?: boolean) => any;
    preloadedShots?: Shot[];
    preloadedCameras?: Camera[];
    preloadedSceneType?: string;
}
declare function useShotBreakdownScene(options: UseShotBreakdownOptions): {
    blocks: Block$1[];
    isLoading: boolean;
    error: boolean;
    shots: Shot[];
    sceneType: string;
    selectionMenu: {
        top: number;
        left: number;
        parts: ShotPart[];
    } | null;
    handleMouseUp: () => void;
    cameras: Camera[];
    initializeProduction: (count: number, type: string, dance_choreographer_required?: boolean, action_sequence_required?: boolean) => Promise<any>;
    addShot: (shotDetails: Omit<Shot, "id" | "shot_number" | "parts">) => any;
    updateShot: (shotId: string | number, updatedDetails: Omit<Shot, "id" | "shot_number" | "parts">) => Promise<any>;
    clearSelection: () => void;
    handleAISummarize: () => Promise<void>;
    isSummarizing: boolean;
    menuRef: React$1.RefObject<HTMLDivElement | null>;
};

declare const shot_types: {
    name: string;
}[];
declare const shot_frame: {
    name: string;
}[];
declare const camera_angles: {
    name: string;
}[];
declare const camera_movements: {
    name: string;
}[];
declare const camera_supports: {
    name: string;
}[];
declare const lens_options: {
    name: string;
    type: string;
}[];
declare const aperture_options: {
    value: number;
    label: string;
}[];
declare const vfx_types: {
    name: string;
}[];
declare const fps_options: {
    value: number;
    label: string;
}[];
declare const scene_types: {
    name: string;
}[];
declare const lighting_options: {
    name: string;
}[];
declare const sound_options: {
    name: string;
}[];
declare const depth_of_field_options: {
    name: string;
}[];
declare const editing_purpose: {
    name: string;
}[];

declare const AddShotForm: ({ userShotValue, onSubmit, cameras, shots, handleCloseModal, parts, }: {
    userShotValue?: Omit<Shot, "id" | "parts">;
    onSubmit: (values: Omit<Shot, "id" | "parts">) => void;
    cameras: Camera[];
    shots: Shot[];
    handleCloseModal: () => void;
    parts: ShotPart[];
}) => react_jsx_runtime.JSX.Element;

declare function SceneScriptView({ blocks, isLoading, sceneNumber, title, }: {
    blocks: Block$1[];
    isLoading?: boolean;
    sceneNumber?: string;
    title?: string;
}): react_jsx_runtime.JSX.Element;

interface UseSceneScriptOptions {
    scene_url: string;
    fetchOptions?: RequestInit;
}
declare function useSceneScript(options: UseSceneScriptOptions): {
    blocks: Block$1[];
    isLoading: boolean;
    error: string | null;
    sceneContent: string | null;
};

type SongwriterBlockType = "SONG_NAME" | "SONG_TYPE" | "SONG_BEAT" | "SONG_LYRICS";
interface SongwriterBlock {
    id: string;
    type: SongwriterBlockType;
    text: string;
    position?: string;
}
declare const songwriterBlockTypes: SongwriterBlockType[];
declare const songwriterToolbarTypes: SongwriterBlockType[];
declare const songwriterIcons: Record<SongwriterBlockType, React__default.ReactNode>;
declare const songwriterStyles: Record<SongwriterBlockType, {
    label: string;
    className: string;
    placeholder: string;
    inputStyle: React__default.CSSProperties;
}>;

interface SongwriterEditorViewProps {
    blocks: SongwriterBlock[];
    isLoading: boolean;
    isLocked?: boolean;
    handleToggleLock?: () => void;
    refs: React__default.MutableRefObject<Record<string, HTMLDivElement | null>>;
    focusedBlockId: string;
    autosaveStatus: "idle" | "typing" | "saving" | "saved" | "error";
    handleBlockTextChange: (id: string, text: string) => void;
    handleBlockTypeChange: (newType: SongwriterBlockType) => void;
    handleKeyDown: (e: React__default.KeyboardEvent<HTMLDivElement>, id: string, text: string) => void;
    handleFocus: (id: string) => void;
    handleSelect: (id: string) => void;
    exportToTxt: () => void;
    onBack?: () => void;
}
declare function SongwriterEditorView({ blocks, isLoading, isLocked, handleToggleLock, refs, focusedBlockId, autosaveStatus, handleBlockTextChange, handleBlockTypeChange, handleKeyDown, handleFocus, handleSelect, exportToTxt, onBack, }: SongwriterEditorViewProps): react_jsx_runtime.JSX.Element;

interface UseSongwriterOptions {
    blocks?: SongwriterBlock[];
    onSave?: (blocks: SongwriterBlock[]) => void | Promise<void>;
    isLocked?: boolean;
}
declare function useSongwriter(options?: UseSongwriterOptions): {
    blocks: SongwriterBlock[];
    isLoading: boolean;
    isLocked: boolean;
    refs: React$1.RefObject<Record<string, HTMLDivElement | null>>;
    focusedBlockId: string;
    newBlockId: string | null;
    autosaveStatus: "idle" | "typing" | "saving" | "saved" | "error";
    setFocusedBlockId: React$1.Dispatch<React$1.SetStateAction<string>>;
    setNewBlockId: React$1.Dispatch<React$1.SetStateAction<string | null>>;
    handleBlockTextChange: (id: string, text: string) => void;
    handleBlockTypeChange: (newType: SongwriterBlockType) => void;
    handleKeyDown: (e: React.KeyboardEvent<HTMLDivElement>, id: string, text: string) => void;
    handleFocus: (id: string) => void;
    handleSelect: (id: string) => void;
    exportToTxt: () => void;
};

/**
 * Assures that all blocks in an array have a valid, sorted position key.
 * Uses TypeScript generics to ensure absolute type safety across any state structure.
 */
declare function assignInitialPositions<T extends {
    id: string;
    position?: string;
}>(blocks: T[]): T[];
/**
 * Safely compares two position strings character-by-character using our custom alphabet.
 * This completely avoids locale-specific sorting discrepancies or ASCII-codepoint bias.
 */
declare function comparePositions(posA: string | undefined | null, posB: string | undefined | null): number;

declare function getNextBlockType(currentType: SongwriterBlockType): SongwriterBlockType;
declare function createNewBlock(type: SongwriterBlockType): SongwriterBlock;
declare function addBlockAfter(blocks: SongwriterBlock[], currentBlockId: string): {
    newBlocks: SongwriterBlock[];
    newBlockId: string;
};
declare function deleteBlock(blocks: SongwriterBlock[], blockIdToDelete: string): {
    newBlocks: SongwriterBlock[];
    nextFocusedId: string | null;
};
declare function updateBlock(blocks: SongwriterBlock[], id: string, text: string): SongwriterBlock[];
declare function changeBlockType(blocks: SongwriterBlock[], id: string, newType: SongwriterBlockType): SongwriterBlock[];

interface LyricalBreakdownViewProps {
    blocks: SongwriterBlock[];
    isLoading: boolean;
    shots: Shot[];
    cameras: Camera[];
    movieCharacters: ShotCharacter[];
    sceneType: string;
    autosaveStatus: "idle" | "typing" | "saving" | "saved" | "error";
    selectionMenu: {
        top: number;
        left: number;
        parts: ShotPart[];
    } | null;
    clearSelection: () => void;
    handleMouseUp: () => void;
    initializeProduction: (count: number, type: string) => Promise<any> | any;
    addShot: (shotDetails: Omit<Shot, "id" | "parts">) => void;
    updateShot: (shotId: string | number, updatedDetails: Omit<Shot, "id" | "parts">) => void;
    deleteShot: (shotId: string | number) => void;
    menuRef: React__default.RefObject<HTMLDivElement | null>;
    headerChildren?: React__default.ReactNode;
}
declare function LyricalBreakdownView({ blocks, isLoading, shots, cameras, movieCharacters, autosaveStatus, selectionMenu, clearSelection, handleMouseUp, initializeProduction, addShot, updateShot, deleteShot, menuRef, headerChildren, }: LyricalBreakdownViewProps): react_jsx_runtime.JSX.Element;

interface UseLyricalBreakdownProps {
    blocks: SongwriterBlock[];
    initialShots?: Shot[];
    initialCameras?: Camera[];
    initialMovieCharacters?: ShotCharacter[];
    initialSceneType?: string;
    onShotAdded?: (shot: Shot) => any;
    onShotUpdated?: (shotId: number | string, shot: Shot) => any;
    onProductionInitialize?: (count: number, cameras: Camera[]) => any;
    deleteShot?: (shotId: number | string) => void;
}
declare function useLyricalBreakdown({ blocks: passedBlocks, initialShots, initialCameras, initialMovieCharacters, initialSceneType, deleteShot: passedDeleteShot, onShotAdded, onShotUpdated, onProductionInitialize, }: UseLyricalBreakdownProps): {
    blocks: SongwriterBlock[];
    isLoading: boolean;
    shots: Shot[];
    cameras: Camera[];
    movieCharacters: ShotCharacter[];
    sceneType: string;
    autosaveStatus: "idle" | "typing" | "saving" | "saved" | "error";
    selectionMenu: {
        top: number;
        left: number;
        parts: ShotPart[];
    } | null;
    clearSelection: () => void;
    handleMouseUp: () => void;
    initializeProduction: (count: number, type: string) => Promise<void>;
    addShot: (shotDetails: Omit<Shot, "id" | "parts">) => any;
    updateShot: (shotId: string | number, updatedDetails: Omit<Shot, "id" | "parts">) => Promise<any>;
    deleteShot: (shotId: string | number) => void;
    menuRef: React$1.RefObject<HTMLDivElement | null>;
};

interface Block {
    id: string;
    type: "SCENE_HEADING" | "ACTION";
    text: string;
    position?: string;
}
interface ScriptBriefEditorViewProps {
    type: "LOGLINE" | "SYNOPSIS" | "STORY";
    initialBlocks?: Block[];
    isLocked?: boolean;
    onToggleLock?: () => void;
    onAutosave?: (blocks: Block[]) => void;
}
declare function ScriptBriefEditorView({ type, initialBlocks, isLocked, onToggleLock, onAutosave, }: ScriptBriefEditorViewProps): react_jsx_runtime.JSX.Element;

export { AddShotForm, type Block$1 as Block, type BlockType, CATEGORIES, type Camera, type ElementCategory, LyricalBreakdownView, SceneScriptView, ScreenplayEditorView, type ScriptBreakdown, ScriptBreakdownSceneView, ScriptBriefEditorView, type Shot, type ShotBreakdown, ShotBreakdownView, type ShotCharacter, type ShotPart, type SongwriterBlock, type SongwriterBlockType, SongwriterEditorView, type Tag, type TimeOfDay, addBlockAfter, aperture_options, assignInitialPositions, blockStyles, blockTypes, camera_angles, camera_movements, camera_supports, changeBlockType, comparePositions, convertBlocksToSbx, createNewBlock, deleteBlock, depth_of_field_options, editing_purpose, fps_options, getNextBlockType, handleSaveAsPdf, handleSyncWithCloud, icons, lens_options, lighting_options, scene_types, shot_frame, shot_types, songwriterBlockTypes, songwriterIcons, songwriterStyles, songwriterToolbarTypes, sound_options, timeOfDayOptions, updateBlock, useLyricalBreakdown, useSceneScript, useScreenplayEditor, useScriptBreakdownScene, useShotBreakdownScene, useSongwriter, uuid, vfx_types };