diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 605668a..31fec57 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -13,8 +13,8 @@ concurrency: jobs: build-and-test: - runs-on: ubuntu-latest - timeout-minutes: 30 + runs-on: macos-latest + timeout-minutes: 45 steps: - uses: actions/checkout@v4 @@ -26,8 +26,33 @@ jobs: - uses: gradle/actions/setup-gradle@v4 - - name: Build - run: ./gradlew :editor:assembleDebug - - - name: Test - run: ./gradlew :editor:testDebugUnitTest + - name: Boot iOS simulator + shell: bash + run: | + simulator="$( + xcrun simctl list devices available --json | + jq -r '[.devices[][] | select(.name | startswith("iPhone"))][0] | [.udid, .state] | @tsv' + )" + IFS=$'\t' read -r simulator_udid simulator_state <<< "$simulator" + if [[ -z "$simulator_udid" || "$simulator_udid" == "null" ]]; then + echo "No available iPhone simulator was found." + exit 1 + fi + if [[ "$simulator_state" != "Booted" ]]; then + xcrun simctl boot "$simulator_udid" + fi + xcrun simctl bootstatus "$simulator_udid" --block + + - name: Check editor + run: | + ./gradlew \ + :editor:assembleDebug \ + :editor:allTests \ + :editor:apiCheck + + - name: Check native iOS SDK + run: | + ./gradlew \ + :editor-ios-sdk:allTests \ + :editor-ios-sdk:apiCheck \ + :editor-ios-sdk:assembleCascadeEditorDebugXCFramework diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md index 80c042c..2e9fb3d 100644 --- a/ARCHITECTURE.md +++ b/ARCHITECTURE.md @@ -10,6 +10,7 @@ Block-based editor (Craft/Notion-like) for Compose Multiplatform. Unidirectional | Sample editor top-bar chrome | `sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/EditorChrome.kt` | `EditorTopBar()`, `SelectionTopBar()`, `SavedPill()`, `OpenedLinkPill()` (shared by editor screens; maps the chrome design onto `MaterialTheme.colorScheme`) | | Sample comments screen | `sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/comments/CommentsScreen.kt`, `CommentComposer.kt`, `CommentsScreenModel.kt`, `CommentModel.kt` | `CommentsScreen()`, `CommentComposer()` (editor-as-chat-composer: focus-driven fade-in formatting bar via `rememberCascadeEditorToolbarController` + Send), `CommentsScreenModel` (`buildOwnComment()`/`resetComposer()`), `Comment` + `rememberCommentAnnotatedString()` (consumer-side `SpanStyle`→`AnnotatedString`) | | Main composable | `ui/CascadeEditor.kt` | `CascadeEditor(stateHolder, textStates, spanStates, registry, slashRegistry, slashCommand, ...)` | +| Native iOS SDK technical context | `docs/iOsNativeSdk.md` | Swift controller facade, UIKit host, native custom blocks/slash commands, public API, integration constraints | | Editor behavior config | `ui/CascadeEditorConfig.kt`, `ui/LocalCascadeEditorConfig.kt` | `CascadeEditorConfig` (incl. `crashPolicy`/`onInternalError`), `LocalCascadeEditorConfig` | | Crash handling | `CrashHandling.kt` | `CrashPolicy`, `CascadeError`, `CascadeErrorReporter`, `guarded()`/`reportContainedFailure()` (internal) | | Editor interaction policy | `ui/EditorInteractionPolicy.kt`, `ui/LocalEditorInteractionPolicy.kt` | `EditorInteractionPolicy` (internal) | @@ -60,12 +61,12 @@ Block-based editor (Craft/Notion-like) for Compose Multiplatform. Unidirectional | Default scoped renderer scope | `ui/DefaultBlockRenderScope.kt` | `DefaultBlockRenderScope` (internal implementation) | | Sample table custom block | `sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/customblocks/SampleTableBlock.kt`, `sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/customblocks/SampleTableBlockRenderer.kt` | `SampleTableModel`, `createTableRenderer()` | | Built-in slash spec | `slash/BuiltInSlashCommandSpec.kt` | `BuiltInSlashCommandSpec`, `BuiltInBlockSlashBehavior` | -| Built-in slash factory | `slash/BuiltInSlashCommandFactory.kt` | `BuiltInSlashCommandFactory` | +| Built-in slash factory | `slash/BuiltInSlashCommandFactory.kt` | `BuiltInSlashCommandFactory`, `builtInBlockSlashCommandId()`, `BUILTIN_BLOCK_SLASH_COMMAND_ID_PREFIX` | | Built-in slash executor | `slash/SlashCommandExecutor.kt` | `createBuiltInSlashExecutor()` (internal) | | Slash editor host | `slash/SlashCommandEditorHost.kt` | `SlashCommandEditorHost` (internal) | | List auto-detect observer | `ui/observers/ListAutoDetectObserver.kt` | `ListAutoDetectObserver` (internal) | | Slash text observer | `slash/SlashCommandTextObserver.kt` | `SlashCommandTextObserver` (internal) | -| Renderer interface | `registry/BlockRenderer.kt` | `BlockRenderer` (+ `handlesSelectionVisual`), `BlockCallbacks`, `DefaultBlockCallbacks` | +| Renderer interface | `registry/BlockRenderer.kt` | `BlockRenderer` (+ `handlesSelectionVisual`, `supportsDragPreview` — platform-view hosts opt out of the live drag ghost), `BlockCallbacks`, `DefaultBlockCallbacks` | | Policy-aware renderer callbacks | `registry/PolicyAwareBlockCallbacks.kt` | `PolicyAwareBlockCallbacks` (internal) | | Unknown block type | `core/UnknownBlockType.kt` | `UnknownBlockType` (implements `CustomBlockType`) | | Document serialization | `serialization/DocumentSchema.kt` | `DocumentSchema` (encode/decode full document) | @@ -87,7 +88,7 @@ Block-based editor (Craft/Notion-like) for Compose Multiplatform. Unidirectional | Doc decode result | `serialization/DocumentDecodeResult.kt` | `DocumentDecodeResult` | | Block type codec | `serialization/BlockTypeCodec.kt` | `BlockTypeCodec` | | Block content codec | `serialization/BlockContentCodec.kt` | `BlockContentCodec` | -| Editor serialization ext | `serialization/DocumentSerializationExt.kt` | `EditorStateHolder.toJson()`, `EditorStateHolder.loadFromJson()` | +| Editor serialization ext | `serialization/DocumentSerializationExt.kt` | `EditorStateHolder.toJson()`, `EditorStateHolder.loadFromJson()` (hard replacement, including parse failure), `EditorStateHolder.resolveDocumentBlocks()` (JSON-free authoritative blocks with live text/spans folded in; cheap content-change signal) | | Editor HTML serialization ext | `htmlserialization/HtmlSerializationExt.kt` | `EditorStateHolder.toHtml()`, `EditorStateHolder.loadFromHtml()` | | HTML schema entry point | `htmlserialization/HtmlSchema.kt` | `HtmlSchema` (`decode` and `encode` wired through profile-driven engines) | | HTML decode limits | `htmlserialization/HtmlDecodeLimits.kt` | `HtmlDecodeLimits` (input-size bound; `loadFromHtml` / `HtmlSchema.decodeWithReport` `limits` param) | @@ -284,6 +285,7 @@ All state changes go through `EditorAction.reduce(state) → newState`. - **Auto-scroll** uses `dispatchRawDelta` to avoid MutatorMutex contention with gesture scroll - **Crash containment has two regimes** — UI-runtime guards (per-block measure/draw via `guardedBlockRender`, span `OutputTransformation`) are policy-gated by `CascadeEditorConfig.crashPolicy` (`Rethrow` in tests/debug, `ContainAndReport` in release) and route through `guarded()`; the serialization layer (`loadFromJson`/`loadFromHtml` string entry points, HTML decode) is always-contain-and-warn (returns `DocumentParseFailed`/`InputLimitExceeded` warning lists, not policy-gated). Compose forbids `try/catch` around `@Composable` calls, so composition-phase renderer throws are not containable in-tree (host trust boundary for custom renderers) - **Tests** go in `editor/src/commonTest/` (Compose UI tests in `editor/src/desktopTest/`). Run: `./gradlew :editor:allTests` +- **Public-API snapshots** — binary-compatibility-validator guards `:editor` (and `:editor-ios-sdk`): JVM/Android dumps in `editor/api/{desktop,android}/`, klib (iOS/wasm) dumps in `editor/api/editor.klib.api`. `apiCheck` runs with `check` and fails on unbaselined public-surface changes; after an intentional API change run `./gradlew :editor:apiDump :editor-ios-sdk:apiDump` and commit the diff ## Implementation Status @@ -298,7 +300,7 @@ All state changes go through `EditorAction.reduce(state) → newState`. | TextBlockRenderer | Done | All text-supporting types except todo | | TextBlockField (shared) | Done | Extracted text editing composable used by all text renderers | | Heading font sizes | Done | No bold weight yet | -| Slash commands (backend) | Done | Session state with query range, submenu nav, highlight; enriched reducer API; `BuiltInSlashCommandSpec` on descriptors with `ConvertInPlace`/`AlwaysInsert` behavior policies; `BuiltInSlashCommandFactory` generates `SlashCommandAction`s from descriptor metadata; `SlashCommandEditorHost` provides safe runtime/snapshot editing; `BlockTextStates.replaceVisibleRange()` + `BlockSpanStates.adjustForRangeReplacement()` primitives; `CascadeEditor` exposes public `slashRegistry` parameter for consumer custom commands | +| Slash commands (backend) | Done | Session state with query range, submenu nav, highlight; enriched reducer API; `BuiltInSlashCommandSpec` on descriptors with `ConvertInPlace`/`AlwaysInsert` behavior policies; `BuiltInSlashCommandFactory` generates `SlashCommandAction`s from descriptor metadata; `SlashCommandEditorHost` provides safe runtime/snapshot editing; `BlockTextStates.replaceVisibleRange()` + `BlockSpanStates.adjustForRangeReplacement()` primitives; `CascadeEditor` exposes public `slashRegistry` parameter for consumer custom commands; public `builtInBlockSlashCommandId(typeId)` exposes the built-in id format (`builtin.block.`) for collision detection by consumers | | Slash commands (integration) | Done | `shouldInvalidateSlashSession()` closes session on drag, selection, or anchor deletion; reactive `LaunchedEffect` + `snapshotFlow` wiring in `CascadeEditor` | | Slash commands (text observer) | Done | `SlashCommandTextObserver` detects `/`, tracks `queryRange`, dismisses on invalid state; wired in `TextBlockField` via combined text+selection `snapshotFlow`; observer is `null` for `BlockType.Code` (call-site suppression keyed in `remember(...)` so same-id Paragraph ↔ Code conversion drops/recreates it) | | Slash commands (UI) | Done | Popup overlay with grouped items, caret-relative positioning, keyboard nav (Up/Down/Enter/Escape), auto-highlight, submenu back-nav, `focusProperties { canFocus = false }` pattern | @@ -352,6 +354,7 @@ All state changes go through `EditorAction.reduce(state) → newState`. | `EditorStateTest.kt` | All action reducers incl. span actions, split/merge span transfer, snapshot stability (~87 tests) | | `SlashCommandStateTest.kt` | Slash session reducers: open/update/navigate/highlight/close, submenu path, no-op guards | | `SlashCommandRegistryTest.kt` | Registry: registration order, dedup, ranking tiers, path-based submenu search, menu discoverability, tie-breaking | +| `BuiltInBlockSlashCommandIdTest.kt` | `builtInBlockSlashCommandId()` prefix format and equivalence with the ids `BuiltInSlashCommandFactory` generates | | `DragActionsTest.kt` | Drag state transitions, subtree payload resolution, depth-aware target clearing, self-drop rejection, depth rewrite, drag renumbering | | `DragSelectionTest.kt` | `isDropAtOriginalPosition` boundary cases for long-press-to-select detection | | `BlockSelectionIntegrationTest.kt` | Block selection workflows: enter/exit selection, multi-select, delete selected, insertion preserves selection, slash invalidation, full lifecycle (11 scenarios) | diff --git a/build.gradle.kts b/build.gradle.kts index 3ee08ca..3f3242c 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -7,4 +7,8 @@ plugins { alias(libs.plugins.composeCompiler) apply false alias(libs.plugins.kotlinMultiplatform) apply false alias(libs.plugins.vanniktechPublish) apply false + // Applied in :editor and :editor-ios-sdk. Baseline dumps live in each module's + // api/ directory; regenerate with `./gradlew :editor:apiDump :editor-ios-sdk:apiDump` + // after an intentional public-API change (`apiCheck` runs as part of `check`). + alias(libs.plugins.binaryCompatibilityValidator) apply false } \ No newline at end of file diff --git a/docs/iOsNativeSdk.md b/docs/iOsNativeSdk.md new file mode 100644 index 0000000..20b7ac5 --- /dev/null +++ b/docs/iOsNativeSdk.md @@ -0,0 +1,270 @@ +# Native iOS SDK Technical Context + +## 1. Feature Overview + +The Native iOS SDK exposes CascadeEditor to Swift applications without requiring consumers to use the Kotlin Multiplatform editor API, Compose types, or internal state holders directly. It packages the editor as a static `CascadeEditor.xcframework`, provides a `CascadeEditorController` for document and editing operations, and hosts the Compose editor in a UIKit `UIViewController` that can be embedded in SwiftUI. The bridge also supports native UIKit/SwiftUI custom blocks, native slash commands, localization, runtime configuration, document import/export, and app-owned formatting chrome. A native Swift sample demonstrates persisted editing, a rich-text comments composer, and custom-block integrations while sharing the same serialized document format as the existing KMP sample. + +## 2. Architecture & Design Decisions + +### Module and framework boundary + +The feature introduces the `:editor-ios-sdk` Kotlin Multiplatform module with iOS device (`iosArm64`) and Apple Silicon simulator (`iosSimulatorArm64`) targets. It builds a static framework named `CascadeEditor`; the lower-level `:editor` framework was renamed to `CascadeEditorCore` to avoid a framework-name collision. The SDK depends on `:editor` with `implementation`, rather than exporting it, which keeps Compose, Skiko, `EditorStateHolder`, and other core implementation types out of Swift-facing signatures. + +Public bridge types use `@ObjCName(..., exact = true)` so generated Objective-C/Swift names remain deliberate. Binary Compatibility Validator snapshots guard the Kotlin public surface of both `:editor` and `:editor-ios-sdk`, and CI now runs the SDK tests, API check, and XCFramework assembly on macOS. + +### Controller facade + +`CascadeEditorController` is the primary SDK entry point. It owns one stable set of: + +- `EditorStateHolder` +- `BlockTextStates` and `BlockSpanStates` +- `BlockRegistry` seeded with built-in block types +- `SlashCommandRegistry` +- configuration and localization snapshots +- mounted toolbar actions and derived toolbar state + +This is a facade pattern: Swift sees curated value objects and controller methods, while the controller translates them into core editor operations. The owned registries are intentionally stable for the controller lifetime, allowing custom blocks and slash commands to be registered before or after the editor is mounted. + +### Compose-to-UIKit host + +`CascadeEditorController.makeViewController()` creates a `ComposeUIViewController` and mounts `CascadeEditor` with the controller-owned state, runtime holders, and registries. It maps `CascadeEditorConfiguration` to `CascadeEditorConfig`, theme, toolbar, link popup, and slash-command slots. The host is created non-opaque (`opaque = false`): `CascadeEditor` paints no canvas background, so the native screen background behind the view controller shows through the editor. + +The host uses Compose snapshot state and `snapshotFlow` for two bridge streams: + +1. formatting, indentation, and link state are mapped into `CascadeToolbarState`; +2. editor state plus authoritative document blocks are observed for `onStateChanged` and `onDocumentChanged` callbacks. + +Document observation uses `EditorStateHolder.resolveDocumentBlocks(...)`, which folds live text and spans into snapshot blocks without serializing JSON on every edit. A per-composition mount token prevents an old view controller from clearing or publishing bridge state when UIKit/SwiftUI transitions temporarily overlap two hosts created from the same controller. + +### Native custom-block adapter + +`CascadeCustomBlockRegistration` describes a native block's identity, slash-menu metadata, default JSON payload, initial height, and `UIViewController` factory. Registration produces four linked pieces: + +- a core `BlockDescriptor` and slash behavior; +- a `NativeCustomBlockType` recognized by the document codec; +- a `NativeCustomBlockRenderer` registered in the core block registry; +- a `CascadeCustomBlockContext` supplied to the native view. + +`NativeCustomBlockRenderer` adapts a `UIViewController` into Compose using `UIKitViewController`. Its height is seeded from `estimatedHeight`, retained with `rememberSaveable`, and updated through `CascadeCustomBlockContext.setPreferredHeight(...)`. The context delegates block mutations to `BlockRenderScope`, preserving the editor's read-only policy and structural-history behavior. `onChange` is a pull-based invalidation signal: native views re-read current payload, focus, selection, read-only, and dark-mode values instead of receiving partial deltas. + +Native block renderers set `BlockRenderer.supportsDragPreview = false`. The core editor therefore draws a lightweight labeled placeholder during drag instead of creating a second live UIKit controller whose interop view would not follow draw-phase translation. + +### Native slash-command adapter + +`CascadeSlashCommand` wraps a synchronous Swift handler in the core editor's suspending slash-command contract. The handler receives a short-lived `CascadeSlashCommandContext`, which exposes only anchor-scoped text replacement, block insertion, focus, and menu-close operations. Native commands use `SlashQueryTextPolicy.KeepText`, so the handler owns removal or replacement of the `/query` token. + +Command and custom-block registration use last-registration-wins semantics and report collisions through `onInternalError`. The core registries now carry Compose-observable revision counters, so registrations made after mount re-derive built-in items, merged slash registries, and renderer lookups without replacing registry instances. + +### Additional core abstractions + +The feature promotes or adds the following reusable core APIs: + +- `EditorStateHolder.dispatchStructuralAction(...)` is public so SDK and external chrome mutations can create one undoable structural history entry when runtime holders are available. +- `EditorStateHolder.resolveDocumentBlocks(...)` returns authoritative blocks with live runtime text/spans folded in. +- `BlockRenderer.supportsDragPreview` lets platform-view renderers opt out of duplicate live preview composition. +- `builtInBlockSlashCommandId(typeId)` and `BUILTIN_BLOCK_SLASH_COMMAND_ID_PREFIX` expose the stable `builtin.block.` identifier scheme for collision detection. + +The built-in slash executor also distinguishes text and non-text conversion targets. A blank anchor can be replaced in place by a non-text block; a nonblank anchor keeps its text and receives the new non-text block after it, preventing silent text loss. + +## 3. Data Flow + +### View creation and state publication + +1. Swift creates a `CascadeEditorController`, optionally with initial JSON and configuration. +2. Swift calls `makeViewController()` and caches the returned controller in a `UIViewControllerRepresentable` or UIKit container. +3. The Compose host mounts `CascadeEditor` with controller-owned state, runtime holders, registries, configuration, localization, and callbacks. +4. `rememberCascadeEditorToolbarController(...)` derives formatting, indentation, and link capabilities from current editor state. +5. `snapshotFlow` maps those values to `CascadeToolbarState` and invokes `onToolbarStateChanged` when the value changes. +6. A second `snapshotFlow` compares `EditorState` and `resolveDocumentBlocks(...)` results. State changes invoke `onStateChanged`; content changes invoke both state and document callbacks as applicable. +7. Swift callback handlers re-read pull properties such as `canUndo`, `hasSelection`, and `toolbarState`, then publish them into app-owned observable state. + +### User edit to persisted document + +1. UIKit events reach the hosted Compose text field or block gesture handlers. +2. Existing editor callbacks dispatch reducer actions or mutate live `BlockTextStates`/`BlockSpanStates` through history-aware integration points. +3. Editor snapshot/runtime state changes and Compose recomposes the affected content. +4. The host's authoritative-block observer detects live text/span or structural changes and invokes `onDocumentChanged`. +5. The Swift app may debounce that signal and call `exportJson()` for persistence. +6. Export synchronously resolves the current document on the main queue and encodes it with `NativeCustomBlockCodec`, preserving registered native custom-block types and payloads. + +### Document load + +1. Swift passes JSON to `loadJson(...)`. +2. The controller preflights with `DocumentSchema.decodeFromStringWithReport(...)` and the native type codec. +3. A parse failure returns `success = false` with warning strings and leaves the current document and history untouched. +4. A successful decode hard-replaces editor state, clears runtime text/span state and history, and resolves registered custom type IDs to `NativeCustomBlockType`. +5. If mounted, the Compose observer publishes changes; if unmounted, the controller invokes the state/document callbacks directly. + +`loadHtml(...)` follows the core default HTML profile, hard-replaces the document, and classifies input-limit or decoder-exception warnings as an unsuccessful load. + +### App-owned toolbar action + +1. Swift reads `toolbarState` or receives `onToolbarStateChanged` to determine availability and active/mixed/inactive styles. +2. Swift calls an action such as `toggleBold()`, `indentForward()`, or `applyLink(url:title:)`. +3. The controller forwards to action delegates installed by the mounted `CascadeEditorToolbarController`. +4. Core formatting/link/indentation actions update runtime state, synchronize snapshot content, and capture history according to existing editor rules. +5. Toolbar and document observers publish the new derived state to Swift. + +### Native custom-block mutation + +1. A registered descriptor decodes or creates a `NativeCustomBlockType` with `BlockContent.Custom` payload data. +2. `NativeCustomBlockRenderer` creates the registered UIKit controller and supplies its block-scoped `CascadeCustomBlockContext`. +3. The native view reads `payloadJson`, selection/focus state, policy flags, and theme state from the context. +4. A context mutation validates the main thread, read-only/capability state, block existence, and JSON-object payload. +5. The context delegates to `BlockRenderScope`; structural mutation updates the document and creates one undo entry when history runtime is bound. +6. Compose observes the changed block. `LaunchedEffect` calls `context.onChange`, and the native view re-reads its context. +7. The view measures its content and reports a preferred height; the renderer clamps and applies the new Compose host height. + +### Native slash command + +1. Typing `/` opens the merged built-in/native slash registry. +2. Selecting a native item enters the core slash executor with the anchor block and query range. +3. The bridge constructs a temporary `CascadeSlashCommandContext` and synchronously calls the Swift handler. +4. Context operations update anchor text, insert built-in or registered custom blocks, focus the anchor, or close the menu through `SlashCommandEditor`. +5. `done` closes normally, `keepOpen` retains the menu, and `failure(message)` closes and reports the optional message through `onInternalError`. + +## 4. Public API Surface + +### SDK identity and configuration + +- `CascadeEditorSdk.version: String` — currently `"1.0.0"`. +- `CascadeEditorConfiguration` — immutable configuration containing `readOnly`, `toolbarMode`, `slashCommandsEnabled`, `blockSelectionEnabled`, `blockDraggingEnabled`, `isDark`, and `crashPolicy`. +- `CascadeToolbarMode` — `builtIn` or `none`; `none` disables both the built-in formatting toolbar and its link popup. +- `CascadeCrashPolicy` — `containAndReport` or `rethrow`. + +### `CascadeEditorController` + +Construction and hosting: + +```kotlin +CascadeEditorController() +CascadeEditorController(initialJson: String?) +CascadeEditorController(initialJson: String?, configuration: CascadeEditorConfiguration) +controller.makeViewController(): UIViewController +``` + +Document APIs: + +- `loadJson(json): CascadeDocumentLoadResult` +- `loadHtml(html): CascadeHtmlLoadResult` +- `reset(toJson): CascadeDocumentLoadResult` +- `exportJson(): String` +- `exportHtml(): String` +- `exportPlainText(): String` +- `exportRichText(): CascadeRichTextSnapshot` + +Derived state: + +- `configuration`, `selectedBlockCount`, `hasSelection`, `toolbarState`, `canUndo`, and `canRedo`. +- `CascadeToolbarState` exposes focus/format availability, tri-state status for six styles, indentation capabilities, link capability, and the existing URL. +- `CascadeStyleState` is `active`, `mixed`, or `inactive`. + +Editing commands: + +- `clearFocus()`, `clearSelection()`, `deleteSelectedOrFocused()` +- `undo()`, `redo()` +- `toggleBold()`, `toggleItalic()`, `toggleUnderline()`, `toggleStrikeThrough()`, `toggleInlineCode()`, `toggleHighlight(argb)` +- `indentForward()`, `indentBackward()` +- `applyLink(url, title)`, `removeLink()` + +Runtime configuration and localization: + +- `updateConfiguration(value)`, `setReadOnly(value)`, `setDarkMode(value)`, `setToolbarMode(value)`, `setSlashCommandsEnabled(value)` +- `setLocalization(CascadeEditorLocalization)` +- `CascadeLocalizedStrings` supplies nullable overrides for built-in UI/accessibility strings. +- `CascadeLocalizedBlockStrings` supplies slash-menu name, description, and additive keywords by block type ID. + +Callbacks: + +- `onDocumentChanged: (() -> Unit)?` +- `onStateChanged: (() -> Unit)?` +- `onInternalError: ((String) -> Unit)?` +- `onOpenLink: ((String) -> Unit)?` +- `onToolbarStateChanged: ((CascadeToolbarState) -> Unit)?` + +### Document and rich-text models + +- `CascadeDocumentLoadResult(success, warningMessages)`; `CascadeHtmlLoadResult` is a type alias. +- `CascadeEditorDocumentBuilder` fluently adds paragraphs, headings, todos, bullet/numbered lists, quotes, code, dividers, and custom blocks, then emits canonical JSON with `buildJson()`. +- `CascadeRichTextSnapshot` contains document-ordered `CascadeRichTextBlock` values. +- `CascadeRichTextSpan(start, end, kind, argb, url)` exposes supported core span styles through `CascadeSpanKind`. + +Example Swift usage: + +```swift +let controller = CascadeEditorController() +_ = controller.loadJson(json: storedJson) +let viewController = controller.makeViewController() +controller.onDocumentChanged = { save(controller.exportJson()) } +``` + +### Custom blocks + +- `CascadeCustomBlockRegistration(...)` — registers identity, slash metadata/behavior, default JSON-object payload, estimated height, and `(CascadeCustomBlockContext) -> UIViewController` factory. +- `CascadeCustomBlockSlashBehavior` — `insert` or `convertInPlace`. +- `CascadeCustomBlockContext` — live `payloadJson`, focus/selection/read-only/capability/theme properties; merge/replace payload; insert before/after; delete/focus block; report preferred height; receive `onChange` invalidations. +- `CascadeCustomBlockMutationResult` — `success`, `readOnly`, `invalidPayload`, `unknownType`, or `blockUnavailable`. +- `CascadeEditorController.registerBlock(registration)` installs the descriptor, codec recognition, renderer, and slash behavior. + +### Slash commands + +- `CascadeSlashCommand(id, title, description, keywords, handler)`. +- `CascadeSlashCommandContext` — `replaceQueryText`, `updateAnchorText`, insert before/after anchor, `focusAnchor`, and `closeMenu`. +- `CascadeSlashCommandResult` — shared `done` and `keepOpen` values plus `failure(message)`. +- `CascadeEditorController.registerSlashCommand(command)` installs or replaces a root command. + +### New `:editor` public APIs + +- `EditorStateHolder.dispatchStructuralAction(action, textStates?, spanStates?)` +- `EditorStateHolder.resolveDocumentBlocks(textStates, spanStates): List` +- `BlockRenderer.supportsDragPreview: Boolean` +- `BUILTIN_BLOCK_SLASH_COMMAND_ID_PREFIX: String` +- `builtInBlockSlashCommandId(typeId): SlashCommandId` + +## 5. Integration Points + +- **Core editor state and history:** the controller owns `EditorStateHolder`, `BlockTextStates`, and `BlockSpanStates`; toolbar and custom-block operations reuse core history-aware actions. +- **Compose UI:** `ComposeUIViewController` hosts the existing `CascadeEditor`, and Compose snapshot state drives all bridge callbacks. +- **UIKit and SwiftUI:** the SDK returns `UIViewController`; the sample embeds it with `UIViewControllerRepresentable`. Custom blocks also return `UIViewController`, allowing `UIHostingController`-backed SwiftUI content. +- **Registry system:** native blocks extend `BlockRegistry`; native commands extend `SlashCommandRegistry`. Observable revisions make runtime registration visible to an already-mounted editor. +- **Serialization:** JSON uses `DocumentSchema` plus `NativeCustomBlockCodec`; HTML uses `HtmlProfile.Default`. Both share the same live text/span holders as rendering. +- **Rich text and toolbar:** the bridge maps `FormattingState`, `IndentationState`, and `LinkState` from `CascadeEditorToolbarController` into Swift-friendly state and actions. +- **Localization and theme:** Swift overrides are resolved into core `CascadeEditorStrings` and `CascadeEditorBlockStrings`; `isDark` selects the core light/dark theme and is exposed to native custom blocks. +- **Build/distribution:** `scripts/build-xcframework.sh` assembles the debug XCFramework at `editor-ios-sdk/build/XCFrameworks/debug/CascadeEditor.xcframework`. The Xcode sample links this local artifact. +- **CI/API compatibility:** macOS CI boots an iOS simulator, runs both module test suites and API checks, and assembles the debug XCFramework. + +## 7. Edge Cases & Known Constraints + +- All state-mutating controller methods, context operations, and ordinary state getters are main-thread-only. Off-main misuse reports `onInternalError` and returns a stable fallback/no-op. Export methods are the exception: they synchronously hop to the main queue to return authoritative content. Callers must not block the main thread waiting for an off-main export, or they can deadlock. +- Toolbar actions, `undo()`, and `redo()` are unavailable before the Compose editor is mounted. `canUndo` and `canRedo` return `false` in that state. Document load/export does not require a mounted view. +- Structural history requires live text/span runtime holders. `dispatchStructuralAction(...)` still applies the action when no holders are bound or passed, but the change is not undoable and is logged. +- JSON parse failure is preflighted and preserves the current document and history. Successful JSON load/reset is a hard replacement and clears history. HTML load follows the core hard-replacement path; fatal warning categories affect `success` but do not provide the same explicit preflight-preservation guarantee. +- Unknown document block types are preserved. Registered native type IDs decode to renderable `NativeCustomBlockType`; custom content still uses the serializer's generic custom-content fallback and can emit a non-fatal unknown-content-kind warning. +- Custom payloads must be JSON objects. Invalid/non-object payloads are rejected by runtime mutation and insertion APIs. The document builder instead records `lastErrorMessage` and emits an empty payload. Supported values are JSON-compatible strings, finite numbers, booleans, nulls, lists, and nested string-keyed objects; unsupported map keys/value types are coerced or omitted. +- Custom-block type IDs cannot collide with built-in IDs, including the `heading_` family. Re-registering a native block ID is accepted, replaces the prior registration, and reports a warning. +- Slash-command IDs use last-registration-wins behavior, including collisions with built-in IDs. Native handlers are synchronous, the context is valid only during the handler call, and the handler owns its `/query` text. +- Custom-block mutations return `readOnly` when either editor read-only state or `BlockRenderScope.canUpdateBlock` denies mutation. `focusBlock()` remains available because it is not a document mutation. +- Custom block height is clamped to `1...10,000` points; NaN/infinity falls back to `120` points. Native views must report height changes to avoid clipping or excess space. +- Custom UIKit renderers opt out of live drag previews and receive a generic placeholder ghost. Renderer factory failures are reported and replaced with an empty `UIViewController`. +- Native callbacks and custom-block `onChange` handlers are exception-contained. Errors in `onInternalError` itself are swallowed to prevent exceptions crossing the Swift/Objective-C boundary. +- `exportPlainText()` omits non-text blocks completely. `exportRichText()` includes every block, representing non-text blocks with empty text/spans; unsupported custom span styles are omitted, and exported ranges are clamped to text length. +- Rich-text offsets are core text offsets and are consumed as UTF-16 offsets by the Swift sample. Consumers combining block runs must shift ranges using UTF-16 length, not Swift grapheme-cluster count. +- The built XCFramework includes arm64 device and arm64 simulator slices only; there is no x64 simulator target in the module configuration. +- Binary API dumps validate Kotlin declarations but do not validate `@ObjCName` spelling or every Objective-C header-lowering detail. Swift-visible naming changes require inspection of the generated `CascadeEditor.h`. +- ⚠️ Unclear: `CascadeEditorSdk.version` is hard-coded to `1.0.0` and is not derived from Gradle publication/version metadata. +- ⚠️ Unclear: iOS native Compose text input is explicitly requested by the common text-field call but currently forced off in the iOS platform implementation due to CMP-10404. The TODO does not define the Compose version or acceptance criteria for enabling it. +- ⚠️ Unclear: only the debug XCFramework has a documented local consumption flow; release publication and external distribution are explicitly deferred. + +## 8. Glossary + +- **Authoritative document blocks:** snapshot blocks with current runtime text and span edits folded in by `resolveDocumentBlocks(...)`. +- **Bridge state:** Swift-friendly state and callbacks derived from the internal Compose editor state. +- **Custom block context:** the block-scoped, main-thread handle through which a native view reads current state and requests editor mutations. +- **Hard replacement:** a document load/reset that replaces the editor state, clears runtime holders, and clears undo/redo history. +- **Mount token:** identity object used to ensure only the current Compose host publishes or clears controller bridge state. +- **Native custom block:** a custom document block whose content is rendered by a UIKit/SwiftUI-owned `UIViewController` hosted inside Compose. +- **Native type codec:** `NativeCustomBlockCodec`, which maps registered custom type IDs between persisted JSON and renderable native block types. +- **Runtime holders:** `BlockTextStates` and `BlockSpanStates`, which contain live editing values that may be newer than `EditorState` snapshot content. +- **Structural action:** a semantic document mutation captured as one full-checkpoint history entry. +- **Toolbar state:** a Swift-facing projection of formatting, indentation, and link state, including tri-state style activation. +- **XCFramework:** Apple's bundle format containing framework binaries for multiple Apple platform architectures. diff --git a/editor-ios-sdk/api/editor-ios-sdk.klib.api b/editor-ios-sdk/api/editor-ios-sdk.klib.api new file mode 100644 index 0000000..04c5e21 --- /dev/null +++ b/editor-ios-sdk/api/editor-ios-sdk.klib.api @@ -0,0 +1,549 @@ +// Klib ABI Dump +// Targets: [iosArm64, iosSimulatorArm64] +// Rendering settings: +// - Signature version: 2 +// - Show manifest properties: true +// - Show declarations: true + +// Library unique name: +final enum class io.github.linreal.cascade.ios.block/CascadeCustomBlockMutationResult : kotlin/Enum { // io.github.linreal.cascade.ios.block/CascadeCustomBlockMutationResult|null[0] + enum entry blockUnavailable // io.github.linreal.cascade.ios.block/CascadeCustomBlockMutationResult.blockUnavailable|null[0] + enum entry invalidPayload // io.github.linreal.cascade.ios.block/CascadeCustomBlockMutationResult.invalidPayload|null[0] + enum entry readOnly // io.github.linreal.cascade.ios.block/CascadeCustomBlockMutationResult.readOnly|null[0] + enum entry success // io.github.linreal.cascade.ios.block/CascadeCustomBlockMutationResult.success|null[0] + enum entry unknownType // io.github.linreal.cascade.ios.block/CascadeCustomBlockMutationResult.unknownType|null[0] + + final val entries // io.github.linreal.cascade.ios.block/CascadeCustomBlockMutationResult.entries|#static{}entries[0] + final fun (): kotlin.enums/EnumEntries // io.github.linreal.cascade.ios.block/CascadeCustomBlockMutationResult.entries.|#static(){}[0] + + final fun valueOf(kotlin/String): io.github.linreal.cascade.ios.block/CascadeCustomBlockMutationResult // io.github.linreal.cascade.ios.block/CascadeCustomBlockMutationResult.valueOf|valueOf#static(kotlin.String){}[0] + final fun values(): kotlin/Array // io.github.linreal.cascade.ios.block/CascadeCustomBlockMutationResult.values|values#static(){}[0] +} + +final enum class io.github.linreal.cascade.ios.block/CascadeCustomBlockSlashBehavior : kotlin/Enum { // io.github.linreal.cascade.ios.block/CascadeCustomBlockSlashBehavior|null[0] + enum entry convertInPlace // io.github.linreal.cascade.ios.block/CascadeCustomBlockSlashBehavior.convertInPlace|null[0] + enum entry insert // io.github.linreal.cascade.ios.block/CascadeCustomBlockSlashBehavior.insert|null[0] + + final val entries // io.github.linreal.cascade.ios.block/CascadeCustomBlockSlashBehavior.entries|#static{}entries[0] + final fun (): kotlin.enums/EnumEntries // io.github.linreal.cascade.ios.block/CascadeCustomBlockSlashBehavior.entries.|#static(){}[0] + + final fun valueOf(kotlin/String): io.github.linreal.cascade.ios.block/CascadeCustomBlockSlashBehavior // io.github.linreal.cascade.ios.block/CascadeCustomBlockSlashBehavior.valueOf|valueOf#static(kotlin.String){}[0] + final fun values(): kotlin/Array // io.github.linreal.cascade.ios.block/CascadeCustomBlockSlashBehavior.values|values#static(){}[0] +} + +final enum class io.github.linreal.cascade.ios.controller/CascadeCrashPolicy : kotlin/Enum { // io.github.linreal.cascade.ios.controller/CascadeCrashPolicy|null[0] + enum entry containAndReport // io.github.linreal.cascade.ios.controller/CascadeCrashPolicy.containAndReport|null[0] + enum entry rethrow // io.github.linreal.cascade.ios.controller/CascadeCrashPolicy.rethrow|null[0] + + final val entries // io.github.linreal.cascade.ios.controller/CascadeCrashPolicy.entries|#static{}entries[0] + final fun (): kotlin.enums/EnumEntries // io.github.linreal.cascade.ios.controller/CascadeCrashPolicy.entries.|#static(){}[0] + + final fun valueOf(kotlin/String): io.github.linreal.cascade.ios.controller/CascadeCrashPolicy // io.github.linreal.cascade.ios.controller/CascadeCrashPolicy.valueOf|valueOf#static(kotlin.String){}[0] + final fun values(): kotlin/Array // io.github.linreal.cascade.ios.controller/CascadeCrashPolicy.values|values#static(){}[0] +} + +final enum class io.github.linreal.cascade.ios.controller/CascadeToolbarMode : kotlin/Enum { // io.github.linreal.cascade.ios.controller/CascadeToolbarMode|null[0] + enum entry builtIn // io.github.linreal.cascade.ios.controller/CascadeToolbarMode.builtIn|null[0] + enum entry none // io.github.linreal.cascade.ios.controller/CascadeToolbarMode.none|null[0] + + final val entries // io.github.linreal.cascade.ios.controller/CascadeToolbarMode.entries|#static{}entries[0] + final fun (): kotlin.enums/EnumEntries // io.github.linreal.cascade.ios.controller/CascadeToolbarMode.entries.|#static(){}[0] + + final fun valueOf(kotlin/String): io.github.linreal.cascade.ios.controller/CascadeToolbarMode // io.github.linreal.cascade.ios.controller/CascadeToolbarMode.valueOf|valueOf#static(kotlin.String){}[0] + final fun values(): kotlin/Array // io.github.linreal.cascade.ios.controller/CascadeToolbarMode.values|values#static(){}[0] +} + +final enum class io.github.linreal.cascade.ios.model/CascadeSpanKind : kotlin/Enum { // io.github.linreal.cascade.ios.model/CascadeSpanKind|null[0] + enum entry bold // io.github.linreal.cascade.ios.model/CascadeSpanKind.bold|null[0] + enum entry highlight // io.github.linreal.cascade.ios.model/CascadeSpanKind.highlight|null[0] + enum entry inlineCode // io.github.linreal.cascade.ios.model/CascadeSpanKind.inlineCode|null[0] + enum entry italic // io.github.linreal.cascade.ios.model/CascadeSpanKind.italic|null[0] + enum entry link // io.github.linreal.cascade.ios.model/CascadeSpanKind.link|null[0] + enum entry strikeThrough // io.github.linreal.cascade.ios.model/CascadeSpanKind.strikeThrough|null[0] + enum entry underline // io.github.linreal.cascade.ios.model/CascadeSpanKind.underline|null[0] + + final val entries // io.github.linreal.cascade.ios.model/CascadeSpanKind.entries|#static{}entries[0] + final fun (): kotlin.enums/EnumEntries // io.github.linreal.cascade.ios.model/CascadeSpanKind.entries.|#static(){}[0] + + final fun valueOf(kotlin/String): io.github.linreal.cascade.ios.model/CascadeSpanKind // io.github.linreal.cascade.ios.model/CascadeSpanKind.valueOf|valueOf#static(kotlin.String){}[0] + final fun values(): kotlin/Array // io.github.linreal.cascade.ios.model/CascadeSpanKind.values|values#static(){}[0] +} + +final enum class io.github.linreal.cascade.ios.toolbar/CascadeStyleState : kotlin/Enum { // io.github.linreal.cascade.ios.toolbar/CascadeStyleState|null[0] + enum entry active // io.github.linreal.cascade.ios.toolbar/CascadeStyleState.active|null[0] + enum entry inactive // io.github.linreal.cascade.ios.toolbar/CascadeStyleState.inactive|null[0] + enum entry mixed // io.github.linreal.cascade.ios.toolbar/CascadeStyleState.mixed|null[0] + + final val entries // io.github.linreal.cascade.ios.toolbar/CascadeStyleState.entries|#static{}entries[0] + final fun (): kotlin.enums/EnumEntries // io.github.linreal.cascade.ios.toolbar/CascadeStyleState.entries.|#static(){}[0] + + final fun valueOf(kotlin/String): io.github.linreal.cascade.ios.toolbar/CascadeStyleState // io.github.linreal.cascade.ios.toolbar/CascadeStyleState.valueOf|valueOf#static(kotlin.String){}[0] + final fun values(): kotlin/Array // io.github.linreal.cascade.ios.toolbar/CascadeStyleState.values|values#static(){}[0] +} + +final class io.github.linreal.cascade.ios.block/CascadeCustomBlockContext { // io.github.linreal.cascade.ios.block/CascadeCustomBlockContext|null[0] + final val blockId // io.github.linreal.cascade.ios.block/CascadeCustomBlockContext.blockId|{}blockId[0] + final fun (): kotlin/String // io.github.linreal.cascade.ios.block/CascadeCustomBlockContext.blockId.|(){}[0] + final val canUpdateBlock // io.github.linreal.cascade.ios.block/CascadeCustomBlockContext.canUpdateBlock|{}canUpdateBlock[0] + final fun (): kotlin/Boolean // io.github.linreal.cascade.ios.block/CascadeCustomBlockContext.canUpdateBlock.|(){}[0] + final val isDark // io.github.linreal.cascade.ios.block/CascadeCustomBlockContext.isDark|{}isDark[0] + final fun (): kotlin/Boolean // io.github.linreal.cascade.ios.block/CascadeCustomBlockContext.isDark.|(){}[0] + final val isFocused // io.github.linreal.cascade.ios.block/CascadeCustomBlockContext.isFocused|{}isFocused[0] + final fun (): kotlin/Boolean // io.github.linreal.cascade.ios.block/CascadeCustomBlockContext.isFocused.|(){}[0] + final val isSelected // io.github.linreal.cascade.ios.block/CascadeCustomBlockContext.isSelected|{}isSelected[0] + final fun (): kotlin/Boolean // io.github.linreal.cascade.ios.block/CascadeCustomBlockContext.isSelected.|(){}[0] + final val payloadJson // io.github.linreal.cascade.ios.block/CascadeCustomBlockContext.payloadJson|{}payloadJson[0] + final fun (): kotlin/String // io.github.linreal.cascade.ios.block/CascadeCustomBlockContext.payloadJson.|(){}[0] + final val readOnly // io.github.linreal.cascade.ios.block/CascadeCustomBlockContext.readOnly|{}readOnly[0] + final fun (): kotlin/Boolean // io.github.linreal.cascade.ios.block/CascadeCustomBlockContext.readOnly.|(){}[0] + final val typeId // io.github.linreal.cascade.ios.block/CascadeCustomBlockContext.typeId|{}typeId[0] + final fun (): kotlin/String // io.github.linreal.cascade.ios.block/CascadeCustomBlockContext.typeId.|(){}[0] + + final var onChange // io.github.linreal.cascade.ios.block/CascadeCustomBlockContext.onChange|{}onChange[0] + final fun (): kotlin/Function0? // io.github.linreal.cascade.ios.block/CascadeCustomBlockContext.onChange.|(){}[0] + final fun (kotlin/Function0?) // io.github.linreal.cascade.ios.block/CascadeCustomBlockContext.onChange.|(kotlin.Function0?){}[0] + + final fun deleteBlock(): io.github.linreal.cascade.ios.block/CascadeCustomBlockMutationResult // io.github.linreal.cascade.ios.block/CascadeCustomBlockContext.deleteBlock|deleteBlock(){}[0] + final fun focusBlock(): io.github.linreal.cascade.ios.block/CascadeCustomBlockMutationResult // io.github.linreal.cascade.ios.block/CascadeCustomBlockContext.focusBlock|focusBlock(){}[0] + final fun insertBlockAfter(kotlin/String, kotlin/String): io.github.linreal.cascade.ios.block/CascadeCustomBlockMutationResult // io.github.linreal.cascade.ios.block/CascadeCustomBlockContext.insertBlockAfter|insertBlockAfter(kotlin.String;kotlin.String){}[0] + final fun insertBlockBefore(kotlin/String, kotlin/String): io.github.linreal.cascade.ios.block/CascadeCustomBlockMutationResult // io.github.linreal.cascade.ios.block/CascadeCustomBlockContext.insertBlockBefore|insertBlockBefore(kotlin.String;kotlin.String){}[0] + final fun replacePayloadJson(kotlin/String): io.github.linreal.cascade.ios.block/CascadeCustomBlockMutationResult // io.github.linreal.cascade.ios.block/CascadeCustomBlockContext.replacePayloadJson|replacePayloadJson(kotlin.String){}[0] + final fun setPreferredHeight(kotlin/Double) // io.github.linreal.cascade.ios.block/CascadeCustomBlockContext.setPreferredHeight|setPreferredHeight(kotlin.Double){}[0] + final fun updatePayloadJson(kotlin/String): io.github.linreal.cascade.ios.block/CascadeCustomBlockMutationResult // io.github.linreal.cascade.ios.block/CascadeCustomBlockContext.updatePayloadJson|updatePayloadJson(kotlin.String){}[0] +} + +final class io.github.linreal.cascade.ios.block/CascadeCustomBlockRegistration { // io.github.linreal.cascade.ios.block/CascadeCustomBlockRegistration|null[0] + constructor (kotlin/String, kotlin/String, kotlin/String, kotlin.collections/List = ..., io.github.linreal.cascade.ios.block/CascadeCustomBlockSlashBehavior = ..., kotlin/String = ..., kotlin/Double = ..., kotlin/Function1) // io.github.linreal.cascade.ios.block/CascadeCustomBlockRegistration.|(kotlin.String;kotlin.String;kotlin.String;kotlin.collections.List;io.github.linreal.cascade.ios.block.CascadeCustomBlockSlashBehavior;kotlin.String;kotlin.Double;kotlin.Function1){}[0] + + final val defaultPayloadJson // io.github.linreal.cascade.ios.block/CascadeCustomBlockRegistration.defaultPayloadJson|{}defaultPayloadJson[0] + final fun (): kotlin/String // io.github.linreal.cascade.ios.block/CascadeCustomBlockRegistration.defaultPayloadJson.|(){}[0] + final val description // io.github.linreal.cascade.ios.block/CascadeCustomBlockRegistration.description|{}description[0] + final fun (): kotlin/String // io.github.linreal.cascade.ios.block/CascadeCustomBlockRegistration.description.|(){}[0] + final val displayName // io.github.linreal.cascade.ios.block/CascadeCustomBlockRegistration.displayName|{}displayName[0] + final fun (): kotlin/String // io.github.linreal.cascade.ios.block/CascadeCustomBlockRegistration.displayName.|(){}[0] + final val estimatedHeight // io.github.linreal.cascade.ios.block/CascadeCustomBlockRegistration.estimatedHeight|{}estimatedHeight[0] + final fun (): kotlin/Double // io.github.linreal.cascade.ios.block/CascadeCustomBlockRegistration.estimatedHeight.|(){}[0] + final val keywords // io.github.linreal.cascade.ios.block/CascadeCustomBlockRegistration.keywords|{}keywords[0] + final fun (): kotlin.collections/List // io.github.linreal.cascade.ios.block/CascadeCustomBlockRegistration.keywords.|(){}[0] + final val rendererFactory // io.github.linreal.cascade.ios.block/CascadeCustomBlockRegistration.rendererFactory|{}rendererFactory[0] + final fun (): kotlin/Function1 // io.github.linreal.cascade.ios.block/CascadeCustomBlockRegistration.rendererFactory.|(){}[0] + final val slashBehavior // io.github.linreal.cascade.ios.block/CascadeCustomBlockRegistration.slashBehavior|{}slashBehavior[0] + final fun (): io.github.linreal.cascade.ios.block/CascadeCustomBlockSlashBehavior // io.github.linreal.cascade.ios.block/CascadeCustomBlockRegistration.slashBehavior.|(){}[0] + final val typeId // io.github.linreal.cascade.ios.block/CascadeCustomBlockRegistration.typeId|{}typeId[0] + final fun (): kotlin/String // io.github.linreal.cascade.ios.block/CascadeCustomBlockRegistration.typeId.|(){}[0] +} + +final class io.github.linreal.cascade.ios.controller/CascadeDocumentLoadResult { // io.github.linreal.cascade.ios.controller/CascadeDocumentLoadResult|null[0] + constructor (kotlin/Boolean, kotlin.collections/List) // io.github.linreal.cascade.ios.controller/CascadeDocumentLoadResult.|(kotlin.Boolean;kotlin.collections.List){}[0] + + final val success // io.github.linreal.cascade.ios.controller/CascadeDocumentLoadResult.success|{}success[0] + final fun (): kotlin/Boolean // io.github.linreal.cascade.ios.controller/CascadeDocumentLoadResult.success.|(){}[0] + final val warningMessages // io.github.linreal.cascade.ios.controller/CascadeDocumentLoadResult.warningMessages|{}warningMessages[0] + final fun (): kotlin.collections/List // io.github.linreal.cascade.ios.controller/CascadeDocumentLoadResult.warningMessages.|(){}[0] + + final fun component1(): kotlin/Boolean // io.github.linreal.cascade.ios.controller/CascadeDocumentLoadResult.component1|component1(){}[0] + final fun component2(): kotlin.collections/List // io.github.linreal.cascade.ios.controller/CascadeDocumentLoadResult.component2|component2(){}[0] + final fun copy(kotlin/Boolean = ..., kotlin.collections/List = ...): io.github.linreal.cascade.ios.controller/CascadeDocumentLoadResult // io.github.linreal.cascade.ios.controller/CascadeDocumentLoadResult.copy|copy(kotlin.Boolean;kotlin.collections.List){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.ios.controller/CascadeDocumentLoadResult.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.ios.controller/CascadeDocumentLoadResult.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.ios.controller/CascadeDocumentLoadResult.toString|toString(){}[0] +} + +final class io.github.linreal.cascade.ios.controller/CascadeEditorConfiguration { // io.github.linreal.cascade.ios.controller/CascadeEditorConfiguration|null[0] + constructor () // io.github.linreal.cascade.ios.controller/CascadeEditorConfiguration.|(){}[0] + constructor (kotlin/Boolean, io.github.linreal.cascade.ios.controller/CascadeToolbarMode, kotlin/Boolean, kotlin/Boolean, kotlin/Boolean, kotlin/Boolean, io.github.linreal.cascade.ios.controller/CascadeCrashPolicy) // io.github.linreal.cascade.ios.controller/CascadeEditorConfiguration.|(kotlin.Boolean;io.github.linreal.cascade.ios.controller.CascadeToolbarMode;kotlin.Boolean;kotlin.Boolean;kotlin.Boolean;kotlin.Boolean;io.github.linreal.cascade.ios.controller.CascadeCrashPolicy){}[0] + + final val blockDraggingEnabled // io.github.linreal.cascade.ios.controller/CascadeEditorConfiguration.blockDraggingEnabled|{}blockDraggingEnabled[0] + final fun (): kotlin/Boolean // io.github.linreal.cascade.ios.controller/CascadeEditorConfiguration.blockDraggingEnabled.|(){}[0] + final val blockSelectionEnabled // io.github.linreal.cascade.ios.controller/CascadeEditorConfiguration.blockSelectionEnabled|{}blockSelectionEnabled[0] + final fun (): kotlin/Boolean // io.github.linreal.cascade.ios.controller/CascadeEditorConfiguration.blockSelectionEnabled.|(){}[0] + final val crashPolicy // io.github.linreal.cascade.ios.controller/CascadeEditorConfiguration.crashPolicy|{}crashPolicy[0] + final fun (): io.github.linreal.cascade.ios.controller/CascadeCrashPolicy // io.github.linreal.cascade.ios.controller/CascadeEditorConfiguration.crashPolicy.|(){}[0] + final val isDark // io.github.linreal.cascade.ios.controller/CascadeEditorConfiguration.isDark|{}isDark[0] + final fun (): kotlin/Boolean // io.github.linreal.cascade.ios.controller/CascadeEditorConfiguration.isDark.|(){}[0] + final val readOnly // io.github.linreal.cascade.ios.controller/CascadeEditorConfiguration.readOnly|{}readOnly[0] + final fun (): kotlin/Boolean // io.github.linreal.cascade.ios.controller/CascadeEditorConfiguration.readOnly.|(){}[0] + final val slashCommandsEnabled // io.github.linreal.cascade.ios.controller/CascadeEditorConfiguration.slashCommandsEnabled|{}slashCommandsEnabled[0] + final fun (): kotlin/Boolean // io.github.linreal.cascade.ios.controller/CascadeEditorConfiguration.slashCommandsEnabled.|(){}[0] + final val toolbarMode // io.github.linreal.cascade.ios.controller/CascadeEditorConfiguration.toolbarMode|{}toolbarMode[0] + final fun (): io.github.linreal.cascade.ios.controller/CascadeToolbarMode // io.github.linreal.cascade.ios.controller/CascadeEditorConfiguration.toolbarMode.|(){}[0] + + final fun component1(): kotlin/Boolean // io.github.linreal.cascade.ios.controller/CascadeEditorConfiguration.component1|component1(){}[0] + final fun component2(): io.github.linreal.cascade.ios.controller/CascadeToolbarMode // io.github.linreal.cascade.ios.controller/CascadeEditorConfiguration.component2|component2(){}[0] + final fun component3(): kotlin/Boolean // io.github.linreal.cascade.ios.controller/CascadeEditorConfiguration.component3|component3(){}[0] + final fun component4(): kotlin/Boolean // io.github.linreal.cascade.ios.controller/CascadeEditorConfiguration.component4|component4(){}[0] + final fun component5(): kotlin/Boolean // io.github.linreal.cascade.ios.controller/CascadeEditorConfiguration.component5|component5(){}[0] + final fun component6(): kotlin/Boolean // io.github.linreal.cascade.ios.controller/CascadeEditorConfiguration.component6|component6(){}[0] + final fun component7(): io.github.linreal.cascade.ios.controller/CascadeCrashPolicy // io.github.linreal.cascade.ios.controller/CascadeEditorConfiguration.component7|component7(){}[0] + final fun copy(kotlin/Boolean = ..., io.github.linreal.cascade.ios.controller/CascadeToolbarMode = ..., kotlin/Boolean = ..., kotlin/Boolean = ..., kotlin/Boolean = ..., kotlin/Boolean = ..., io.github.linreal.cascade.ios.controller/CascadeCrashPolicy = ...): io.github.linreal.cascade.ios.controller/CascadeEditorConfiguration // io.github.linreal.cascade.ios.controller/CascadeEditorConfiguration.copy|copy(kotlin.Boolean;io.github.linreal.cascade.ios.controller.CascadeToolbarMode;kotlin.Boolean;kotlin.Boolean;kotlin.Boolean;kotlin.Boolean;io.github.linreal.cascade.ios.controller.CascadeCrashPolicy){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.ios.controller/CascadeEditorConfiguration.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.ios.controller/CascadeEditorConfiguration.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.ios.controller/CascadeEditorConfiguration.toString|toString(){}[0] +} + +final class io.github.linreal.cascade.ios.controller/CascadeEditorController { // io.github.linreal.cascade.ios.controller/CascadeEditorController|null[0] + constructor () // io.github.linreal.cascade.ios.controller/CascadeEditorController.|(){}[0] + constructor (kotlin/String?) // io.github.linreal.cascade.ios.controller/CascadeEditorController.|(kotlin.String?){}[0] + constructor (kotlin/String?, io.github.linreal.cascade.ios.controller/CascadeEditorConfiguration) // io.github.linreal.cascade.ios.controller/CascadeEditorController.|(kotlin.String?;io.github.linreal.cascade.ios.controller.CascadeEditorConfiguration){}[0] + + final val canRedo // io.github.linreal.cascade.ios.controller/CascadeEditorController.canRedo|{}canRedo[0] + final fun (): kotlin/Boolean // io.github.linreal.cascade.ios.controller/CascadeEditorController.canRedo.|(){}[0] + final val canUndo // io.github.linreal.cascade.ios.controller/CascadeEditorController.canUndo|{}canUndo[0] + final fun (): kotlin/Boolean // io.github.linreal.cascade.ios.controller/CascadeEditorController.canUndo.|(){}[0] + final val configuration // io.github.linreal.cascade.ios.controller/CascadeEditorController.configuration|{}configuration[0] + final fun (): io.github.linreal.cascade.ios.controller/CascadeEditorConfiguration // io.github.linreal.cascade.ios.controller/CascadeEditorController.configuration.|(){}[0] + final val hasSelection // io.github.linreal.cascade.ios.controller/CascadeEditorController.hasSelection|{}hasSelection[0] + final fun (): kotlin/Boolean // io.github.linreal.cascade.ios.controller/CascadeEditorController.hasSelection.|(){}[0] + final val selectedBlockCount // io.github.linreal.cascade.ios.controller/CascadeEditorController.selectedBlockCount|{}selectedBlockCount[0] + final fun (): kotlin/Int // io.github.linreal.cascade.ios.controller/CascadeEditorController.selectedBlockCount.|(){}[0] + final val toolbarState // io.github.linreal.cascade.ios.controller/CascadeEditorController.toolbarState|{}toolbarState[0] + final fun (): io.github.linreal.cascade.ios.toolbar/CascadeToolbarState // io.github.linreal.cascade.ios.controller/CascadeEditorController.toolbarState.|(){}[0] + + final var onDocumentChanged // io.github.linreal.cascade.ios.controller/CascadeEditorController.onDocumentChanged|{}onDocumentChanged[0] + final fun (): kotlin/Function0? // io.github.linreal.cascade.ios.controller/CascadeEditorController.onDocumentChanged.|(){}[0] + final fun (kotlin/Function0?) // io.github.linreal.cascade.ios.controller/CascadeEditorController.onDocumentChanged.|(kotlin.Function0?){}[0] + final var onInternalError // io.github.linreal.cascade.ios.controller/CascadeEditorController.onInternalError|{}onInternalError[0] + final fun (): kotlin/Function1? // io.github.linreal.cascade.ios.controller/CascadeEditorController.onInternalError.|(){}[0] + final fun (kotlin/Function1?) // io.github.linreal.cascade.ios.controller/CascadeEditorController.onInternalError.|(kotlin.Function1?){}[0] + final var onOpenLink // io.github.linreal.cascade.ios.controller/CascadeEditorController.onOpenLink|{}onOpenLink[0] + final fun (): kotlin/Function1? // io.github.linreal.cascade.ios.controller/CascadeEditorController.onOpenLink.|(){}[0] + final fun (kotlin/Function1?) // io.github.linreal.cascade.ios.controller/CascadeEditorController.onOpenLink.|(kotlin.Function1?){}[0] + final var onStateChanged // io.github.linreal.cascade.ios.controller/CascadeEditorController.onStateChanged|{}onStateChanged[0] + final fun (): kotlin/Function0? // io.github.linreal.cascade.ios.controller/CascadeEditorController.onStateChanged.|(){}[0] + final fun (kotlin/Function0?) // io.github.linreal.cascade.ios.controller/CascadeEditorController.onStateChanged.|(kotlin.Function0?){}[0] + final var onToolbarStateChanged // io.github.linreal.cascade.ios.controller/CascadeEditorController.onToolbarStateChanged|{}onToolbarStateChanged[0] + final fun (): kotlin/Function1? // io.github.linreal.cascade.ios.controller/CascadeEditorController.onToolbarStateChanged.|(){}[0] + final fun (kotlin/Function1?) // io.github.linreal.cascade.ios.controller/CascadeEditorController.onToolbarStateChanged.|(kotlin.Function1?){}[0] + + final fun applyLink(kotlin/String, kotlin/String?) // io.github.linreal.cascade.ios.controller/CascadeEditorController.applyLink|applyLink(kotlin.String;kotlin.String?){}[0] + final fun clearFocus() // io.github.linreal.cascade.ios.controller/CascadeEditorController.clearFocus|clearFocus(){}[0] + final fun clearSelection() // io.github.linreal.cascade.ios.controller/CascadeEditorController.clearSelection|clearSelection(){}[0] + final fun deleteSelectedOrFocused() // io.github.linreal.cascade.ios.controller/CascadeEditorController.deleteSelectedOrFocused|deleteSelectedOrFocused(){}[0] + final fun exportHtml(): kotlin/String // io.github.linreal.cascade.ios.controller/CascadeEditorController.exportHtml|exportHtml(){}[0] + final fun exportJson(): kotlin/String // io.github.linreal.cascade.ios.controller/CascadeEditorController.exportJson|exportJson(){}[0] + final fun exportPlainText(): kotlin/String // io.github.linreal.cascade.ios.controller/CascadeEditorController.exportPlainText|exportPlainText(){}[0] + final fun exportRichText(): io.github.linreal.cascade.ios.model/CascadeRichTextSnapshot // io.github.linreal.cascade.ios.controller/CascadeEditorController.exportRichText|exportRichText(){}[0] + final fun indentBackward() // io.github.linreal.cascade.ios.controller/CascadeEditorController.indentBackward|indentBackward(){}[0] + final fun indentForward() // io.github.linreal.cascade.ios.controller/CascadeEditorController.indentForward|indentForward(){}[0] + final fun loadHtml(kotlin/String): io.github.linreal.cascade.ios.controller/CascadeDocumentLoadResult // io.github.linreal.cascade.ios.controller/CascadeEditorController.loadHtml|loadHtml(kotlin.String){}[0] + final fun loadJson(kotlin/String): io.github.linreal.cascade.ios.controller/CascadeDocumentLoadResult // io.github.linreal.cascade.ios.controller/CascadeEditorController.loadJson|loadJson(kotlin.String){}[0] + final fun redo() // io.github.linreal.cascade.ios.controller/CascadeEditorController.redo|redo(){}[0] + final fun registerBlock(io.github.linreal.cascade.ios.block/CascadeCustomBlockRegistration) // io.github.linreal.cascade.ios.controller/CascadeEditorController.registerBlock|registerBlock(io.github.linreal.cascade.ios.block.CascadeCustomBlockRegistration){}[0] + final fun registerSlashCommand(io.github.linreal.cascade.ios.slash/CascadeSlashCommand) // io.github.linreal.cascade.ios.controller/CascadeEditorController.registerSlashCommand|registerSlashCommand(io.github.linreal.cascade.ios.slash.CascadeSlashCommand){}[0] + final fun removeLink() // io.github.linreal.cascade.ios.controller/CascadeEditorController.removeLink|removeLink(){}[0] + final fun reset(kotlin/String): io.github.linreal.cascade.ios.controller/CascadeDocumentLoadResult // io.github.linreal.cascade.ios.controller/CascadeEditorController.reset|reset(kotlin.String){}[0] + final fun setDarkMode(kotlin/Boolean) // io.github.linreal.cascade.ios.controller/CascadeEditorController.setDarkMode|setDarkMode(kotlin.Boolean){}[0] + final fun setLocalization(io.github.linreal.cascade.ios.localization/CascadeEditorLocalization) // io.github.linreal.cascade.ios.controller/CascadeEditorController.setLocalization|setLocalization(io.github.linreal.cascade.ios.localization.CascadeEditorLocalization){}[0] + final fun setReadOnly(kotlin/Boolean) // io.github.linreal.cascade.ios.controller/CascadeEditorController.setReadOnly|setReadOnly(kotlin.Boolean){}[0] + final fun setSlashCommandsEnabled(kotlin/Boolean) // io.github.linreal.cascade.ios.controller/CascadeEditorController.setSlashCommandsEnabled|setSlashCommandsEnabled(kotlin.Boolean){}[0] + final fun setToolbarMode(io.github.linreal.cascade.ios.controller/CascadeToolbarMode) // io.github.linreal.cascade.ios.controller/CascadeEditorController.setToolbarMode|setToolbarMode(io.github.linreal.cascade.ios.controller.CascadeToolbarMode){}[0] + final fun toggleBold() // io.github.linreal.cascade.ios.controller/CascadeEditorController.toggleBold|toggleBold(){}[0] + final fun toggleHighlight(kotlin/Long) // io.github.linreal.cascade.ios.controller/CascadeEditorController.toggleHighlight|toggleHighlight(kotlin.Long){}[0] + final fun toggleInlineCode() // io.github.linreal.cascade.ios.controller/CascadeEditorController.toggleInlineCode|toggleInlineCode(){}[0] + final fun toggleItalic() // io.github.linreal.cascade.ios.controller/CascadeEditorController.toggleItalic|toggleItalic(){}[0] + final fun toggleStrikeThrough() // io.github.linreal.cascade.ios.controller/CascadeEditorController.toggleStrikeThrough|toggleStrikeThrough(){}[0] + final fun toggleUnderline() // io.github.linreal.cascade.ios.controller/CascadeEditorController.toggleUnderline|toggleUnderline(){}[0] + final fun undo() // io.github.linreal.cascade.ios.controller/CascadeEditorController.undo|undo(){}[0] + final fun updateConfiguration(io.github.linreal.cascade.ios.controller/CascadeEditorConfiguration) // io.github.linreal.cascade.ios.controller/CascadeEditorController.updateConfiguration|updateConfiguration(io.github.linreal.cascade.ios.controller.CascadeEditorConfiguration){}[0] +} + +final class io.github.linreal.cascade.ios.localization/CascadeEditorLocalization { // io.github.linreal.cascade.ios.localization/CascadeEditorLocalization|null[0] + constructor () // io.github.linreal.cascade.ios.localization/CascadeEditorLocalization.|(){}[0] + constructor (io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings?) // io.github.linreal.cascade.ios.localization/CascadeEditorLocalization.|(io.github.linreal.cascade.ios.localization.CascadeLocalizedStrings?){}[0] + constructor (io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings?, kotlin.collections/List) // io.github.linreal.cascade.ios.localization/CascadeEditorLocalization.|(io.github.linreal.cascade.ios.localization.CascadeLocalizedStrings?;kotlin.collections.List){}[0] + constructor (kotlin.collections/List) // io.github.linreal.cascade.ios.localization/CascadeEditorLocalization.|(kotlin.collections.List){}[0] + + final val blockStrings // io.github.linreal.cascade.ios.localization/CascadeEditorLocalization.blockStrings|{}blockStrings[0] + final fun (): kotlin.collections/List // io.github.linreal.cascade.ios.localization/CascadeEditorLocalization.blockStrings.|(){}[0] + final val strings // io.github.linreal.cascade.ios.localization/CascadeEditorLocalization.strings|{}strings[0] + final fun (): io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings? // io.github.linreal.cascade.ios.localization/CascadeEditorLocalization.strings.|(){}[0] +} + +final class io.github.linreal.cascade.ios.localization/CascadeLocalizedBlockStrings { // io.github.linreal.cascade.ios.localization/CascadeLocalizedBlockStrings|null[0] + constructor (kotlin/String, kotlin/String, kotlin/String) // io.github.linreal.cascade.ios.localization/CascadeLocalizedBlockStrings.|(kotlin.String;kotlin.String;kotlin.String){}[0] + constructor (kotlin/String, kotlin/String, kotlin/String, kotlin.collections/List) // io.github.linreal.cascade.ios.localization/CascadeLocalizedBlockStrings.|(kotlin.String;kotlin.String;kotlin.String;kotlin.collections.List){}[0] + + final val description // io.github.linreal.cascade.ios.localization/CascadeLocalizedBlockStrings.description|{}description[0] + final fun (): kotlin/String // io.github.linreal.cascade.ios.localization/CascadeLocalizedBlockStrings.description.|(){}[0] + final val displayName // io.github.linreal.cascade.ios.localization/CascadeLocalizedBlockStrings.displayName|{}displayName[0] + final fun (): kotlin/String // io.github.linreal.cascade.ios.localization/CascadeLocalizedBlockStrings.displayName.|(){}[0] + final val keywords // io.github.linreal.cascade.ios.localization/CascadeLocalizedBlockStrings.keywords|{}keywords[0] + final fun (): kotlin.collections/List // io.github.linreal.cascade.ios.localization/CascadeLocalizedBlockStrings.keywords.|(){}[0] + final val typeId // io.github.linreal.cascade.ios.localization/CascadeLocalizedBlockStrings.typeId|{}typeId[0] + final fun (): kotlin/String // io.github.linreal.cascade.ios.localization/CascadeLocalizedBlockStrings.typeId.|(){}[0] +} + +final class io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings { // io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings|null[0] + constructor () // io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings.|(){}[0] + + final var back // io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings.back|{}back[0] + final fun (): kotlin/String? // io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings.back.|(){}[0] + final fun (kotlin/String?) // io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings.back.|(kotlin.String?){}[0] + final var bold // io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings.bold|{}bold[0] + final fun (): kotlin/String? // io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings.bold.|(){}[0] + final fun (kotlin/String?) // io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings.bold.|(kotlin.String?){}[0] + final var hideKeyboard // io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings.hideKeyboard|{}hideKeyboard[0] + final fun (): kotlin/String? // io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings.hideKeyboard.|(){}[0] + final fun (kotlin/String?) // io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings.hideKeyboard.|(kotlin.String?){}[0] + final var highlight // io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings.highlight|{}highlight[0] + final fun (): kotlin/String? // io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings.highlight.|(){}[0] + final fun (kotlin/String?) // io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings.highlight.|(kotlin.String?){}[0] + final var indentBackward // io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings.indentBackward|{}indentBackward[0] + final fun (): kotlin/String? // io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings.indentBackward.|(){}[0] + final fun (kotlin/String?) // io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings.indentBackward.|(kotlin.String?){}[0] + final var indentForward // io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings.indentForward|{}indentForward[0] + final fun (): kotlin/String? // io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings.indentForward.|(){}[0] + final fun (kotlin/String?) // io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings.indentForward.|(kotlin.String?){}[0] + final var inlineCode // io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings.inlineCode|{}inlineCode[0] + final fun (): kotlin/String? // io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings.inlineCode.|(){}[0] + final fun (kotlin/String?) // io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings.inlineCode.|(kotlin.String?){}[0] + final var italic // io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings.italic|{}italic[0] + final fun (): kotlin/String? // io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings.italic.|(){}[0] + final fun (kotlin/String?) // io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings.italic.|(kotlin.String?){}[0] + final var link // io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings.link|{}link[0] + final fun (): kotlin/String? // io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings.link.|(){}[0] + final fun (kotlin/String?) // io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings.link.|(kotlin.String?){}[0] + final var linkApply // io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings.linkApply|{}linkApply[0] + final fun (): kotlin/String? // io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings.linkApply.|(){}[0] + final fun (kotlin/String?) // io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings.linkApply.|(kotlin.String?){}[0] + final var linkCancel // io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings.linkCancel|{}linkCancel[0] + final fun (): kotlin/String? // io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings.linkCancel.|(){}[0] + final fun (kotlin/String?) // io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings.linkCancel.|(kotlin.String?){}[0] + final var linkRemove // io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings.linkRemove|{}linkRemove[0] + final fun (): kotlin/String? // io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings.linkRemove.|(){}[0] + final fun (kotlin/String?) // io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings.linkRemove.|(kotlin.String?){}[0] + final var linkTitle // io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings.linkTitle|{}linkTitle[0] + final fun (): kotlin/String? // io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings.linkTitle.|(){}[0] + final fun (kotlin/String?) // io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings.linkTitle.|(kotlin.String?){}[0] + final var linkUrl // io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings.linkUrl|{}linkUrl[0] + final fun (): kotlin/String? // io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings.linkUrl.|(){}[0] + final fun (kotlin/String?) // io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings.linkUrl.|(kotlin.String?){}[0] + final var linkValidationBlankUrl // io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings.linkValidationBlankUrl|{}linkValidationBlankUrl[0] + final fun (): kotlin/String? // io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings.linkValidationBlankUrl.|(){}[0] + final fun (kotlin/String?) // io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings.linkValidationBlankUrl.|(kotlin.String?){}[0] + final var slashCommand // io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings.slashCommand|{}slashCommand[0] + final fun (): kotlin/String? // io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings.slashCommand.|(){}[0] + final fun (kotlin/String?) // io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings.slashCommand.|(kotlin.String?){}[0] + final var strikethrough // io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings.strikethrough|{}strikethrough[0] + final fun (): kotlin/String? // io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings.strikethrough.|(){}[0] + final fun (kotlin/String?) // io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings.strikethrough.|(kotlin.String?){}[0] + final var underline // io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings.underline|{}underline[0] + final fun (): kotlin/String? // io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings.underline.|(){}[0] + final fun (kotlin/String?) // io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings.underline.|(kotlin.String?){}[0] + final var unsupportedBlock // io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings.unsupportedBlock|{}unsupportedBlock[0] + final fun (): kotlin/Function1? // io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings.unsupportedBlock.|(){}[0] + final fun (kotlin/Function1?) // io.github.linreal.cascade.ios.localization/CascadeLocalizedStrings.unsupportedBlock.|(kotlin.Function1?){}[0] +} + +final class io.github.linreal.cascade.ios.model/CascadeEditorDocumentBuilder { // io.github.linreal.cascade.ios.model/CascadeEditorDocumentBuilder|null[0] + constructor () // io.github.linreal.cascade.ios.model/CascadeEditorDocumentBuilder.|(){}[0] + + final var lastErrorMessage // io.github.linreal.cascade.ios.model/CascadeEditorDocumentBuilder.lastErrorMessage|{}lastErrorMessage[0] + final fun (): kotlin/String? // io.github.linreal.cascade.ios.model/CascadeEditorDocumentBuilder.lastErrorMessage.|(){}[0] + + final fun buildJson(): kotlin/String // io.github.linreal.cascade.ios.model/CascadeEditorDocumentBuilder.buildJson|buildJson(){}[0] + final fun bulletList(kotlin/String): io.github.linreal.cascade.ios.model/CascadeEditorDocumentBuilder // io.github.linreal.cascade.ios.model/CascadeEditorDocumentBuilder.bulletList|bulletList(kotlin.String){}[0] + final fun clearLastError(): io.github.linreal.cascade.ios.model/CascadeEditorDocumentBuilder // io.github.linreal.cascade.ios.model/CascadeEditorDocumentBuilder.clearLastError|clearLastError(){}[0] + final fun code(kotlin/String): io.github.linreal.cascade.ios.model/CascadeEditorDocumentBuilder // io.github.linreal.cascade.ios.model/CascadeEditorDocumentBuilder.code|code(kotlin.String){}[0] + final fun customBlock(kotlin/String, kotlin/String): io.github.linreal.cascade.ios.model/CascadeEditorDocumentBuilder // io.github.linreal.cascade.ios.model/CascadeEditorDocumentBuilder.customBlock|customBlock(kotlin.String;kotlin.String){}[0] + final fun divider(): io.github.linreal.cascade.ios.model/CascadeEditorDocumentBuilder // io.github.linreal.cascade.ios.model/CascadeEditorDocumentBuilder.divider|divider(){}[0] + final fun heading(kotlin/Int, kotlin/String): io.github.linreal.cascade.ios.model/CascadeEditorDocumentBuilder // io.github.linreal.cascade.ios.model/CascadeEditorDocumentBuilder.heading|heading(kotlin.Int;kotlin.String){}[0] + final fun numberedList(kotlin/String, kotlin/Int): io.github.linreal.cascade.ios.model/CascadeEditorDocumentBuilder // io.github.linreal.cascade.ios.model/CascadeEditorDocumentBuilder.numberedList|numberedList(kotlin.String;kotlin.Int){}[0] + final fun paragraph(kotlin/String): io.github.linreal.cascade.ios.model/CascadeEditorDocumentBuilder // io.github.linreal.cascade.ios.model/CascadeEditorDocumentBuilder.paragraph|paragraph(kotlin.String){}[0] + final fun quote(kotlin/String): io.github.linreal.cascade.ios.model/CascadeEditorDocumentBuilder // io.github.linreal.cascade.ios.model/CascadeEditorDocumentBuilder.quote|quote(kotlin.String){}[0] + final fun todo(kotlin/String, kotlin/Boolean): io.github.linreal.cascade.ios.model/CascadeEditorDocumentBuilder // io.github.linreal.cascade.ios.model/CascadeEditorDocumentBuilder.todo|todo(kotlin.String;kotlin.Boolean){}[0] +} + +final class io.github.linreal.cascade.ios.model/CascadeRichTextBlock { // io.github.linreal.cascade.ios.model/CascadeRichTextBlock|null[0] + constructor (kotlin/String, kotlin/String, kotlin/String, kotlin.collections/List) // io.github.linreal.cascade.ios.model/CascadeRichTextBlock.|(kotlin.String;kotlin.String;kotlin.String;kotlin.collections.List){}[0] + + final val blockId // io.github.linreal.cascade.ios.model/CascadeRichTextBlock.blockId|{}blockId[0] + final fun (): kotlin/String // io.github.linreal.cascade.ios.model/CascadeRichTextBlock.blockId.|(){}[0] + final val spans // io.github.linreal.cascade.ios.model/CascadeRichTextBlock.spans|{}spans[0] + final fun (): kotlin.collections/List // io.github.linreal.cascade.ios.model/CascadeRichTextBlock.spans.|(){}[0] + final val text // io.github.linreal.cascade.ios.model/CascadeRichTextBlock.text|{}text[0] + final fun (): kotlin/String // io.github.linreal.cascade.ios.model/CascadeRichTextBlock.text.|(){}[0] + final val typeId // io.github.linreal.cascade.ios.model/CascadeRichTextBlock.typeId|{}typeId[0] + final fun (): kotlin/String // io.github.linreal.cascade.ios.model/CascadeRichTextBlock.typeId.|(){}[0] + + final fun component1(): kotlin/String // io.github.linreal.cascade.ios.model/CascadeRichTextBlock.component1|component1(){}[0] + final fun component2(): kotlin/String // io.github.linreal.cascade.ios.model/CascadeRichTextBlock.component2|component2(){}[0] + final fun component3(): kotlin/String // io.github.linreal.cascade.ios.model/CascadeRichTextBlock.component3|component3(){}[0] + final fun component4(): kotlin.collections/List // io.github.linreal.cascade.ios.model/CascadeRichTextBlock.component4|component4(){}[0] + final fun copy(kotlin/String = ..., kotlin/String = ..., kotlin/String = ..., kotlin.collections/List = ...): io.github.linreal.cascade.ios.model/CascadeRichTextBlock // io.github.linreal.cascade.ios.model/CascadeRichTextBlock.copy|copy(kotlin.String;kotlin.String;kotlin.String;kotlin.collections.List){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.ios.model/CascadeRichTextBlock.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.ios.model/CascadeRichTextBlock.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.ios.model/CascadeRichTextBlock.toString|toString(){}[0] +} + +final class io.github.linreal.cascade.ios.model/CascadeRichTextSnapshot { // io.github.linreal.cascade.ios.model/CascadeRichTextSnapshot|null[0] + constructor (kotlin.collections/List) // io.github.linreal.cascade.ios.model/CascadeRichTextSnapshot.|(kotlin.collections.List){}[0] + + final val blocks // io.github.linreal.cascade.ios.model/CascadeRichTextSnapshot.blocks|{}blocks[0] + final fun (): kotlin.collections/List // io.github.linreal.cascade.ios.model/CascadeRichTextSnapshot.blocks.|(){}[0] + + final fun component1(): kotlin.collections/List // io.github.linreal.cascade.ios.model/CascadeRichTextSnapshot.component1|component1(){}[0] + final fun copy(kotlin.collections/List = ...): io.github.linreal.cascade.ios.model/CascadeRichTextSnapshot // io.github.linreal.cascade.ios.model/CascadeRichTextSnapshot.copy|copy(kotlin.collections.List){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.ios.model/CascadeRichTextSnapshot.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.ios.model/CascadeRichTextSnapshot.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.ios.model/CascadeRichTextSnapshot.toString|toString(){}[0] +} + +final class io.github.linreal.cascade.ios.model/CascadeRichTextSpan { // io.github.linreal.cascade.ios.model/CascadeRichTextSpan|null[0] + constructor (kotlin/Int, kotlin/Int, io.github.linreal.cascade.ios.model/CascadeSpanKind, kotlin/Long = ..., kotlin/String? = ...) // io.github.linreal.cascade.ios.model/CascadeRichTextSpan.|(kotlin.Int;kotlin.Int;io.github.linreal.cascade.ios.model.CascadeSpanKind;kotlin.Long;kotlin.String?){}[0] + + final val argb // io.github.linreal.cascade.ios.model/CascadeRichTextSpan.argb|{}argb[0] + final fun (): kotlin/Long // io.github.linreal.cascade.ios.model/CascadeRichTextSpan.argb.|(){}[0] + final val end // io.github.linreal.cascade.ios.model/CascadeRichTextSpan.end|{}end[0] + final fun (): kotlin/Int // io.github.linreal.cascade.ios.model/CascadeRichTextSpan.end.|(){}[0] + final val kind // io.github.linreal.cascade.ios.model/CascadeRichTextSpan.kind|{}kind[0] + final fun (): io.github.linreal.cascade.ios.model/CascadeSpanKind // io.github.linreal.cascade.ios.model/CascadeRichTextSpan.kind.|(){}[0] + final val start // io.github.linreal.cascade.ios.model/CascadeRichTextSpan.start|{}start[0] + final fun (): kotlin/Int // io.github.linreal.cascade.ios.model/CascadeRichTextSpan.start.|(){}[0] + final val url // io.github.linreal.cascade.ios.model/CascadeRichTextSpan.url|{}url[0] + final fun (): kotlin/String? // io.github.linreal.cascade.ios.model/CascadeRichTextSpan.url.|(){}[0] + + final fun component1(): kotlin/Int // io.github.linreal.cascade.ios.model/CascadeRichTextSpan.component1|component1(){}[0] + final fun component2(): kotlin/Int // io.github.linreal.cascade.ios.model/CascadeRichTextSpan.component2|component2(){}[0] + final fun component3(): io.github.linreal.cascade.ios.model/CascadeSpanKind // io.github.linreal.cascade.ios.model/CascadeRichTextSpan.component3|component3(){}[0] + final fun component4(): kotlin/Long // io.github.linreal.cascade.ios.model/CascadeRichTextSpan.component4|component4(){}[0] + final fun component5(): kotlin/String? // io.github.linreal.cascade.ios.model/CascadeRichTextSpan.component5|component5(){}[0] + final fun copy(kotlin/Int = ..., kotlin/Int = ..., io.github.linreal.cascade.ios.model/CascadeSpanKind = ..., kotlin/Long = ..., kotlin/String? = ...): io.github.linreal.cascade.ios.model/CascadeRichTextSpan // io.github.linreal.cascade.ios.model/CascadeRichTextSpan.copy|copy(kotlin.Int;kotlin.Int;io.github.linreal.cascade.ios.model.CascadeSpanKind;kotlin.Long;kotlin.String?){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.ios.model/CascadeRichTextSpan.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.ios.model/CascadeRichTextSpan.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.ios.model/CascadeRichTextSpan.toString|toString(){}[0] +} + +final class io.github.linreal.cascade.ios.slash/CascadeSlashCommand { // io.github.linreal.cascade.ios.slash/CascadeSlashCommand|null[0] + constructor (kotlin/String, kotlin/String, kotlin/String, kotlin.collections/List = ..., kotlin/Function1) // io.github.linreal.cascade.ios.slash/CascadeSlashCommand.|(kotlin.String;kotlin.String;kotlin.String;kotlin.collections.List;kotlin.Function1){}[0] + + final val description // io.github.linreal.cascade.ios.slash/CascadeSlashCommand.description|{}description[0] + final fun (): kotlin/String // io.github.linreal.cascade.ios.slash/CascadeSlashCommand.description.|(){}[0] + final val handler // io.github.linreal.cascade.ios.slash/CascadeSlashCommand.handler|{}handler[0] + final fun (): kotlin/Function1 // io.github.linreal.cascade.ios.slash/CascadeSlashCommand.handler.|(){}[0] + final val id // io.github.linreal.cascade.ios.slash/CascadeSlashCommand.id|{}id[0] + final fun (): kotlin/String // io.github.linreal.cascade.ios.slash/CascadeSlashCommand.id.|(){}[0] + final val keywords // io.github.linreal.cascade.ios.slash/CascadeSlashCommand.keywords|{}keywords[0] + final fun (): kotlin.collections/List // io.github.linreal.cascade.ios.slash/CascadeSlashCommand.keywords.|(){}[0] + final val title // io.github.linreal.cascade.ios.slash/CascadeSlashCommand.title|{}title[0] + final fun (): kotlin/String // io.github.linreal.cascade.ios.slash/CascadeSlashCommand.title.|(){}[0] +} + +final class io.github.linreal.cascade.ios.slash/CascadeSlashCommandContext { // io.github.linreal.cascade.ios.slash/CascadeSlashCommandContext|null[0] + final fun closeMenu() // io.github.linreal.cascade.ios.slash/CascadeSlashCommandContext.closeMenu|closeMenu(){}[0] + final fun focusAnchor() // io.github.linreal.cascade.ios.slash/CascadeSlashCommandContext.focusAnchor|focusAnchor(){}[0] + final fun insertBlockAfterAnchor(kotlin/String, kotlin/String): kotlin/Boolean // io.github.linreal.cascade.ios.slash/CascadeSlashCommandContext.insertBlockAfterAnchor|insertBlockAfterAnchor(kotlin.String;kotlin.String){}[0] + final fun insertBlockBeforeAnchor(kotlin/String, kotlin/String): kotlin/Boolean // io.github.linreal.cascade.ios.slash/CascadeSlashCommandContext.insertBlockBeforeAnchor|insertBlockBeforeAnchor(kotlin.String;kotlin.String){}[0] + final fun replaceQueryText(kotlin/String) // io.github.linreal.cascade.ios.slash/CascadeSlashCommandContext.replaceQueryText|replaceQueryText(kotlin.String){}[0] + final fun updateAnchorText(kotlin/String, kotlin/Int) // io.github.linreal.cascade.ios.slash/CascadeSlashCommandContext.updateAnchorText|updateAnchorText(kotlin.String;kotlin.Int){}[0] +} + +final class io.github.linreal.cascade.ios.slash/CascadeSlashCommandResult { // io.github.linreal.cascade.ios.slash/CascadeSlashCommandResult|null[0] + final object Companion { // io.github.linreal.cascade.ios.slash/CascadeSlashCommandResult.Companion|null[0] + final val done // io.github.linreal.cascade.ios.slash/CascadeSlashCommandResult.Companion.done|{}done[0] + final fun (): io.github.linreal.cascade.ios.slash/CascadeSlashCommandResult // io.github.linreal.cascade.ios.slash/CascadeSlashCommandResult.Companion.done.|(){}[0] + final val keepOpen // io.github.linreal.cascade.ios.slash/CascadeSlashCommandResult.Companion.keepOpen|{}keepOpen[0] + final fun (): io.github.linreal.cascade.ios.slash/CascadeSlashCommandResult // io.github.linreal.cascade.ios.slash/CascadeSlashCommandResult.Companion.keepOpen.|(){}[0] + + final fun failure(kotlin/String? = ...): io.github.linreal.cascade.ios.slash/CascadeSlashCommandResult // io.github.linreal.cascade.ios.slash/CascadeSlashCommandResult.Companion.failure|failure(kotlin.String?){}[0] + } +} + +final class io.github.linreal.cascade.ios.toolbar/CascadeToolbarState { // io.github.linreal.cascade.ios.toolbar/CascadeToolbarState|null[0] + constructor (kotlin/Boolean, kotlin/Boolean, io.github.linreal.cascade.ios.toolbar/CascadeStyleState, io.github.linreal.cascade.ios.toolbar/CascadeStyleState, io.github.linreal.cascade.ios.toolbar/CascadeStyleState, io.github.linreal.cascade.ios.toolbar/CascadeStyleState, io.github.linreal.cascade.ios.toolbar/CascadeStyleState, io.github.linreal.cascade.ios.toolbar/CascadeStyleState, kotlin/Boolean, kotlin/Boolean, kotlin/Boolean, kotlin/String?) // io.github.linreal.cascade.ios.toolbar/CascadeToolbarState.|(kotlin.Boolean;kotlin.Boolean;io.github.linreal.cascade.ios.toolbar.CascadeStyleState;io.github.linreal.cascade.ios.toolbar.CascadeStyleState;io.github.linreal.cascade.ios.toolbar.CascadeStyleState;io.github.linreal.cascade.ios.toolbar.CascadeStyleState;io.github.linreal.cascade.ios.toolbar.CascadeStyleState;io.github.linreal.cascade.ios.toolbar.CascadeStyleState;kotlin.Boolean;kotlin.Boolean;kotlin.Boolean;kotlin.String?){}[0] + + final val bold // io.github.linreal.cascade.ios.toolbar/CascadeToolbarState.bold|{}bold[0] + final fun (): io.github.linreal.cascade.ios.toolbar/CascadeStyleState // io.github.linreal.cascade.ios.toolbar/CascadeToolbarState.bold.|(){}[0] + final val canFormat // io.github.linreal.cascade.ios.toolbar/CascadeToolbarState.canFormat|{}canFormat[0] + final fun (): kotlin/Boolean // io.github.linreal.cascade.ios.toolbar/CascadeToolbarState.canFormat.|(){}[0] + final val canIndentBackward // io.github.linreal.cascade.ios.toolbar/CascadeToolbarState.canIndentBackward|{}canIndentBackward[0] + final fun (): kotlin/Boolean // io.github.linreal.cascade.ios.toolbar/CascadeToolbarState.canIndentBackward.|(){}[0] + final val canIndentForward // io.github.linreal.cascade.ios.toolbar/CascadeToolbarState.canIndentForward|{}canIndentForward[0] + final fun (): kotlin/Boolean // io.github.linreal.cascade.ios.toolbar/CascadeToolbarState.canIndentForward.|(){}[0] + final val canLink // io.github.linreal.cascade.ios.toolbar/CascadeToolbarState.canLink|{}canLink[0] + final fun (): kotlin/Boolean // io.github.linreal.cascade.ios.toolbar/CascadeToolbarState.canLink.|(){}[0] + final val existingUrl // io.github.linreal.cascade.ios.toolbar/CascadeToolbarState.existingUrl|{}existingUrl[0] + final fun (): kotlin/String? // io.github.linreal.cascade.ios.toolbar/CascadeToolbarState.existingUrl.|(){}[0] + final val focused // io.github.linreal.cascade.ios.toolbar/CascadeToolbarState.focused|{}focused[0] + final fun (): kotlin/Boolean // io.github.linreal.cascade.ios.toolbar/CascadeToolbarState.focused.|(){}[0] + final val highlight // io.github.linreal.cascade.ios.toolbar/CascadeToolbarState.highlight|{}highlight[0] + final fun (): io.github.linreal.cascade.ios.toolbar/CascadeStyleState // io.github.linreal.cascade.ios.toolbar/CascadeToolbarState.highlight.|(){}[0] + final val inlineCode // io.github.linreal.cascade.ios.toolbar/CascadeToolbarState.inlineCode|{}inlineCode[0] + final fun (): io.github.linreal.cascade.ios.toolbar/CascadeStyleState // io.github.linreal.cascade.ios.toolbar/CascadeToolbarState.inlineCode.|(){}[0] + final val italic // io.github.linreal.cascade.ios.toolbar/CascadeToolbarState.italic|{}italic[0] + final fun (): io.github.linreal.cascade.ios.toolbar/CascadeStyleState // io.github.linreal.cascade.ios.toolbar/CascadeToolbarState.italic.|(){}[0] + final val strikeThrough // io.github.linreal.cascade.ios.toolbar/CascadeToolbarState.strikeThrough|{}strikeThrough[0] + final fun (): io.github.linreal.cascade.ios.toolbar/CascadeStyleState // io.github.linreal.cascade.ios.toolbar/CascadeToolbarState.strikeThrough.|(){}[0] + final val underline // io.github.linreal.cascade.ios.toolbar/CascadeToolbarState.underline|{}underline[0] + final fun (): io.github.linreal.cascade.ios.toolbar/CascadeStyleState // io.github.linreal.cascade.ios.toolbar/CascadeToolbarState.underline.|(){}[0] + + final fun component1(): kotlin/Boolean // io.github.linreal.cascade.ios.toolbar/CascadeToolbarState.component1|component1(){}[0] + final fun component10(): kotlin/Boolean // io.github.linreal.cascade.ios.toolbar/CascadeToolbarState.component10|component10(){}[0] + final fun component11(): kotlin/Boolean // io.github.linreal.cascade.ios.toolbar/CascadeToolbarState.component11|component11(){}[0] + final fun component12(): kotlin/String? // io.github.linreal.cascade.ios.toolbar/CascadeToolbarState.component12|component12(){}[0] + final fun component2(): kotlin/Boolean // io.github.linreal.cascade.ios.toolbar/CascadeToolbarState.component2|component2(){}[0] + final fun component3(): io.github.linreal.cascade.ios.toolbar/CascadeStyleState // io.github.linreal.cascade.ios.toolbar/CascadeToolbarState.component3|component3(){}[0] + final fun component4(): io.github.linreal.cascade.ios.toolbar/CascadeStyleState // io.github.linreal.cascade.ios.toolbar/CascadeToolbarState.component4|component4(){}[0] + final fun component5(): io.github.linreal.cascade.ios.toolbar/CascadeStyleState // io.github.linreal.cascade.ios.toolbar/CascadeToolbarState.component5|component5(){}[0] + final fun component6(): io.github.linreal.cascade.ios.toolbar/CascadeStyleState // io.github.linreal.cascade.ios.toolbar/CascadeToolbarState.component6|component6(){}[0] + final fun component7(): io.github.linreal.cascade.ios.toolbar/CascadeStyleState // io.github.linreal.cascade.ios.toolbar/CascadeToolbarState.component7|component7(){}[0] + final fun component8(): io.github.linreal.cascade.ios.toolbar/CascadeStyleState // io.github.linreal.cascade.ios.toolbar/CascadeToolbarState.component8|component8(){}[0] + final fun component9(): kotlin/Boolean // io.github.linreal.cascade.ios.toolbar/CascadeToolbarState.component9|component9(){}[0] + final fun copy(kotlin/Boolean = ..., kotlin/Boolean = ..., io.github.linreal.cascade.ios.toolbar/CascadeStyleState = ..., io.github.linreal.cascade.ios.toolbar/CascadeStyleState = ..., io.github.linreal.cascade.ios.toolbar/CascadeStyleState = ..., io.github.linreal.cascade.ios.toolbar/CascadeStyleState = ..., io.github.linreal.cascade.ios.toolbar/CascadeStyleState = ..., io.github.linreal.cascade.ios.toolbar/CascadeStyleState = ..., kotlin/Boolean = ..., kotlin/Boolean = ..., kotlin/Boolean = ..., kotlin/String? = ...): io.github.linreal.cascade.ios.toolbar/CascadeToolbarState // io.github.linreal.cascade.ios.toolbar/CascadeToolbarState.copy|copy(kotlin.Boolean;kotlin.Boolean;io.github.linreal.cascade.ios.toolbar.CascadeStyleState;io.github.linreal.cascade.ios.toolbar.CascadeStyleState;io.github.linreal.cascade.ios.toolbar.CascadeStyleState;io.github.linreal.cascade.ios.toolbar.CascadeStyleState;io.github.linreal.cascade.ios.toolbar.CascadeStyleState;io.github.linreal.cascade.ios.toolbar.CascadeStyleState;kotlin.Boolean;kotlin.Boolean;kotlin.Boolean;kotlin.String?){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.ios.toolbar/CascadeToolbarState.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.ios.toolbar/CascadeToolbarState.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.ios.toolbar/CascadeToolbarState.toString|toString(){}[0] + + final object Companion { // io.github.linreal.cascade.ios.toolbar/CascadeToolbarState.Companion|null[0] + final val Empty // io.github.linreal.cascade.ios.toolbar/CascadeToolbarState.Companion.Empty|{}Empty[0] + final fun (): io.github.linreal.cascade.ios.toolbar/CascadeToolbarState // io.github.linreal.cascade.ios.toolbar/CascadeToolbarState.Companion.Empty.|(){}[0] + } +} + +final object io.github.linreal.cascade.ios/CascadeEditorSdk { // io.github.linreal.cascade.ios/CascadeEditorSdk|null[0] + final const val version // io.github.linreal.cascade.ios/CascadeEditorSdk.version|{}version[0] + final fun (): kotlin/String // io.github.linreal.cascade.ios/CascadeEditorSdk.version.|(){}[0] +} + +final val io.github.linreal.cascade.ios.block/io_github_linreal_cascade_ios_block_CascadeBlockBuildOutcome_InvalidPayload$stableprop // io.github.linreal.cascade.ios.block/io_github_linreal_cascade_ios_block_CascadeBlockBuildOutcome_InvalidPayload$stableprop|#static{}io_github_linreal_cascade_ios_block_CascadeBlockBuildOutcome_InvalidPayload$stableprop[0] +final val io.github.linreal.cascade.ios.block/io_github_linreal_cascade_ios_block_CascadeBlockBuildOutcome_Success$stableprop // io.github.linreal.cascade.ios.block/io_github_linreal_cascade_ios_block_CascadeBlockBuildOutcome_Success$stableprop|#static{}io_github_linreal_cascade_ios_block_CascadeBlockBuildOutcome_Success$stableprop[0] +final val io.github.linreal.cascade.ios.block/io_github_linreal_cascade_ios_block_CascadeBlockBuildOutcome_UnknownType$stableprop // io.github.linreal.cascade.ios.block/io_github_linreal_cascade_ios_block_CascadeBlockBuildOutcome_UnknownType$stableprop|#static{}io_github_linreal_cascade_ios_block_CascadeBlockBuildOutcome_UnknownType$stableprop[0] +final val io.github.linreal.cascade.ios.block/io_github_linreal_cascade_ios_block_CascadeCustomBlockContext$stableprop // io.github.linreal.cascade.ios.block/io_github_linreal_cascade_ios_block_CascadeCustomBlockContext$stableprop|#static{}io_github_linreal_cascade_ios_block_CascadeCustomBlockContext$stableprop[0] +final val io.github.linreal.cascade.ios.block/io_github_linreal_cascade_ios_block_CascadeCustomBlockRegistration$stableprop // io.github.linreal.cascade.ios.block/io_github_linreal_cascade_ios_block_CascadeCustomBlockRegistration$stableprop|#static{}io_github_linreal_cascade_ios_block_CascadeCustomBlockRegistration$stableprop[0] +final val io.github.linreal.cascade.ios.controller/io_github_linreal_cascade_ios_controller_CascadeDocumentLoadResult$stableprop // io.github.linreal.cascade.ios.controller/io_github_linreal_cascade_ios_controller_CascadeDocumentLoadResult$stableprop|#static{}io_github_linreal_cascade_ios_controller_CascadeDocumentLoadResult$stableprop[0] +final val io.github.linreal.cascade.ios.controller/io_github_linreal_cascade_ios_controller_CascadeEditorConfiguration$stableprop // io.github.linreal.cascade.ios.controller/io_github_linreal_cascade_ios_controller_CascadeEditorConfiguration$stableprop|#static{}io_github_linreal_cascade_ios_controller_CascadeEditorConfiguration$stableprop[0] +final val io.github.linreal.cascade.ios.controller/io_github_linreal_cascade_ios_controller_CascadeEditorController$stableprop // io.github.linreal.cascade.ios.controller/io_github_linreal_cascade_ios_controller_CascadeEditorController$stableprop|#static{}io_github_linreal_cascade_ios_controller_CascadeEditorController$stableprop[0] +final val io.github.linreal.cascade.ios.localization/io_github_linreal_cascade_ios_localization_CascadeEditorLocalization$stableprop // io.github.linreal.cascade.ios.localization/io_github_linreal_cascade_ios_localization_CascadeEditorLocalization$stableprop|#static{}io_github_linreal_cascade_ios_localization_CascadeEditorLocalization$stableprop[0] +final val io.github.linreal.cascade.ios.localization/io_github_linreal_cascade_ios_localization_CascadeLocalizedBlockStrings$stableprop // io.github.linreal.cascade.ios.localization/io_github_linreal_cascade_ios_localization_CascadeLocalizedBlockStrings$stableprop|#static{}io_github_linreal_cascade_ios_localization_CascadeLocalizedBlockStrings$stableprop[0] +final val io.github.linreal.cascade.ios.localization/io_github_linreal_cascade_ios_localization_CascadeLocalizedStrings$stableprop // io.github.linreal.cascade.ios.localization/io_github_linreal_cascade_ios_localization_CascadeLocalizedStrings$stableprop|#static{}io_github_linreal_cascade_ios_localization_CascadeLocalizedStrings$stableprop[0] +final val io.github.linreal.cascade.ios.model/io_github_linreal_cascade_ios_model_CascadeEditorDocumentBuilder$stableprop // io.github.linreal.cascade.ios.model/io_github_linreal_cascade_ios_model_CascadeEditorDocumentBuilder$stableprop|#static{}io_github_linreal_cascade_ios_model_CascadeEditorDocumentBuilder$stableprop[0] +final val io.github.linreal.cascade.ios.model/io_github_linreal_cascade_ios_model_CascadeRichTextBlock$stableprop // io.github.linreal.cascade.ios.model/io_github_linreal_cascade_ios_model_CascadeRichTextBlock$stableprop|#static{}io_github_linreal_cascade_ios_model_CascadeRichTextBlock$stableprop[0] +final val io.github.linreal.cascade.ios.model/io_github_linreal_cascade_ios_model_CascadeRichTextSnapshot$stableprop // io.github.linreal.cascade.ios.model/io_github_linreal_cascade_ios_model_CascadeRichTextSnapshot$stableprop|#static{}io_github_linreal_cascade_ios_model_CascadeRichTextSnapshot$stableprop[0] +final val io.github.linreal.cascade.ios.model/io_github_linreal_cascade_ios_model_CascadeRichTextSpan$stableprop // io.github.linreal.cascade.ios.model/io_github_linreal_cascade_ios_model_CascadeRichTextSpan$stableprop|#static{}io_github_linreal_cascade_ios_model_CascadeRichTextSpan$stableprop[0] +final val io.github.linreal.cascade.ios.slash/io_github_linreal_cascade_ios_slash_CascadeSlashCommand$stableprop // io.github.linreal.cascade.ios.slash/io_github_linreal_cascade_ios_slash_CascadeSlashCommand$stableprop|#static{}io_github_linreal_cascade_ios_slash_CascadeSlashCommand$stableprop[0] +final val io.github.linreal.cascade.ios.slash/io_github_linreal_cascade_ios_slash_CascadeSlashCommandContext$stableprop // io.github.linreal.cascade.ios.slash/io_github_linreal_cascade_ios_slash_CascadeSlashCommandContext$stableprop|#static{}io_github_linreal_cascade_ios_slash_CascadeSlashCommandContext$stableprop[0] +final val io.github.linreal.cascade.ios.slash/io_github_linreal_cascade_ios_slash_CascadeSlashCommandResult$stableprop // io.github.linreal.cascade.ios.slash/io_github_linreal_cascade_ios_slash_CascadeSlashCommandResult$stableprop|#static{}io_github_linreal_cascade_ios_slash_CascadeSlashCommandResult$stableprop[0] +final val io.github.linreal.cascade.ios.toolbar/io_github_linreal_cascade_ios_toolbar_CascadeToolbarState$stableprop // io.github.linreal.cascade.ios.toolbar/io_github_linreal_cascade_ios_toolbar_CascadeToolbarState$stableprop|#static{}io_github_linreal_cascade_ios_toolbar_CascadeToolbarState$stableprop[0] +final val io.github.linreal.cascade.ios/io_github_linreal_cascade_ios_CascadeEditorSdk$stableprop // io.github.linreal.cascade.ios/io_github_linreal_cascade_ios_CascadeEditorSdk$stableprop|#static{}io_github_linreal_cascade_ios_CascadeEditorSdk$stableprop[0] + +final fun (io.github.linreal.cascade.ios.controller/CascadeEditorController).io.github.linreal.cascade.ios.controller/makeViewController(): platform.UIKit/UIViewController // io.github.linreal.cascade.ios.controller/makeViewController|makeViewController@io.github.linreal.cascade.ios.controller.CascadeEditorController(){}[0] +final fun io.github.linreal.cascade.ios.block/io_github_linreal_cascade_ios_block_CascadeBlockBuildOutcome_InvalidPayload$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.ios.block/io_github_linreal_cascade_ios_block_CascadeBlockBuildOutcome_InvalidPayload$stableprop_getter|io_github_linreal_cascade_ios_block_CascadeBlockBuildOutcome_InvalidPayload$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.ios.block/io_github_linreal_cascade_ios_block_CascadeBlockBuildOutcome_Success$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.ios.block/io_github_linreal_cascade_ios_block_CascadeBlockBuildOutcome_Success$stableprop_getter|io_github_linreal_cascade_ios_block_CascadeBlockBuildOutcome_Success$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.ios.block/io_github_linreal_cascade_ios_block_CascadeBlockBuildOutcome_UnknownType$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.ios.block/io_github_linreal_cascade_ios_block_CascadeBlockBuildOutcome_UnknownType$stableprop_getter|io_github_linreal_cascade_ios_block_CascadeBlockBuildOutcome_UnknownType$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.ios.block/io_github_linreal_cascade_ios_block_CascadeCustomBlockContext$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.ios.block/io_github_linreal_cascade_ios_block_CascadeCustomBlockContext$stableprop_getter|io_github_linreal_cascade_ios_block_CascadeCustomBlockContext$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.ios.block/io_github_linreal_cascade_ios_block_CascadeCustomBlockRegistration$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.ios.block/io_github_linreal_cascade_ios_block_CascadeCustomBlockRegistration$stableprop_getter|io_github_linreal_cascade_ios_block_CascadeCustomBlockRegistration$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.ios.controller/io_github_linreal_cascade_ios_controller_CascadeDocumentLoadResult$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.ios.controller/io_github_linreal_cascade_ios_controller_CascadeDocumentLoadResult$stableprop_getter|io_github_linreal_cascade_ios_controller_CascadeDocumentLoadResult$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.ios.controller/io_github_linreal_cascade_ios_controller_CascadeEditorConfiguration$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.ios.controller/io_github_linreal_cascade_ios_controller_CascadeEditorConfiguration$stableprop_getter|io_github_linreal_cascade_ios_controller_CascadeEditorConfiguration$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.ios.controller/io_github_linreal_cascade_ios_controller_CascadeEditorController$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.ios.controller/io_github_linreal_cascade_ios_controller_CascadeEditorController$stableprop_getter|io_github_linreal_cascade_ios_controller_CascadeEditorController$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.ios.localization/io_github_linreal_cascade_ios_localization_CascadeEditorLocalization$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.ios.localization/io_github_linreal_cascade_ios_localization_CascadeEditorLocalization$stableprop_getter|io_github_linreal_cascade_ios_localization_CascadeEditorLocalization$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.ios.localization/io_github_linreal_cascade_ios_localization_CascadeLocalizedBlockStrings$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.ios.localization/io_github_linreal_cascade_ios_localization_CascadeLocalizedBlockStrings$stableprop_getter|io_github_linreal_cascade_ios_localization_CascadeLocalizedBlockStrings$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.ios.localization/io_github_linreal_cascade_ios_localization_CascadeLocalizedStrings$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.ios.localization/io_github_linreal_cascade_ios_localization_CascadeLocalizedStrings$stableprop_getter|io_github_linreal_cascade_ios_localization_CascadeLocalizedStrings$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.ios.model/io_github_linreal_cascade_ios_model_CascadeEditorDocumentBuilder$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.ios.model/io_github_linreal_cascade_ios_model_CascadeEditorDocumentBuilder$stableprop_getter|io_github_linreal_cascade_ios_model_CascadeEditorDocumentBuilder$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.ios.model/io_github_linreal_cascade_ios_model_CascadeRichTextBlock$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.ios.model/io_github_linreal_cascade_ios_model_CascadeRichTextBlock$stableprop_getter|io_github_linreal_cascade_ios_model_CascadeRichTextBlock$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.ios.model/io_github_linreal_cascade_ios_model_CascadeRichTextSnapshot$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.ios.model/io_github_linreal_cascade_ios_model_CascadeRichTextSnapshot$stableprop_getter|io_github_linreal_cascade_ios_model_CascadeRichTextSnapshot$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.ios.model/io_github_linreal_cascade_ios_model_CascadeRichTextSpan$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.ios.model/io_github_linreal_cascade_ios_model_CascadeRichTextSpan$stableprop_getter|io_github_linreal_cascade_ios_model_CascadeRichTextSpan$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.ios.slash/io_github_linreal_cascade_ios_slash_CascadeSlashCommand$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.ios.slash/io_github_linreal_cascade_ios_slash_CascadeSlashCommand$stableprop_getter|io_github_linreal_cascade_ios_slash_CascadeSlashCommand$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.ios.slash/io_github_linreal_cascade_ios_slash_CascadeSlashCommandContext$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.ios.slash/io_github_linreal_cascade_ios_slash_CascadeSlashCommandContext$stableprop_getter|io_github_linreal_cascade_ios_slash_CascadeSlashCommandContext$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.ios.slash/io_github_linreal_cascade_ios_slash_CascadeSlashCommandResult$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.ios.slash/io_github_linreal_cascade_ios_slash_CascadeSlashCommandResult$stableprop_getter|io_github_linreal_cascade_ios_slash_CascadeSlashCommandResult$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.ios.toolbar/io_github_linreal_cascade_ios_toolbar_CascadeToolbarState$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.ios.toolbar/io_github_linreal_cascade_ios_toolbar_CascadeToolbarState$stableprop_getter|io_github_linreal_cascade_ios_toolbar_CascadeToolbarState$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.ios/io_github_linreal_cascade_ios_CascadeEditorSdk$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.ios/io_github_linreal_cascade_ios_CascadeEditorSdk$stableprop_getter|io_github_linreal_cascade_ios_CascadeEditorSdk$stableprop_getter(){}[0] diff --git a/editor-ios-sdk/build.gradle.kts b/editor-ios-sdk/build.gradle.kts new file mode 100644 index 0000000..ee1c6a3 --- /dev/null +++ b/editor-ios-sdk/build.gradle.kts @@ -0,0 +1,75 @@ +import org.jetbrains.kotlin.gradle.plugin.mpp.apple.XCFramework +import org.jetbrains.kotlin.gradle.targets.native.tasks.KotlinNativeSimulatorTest + +plugins { + alias(libs.plugins.kotlinMultiplatform) + alias(libs.plugins.composeMultiplatform) + alias(libs.plugins.composeCompiler) + alias(libs.plugins.binaryCompatibilityValidator) +} + +// The Swift-facing contract snapshot: api/editor-ios-sdk.klib.api captures every +// public Kotlin declaration of the iOS targets, which is the source the Obj-C +// framework header is generated from — bridge drift fails `apiCheck` (wired into +// `check`). Refresh intentionally with `./gradlew :editor-ios-sdk:apiDump` and +// commit the diff. Note the klib dump does not capture @ObjCName spellings or +// Obj-C-specific lowering; renames visible only in the generated header should be +// eyeballed in CascadeEditor.h when touching @ObjCName annotations. +apiValidation { + @OptIn(kotlinx.validation.ExperimentalBCVApi::class) + klib { + enabled = true + } +} + +val cascadeEditorXcframework = XCFramework("CascadeEditor") + +kotlin { + explicitApi() + + listOf( + iosArm64(), + iosSimulatorArm64(), + ).forEach { iosTarget -> + iosTarget.binaries.framework { + baseName = "CascadeEditor" + isStatic = true + cascadeEditorXcframework.add(this) + } + } + + sourceSets { + all { + languageSettings.optIn("io.github.linreal.cascade.editor.htmlserialization.ExperimentalCascadeHtmlApi") + } + + iosMain.dependencies { + implementation(projects.editor) + implementation(libs.compose.runtime) + implementation(libs.compose.foundation) + implementation(libs.compose.ui) + implementation(libs.compose.components.resources) + implementation(libs.kotlinx.serialization.json) + } + + val iosSimulatorArm64Test by getting { + dependencies { + implementation(libs.kotlin.test) + implementation(libs.kotlinx.coroutines.test) + } + } + } +} + +// Golden parity tests read fixture files from the host filesystem. `simctl spawn` +// forwards only SIMCTL_CHILD_-prefixed variables to the spawned test binary, where +// they arrive with the prefix stripped (CASCADE_FIXTURES_DIR / CASCADE_SAMPLE_FILES_DIR). +// Both directories are declared as task inputs so fixture edits re-run the tests. +tasks.withType().configureEach { + val fixturesDir = projectDir.resolve("src/commonTest/resources") + val sampleFilesDir = rootDir.resolve("sample/src/commonMain/composeResources/files") + inputs.dir(fixturesDir).withPathSensitivity(PathSensitivity.RELATIVE) + inputs.dir(sampleFilesDir).withPathSensitivity(PathSensitivity.RELATIVE) + environment("SIMCTL_CHILD_CASCADE_FIXTURES_DIR", fixturesDir.absolutePath) + environment("SIMCTL_CHILD_CASCADE_SAMPLE_FILES_DIR", sampleFilesDir.absolutePath) +} diff --git a/editor-ios-sdk/src/commonTest/resources/comments_composer_document.json b/editor-ios-sdk/src/commonTest/resources/comments_composer_document.json new file mode 100644 index 0000000..9cd8c36 --- /dev/null +++ b/editor-ios-sdk/src/commonTest/resources/comments_composer_document.json @@ -0,0 +1,17 @@ +{ + "version": 2, + "blocks": [ + { + "id": "composer-paragraph-1", + "type": { + "typeId": "paragraph" + }, + "content": { + "kind": "text", + "version": 1, + "text": "", + "spans": [] + } + } + ] +} diff --git a/editor-ios-sdk/src/commonTest/resources/custom_blocks_document.json b/editor-ios-sdk/src/commonTest/resources/custom_blocks_document.json new file mode 100644 index 0000000..1b3b8ed --- /dev/null +++ b/editor-ios-sdk/src/commonTest/resources/custom_blocks_document.json @@ -0,0 +1,357 @@ +{ + "version": 2, + "blocks": [ + { + "id": "custom-blocks-1", + "type": { + "typeId": "heading_1" + }, + "content": { + "kind": "text", + "version": 1, + "text": "Custom Blocks & Commands", + "spans": [] + } + }, + { + "id": "custom-blocks-2", + "type": { + "typeId": "paragraph" + }, + "content": { + "kind": "text", + "version": 1, + "text": "This demo shows how to extend CascadeEditor with custom block types and slash commands.", + "spans": [] + } + }, + { + "id": "custom-blocks-3", + "type": { + "typeId": "heading_2" + }, + "content": { + "kind": "text", + "version": 1, + "text": "Interactive Tables", + "spans": [] + } + }, + { + "id": "custom-blocks-4", + "type": { + "typeId": "paragraph" + }, + "content": { + "kind": "text", + "version": 1, + "text": "Table blocks are implemented by the sample app with public custom block APIs.", + "spans": [] + } + }, + { + "id": "custom-blocks-5", + "type": { + "typeId": "table" + }, + "content": { + "kind": "table", + "data": { + "rows": [ + ["Name", "Role", "Status"], + ["Ada", "Engineer", "Active"], + ["Linus", "Maintainer", "Review"] + ], + "headerRow": true + } + } + }, + { + "id": "custom-blocks-6", + "type": { + "typeId": "paragraph" + }, + "content": { + "kind": "text", + "version": 1, + "text": "Type /table to insert another table.", + "spans": [] + } + }, + { + "id": "custom-blocks-7", + "type": { + "typeId": "divider" + }, + "content": { + "kind": "empty" + } + }, + { + "id": "custom-blocks-8", + "type": { + "typeId": "heading_2" + }, + "content": { + "kind": "text", + "version": 1, + "text": "Metric Cards", + "spans": [] + } + }, + { + "id": "custom-blocks-9", + "type": { + "typeId": "paragraph" + }, + "content": { + "kind": "text", + "version": 1, + "text": "Metric cards are non-editable custom blocks — perfect for dashboards and status displays:", + "spans": [] + } + }, + { + "id": "custom-blocks-10", + "type": { + "typeId": "metric" + }, + "content": { + "kind": "metric", + "data": { + "value": "2,847", + "label": "Downloads", + "trend": "up", + "trendValue": "12.5%" + } + } + }, + { + "id": "custom-blocks-11", + "type": { + "typeId": "metric" + }, + "content": { + "kind": "metric", + "data": { + "value": "99.9%", + "label": "Uptime", + "trend": "up", + "trendValue": "0.1%" + } + } + }, + { + "id": "custom-blocks-12", + "type": { + "typeId": "metric" + }, + "content": { + "kind": "metric", + "data": { + "value": "142ms", + "label": "Avg Latency", + "trend": "down", + "trendValue": "23%" + } + } + }, + { + "id": "custom-blocks-13", + "type": { + "typeId": "paragraph" + }, + "content": { + "kind": "text", + "version": 1, + "text": "Type /metric to insert a new metric card.", + "spans": [] + } + }, + { + "id": "custom-blocks-14", + "type": { + "typeId": "divider" + }, + "content": { + "kind": "empty" + } + }, + { + "id": "custom-blocks-15", + "type": { + "typeId": "heading_2" + }, + "content": { + "kind": "text", + "version": 1, + "text": "Color Palettes", + "spans": [] + } + }, + { + "id": "custom-blocks-16", + "type": { + "typeId": "paragraph" + }, + "content": { + "kind": "text", + "version": 1, + "text": "Color palette blocks showcase full Compose rendering — circles, hex labels, and layout:", + "spans": [] + } + }, + { + "id": "custom-blocks-17", + "type": { + "typeId": "palette" + }, + "content": { + "kind": "palette", + "data": { + "name": "Ocean Breeze", + "colors": "0077B6,00B4D8,90E0EF,CAF0F8" + } + } + }, + { + "id": "custom-blocks-18", + "type": { + "typeId": "palette" + }, + "content": { + "kind": "palette", + "data": { + "name": "Sunset Warmth", + "colors": "FF6B6B,FFA06B,FFD93D,6BCB77" + } + } + }, + { + "id": "custom-blocks-19", + "type": { + "typeId": "paragraph" + }, + "content": { + "kind": "text", + "version": 1, + "text": "Type /palette to insert a new color palette.", + "spans": [] + } + }, + { + "id": "custom-blocks-20", + "type": { + "typeId": "divider" + }, + "content": { + "kind": "empty" + } + }, + { + "id": "custom-blocks-21", + "type": { + "typeId": "heading_2" + }, + "content": { + "kind": "text", + "version": 1, + "text": "Custom Slash Commands", + "spans": [] + } + }, + { + "id": "custom-blocks-22", + "type": { + "typeId": "paragraph" + }, + "content": { + "kind": "text", + "version": 1, + "text": "Type /timestamp to insert the current date and time.", + "spans": [] + } + }, + { + "id": "custom-blocks-23", + "type": { + "typeId": "paragraph" + }, + "content": { + "kind": "text", + "version": 1, + "text": "Type /lorem to insert placeholder text.", + "spans": [] + } + }, + { + "id": "custom-blocks-24", + "type": { + "typeId": "paragraph" + }, + "content": { + "kind": "text", + "version": 1, + "text": "These custom commands coexist with all built-in commands in the slash popup.", + "spans": [] + } + }, + { + "id": "custom-blocks-25", + "type": { + "typeId": "divider" + }, + "content": { + "kind": "empty" + } + }, + { + "id": "custom-blocks-26", + "type": { + "typeId": "heading_2" + }, + "content": { + "kind": "text", + "version": 1, + "text": "Try It Out", + "spans": [] + } + }, + { + "id": "custom-blocks-27", + "type": { + "typeId": "paragraph" + }, + "content": { + "kind": "text", + "version": 1, + "text": "Click on any empty paragraph and type / to see all available commands:", + "spans": [] + } + }, + { + "id": "custom-blocks-28", + "type": { + "typeId": "paragraph" + }, + "content": { + "kind": "text", + "version": 1, + "text": "", + "spans": [] + } + }, + { + "id": "custom-blocks-29", + "type": { + "typeId": "paragraph" + }, + "content": { + "kind": "text", + "version": 1, + "text": "", + "spans": [] + } + } + ] +} diff --git a/editor-ios-sdk/src/commonTest/resources/editor_demo_document.json b/editor-ios-sdk/src/commonTest/resources/editor_demo_document.json new file mode 100644 index 0000000..c90f98c --- /dev/null +++ b/editor-ios-sdk/src/commonTest/resources/editor_demo_document.json @@ -0,0 +1,467 @@ +{ + "version": 2, + "blocks": [ + { + "id": "welcome-1", + "type": { + "typeId": "heading_1" + }, + "content": { + "kind": "text", + "version": 1, + "text": "Welcome to Cascade Editor", + "spans": [ + { + "start": 0, + "end": 25, + "style": { + "type": "bold" + } + } + ] + } + }, + { + "id": "welcome-2", + "type": { + "typeId": "paragraph" + }, + "content": { + "kind": "text", + "version": 1, + "text": "A block-based document editor for Compose Multiplatform. Everything you see here is editable \u2014 try it out!", + "spans": [ + { + "start": 2, + "end": 29, + "style": { + "type": "bold" + } + }, + { + "start": 34, + "end": 55, + "style": { + "type": "italic" + } + } + ] + } + }, + { + "id": "welcome-3", + "type": { + "typeId": "divider" + }, + "content": { + "kind": "empty" + } + }, + { + "id": "try-1", + "type": { + "typeId": "heading_2" + }, + "content": { + "kind": "text", + "version": 1, + "text": "Try These", + "spans": [ + { + "start": 0, + "end": 9, + "style": { + "type": "bold" + } + } + ] + } + }, + { + "id": "try-format-1", + "type": { + "typeId": "todo" + }, + "content": { + "kind": "text", + "version": 1, + "text": "Mix bold, italic, underline, strikethrough, code, and highlights in any block.", + "spans": [ + { + "start": 4, + "end": 8, + "style": { + "type": "bold" + } + }, + { + "start": 10, + "end": 16, + "style": { + "type": "italic" + } + }, + { + "start": 18, + "end": 27, + "style": { + "type": "underline" + } + }, + { + "start": 29, + "end": 42, + "style": { + "type": "strikethrough" + } + }, + { + "start": 44, + "end": 48, + "style": { + "type": "inline_code" + } + }, + { + "start": 54, + "end": 64, + "style": { + "type": "highlight", + "colorArgb": 4294961979 + } + }, + { + "start": 65, + "end": 71, + "style": { + "type": "link", + "url": "https://github.com/linreal/cascade-editor" + } + } + ] + } + }, + + { + "id": "try-2", + "type": { + "typeId": "todo", + "checked": false + }, + "content": { + "kind": "text", + "version": 1, + "text": "Tap here and start typing", + "spans": [] + } + }, + { + "id": "try-3", + "type": { + "typeId": "todo", + "checked": false + }, + "content": { + "kind": "text", + "version": 1, + "text": "Select text, then use the toolbar to make it bold or italic", + "spans": [ + { + "start": 26, + "end": 33, + "style": { + "type": "bold" + } + } + ] + } + }, + { + "id": "try-4", + "type": { + "typeId": "todo", + "checked": false + }, + "content": { + "kind": "text", + "version": 1, + "text": "Type / to open slash commands (or just use / icon from the toolbar)", + "spans": [ + { + "start": 5, + "end": 6, + "style": { + "type": "inline_code" + } + } + ] + } + }, + { + "id": "try-5", + "type": { + "typeId": "todo", + "checked": false + }, + "content": { + "kind": "text", + "version": 1, + "text": "Use indentation to group related tasks", + "spans": [] + } + }, + { + "id": "try-nested-todo-1", + "type": { + "typeId": "todo", + "checked": false + }, + "attributes": { + "indentationLevel": 1 + }, + "content": { + "kind": "text", + "version": 1, + "text": "Subtasks can sit under a parent todo", + "spans": [] + } + }, + { + "id": "try-nested-todo-2", + "type": { + "typeId": "todo", + "checked": false + }, + "attributes": { + "indentationLevel": 2 + }, + "content": { + "kind": "text", + "version": 1, + "text": "Deeper todo levels stay attached to the outline", + "spans": [] + } + }, + { + "id": "try-nested-todo-3", + "type": { + "typeId": "todo", + "checked": false + }, + "attributes": { + "indentationLevel": 1 + }, + "content": { + "kind": "text", + "version": 1, + "text": "Outdent again when the group is done", + "spans": [] + } + }, + { + "id": "try-6", + "type": { + "typeId": "todo", + "checked": false + }, + "content": { + "kind": "text", + "version": 1, + "text": "Hold and drag any block to reorder it", + "spans": [] + } + }, + { + "id": "try-7", + "type": { + "typeId": "todo", + "checked": false + }, + "content": { + "kind": "text", + "version": 1, + "text": "Long-press a block to select it, then tap others to multi-select and delete", + "spans": [] + } + }, + { + "id": "try-8", + "type": { + "typeId": "todo", + "checked": false + }, + "content": { + "kind": "text", + "version": 1, + "text": "Press Enter at the end of this line to create a new block", + "spans": [] + } + }, + { + "id": "blocks-1", + "type": { + "typeId": "heading_2" + }, + "content": { + "kind": "text", + "version": 1, + "text": "Block Types", + "spans": [ + { + "start": 0, + "end": 11, + "style": { + "type": "bold" + } + } + ] + } + }, + { + "id": "blocks-2", + "type": { + "typeId": "bullet_list" + }, + "content": { + "kind": "text", + "version": 1, + "text": "Bullet lists for unordered content", + "spans": [] + } + }, + { + "id": "blocks-3", + "type": { + "typeId": "bullet_list" + }, + "attributes": { + "indentationLevel": 1 + }, + "content": { + "kind": "text", + "version": 1, + "text": "Nest ideas without numbering", + "spans": [] + } + }, + { + "id": "blocks-4", + "type": { + "typeId": "numbered_list", + "number": 1 + }, + "content": { + "kind": "text", + "version": 1, + "text": "Numbered lists auto-increment", + "spans": [] + } + }, + { + "id": "blocks-5", + "type": { + "typeId": "numbered_list", + "number": 1 + }, + "attributes": { + "indentationLevel": 1 + }, + "content": { + "kind": "text", + "version": 1, + "text": "Indented numbered items keep their own sequence", + "spans": [] + } + }, + { + "id": "blocks-6", + "type": { + "typeId": "numbered_list", + "number": 1 + }, + "attributes": { + "indentationLevel": 2 + }, + "content": { + "kind": "text", + "version": 1, + "text": "Deeper levels can explain a step in detail", + "spans": [] + } + }, + { + "id": "blocks-7", + "type": { + "typeId": "numbered_list", + "number": 2 + }, + "attributes": { + "indentationLevel": 1 + }, + "content": { + "kind": "text", + "version": 1, + "text": "Sibling nested items continue at the same depth", + "spans": [] + } + }, + { + "id": "blocks-numbered-root-2", + "type": { + "typeId": "numbered_list", + "number": 2 + }, + "content": { + "kind": "text", + "version": 1, + "text": "Delete or reorder and every level renumbers", + "spans": [] + } + }, + { + "id": "blocks-8", + "type": { + "typeId": "quote" + }, + "content": { + "kind": "text", + "version": 1, + "text": "The best way to predict the future is to invent it. \u2014 Alan Kay", + "spans": [] + } + }, + { + "id": "blocks-code-1", + "type": { + "typeId": "code" + }, + "content": { + "kind": "text", + "version": 1, + "text": "fun greet(name: String) {\n println(\"Hello, $name!\")\n}", + "spans": [] + } + }, + { + "id": "blocks-9", + "type": { + "typeId": "divider" + }, + "content": { + "kind": "empty" + } + }, + { + "id": "blocks-10", + "type": { + "typeId": "paragraph" + }, + "content": { + "kind": "text", + "version": 1, + "text": "Your changes are saved automatically. Hit Reset in the toolbar to start fresh.", + "spans": [] + } + } + ] +} diff --git a/editor-ios-sdk/src/iosMain/kotlin/io/github/linreal/cascade/ios/CascadeEditorSdk.kt b/editor-ios-sdk/src/iosMain/kotlin/io/github/linreal/cascade/ios/CascadeEditorSdk.kt new file mode 100644 index 0000000..92ec4ab --- /dev/null +++ b/editor-ios-sdk/src/iosMain/kotlin/io/github/linreal/cascade/ios/CascadeEditorSdk.kt @@ -0,0 +1,10 @@ +package io.github.linreal.cascade.ios + +import kotlin.experimental.ExperimentalObjCName +import kotlin.native.ObjCName + +@OptIn(ExperimentalObjCName::class) +@ObjCName("CascadeEditorSdk", exact = true) +public object CascadeEditorSdk { + public const val version: String = "1.7.0" +} diff --git a/editor-ios-sdk/src/iosMain/kotlin/io/github/linreal/cascade/ios/block/CascadeBlockRegistration.kt b/editor-ios-sdk/src/iosMain/kotlin/io/github/linreal/cascade/ios/block/CascadeBlockRegistration.kt new file mode 100644 index 0000000..bbc03ee --- /dev/null +++ b/editor-ios-sdk/src/iosMain/kotlin/io/github/linreal/cascade/ios/block/CascadeBlockRegistration.kt @@ -0,0 +1,55 @@ +@file:OptIn(ExperimentalObjCName::class) + +package io.github.linreal.cascade.ios.block + +import platform.UIKit.UIViewController +import kotlin.experimental.ExperimentalObjCName +import kotlin.native.ObjCName + +/** + * How a registered custom block behaves when chosen from the slash menu. + */ +@ObjCName("CascadeCustomBlockSlashBehavior", exact = true) +public enum class CascadeCustomBlockSlashBehavior { + /** Insert a new block of this type below the anchor block. */ + insert, + + /** Convert the anchor block in place into this type. */ + @ObjCName(name = "convertInPlace", swiftName = "convertInPlace") + convertInPlace, +} + +/** + * Swift-facing description of a native custom block type. + * + * A registration is turned into a block descriptor (for the slash menu), a + * renderable type, a serialization codec entry, and a renderer that hosts the + * native view returned by [rendererFactory] inside the editor. + * + * @property typeId Unique id matching the `typeId` used in persisted documents + * and [CascadeEditorDocumentBuilder.customBlock][io.github.linreal.cascade.ios.model.CascadeEditorDocumentBuilder.customBlock]. + * @property displayName Human-readable name shown in the slash menu. + * @property description Short description shown in the slash menu. + * @property keywords Extra search terms for the slash menu. + * @property slashBehavior Insert-below vs convert-in-place semantics. + * @property defaultPayloadJson JSON object used as the block's payload when it is + * created from the slash menu. Must be a JSON object; a non-object or malformed + * value falls back to an empty payload. + * @property estimatedHeight Initial host height in points, applied before the + * native view reports its own height via + * [CascadeCustomBlockContext.setPreferredHeight]. Clamped to a sane range. + * @property rendererFactory Builds the native view controller that renders a + * block instance. Called once per rendered block; the supplied + * [CascadeCustomBlockContext] stays valid for that block's lifetime. + */ +@ObjCName("CascadeCustomBlockRegistration", exact = true) +public class CascadeCustomBlockRegistration public constructor( + public val typeId: String, + public val displayName: String, + public val description: String, + public val keywords: List = emptyList(), + public val slashBehavior: CascadeCustomBlockSlashBehavior = CascadeCustomBlockSlashBehavior.insert, + public val defaultPayloadJson: String = "{}", + public val estimatedHeight: Double = DEFAULT_BLOCK_HEIGHT, + public val rendererFactory: (CascadeCustomBlockContext) -> UIViewController, +) diff --git a/editor-ios-sdk/src/iosMain/kotlin/io/github/linreal/cascade/ios/block/CascadeCustomBlockContext.kt b/editor-ios-sdk/src/iosMain/kotlin/io/github/linreal/cascade/ios/block/CascadeCustomBlockContext.kt new file mode 100644 index 0000000..ad0afef --- /dev/null +++ b/editor-ios-sdk/src/iosMain/kotlin/io/github/linreal/cascade/ios/block/CascadeCustomBlockContext.kt @@ -0,0 +1,286 @@ +@file:OptIn(ExperimentalObjCName::class) + +package io.github.linreal.cascade.ios.block + +import io.github.linreal.cascade.editor.core.Block +import io.github.linreal.cascade.editor.core.BlockContent +import io.github.linreal.cascade.editor.core.BlockId +import io.github.linreal.cascade.editor.registry.BlockRegistry +import io.github.linreal.cascade.editor.registry.BlockRenderScope +import io.github.linreal.cascade.ios.model.parseJsonObjectPayloadSafely +import io.github.linreal.cascade.ios.model.toCascadeJsonString +import kotlin.experimental.ExperimentalObjCName +import kotlin.native.ObjCName +import platform.Foundation.NSThread + +internal const val MIN_BLOCK_HEIGHT: Double = 1.0 +internal const val MAX_BLOCK_HEIGHT: Double = 10_000.0 +internal const val DEFAULT_BLOCK_HEIGHT: Double = 120.0 + +private const val CONTEXT_MAIN_THREAD_ERROR: String = + "CascadeCustomBlockContext must be used on the main thread" + +/** + * Clamps a caller-supplied block height (points) into a sane positive range. + * Non-finite values fall back to [DEFAULT_BLOCK_HEIGHT]. + */ +internal fun clampBlockHeight(raw: Double): Double = when { + raw.isNaN() || raw.isInfinite() -> DEFAULT_BLOCK_HEIGHT + raw < MIN_BLOCK_HEIGHT -> MIN_BLOCK_HEIGHT + raw > MAX_BLOCK_HEIGHT -> MAX_BLOCK_HEIGHT + else -> raw +} + +/** + * Outcome of building a block for an insert request. + */ +internal sealed interface CascadeBlockBuildOutcome { + data class Success(val block: Block) : CascadeBlockBuildOutcome + data class InvalidPayload(val message: String) : CascadeBlockBuildOutcome + data class UnknownType(val message: String) : CascadeBlockBuildOutcome +} + +/** + * Builds the block inserted by a context/slash insert request. + * + * A registered native type id yields a renderable [NativeCustomBlockType] carrying + * the marshaled payload; a built-in descriptor id yields that descriptor's default + * block (payload ignored — built-ins have no JSON payload). Any other id is an + * error. Invalid payload JSON for a native type is rejected using the same + * coercion as every other custom-block payload path. + */ +internal fun buildInsertableBlock( + typeId: String, + payloadJson: String, + registry: BlockRegistry, + isNativeCustomType: (String) -> Boolean, +): CascadeBlockBuildOutcome { + if (isNativeCustomType(typeId)) { + val parsed = parseJsonObjectPayloadSafely(payloadJson) + parsed.errorMessage?.let { return CascadeBlockBuildOutcome.InvalidPayload(it) } + return CascadeBlockBuildOutcome.Success( + Block( + id = BlockId.generate(), + type = NativeCustomBlockType(typeId), + content = BlockContent.Custom(typeId, parsed.data), + ), + ) + } + val descriptor = registry.getDescriptor(typeId) + ?: return CascadeBlockBuildOutcome.UnknownType("Unknown block typeId '$typeId'") + return CascadeBlockBuildOutcome.Success(descriptor.createBlock()) +} + +/** + * Result of a context mutation. Errors are also reported through + * [CascadeEditorController.onInternalError][io.github.linreal.cascade.ios.controller.CascadeEditorController.onInternalError] + * for diagnosability. + */ +@ObjCName("CascadeCustomBlockMutationResult", exact = true) +public enum class CascadeCustomBlockMutationResult { + success, + + @ObjCName(name = "readOnly", swiftName = "readOnly") + readOnly, + + @ObjCName(name = "invalidPayload", swiftName = "invalidPayload") + invalidPayload, + + @ObjCName(name = "unknownType", swiftName = "unknownType") + unknownType, + + @ObjCName(name = "blockUnavailable", swiftName = "blockUnavailable") + blockUnavailable, +} + +/** + * Per-instance handle a native custom block view uses to read editor state for + * its block and to push changes back into the document. + * + * Reads reflect live editor state; mutations route through the editor's + * history-aware [BlockRenderScope], so once the editor is mounted they are + * undo/redo-aware and gated by read-only/policy exactly like built-in edits. + * + * All members must be used on the main thread. Set [onChange] to be notified + * on any editor-side change, so the native view can re-read the context and + * refresh. + */ +@ObjCName("CascadeCustomBlockContext", exact = true) +public class CascadeCustomBlockContext internal constructor( + public val blockId: String, + public val typeId: String, + private val scope: BlockRenderScope, + private val reportError: (String) -> Unit, + private val isDarkProvider: () -> Boolean, + private val applyPreferredHeight: (Double) -> Unit, + private val buildBlock: (typeId: String, payloadJson: String) -> CascadeBlockBuildOutcome, +) { + private val id: BlockId = BlockId(blockId) + + /** + * Set by the native view to observe editor-side changes to this block. + * + * The native view is built once and hosted inside the editor; it does not + * automatically observe editor state, so this callback is its single refresh + * signal — everything a native block renders from is pulled from this context, + * and the values change underneath it without UIKit knowing. It is invoked on + * the main thread after any editor-side change this block depends on: + * - the payload changed — whether from this view's own [updatePayloadJson] / + * [replacePayloadJson], an undo/redo, or a document load/reset; + * - focus or block selection moved to or away from this block; + * - the read-only state or the dark-mode theme toggled. + * + * On each invocation, re-read the context properties this view depends on + * ([payloadJson], [isFocused], [isSelected], [readOnly], [isDark]) and update + * the view to match. The callback takes no arguments because the context + * always exposes the current values; it may also fire when nothing this + * particular view cares about changed, so treat it as "re-sync from the + * context", not "exactly one meaningful change happened". + */ + public var onChange: (() -> Unit)? = null + + /** + * Invokes [onChange] with the failure contained. The handler is native (Swift) + * code; a throw must never cancel the hosting effect or escape into the Compose + * runtime, so any error is reported through [reportError] instead of propagating. + */ + internal fun fireOnChange() { + val handler = onChange ?: return + try { + handler() + } catch (throwable: Throwable) { + reportError( + "Custom block '$typeId' onChange failed: ${throwable.message ?: throwable.toString()}" + ) + } + } + + /** Current payload as a JSON object string, or `"{}"` when unavailable. */ + public val payloadJson: String + get() = read(fallback = "{}") { currentData().toCascadeJsonString() } + + public val isFocused: Boolean + get() = read(fallback = false) { scope.state.focusedBlockId == id } + + public val isSelected: Boolean + get() = read(fallback = false) { id in scope.state.selectedBlockIds } + + public val readOnly: Boolean + get() = read(fallback = true) { scope.readOnly } + + public val canUpdateBlock: Boolean + get() = read(fallback = false) { scope.canUpdateBlock } + + public val isDark: Boolean + get() = read(fallback = false) { isDarkProvider() } + + /** Merges [payloadJson] into the current payload (undo-aware once mounted). */ + public fun updatePayloadJson(payloadJson: String): CascadeCustomBlockMutationResult = mutate { + if (isMutationDisabled()) return@mutate CascadeCustomBlockMutationResult.readOnly + val parsed = parseJsonObjectPayloadSafely(payloadJson) + parsed.errorMessage?.let { + reportError(it) + return@mutate CascadeCustomBlockMutationResult.invalidPayload + } + if (scope.getBlock(id) == null) return@mutate CascadeCustomBlockMutationResult.blockUnavailable + scope.updateBlock(id) { block -> + block.withContent(BlockContent.Custom(typeId, currentData() + parsed.data)) + } + CascadeCustomBlockMutationResult.success + } + + /** Replaces the entire payload with [payloadJson] (undo-aware once mounted). */ + public fun replacePayloadJson(payloadJson: String): CascadeCustomBlockMutationResult = mutate { + if (isMutationDisabled()) return@mutate CascadeCustomBlockMutationResult.readOnly + val parsed = parseJsonObjectPayloadSafely(payloadJson) + parsed.errorMessage?.let { + reportError(it) + return@mutate CascadeCustomBlockMutationResult.invalidPayload + } + val block = scope.getBlock(id) ?: return@mutate CascadeCustomBlockMutationResult.blockUnavailable + scope.replaceBlock(id, block.withContent(BlockContent.Custom(typeId, parsed.data))) + CascadeCustomBlockMutationResult.success + } + + public fun insertBlockBefore( + typeId: String, + payloadJson: String, + ): CascadeCustomBlockMutationResult = mutate { + insert(typeId, payloadJson) { block -> scope.insertBlockBefore(id, block) } + } + + public fun insertBlockAfter( + typeId: String, + payloadJson: String, + ): CascadeCustomBlockMutationResult = mutate { + insert(typeId, payloadJson) { block -> scope.insertBlockAfter(id, block) } + } + + public fun deleteBlock(): CascadeCustomBlockMutationResult = mutate { + if (isMutationDisabled()) return@mutate CascadeCustomBlockMutationResult.readOnly + if (scope.getBlock(id) == null) return@mutate CascadeCustomBlockMutationResult.blockUnavailable + scope.deleteBlock(id) + CascadeCustomBlockMutationResult.success + } + + public fun focusBlock(): CascadeCustomBlockMutationResult = mutate { + if (scope.getBlock(id) == null) return@mutate CascadeCustomBlockMutationResult.blockUnavailable + scope.focusBlock(id) + CascadeCustomBlockMutationResult.success + } + + /** Reports the native view's preferred height (points), clamped to a sane range. */ + public fun setPreferredHeight(height: Double) { + if (!NSThread.isMainThread) { + reportError(CONTEXT_MAIN_THREAD_ERROR) + return + } + applyPreferredHeight(clampBlockHeight(height)) + } + + private inline fun insert( + typeId: String, + payloadJson: String, + place: (Block) -> Unit, + ): CascadeCustomBlockMutationResult { + if (isMutationDisabled()) return CascadeCustomBlockMutationResult.readOnly + if (scope.getBlock(id) == null) return CascadeCustomBlockMutationResult.blockUnavailable + return when (val outcome = buildBlock(typeId, payloadJson)) { + is CascadeBlockBuildOutcome.Success -> { + place(outcome.block) + CascadeCustomBlockMutationResult.success + } + is CascadeBlockBuildOutcome.InvalidPayload -> { + reportError(outcome.message) + CascadeCustomBlockMutationResult.invalidPayload + } + is CascadeBlockBuildOutcome.UnknownType -> { + reportError(outcome.message) + CascadeCustomBlockMutationResult.unknownType + } + } + } + + private fun isMutationDisabled(): Boolean = scope.readOnly || !scope.canUpdateBlock + + private fun currentData(): Map = + (scope.getBlock(id)?.content as? BlockContent.Custom)?.data ?: emptyMap() + + private inline fun mutate( + block: () -> CascadeCustomBlockMutationResult, + ): CascadeCustomBlockMutationResult { + if (!NSThread.isMainThread) { + reportError(CONTEXT_MAIN_THREAD_ERROR) + return CascadeCustomBlockMutationResult.blockUnavailable + } + return block() + } + + private inline fun read(fallback: T, block: () -> T): T { + if (!NSThread.isMainThread) { + reportError(CONTEXT_MAIN_THREAD_ERROR) + return fallback + } + return block() + } +} diff --git a/editor-ios-sdk/src/iosMain/kotlin/io/github/linreal/cascade/ios/block/NativeCustomBlockCodec.kt b/editor-ios-sdk/src/iosMain/kotlin/io/github/linreal/cascade/ios/block/NativeCustomBlockCodec.kt new file mode 100644 index 0000000..29c64c0 --- /dev/null +++ b/editor-ios-sdk/src/iosMain/kotlin/io/github/linreal/cascade/ios/block/NativeCustomBlockCodec.kt @@ -0,0 +1,30 @@ +package io.github.linreal.cascade.ios.block + +import io.github.linreal.cascade.editor.core.BlockType +import io.github.linreal.cascade.editor.serialization.BlockTypeCodec +import kotlinx.serialization.json.JsonObject +import kotlinx.serialization.json.JsonPrimitive +import kotlinx.serialization.json.buildJsonObject + +/** + * Bridges registered native custom block ids across the document serializer. + * + * [isRegistered] is queried live (not captured), so blocks registered after this + * codec is wired into the load path still decode to a renderable + * [NativeCustomBlockType]. Unregistered ids return `null` from [decodeType] and + * fall through to the serializer's `UnknownBlockType` preservation. + */ +internal class NativeCustomBlockCodec( + private val isRegistered: (String) -> Boolean, +) : BlockTypeCodec { + + override fun encodeType(type: BlockType): JsonObject? { + if (type !is NativeCustomBlockType) return null + return buildJsonObject { put("typeId", JsonPrimitive(type.typeId)) } + } + + override fun decodeType(typeId: String, json: JsonObject): BlockType? { + if (!isRegistered(typeId)) return null + return NativeCustomBlockType(typeId) + } +} diff --git a/editor-ios-sdk/src/iosMain/kotlin/io/github/linreal/cascade/ios/block/NativeCustomBlockRenderer.kt b/editor-ios-sdk/src/iosMain/kotlin/io/github/linreal/cascade/ios/block/NativeCustomBlockRenderer.kt new file mode 100644 index 0000000..8089998 --- /dev/null +++ b/editor-ios-sdk/src/iosMain/kotlin/io/github/linreal/cascade/ios/block/NativeCustomBlockRenderer.kt @@ -0,0 +1,102 @@ +package io.github.linreal.cascade.ios.block + +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.saveable.autoSaver +import androidx.compose.runtime.saveable.rememberSaveable +import androidx.compose.runtime.setValue +import androidx.compose.ui.Modifier +import androidx.compose.ui.unit.dp +import androidx.compose.ui.viewinterop.UIKitViewController +import io.github.linreal.cascade.editor.core.Block +import io.github.linreal.cascade.editor.registry.BlockCallbacks +import io.github.linreal.cascade.editor.registry.BlockRenderScope +import io.github.linreal.cascade.editor.registry.ScopedBlockRenderer +import io.github.linreal.cascade.ios.controller.CascadeEditorController +import platform.UIKit.UIViewController + +/** + * Hosts a native custom block view inside the editor. + * + * The renderer owns a height state seeded from the registration estimate and + * updated when the context reports a preferred height, and builds a + * [CascadeCustomBlockContext] bound to the live [BlockRenderScope] so native + * mutations route through editor history. A [LaunchedEffect] keyed on the + * editor-side signals the block depends on notifies the native view (via + * [CascadeCustomBlockContext.onChange]) so it can refresh after undo/redo, + * loads, or theme/read-only changes. + * + * A failing renderer factory is contained: the error is reported and an empty + * placeholder view controller is hosted instead of crashing the host app. + */ +internal class NativeCustomBlockRenderer( + private val registration: CascadeCustomBlockRegistration, + private val controller: CascadeEditorController, +) : ScopedBlockRenderer { + + // The drag ghost would instantiate a second live UIViewController for the + // same block mid-gesture, and interop views ignore the ghost's draw-phase + // translation — the editor shows a placeholder ghost instead. + override val supportsDragPreview: Boolean get() = false + + @Composable + override fun Render( + block: Block, + isSelected: Boolean, + isFocused: Boolean, + modifier: Modifier, + callbacks: BlockCallbacks, + scope: BlockRenderScope, + ) { + val isDark = controller.configurationSnapshot.value.isDark + // rememberSaveable (keyed per LazyColumn item) keeps the last reported + // preferred height while the block is scrolled off-screen, so it re-enters + // at its real size instead of jumping from the registration estimate. + var height by rememberSaveable(block.id.value, stateSaver = autoSaver()) { + mutableStateOf(clampBlockHeight(registration.estimatedHeight)) + } + val context = remember(block.id.value) { + CascadeCustomBlockContext( + blockId = block.id.value, + typeId = registration.typeId, + scope = scope, + reportError = { message -> controller.reportInternalError(message) }, + isDarkProvider = { controller.configurationSnapshot.value.isDark }, + applyPreferredHeight = { height = it }, + buildBlock = { typeId, payloadJson -> + buildInsertableBlock(typeId, payloadJson, controller.registry) { candidate -> + candidate in controller.nativeRegistrations + } + }, + ) + } + + LaunchedEffect(block.content, isFocused, isSelected, scope.readOnly, isDark) { + // onChange is native (Swift) code; fireOnChange contains a throw so it can + // neither cancel this effect nor escape into the Compose runtime. + context.fireOnChange() + } + + UIKitViewController( + factory = { + try { + registration.rendererFactory(context) + } catch (throwable: Throwable) { + controller.reportInternalError( + "Custom block renderer '${registration.typeId}' failed to build: " + + (throwable.message ?: throwable.toString()) + ) + UIViewController() + } + }, + // The native host owns its height (via the preferred-height contract) + // but must always span the editor's content width, like built-in blocks. + modifier = modifier.fillMaxWidth().height(height.dp), + ) + } +} diff --git a/editor-ios-sdk/src/iosMain/kotlin/io/github/linreal/cascade/ios/block/NativeCustomBlockType.kt b/editor-ios-sdk/src/iosMain/kotlin/io/github/linreal/cascade/ios/block/NativeCustomBlockType.kt new file mode 100644 index 0000000..96da544 --- /dev/null +++ b/editor-ios-sdk/src/iosMain/kotlin/io/github/linreal/cascade/ios/block/NativeCustomBlockType.kt @@ -0,0 +1,25 @@ +package io.github.linreal.cascade.ios.block + +import io.github.linreal.cascade.editor.core.CustomBlockType + +/** + * Renderable [CustomBlockType] for a type id registered via + * [CascadeEditorController.registerBlock][io.github.linreal.cascade.ios.controller.CascadeEditorController.registerBlock]. + * + * Produced by [NativeCustomBlockCodec] when decoding a persisted document, so a + * stored custom block resolves to a type the registered renderer can draw rather + * than to [io.github.linreal.cascade.editor.core.UnknownBlockType]. + * + * Distinct from the builder-only `NativeDocumentBlockType`: both carry only a + * type id and produce the same JSON, but this one is the type the editor renders + * and mutates, whereas the builder's variant is inert marshaling metadata used + * only to emit document JSON. They share a JSON representation, so a document + * emitted by the builder decodes into this type once its id is registered. + */ +internal data class NativeCustomBlockType( + override val typeId: String, +) : CustomBlockType { + override val displayName: String = typeId + override val supportsText: Boolean = false + override val isConvertible: Boolean = false +} diff --git a/editor-ios-sdk/src/iosMain/kotlin/io/github/linreal/cascade/ios/controller/CascadeEditorConfiguration.kt b/editor-ios-sdk/src/iosMain/kotlin/io/github/linreal/cascade/ios/controller/CascadeEditorConfiguration.kt new file mode 100644 index 0000000..498b474 --- /dev/null +++ b/editor-ios-sdk/src/iosMain/kotlin/io/github/linreal/cascade/ios/controller/CascadeEditorConfiguration.kt @@ -0,0 +1,55 @@ +@file:OptIn(ExperimentalObjCName::class) + +package io.github.linreal.cascade.ios.controller + +import io.github.linreal.cascade.editor.CrashPolicy +import io.github.linreal.cascade.editor.theme.CascadeEditorTheme +import kotlin.experimental.ExperimentalObjCName +import kotlin.native.ObjCName + +@ObjCName("CascadeToolbarMode", exact = true) +public enum class CascadeToolbarMode { + @ObjCName(name = "builtIn", swiftName = "builtIn") + builtIn, + none, +} + +@ObjCName("CascadeCrashPolicy", exact = true) +public enum class CascadeCrashPolicy { + @ObjCName(name = "containAndReport", swiftName = "containAndReport") + containAndReport, + rethrow, +} + +@ObjCName("CascadeEditorConfiguration", exact = true) +public data class CascadeEditorConfiguration( + public val readOnly: Boolean, + public val toolbarMode: CascadeToolbarMode, + public val slashCommandsEnabled: Boolean, + public val blockSelectionEnabled: Boolean, + public val blockDraggingEnabled: Boolean, + public val isDark: Boolean, + public val crashPolicy: CascadeCrashPolicy, +) { + public constructor() : this( + readOnly = false, + toolbarMode = CascadeToolbarMode.builtIn, + slashCommandsEnabled = true, + blockSelectionEnabled = true, + blockDraggingEnabled = true, + isDark = false, + crashPolicy = CascadeCrashPolicy.containAndReport, + ) +} + +internal fun CascadeCrashPolicy.toCoreCrashPolicy(): CrashPolicy = when (this) { + CascadeCrashPolicy.containAndReport -> CrashPolicy.ContainAndReport + CascadeCrashPolicy.rethrow -> CrashPolicy.Rethrow +} + +/** + * The theme the hosted editor mounts for this configuration. Extracted so tests + * can assert the exact mapping the view host composes from when `isDark` flips. + */ +internal fun CascadeEditorConfiguration.resolveEditorTheme(): CascadeEditorTheme = + if (isDark) CascadeEditorTheme.dark() else CascadeEditorTheme.light() diff --git a/editor-ios-sdk/src/iosMain/kotlin/io/github/linreal/cascade/ios/controller/CascadeEditorController.kt b/editor-ios-sdk/src/iosMain/kotlin/io/github/linreal/cascade/ios/controller/CascadeEditorController.kt new file mode 100644 index 0000000..e717565 --- /dev/null +++ b/editor-ios-sdk/src/iosMain/kotlin/io/github/linreal/cascade/ios/controller/CascadeEditorController.kt @@ -0,0 +1,851 @@ +@file:OptIn(ExperimentalObjCName::class, ExperimentalCascadeHtmlApi::class) + +package io.github.linreal.cascade.ios.controller + +import androidx.compose.runtime.MutableState +import androidx.compose.runtime.mutableStateOf +import io.github.linreal.cascade.editor.action.ClearFocus +import io.github.linreal.cascade.editor.action.ClearSelection +import io.github.linreal.cascade.editor.action.DeleteSelectedOrFocused +import io.github.linreal.cascade.editor.core.Block +import io.github.linreal.cascade.editor.core.BlockContent +import io.github.linreal.cascade.editor.core.BlockId +import io.github.linreal.cascade.editor.core.SpanStyle +import io.github.linreal.cascade.editor.core.TextSpan +import io.github.linreal.cascade.editor.htmlserialization.ExperimentalCascadeHtmlApi +import io.github.linreal.cascade.editor.htmlserialization.HtmlDecodeWarning +import io.github.linreal.cascade.editor.htmlserialization.HtmlProfile +import io.github.linreal.cascade.editor.htmlserialization.loadFromHtml +import io.github.linreal.cascade.editor.htmlserialization.toHtml +import io.github.linreal.cascade.editor.registry.BlockDescriptor +import io.github.linreal.cascade.editor.registry.BlockRegistry +import io.github.linreal.cascade.editor.serialization.DocumentDecodeWarning +import io.github.linreal.cascade.editor.serialization.DocumentSchema +import io.github.linreal.cascade.editor.serialization.loadFromJson +import io.github.linreal.cascade.editor.serialization.resolveDocumentBlocks +import io.github.linreal.cascade.editor.serialization.toJson +import io.github.linreal.cascade.editor.slash.BuiltInBlockSlashBehavior +import io.github.linreal.cascade.editor.slash.BuiltInSlashCommandSpec +import io.github.linreal.cascade.editor.slash.SlashCommandAction +import io.github.linreal.cascade.editor.slash.SlashCommandId +import io.github.linreal.cascade.editor.slash.SlashCommandRegistry +import io.github.linreal.cascade.editor.slash.SlashCommandResult +import io.github.linreal.cascade.editor.slash.SlashQueryTextPolicy +import io.github.linreal.cascade.editor.slash.builtInBlockSlashCommandId +import io.github.linreal.cascade.editor.state.BlockSpanStates +import io.github.linreal.cascade.editor.state.BlockTextStates +import io.github.linreal.cascade.editor.state.EditorStateHolder +import io.github.linreal.cascade.editor.theme.CascadeEditorBlockStrings +import io.github.linreal.cascade.editor.theme.CascadeEditorStrings +import io.github.linreal.cascade.editor.ui.createEditorRegistry +import io.github.linreal.cascade.ios.block.CascadeCustomBlockRegistration +import io.github.linreal.cascade.ios.block.CascadeCustomBlockSlashBehavior +import io.github.linreal.cascade.ios.block.NativeCustomBlockCodec +import io.github.linreal.cascade.ios.block.NativeCustomBlockRenderer +import io.github.linreal.cascade.ios.block.NativeCustomBlockType +import io.github.linreal.cascade.ios.block.buildInsertableBlock +import io.github.linreal.cascade.ios.localization.CascadeEditorLocalization +import io.github.linreal.cascade.ios.localization.toEditorBlockStrings +import io.github.linreal.cascade.ios.localization.toEditorStrings +import io.github.linreal.cascade.ios.slash.CascadeSlashCommand +import io.github.linreal.cascade.ios.slash.CascadeSlashCommandContext +import io.github.linreal.cascade.ios.slash.CascadeSlashCommandResult +import io.github.linreal.cascade.ios.model.CascadeRichTextBlock +import io.github.linreal.cascade.ios.model.CascadeRichTextSnapshot +import io.github.linreal.cascade.ios.model.CascadeRichTextSpan +import io.github.linreal.cascade.ios.model.CascadeSpanKind +import io.github.linreal.cascade.ios.model.parseJsonObjectPayloadSafely +import io.github.linreal.cascade.ios.toolbar.CascadeToolbarState +import kotlin.experimental.ExperimentalObjCName +import kotlin.native.ObjCName +import platform.Foundation.NSThread +import platform.darwin.dispatch_async +import platform.darwin.dispatch_get_main_queue +import platform.darwin.dispatch_sync + +private const val MAIN_THREAD_ERROR: String = "CascadeEditorController must be used on the main thread" + +internal class CascadeToolbarActions internal constructor( + internal val toggleBold: () -> Unit, + internal val toggleItalic: () -> Unit, + internal val toggleUnderline: () -> Unit, + internal val toggleStrikeThrough: () -> Unit, + internal val toggleInlineCode: () -> Unit, + internal val toggleHighlight: (Long) -> Unit, + internal val indentForward: () -> Unit, + internal val indentBackward: () -> Unit, + internal val applyLink: (String, String?) -> Unit, + internal val removeLink: () -> Unit, +) + +@ObjCName("CascadeEditorController", exact = true) +public class CascadeEditorController public constructor( + initialJson: String?, + configuration: CascadeEditorConfiguration, +) { + public constructor() : this(initialJson = null, configuration = CascadeEditorConfiguration()) + + public constructor(initialJson: String?) : this( + initialJson = initialJson, + configuration = CascadeEditorConfiguration(), + ) + + internal val stateHolder: EditorStateHolder = EditorStateHolder() + internal val textStates: BlockTextStates = BlockTextStates() + internal val spanStates: BlockSpanStates = BlockSpanStates() + + // Block/slash registries owned for the controller's lifetime so registrations + // made before or after the first mount are visible to the hosted editor. + // These are the exact instances passed into CascadeEditor by makeViewController. + // Kept internal so raw :editor registry types never surface in Swift signatures. + internal val registry: BlockRegistry = createEditorRegistry() + internal val slashRegistry: SlashCommandRegistry = SlashCommandRegistry() + + // Type ids owned by built-in block types. A native custom-block registration is + // rejected when it collides with one of these: the document decoder resolves + // these ids to built-in types before the native codec runs, so allowing an + // overwrite of the built-in descriptor/renderer would desynchronize decode from + // render. Captured from the seeded registry (so it tracks whatever built-ins + // createEditorRegistry() provides) plus the `heading_` family the decoder treats + // as built-in regardless of level. + private val reservedBuiltInTypeIds: Set = + registry.getAllDescriptors().mapTo(mutableSetOf()) { descriptor -> descriptor.typeId } + + // Native custom-block registrations keyed by type id. The codec reads this map + // live so registrations made before or after the JSON load path is invoked are + // both visible; the JSON load/export paths use it to decode/encode registered + // ids as renderable NativeCustomBlockType rather than UnknownBlockType. + internal val nativeRegistrations: MutableMap = mutableMapOf() + internal val nativeBlockCodec: NativeCustomBlockCodec = + NativeCustomBlockCodec { typeId -> typeId in nativeRegistrations } + + internal val configurationSnapshot: MutableState = mutableStateOf(configuration) + + // Localization resolved onto :editor's string types at setLocalization time + // (snapshot semantics) and observed by the hosted editor as state, so runtime + // updates recompose the mounted tree the same way configuration changes do. + internal val resolvedStrings: MutableState = + mutableStateOf(CascadeEditorStrings.default()) + internal val resolvedBlockStrings: MutableState = + mutableStateOf(CascadeEditorBlockStrings.default()) + // Identity of the Compose host that currently owns this controller's bridge + // state. makeViewController() can be called more than once, and UIKit/SwiftUI + // transitions overlap the old and new hosts; only the owning host may publish + // toolbar actions/state or clear the mounted flags on dispose, so a stale + // host tearing down cannot disable the editor the user is looking at. + internal var mountOwner: Any? = null + internal var mounted: Boolean = false + internal var toolbarActions: CascadeToolbarActions? = null + private var currentConfiguration: CascadeEditorConfiguration = configuration + private var currentToolbarState: CascadeToolbarState = CascadeToolbarState.Empty + + public val configuration: CascadeEditorConfiguration + get() = onMainThread( + fallback = { CascadeEditorConfiguration() }, + block = { currentConfiguration }, + ) + + public val selectedBlockCount: Int + get() = onMainThread( + fallback = { 0 }, + block = { stateHolder.state.selectedBlockIds.size }, + ) + + /** + * Whether any block is currently selected. Reads the same selection set as + * [selectedBlockCount], so the two are always consistent. + */ + public val hasSelection: Boolean + get() = onMainThread( + fallback = { false }, + block = { stateHolder.state.hasSelection }, + ) + + public val toolbarState: CascadeToolbarState + get() = onMainThread( + fallback = { CascadeToolbarState.Empty }, + block = { currentToolbarState }, + ) + + public val canUndo: Boolean + get() = onMainThread( + fallback = { false }, + block = { mounted && stateHolder.canUndo }, + ) + + public val canRedo: Boolean + get() = onMainThread( + fallback = { false }, + block = { mounted && stateHolder.canRedo }, + ) + + public var onDocumentChanged: (() -> Unit)? = null + public var onStateChanged: (() -> Unit)? = null + public var onInternalError: ((String) -> Unit)? = null + public var onOpenLink: ((String) -> Unit)? = null + public var onToolbarStateChanged: ((CascadeToolbarState) -> Unit)? = null + + init { + if (initialJson != null) { + loadJson(initialJson) + } + } + + /** + * Loads a JSON document, replacing the current content and clearing history. + * + * When the document fails to parse ([CascadeDocumentLoadResult.success] is + * false) the currently loaded document, runtime state, and undo history are + * left untouched, so a corrupt payload can be rejected without losing what + * the user is editing. + */ + public fun loadJson(json: String): CascadeDocumentLoadResult = onMainThread( + fallback = { failedLoadResult(MAIN_THREAD_ERROR) }, + ) { + // The core load API is intentionally a hard replacement, including on + // parse failure. Preflight here so the native SDK can reject malformed + // host input without destroying the currently edited document. + val preflight = DocumentSchema.decodeFromStringWithReport(json, typeCodec = nativeBlockCodec) + if (preflight.warnings.any { warning -> warning is DocumentDecodeWarning.DocumentParseFailed }) { + return@onMainThread CascadeDocumentLoadResult( + success = false, + warningMessages = preflight.warnings.map { warning -> warning.message() }, + ) + } + val result = stateHolder.loadFromJson(json, textStates, spanStates, typeCodec = nativeBlockCodec) + val success = result.warnings.none { warning -> + warning is DocumentDecodeWarning.DocumentParseFailed + } + // Parse failures return during preflight, so only a successful load reaches + // the hard-replacement path and becomes a document change. + if (success) { + notifyDocumentAndStateChangedFromPublicMutation() + } + CascadeDocumentLoadResult( + success = success, + warningMessages = result.warnings.map { warning -> warning.message() }, + ) + } + + public fun loadHtml(html: String): CascadeHtmlLoadResult = onMainThread( + fallback = { failedLoadResult(MAIN_THREAD_ERROR) }, + ) { + val result = stateHolder.loadFromHtml(html, textStates, spanStates, HtmlProfile.Default) + notifyDocumentAndStateChangedFromPublicMutation() + CascadeDocumentLoadResult( + success = result.warnings.isSuccessfulHtmlLoad(), + warningMessages = result.warnings.map { warning -> warning.message() }, + ) + } + + /** + * Exports the current document as canonical JSON. + * + * Safe to call from any thread: off-main calls hop synchronously onto the + * main queue so the export always reflects the real document instead of an + * empty fallback a caller could persist by mistake. Do not block the main + * thread waiting for an off-main export — the synchronous hop would deadlock. + */ + public fun exportJson(): String = onMainThreadSync { + stateHolder.toJson(textStates, spanStates, typeCodec = nativeBlockCodec) + } + + /** + * Exports the current document as HTML. Same threading contract as + * [exportJson]: callable from any thread via a synchronous main-queue hop. + */ + public fun exportHtml(): String = onMainThreadSync { + stateHolder.toHtml(textStates, spanStates, HtmlProfile.Default) + } + + /** + * Document-ordered plain text: the text of every text-bearing block joined + * with newlines. Non-text blocks (dividers, custom blocks) contribute no + * lines — use [exportRichText] for the full typed per-block runs. Same + * threading contract as [exportJson]. + */ + public fun exportPlainText(): String = onMainThreadSync { + currentDocumentBlocks() + .mapNotNull { block -> (block.content as? BlockContent.Text)?.text } + .joinToString(separator = "\n") + } + + /** + * Exports per-block rich-text runs (text plus span styling) in document + * order, including non-text blocks as empty typed runs. Same threading + * contract as [exportJson]. + */ + public fun exportRichText(): CascadeRichTextSnapshot = onMainThreadSync { + CascadeRichTextSnapshot( + blocks = stateHolder.state.blocks.map { block -> + val text = textStates.getVisibleText(block.id) + ?: (block.content as? BlockContent.Text)?.text + ?: "" + val spans = if (block.type.supportsSpans) { + resolveCurrentSpans(block.id, block.content, text.length) + .mapNotNull { span -> span.toCascadeRichTextSpan() } + } else { + emptyList() + } + + CascadeRichTextBlock( + blockId = block.id.value, + typeId = block.type.typeId, + text = text, + spans = spans, + ) + }, + ) + } + + public fun reset(toJson: String): CascadeDocumentLoadResult = loadJson(toJson) + + public fun clearFocus(): Unit = onMainThread( + fallback = {}, + ) { + dispatchStateAction(ClearFocus) + } + + public fun clearSelection(): Unit = onMainThread( + fallback = {}, + ) { + dispatchStateAction(ClearSelection) + } + + public fun deleteSelectedOrFocused(): Unit = onMainThread( + fallback = {}, + ) { + if (currentConfiguration.readOnly) return@onMainThread + + val before = stateHolder.state + if (mounted) { + stateHolder.dispatchStructuralAction(DeleteSelectedOrFocused, textStates, spanStates) + } else { + stateHolder.dispatch(DeleteSelectedOrFocused) + } + cleanupRuntimeForCurrentBlocks() + if (stateHolder.state != before) { + notifyDocumentAndStateChangedFromPublicMutation() + } + } + + public fun undo(): Unit = performMountedEditorCommand("undo") { + stateHolder.undo() + } + + public fun redo(): Unit = performMountedEditorCommand("redo") { + stateHolder.redo() + } + + public fun toggleBold(): Unit = performToolbarAction("toggleBold") { actions -> + actions.toggleBold() + } + + public fun toggleItalic(): Unit = performToolbarAction("toggleItalic") { actions -> + actions.toggleItalic() + } + + public fun toggleUnderline(): Unit = performToolbarAction("toggleUnderline") { actions -> + actions.toggleUnderline() + } + + public fun toggleStrikeThrough(): Unit = performToolbarAction("toggleStrikeThrough") { actions -> + actions.toggleStrikeThrough() + } + + public fun toggleInlineCode(): Unit = performToolbarAction("toggleInlineCode") { actions -> + actions.toggleInlineCode() + } + + public fun toggleHighlight(argb: Long): Unit = performToolbarAction("toggleHighlight") { actions -> + actions.toggleHighlight(argb) + } + + public fun indentForward(): Unit = performToolbarAction("indentForward") { actions -> + actions.indentForward() + } + + public fun indentBackward(): Unit = performToolbarAction("indentBackward") { actions -> + actions.indentBackward() + } + + public fun applyLink( + url: String, + title: String?, + ): Unit = performToolbarAction("applyLink") { actions -> + actions.applyLink(url, title) + } + + public fun removeLink(): Unit = performToolbarAction("removeLink") { actions -> + actions.removeLink() + } + + public fun updateConfiguration(value: CascadeEditorConfiguration): Unit = onMainThread( + fallback = {}, + ) { + updateConfigurationOnMain(value) + } + + public fun setReadOnly(value: Boolean): Unit = updateConfiguration { + copy(readOnly = value) + } + + public fun setDarkMode(value: Boolean): Unit = updateConfiguration { + copy(isDark = value) + } + + public fun setToolbarMode(value: CascadeToolbarMode): Unit = updateConfiguration { + copy(toolbarMode = value) + } + + public fun setSlashCommandsEnabled(value: Boolean): Unit = updateConfiguration { + copy(slashCommandsEnabled = value) + } + + /** + * Applies localized strings to the editor's built-in UI chrome and to block + * names/descriptions/keywords in the slash menu. Fields left unset keep the + * built-in English defaults. + * + * Values are resolved immediately (mutating the passed bags afterwards has no + * effect until this is called again) and take effect whether called before or + * after the editor is mounted. + */ + public fun setLocalization(localization: CascadeEditorLocalization): Unit = onMainThread( + fallback = {}, + ) { + resolvedStrings.value = localization.toEditorStrings() + resolvedBlockStrings.value = localization.toEditorBlockStrings() + } + + /** + * Registers a native custom block type. Adds its slash-menu descriptor and a + * renderer that hosts the native view into the owned registry, and makes its + * type id decode/encode as a renderable block on the JSON paths. + * + * Re-registering an id replaces the previous registration (last-registration + * wins) and reports a non-fatal warning through [onInternalError]. Takes effect + * whether called before or after the editor is mounted. + */ + public fun registerBlock(registration: CascadeCustomBlockRegistration): Unit = onMainThread( + fallback = {}, + ) { + val typeId = registration.typeId + if (isReservedBuiltInTypeId(typeId)) { + reportInternalError( + "Custom block type '$typeId' is reserved by a built-in block type and was not registered." + ) + return@onMainThread + } + if (typeId in nativeRegistrations) { + reportInternalError( + "Custom block type '$typeId' is already registered; overriding the previous registration." + ) + } + val defaultPayload = parseJsonObjectPayloadSafely(registration.defaultPayloadJson) + if (defaultPayload.errorMessage != null) { + reportInternalError( + "Custom block '$typeId' default payload ignored: ${defaultPayload.errorMessage}" + ) + } + val descriptor = BlockDescriptor( + typeId = typeId, + displayName = registration.displayName, + description = registration.description, + keywords = registration.keywords, + slash = BuiltInSlashCommandSpec(behavior = registration.slashBehavior.toBuiltInBehavior()), + factory = { id -> + Block(id, NativeCustomBlockType(typeId), BlockContent.Custom(typeId, defaultPayload.data)) + }, + ) + registry.register(descriptor, NativeCustomBlockRenderer(registration, this)) + nativeRegistrations[typeId] = registration + } + + /** + * Registers a native slash command into the owned slash registry. Built-in + * commands stay available alongside it, and registration takes effect whether + * called before or after the editor is mounted. + * + * Registering an id that is already occupied — by a prior native command or a + * built-in one — overrides the previous entry (last registration wins) and + * reports a non-fatal warning through [onInternalError]; the registration is + * still kept. The command's synchronous handler is wrapped so it runs inside the + * editor's suspending slash-execution contract. + */ + public fun registerSlashCommand(command: CascadeSlashCommand): Unit = onMainThread( + fallback = {}, + ) { + if (isSlashCommandIdRegistered(command.id)) { + reportInternalError( + "Slash command '${command.id}' overrides an existing registration." + ) + } + slashRegistry.register( + SlashCommandAction( + id = SlashCommandId(command.id), + title = command.title, + description = command.description, + keywords = command.keywords, + // Native handlers own their query text (they edit it via the context), + // so the token is left in place rather than removed before execution. + queryTextPolicy = SlashQueryTextPolicy.KeepText, + onExecute = { + val context = CascadeSlashCommandContext( + editor = editor, + anchorBlockId = anchorBlockId, + buildBlock = { typeId, payloadJson -> + buildInsertableBlock(typeId, payloadJson, registry) { id -> + id in nativeRegistrations + } + }, + reportError = ::reportInternalError, + ) + command.handler(context).toSlashCommandResult(command.id) + }, + ), + ) + } + + internal fun updateToolbarStateFromHost(value: CascadeToolbarState): Unit { + if (currentToolbarState == value) return + currentToolbarState = value + invokeCallback("onToolbarStateChanged", onToolbarStateChanged, value) + } + + internal fun notifyStateChangedFromHost(): Unit { + invokeCallback("onStateChanged", onStateChanged) + } + + internal fun notifyDocumentChangedFromHost(): Unit { + invokeCallback("onDocumentChanged", onDocumentChanged) + } + + /** + * Resolves the authoritative document blocks (live text/span state folded in) + * without JSON encoding. The hosted change observer compares consecutive + * results by structural equality: a cheap content-change signal that catches + * text/span edits which never alter [EditorStateHolder]'s [state] identity. + */ + internal fun currentDocumentBlocks(): List = + stateHolder.resolveDocumentBlocks(textStates, spanStates) + + /** + * Slash command ids currently occupied by built-in block commands, derived from + * the owned block registry. Used to detect collisions when registering native + * commands (built-ins are merged into the mounted registry at composition time, + * so they are not otherwise visible in [slashRegistry]). + */ + internal fun builtInSlashCommandIds(): Set = + registry.getAllDescriptors() + .filter { descriptor -> descriptor.slash != null } + .mapTo(mutableSetOf()) { descriptor -> builtInBlockSlashCommandId(descriptor.typeId) } + + private fun isReservedBuiltInTypeId(typeId: String): Boolean = + typeId in reservedBuiltInTypeIds || typeId.startsWith("heading_") + + private fun isSlashCommandIdRegistered(id: String): Boolean { + val slashId = SlashCommandId(id) + if (slashRegistry.getRootItems().any { item -> item.id == slashId }) return true + return slashId in builtInSlashCommandIds() + } + + private fun CascadeSlashCommandResult.toSlashCommandResult(commandId: String): SlashCommandResult = + when (kind) { + CascadeSlashCommandResult.Kind.Done -> SlashCommandResult.Done + CascadeSlashCommandResult.Kind.KeepOpen -> SlashCommandResult.KeepOpen + CascadeSlashCommandResult.Kind.Failure -> { + failureMessage?.let { message -> + reportInternalError("Slash command '$commandId' failed: $message") + } + SlashCommandResult.Failure(failureMessage) + } + } + + internal inline fun onMainThread( + fallback: () -> T, + block: () -> T, + ): T { + if (!NSThread.isMainThread) { + reportInternalError(MAIN_THREAD_ERROR) + return fallback() + } + return block() + } + + /** + * Runs a read-only [block] on the main thread and returns its result, + * hopping synchronously onto the main queue when called from another + * thread. Used by the export methods: they must never hand back a + * valid-looking empty document to an off-main caller (e.g. a background + * autosave) that would then persist it. Mutating methods keep the + * report-and-fallback [onMainThread] guard. + */ + internal fun onMainThreadSync(block: () -> T): T { + if (NSThread.isMainThread) return block() + var result: T? = null + dispatch_sync(dispatch_get_main_queue()) { + result = block() + } + @Suppress("UNCHECKED_CAST") + return result as T + } + + private fun performMountedEditorCommand( + label: String, + command: () -> Unit, + ) { + onMainThread(fallback = {}) { + if (!mounted) return@onMainThread + + try { + command() + } catch (throwable: Throwable) { + reportInternalError( + "CascadeEditorController command $label failed: " + + (throwable.message ?: throwable.toString()) + ) + } + } + } + + private fun performToolbarAction( + label: String, + action: (CascadeToolbarActions) -> Unit, + ) { + onMainThread(fallback = {}) { + val actions = toolbarActions ?: return@onMainThread + if (!mounted) return@onMainThread + + try { + action(actions) + } catch (throwable: Throwable) { + reportInternalError( + "CascadeEditorController toolbar action $label failed: " + + (throwable.message ?: throwable.toString()) + ) + } + } + } + + private fun resolveCurrentSpans( + blockId: BlockId, + content: BlockContent, + textLength: Int, + ): List { + val runtime = spanStates.get(blockId)?.value + if (runtime != null) return runtime.clampToTextLength(textLength) + val snapshot = content as? BlockContent.Text ?: return emptyList() + return snapshot.spans.clampToTextLength(textLength) + } + + private fun TextSpan.toCascadeRichTextSpan(): CascadeRichTextSpan? = when (val spanStyle = style) { + SpanStyle.Bold -> CascadeRichTextSpan(start, end, CascadeSpanKind.bold) + SpanStyle.Italic -> CascadeRichTextSpan(start, end, CascadeSpanKind.italic) + SpanStyle.Underline -> CascadeRichTextSpan(start, end, CascadeSpanKind.underline) + SpanStyle.StrikeThrough -> CascadeRichTextSpan(start, end, CascadeSpanKind.strikeThrough) + SpanStyle.InlineCode -> CascadeRichTextSpan(start, end, CascadeSpanKind.inlineCode) + is SpanStyle.Highlight -> CascadeRichTextSpan( + start = start, + end = end, + kind = CascadeSpanKind.highlight, + argb = spanStyle.colorArgb, + ) + + is SpanStyle.Link -> CascadeRichTextSpan( + start = start, + end = end, + kind = CascadeSpanKind.link, + url = spanStyle.url, + ) + + is SpanStyle.Custom -> null + } + + private fun dispatchStateAction(action: io.github.linreal.cascade.editor.action.EditorAction) { + val before = stateHolder.state + stateHolder.dispatch(action) + if (stateHolder.state != before) { + notifyStateChangedFromPublicMutation() + } + } + + private fun cleanupRuntimeForCurrentBlocks() { + val existingBlockIds = stateHolder.state.blocks.mapTo(mutableSetOf()) { block -> block.id } + textStates.cleanup(existingBlockIds) + spanStates.cleanup(existingBlockIds) + } + + private fun notifyDocumentAndStateChanged() { + invokeCallback("onDocumentChanged", onDocumentChanged) + invokeCallback("onStateChanged", onStateChanged) + } + + private fun notifyDocumentAndStateChangedFromPublicMutation() { + if (!mounted) { + notifyDocumentAndStateChanged() + } + } + + private fun notifyStateChangedFromPublicMutation() { + if (!mounted) { + invokeCallback("onStateChanged", onStateChanged) + } + } + + private fun updateConfiguration(transform: CascadeEditorConfiguration.() -> CascadeEditorConfiguration) { + onMainThread(fallback = {}) { + updateConfigurationOnMain(currentConfiguration.transform()) + } + } + + private fun updateConfigurationOnMain(value: CascadeEditorConfiguration) { + if (currentConfiguration == value) return + currentConfiguration = value + configurationSnapshot.value = value + invokeCallback("onStateChanged", onStateChanged) + } + + private fun List.clampToTextLength(textLength: Int): List { + return mapNotNull { span -> + val start = span.start.coerceIn(0, textLength) + val end = span.end.coerceIn(0, textLength) + if (end <= start) { + null + } else if (start == span.start && end == span.end) { + span + } else { + TextSpan(start = start, end = end, style = span.style) + } + } + } + + internal fun invokeCallback( + label: String, + callback: (() -> Unit)?, + ): Unit { + if (callback == null) return + try { + callback() + } catch (throwable: Throwable) { + reportInternalError( + "CascadeEditorController callback $label failed: ${throwable.message ?: throwable.toString()}" + ) + } + } + + internal fun invokeCallback( + label: String, + callback: ((T) -> Unit)?, + value: T, + ): Unit { + if (callback == null) return + try { + callback(value) + } catch (throwable: Throwable) { + reportInternalError( + "CascadeEditorController callback $label failed: ${throwable.message ?: throwable.toString()}" + ) + } + } + + internal fun reportInternalError(message: String): Unit { + // Callbacks are contractually delivered on the main thread. When a misuse is + // detected off the main thread (the onMainThread guard), marshal the report + // onto the main queue so a Swift onInternalError handler can safely touch UI. + if (NSThread.isMainThread) { + deliverInternalError(message) + } else { + dispatch_async(dispatch_get_main_queue()) { + deliverInternalError(message) + } + } + } + + private fun deliverInternalError(message: String) { + try { + onInternalError?.invoke(message) + } catch (_: Throwable) { + // Host error-reporting callbacks must never escape into Swift/Obj-C. + } + } + + private fun failedLoadResult(message: String): CascadeDocumentLoadResult { + return CascadeDocumentLoadResult(success = false, warningMessages = listOf(message)) + } + + private fun DocumentDecodeWarning.message(): String = when (this) { + is DocumentDecodeWarning.DocumentParseFailed -> "Document parse failed: $reason" + is DocumentDecodeWarning.DuplicateIdRegenerated -> + "Duplicate block id '$originalId' at block $blockIndex was replaced with '$newId'." + + is DocumentDecodeWarning.MissingIdRegenerated -> { + "Missing block id at block $blockIndex was replaced." + } + + is DocumentDecodeWarning.InvalidBlockAttributeParam -> + "Invalid block attribute at block $blockIndex: $param; using $fallback." + + is DocumentDecodeWarning.InvalidBlockTypeParam -> + "Invalid '$param' for block type '$typeId' at block $blockIndex; using $fallback." + + is DocumentDecodeWarning.MalformedBlockSkipped -> + "Malformed block at index $blockIndex was skipped: $reason." + + is DocumentDecodeWarning.UnknownBlockTypePreserved -> + "Unknown block type '$typeId' at block $blockIndex was preserved." + + is DocumentDecodeWarning.UnknownContentKind -> + "Unknown content kind '$kind' at block $blockIndex was preserved as custom content." + + is DocumentDecodeWarning.UnsupportedCustomDataDropped -> + "Unsupported custom value '$key' at block $blockIndex was dropped: $valueType." + } + + private fun HtmlDecodeWarning.message(): String = when (this) { + is HtmlDecodeWarning.BlockInInlineContext -> + "HTML block tag '$tag' at offset $charOffset was flattened in inline content." + + is HtmlDecodeWarning.DecoderException -> + "HTML decoder failed for '${tag ?: "unknown"}' at offset $charOffset: $message." + + is HtmlDecodeWarning.DroppedAttribute -> + "HTML attribute '$attr' on '$tag' at offset $charOffset was dropped: $reason." + + is HtmlDecodeWarning.DroppedContent -> + "HTML content at offset $charOffset was dropped: $reason." + + is HtmlDecodeWarning.InputLimitExceeded -> + "HTML input exceeded limit $limit with $actual characters." + + is HtmlDecodeWarning.InvalidAttribute -> + "HTML attribute '$attr' on '$tag' at offset $charOffset was invalid: $reason." + + is HtmlDecodeWarning.MismatchedNesting -> + "HTML nesting at offset $charOffset expected '$expected' but found '$found'." + + is HtmlDecodeWarning.StrayClosingTag -> + "HTML closing tag '$tag' at offset $charOffset had no matching open tag." + + is HtmlDecodeWarning.UnclosedTag -> + "HTML tag '$tag' at offset $charOffset was not closed." + + is HtmlDecodeWarning.UnknownAttribute -> + "HTML attribute '$attr' on '$tag' at offset $charOffset was ignored." + + is HtmlDecodeWarning.UnknownTag -> + "HTML tag '$tag' at offset $charOffset was ignored." + } +} + +internal fun List.isSuccessfulHtmlLoad(): Boolean { + return none { warning -> + warning is HtmlDecodeWarning.InputLimitExceeded || + warning is HtmlDecodeWarning.DecoderException + } +} + +private fun CascadeCustomBlockSlashBehavior.toBuiltInBehavior(): BuiltInBlockSlashBehavior = when (this) { + CascadeCustomBlockSlashBehavior.insert -> BuiltInBlockSlashBehavior.AlwaysInsert + CascadeCustomBlockSlashBehavior.convertInPlace -> BuiltInBlockSlashBehavior.ConvertInPlace +} diff --git a/editor-ios-sdk/src/iosMain/kotlin/io/github/linreal/cascade/ios/controller/CascadeEditorViewController.kt b/editor-ios-sdk/src/iosMain/kotlin/io/github/linreal/cascade/ios/controller/CascadeEditorViewController.kt new file mode 100644 index 0000000..a70fbe9 --- /dev/null +++ b/editor-ios-sdk/src/iosMain/kotlin/io/github/linreal/cascade/ios/controller/CascadeEditorViewController.kt @@ -0,0 +1,202 @@ +package io.github.linreal.cascade.ios.controller + +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.runtime.DisposableEffect +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.SideEffect +import androidx.compose.runtime.getValue +import androidx.compose.runtime.remember +import androidx.compose.runtime.snapshotFlow +import androidx.compose.ui.ExperimentalComposeUiApi +import androidx.compose.ui.Modifier +import androidx.compose.ui.window.ComposeUIViewController +import io.github.linreal.cascade.editor.core.SpanStyle +import io.github.linreal.cascade.editor.ui.CascadeEditor +import io.github.linreal.cascade.editor.ui.CascadeEditorConfig +import io.github.linreal.cascade.editor.ui.LinkPopupSlot +import io.github.linreal.cascade.editor.ui.SlashCommandSlot +import io.github.linreal.cascade.editor.ui.ToolbarSlot +import io.github.linreal.cascade.editor.ui.rememberCascadeEditorToolbarController +import io.github.linreal.cascade.ios.toolbar.CascadeToolbarState +import io.github.linreal.cascade.ios.toolbar.toCascadeStyleState +import platform.UIKit.UIViewController + +private val IosToolbarHighlightStyle: SpanStyle = SpanStyle.Highlight(0xFFFFEB3BL) + +private val IosToolbarTrackedStyles: List = listOf( + SpanStyle.Bold, + SpanStyle.Italic, + SpanStyle.Underline, + SpanStyle.StrikeThrough, + SpanStyle.InlineCode, + IosToolbarHighlightStyle, +) + +internal fun CascadeToolbarMode.toEditorLinkPopupSlot(): LinkPopupSlot = when (this) { + CascadeToolbarMode.builtIn -> LinkPopupSlot.Default + CascadeToolbarMode.none -> LinkPopupSlot.None +} + +@OptIn(ExperimentalComposeUiApi::class) +public fun CascadeEditorController.makeViewController(): UIViewController = onMainThread( + fallback = { UIViewController() }, +) { + // CascadeEditor paints no canvas background, so the Compose host must be + // non-opaque for the native screen background to show through it. + ComposeUIViewController(configure = { opaque = false }) { + val configurationState by configurationSnapshot + val editorConfig = remember(configurationState) { + CascadeEditorConfig( + readOnly = configurationState.readOnly, + blockSelectionEnabled = configurationState.blockSelectionEnabled, + blockDraggingEnabled = configurationState.blockDraggingEnabled, + crashPolicy = configurationState.crashPolicy.toCoreCrashPolicy(), + onInternalError = { error -> + reportInternalError( + "CascadeEditor ${error.context} failed: " + + (error.cause.message ?: error.cause.toString()) + ) + }, + ) + } + val theme = remember(configurationState.isDark) { + configurationState.resolveEditorTheme() + } + val strings by resolvedStrings + val blockStrings by resolvedBlockStrings + val toolbarController = rememberCascadeEditorToolbarController( + stateHolder = stateHolder, + textStates = textStates, + spanStates = spanStates, + trackedStyles = IosToolbarTrackedStyles, + config = editorConfig, + ) + + // Ownership token for this composition. All bridge-state publishes and the + // dispose-time teardown are guarded on it, so when two hosts briefly overlap + // (a second makeViewController() mounting before the first disposes) the + // stale host can neither clobber live toolbar state nor un-mount the + // controller out from under the visible editor. + val mountToken = remember { Any() } + + DisposableEffect(Unit) { + mountOwner = mountToken + onDispose { + if (mountOwner === mountToken) { + mountOwner = null + mounted = false + toolbarActions = null + updateToolbarStateFromHost(CascadeToolbarState.Empty) + } + } + } + + SideEffect { + if (mountOwner !== mountToken) return@SideEffect + toolbarActions = CascadeToolbarActions( + toggleBold = { toolbarController.formattingActions.toggleStyle(SpanStyle.Bold) }, + toggleItalic = { toolbarController.formattingActions.toggleStyle(SpanStyle.Italic) }, + toggleUnderline = { toolbarController.formattingActions.toggleStyle(SpanStyle.Underline) }, + toggleStrikeThrough = { + toolbarController.formattingActions.toggleStyle(SpanStyle.StrikeThrough) + }, + toggleInlineCode = { + toolbarController.formattingActions.toggleStyle(SpanStyle.InlineCode) + }, + toggleHighlight = { argb -> + toolbarController.formattingActions.toggleStyle(SpanStyle.Highlight(argb)) + }, + indentForward = { toolbarController.indentationActions.indentForward() }, + indentBackward = { toolbarController.indentationActions.indentBackward() }, + applyLink = { url, title -> + toolbarController.linkActions.applyLinkAtCurrentTarget(url, title) + }, + removeLink = { toolbarController.linkActions.removeLinkAtCurrentTarget() }, + ) + } + + LaunchedEffect(toolbarController) { + snapshotFlow { + val formatting = toolbarController.formattingState.value + val indentation = toolbarController.indentationState.value + val link = toolbarController.linkState.value + + CascadeToolbarState( + focused = formatting.focusedBlockId != null, + canFormat = formatting.canFormat, + bold = formatting.styleStatusOf(SpanStyle.Bold).toCascadeStyleState(), + italic = formatting.styleStatusOf(SpanStyle.Italic).toCascadeStyleState(), + underline = formatting.styleStatusOf(SpanStyle.Underline).toCascadeStyleState(), + strikeThrough = formatting.styleStatusOf(SpanStyle.StrikeThrough).toCascadeStyleState(), + inlineCode = formatting.styleStatusOf(SpanStyle.InlineCode).toCascadeStyleState(), + highlight = formatting.styleStatusOf(IosToolbarHighlightStyle).toCascadeStyleState(), + canIndentForward = indentation.canIndentForward, + canIndentBackward = indentation.canIndentBackward, + canLink = link.canLink, + existingUrl = link.existingUrl, + ) + }.collect { toolbarState -> + if (mountOwner === mountToken) { + updateToolbarStateFromHost(toolbarState) + } + } + } + + LaunchedEffect(Unit) { + var previousState = stateHolder.state + var previousDocumentBlocks = currentDocumentBlocks() + // The controller only counts as mounted once this observer holds its + // baseline. A public mutation landing between first composition and + // this coroutine's start is therefore still delivered through the + // direct (unmounted) notification path, and the baseline captured + // here already includes it — no change signal is lost in the window. + if (mountOwner === mountToken) { + mounted = true + } + snapshotFlow { + stateHolder.state to currentDocumentBlocks() + }.collect { (state, documentBlocks) -> + val documentChanged = documentBlocks != previousDocumentBlocks + if (state != previousState || documentChanged) { + previousState = state + if (mountOwner === mountToken) { + notifyStateChangedFromHost() + } + } + if (documentChanged) { + previousDocumentBlocks = documentBlocks + if (mountOwner === mountToken) { + notifyDocumentChangedFromHost() + } + } + } + } + + CascadeEditor( + stateHolder = stateHolder, + textStates = textStates, + spanStates = spanStates, + registry = registry, + slashRegistry = slashRegistry, + slashCommand = if (configurationState.slashCommandsEnabled) { + SlashCommandSlot.Default + } else { + SlashCommandSlot.None + }, + theme = theme, + strings = strings, + blockStrings = blockStrings, + modifier = Modifier.fillMaxSize(), + toolbar = if (configurationState.toolbarMode == CascadeToolbarMode.builtIn) { + ToolbarSlot.Default() + } else { + ToolbarSlot.None + }, + linkPopup = configurationState.toolbarMode.toEditorLinkPopupSlot(), + onOpenLink = { url -> + invokeCallback("onOpenLink", onOpenLink, url) + }, + config = editorConfig, + ) + } +} diff --git a/editor-ios-sdk/src/iosMain/kotlin/io/github/linreal/cascade/ios/controller/CascadeLoadResult.kt b/editor-ios-sdk/src/iosMain/kotlin/io/github/linreal/cascade/ios/controller/CascadeLoadResult.kt new file mode 100644 index 0000000..40eea89 --- /dev/null +++ b/editor-ios-sdk/src/iosMain/kotlin/io/github/linreal/cascade/ios/controller/CascadeLoadResult.kt @@ -0,0 +1,14 @@ +@file:OptIn(ExperimentalObjCName::class) + +package io.github.linreal.cascade.ios.controller + +import kotlin.experimental.ExperimentalObjCName +import kotlin.native.ObjCName + +@ObjCName("CascadeDocumentLoadResult", exact = true) +public data class CascadeDocumentLoadResult( + public val success: Boolean, + public val warningMessages: List, +) + +public typealias CascadeHtmlLoadResult = CascadeDocumentLoadResult diff --git a/editor-ios-sdk/src/iosMain/kotlin/io/github/linreal/cascade/ios/localization/CascadeEditorStringsBridge.kt b/editor-ios-sdk/src/iosMain/kotlin/io/github/linreal/cascade/ios/localization/CascadeEditorStringsBridge.kt new file mode 100644 index 0000000..aac3bdd --- /dev/null +++ b/editor-ios-sdk/src/iosMain/kotlin/io/github/linreal/cascade/ios/localization/CascadeEditorStringsBridge.kt @@ -0,0 +1,170 @@ +@file:OptIn(ExperimentalObjCName::class) + +package io.github.linreal.cascade.ios.localization + +import io.github.linreal.cascade.editor.theme.BlockLocalizedStrings +import io.github.linreal.cascade.editor.theme.CascadeEditorBlockStrings +import io.github.linreal.cascade.editor.theme.CascadeEditorStrings +import kotlin.experimental.ExperimentalObjCName +import kotlin.native.ObjCName + +/** + * Localized overrides for the editor's built-in UI chrome strings. + * + * Every field defaults to `null`, which keeps the editor's built-in English + * value — supply only the strings the app localizes. The type is a mutable bag + * (rather than a value with default arguments) because Objective-C initializers + * cannot omit arguments; configure the fields and pass the bag to + * [CascadeEditorLocalization]. + */ +@ObjCName("CascadeLocalizedStrings", exact = true) +public class CascadeLocalizedStrings public constructor() { + /** Slash popup submenu back button label. */ + public var back: String? = null + + /** Message for unknown/unsupported blocks; receives the block's type id. */ + public var unsupportedBlock: ((typeId: String) -> String)? = null + + /** Toolbar accessibility label for the Bold button. */ + public var bold: String? = null + + /** Toolbar accessibility label for the Italic button. */ + public var italic: String? = null + + /** Toolbar accessibility label for the Underline button. */ + public var underline: String? = null + + /** Toolbar accessibility label for the Strikethrough button. */ + public var strikethrough: String? = null + + /** Toolbar accessibility label for the Inline Code button. */ + public var inlineCode: String? = null + + /** Toolbar accessibility label for the Highlight button. */ + public var highlight: String? = null + + /** Toolbar accessibility label for the Slash Command button. */ + public var slashCommand: String? = null + + /** Toolbar accessibility label for the Hide Keyboard button. */ + public var hideKeyboard: String? = null + + /** Toolbar accessibility label for the Indent Forward button. */ + public var indentForward: String? = null + + /** Toolbar accessibility label for the Indent Backward button. */ + public var indentBackward: String? = null + + /** Toolbar accessibility label for the Link button. */ + public var link: String? = null + + /** Label for applying a link from the link popup. */ + public var linkApply: String? = null + + /** Label for canceling the link popup. */ + public var linkCancel: String? = null + + /** Label for removing a link from the link popup. */ + public var linkRemove: String? = null + + /** Label for the link title field in the link popup. */ + public var linkTitle: String? = null + + /** Label for the link URL field in the link popup. */ + public var linkUrl: String? = null + + /** Validation message shown when the link URL field is left blank. */ + public var linkValidationBlankUrl: String? = null +} + +/** + * Localized display strings for one block type, keyed by [typeId]. + * + * Applies to built-in block types and to natively registered custom blocks + * alike; the values surface in the slash-command menu (name, description, and + * additional search keywords — keywords are additive to the English ones, so + * English search keeps working in any locale). + */ +@ObjCName("CascadeLocalizedBlockStrings", exact = true) +public class CascadeLocalizedBlockStrings public constructor( + public val typeId: String, + public val displayName: String, + public val description: String, + public val keywords: List, +) { + public constructor( + typeId: String, + displayName: String, + description: String, + ) : this(typeId, displayName, description, keywords = emptyList()) +} + +/** + * The localization payload a Swift app supplies to + * `CascadeEditorController.setLocalization`. + * + * Values are snapshotted when applied: mutating a [CascadeLocalizedStrings] bag + * after passing it here has no effect until `setLocalization` is called again. + */ +@ObjCName("CascadeEditorLocalization", exact = true) +public class CascadeEditorLocalization public constructor( + public val strings: CascadeLocalizedStrings?, + public val blockStrings: List, +) { + public constructor() : this(strings = null, blockStrings = emptyList()) + + public constructor(strings: CascadeLocalizedStrings?) : this(strings, blockStrings = emptyList()) + + public constructor(blockStrings: List) : this(strings = null, blockStrings) +} + +/** + * Resolves the curated overrides onto the editor's string set. Unset fields keep + * the built-in English defaults, so the result is always complete. + */ +internal fun CascadeEditorLocalization.toEditorStrings(): CascadeEditorStrings { + val defaults = CascadeEditorStrings.default() + val overrides = strings ?: return defaults + return CascadeEditorStrings( + back = overrides.back ?: defaults.back, + unsupportedBlock = overrides.unsupportedBlock ?: defaults.unsupportedBlock, + bold = overrides.bold ?: defaults.bold, + italic = overrides.italic ?: defaults.italic, + underline = overrides.underline ?: defaults.underline, + strikethrough = overrides.strikethrough ?: defaults.strikethrough, + inlineCode = overrides.inlineCode ?: defaults.inlineCode, + highlight = overrides.highlight ?: defaults.highlight, + slashCommand = overrides.slashCommand ?: defaults.slashCommand, + hideKeyboard = overrides.hideKeyboard ?: defaults.hideKeyboard, + indentForward = overrides.indentForward ?: defaults.indentForward, + indentBackward = overrides.indentBackward ?: defaults.indentBackward, + link = overrides.link ?: defaults.link, + linkApply = overrides.linkApply ?: defaults.linkApply, + linkCancel = overrides.linkCancel ?: defaults.linkCancel, + linkRemove = overrides.linkRemove ?: defaults.linkRemove, + linkTitle = overrides.linkTitle ?: defaults.linkTitle, + linkUrl = overrides.linkUrl ?: defaults.linkUrl, + linkValidationError = overrides.linkValidationBlankUrl?.let { message -> + { _ -> message } + } ?: defaults.linkValidationError, + ) +} + +/** + * Merges the localized block entries over the editor's default English set. + * Entries for type ids the editor does not know yet (e.g. custom blocks) are + * carried through so their slash items localize too. + */ +internal fun CascadeEditorLocalization.toEditorBlockStrings(): CascadeEditorBlockStrings { + val defaults = CascadeEditorBlockStrings.default() + if (blockStrings.isEmpty()) return defaults + val merged = defaults.blocks.toMutableMap() + for (entry in blockStrings) { + merged[entry.typeId] = BlockLocalizedStrings( + displayName = entry.displayName, + description = entry.description, + keywords = entry.keywords, + ) + } + return CascadeEditorBlockStrings(merged) +} diff --git a/editor-ios-sdk/src/iosMain/kotlin/io/github/linreal/cascade/ios/model/CascadeDocumentBuilder.kt b/editor-ios-sdk/src/iosMain/kotlin/io/github/linreal/cascade/ios/model/CascadeDocumentBuilder.kt new file mode 100644 index 0000000..f2aef1a --- /dev/null +++ b/editor-ios-sdk/src/iosMain/kotlin/io/github/linreal/cascade/ios/model/CascadeDocumentBuilder.kt @@ -0,0 +1,94 @@ +@file:OptIn(ExperimentalObjCName::class) + +package io.github.linreal.cascade.ios.model + +import io.github.linreal.cascade.editor.core.Block +import io.github.linreal.cascade.editor.core.BlockContent +import io.github.linreal.cascade.editor.core.BlockId +import io.github.linreal.cascade.editor.core.BlockType +import io.github.linreal.cascade.editor.core.CustomBlockType +import io.github.linreal.cascade.editor.serialization.DocumentSchema +import kotlin.experimental.ExperimentalObjCName +import kotlin.native.ObjCName + +@ObjCName("CascadeEditorDocumentBuilder", exact = true) +public class CascadeEditorDocumentBuilder { + private val blocks: MutableList = mutableListOf() + + public var lastErrorMessage: String? = null + private set + + public fun clearLastError(): CascadeEditorDocumentBuilder = apply { + lastErrorMessage = null + } + + public fun paragraph(text: String): CascadeEditorDocumentBuilder = apply { + blocks += Block.paragraph(text) + } + + public fun heading(level: Int, text: String): CascadeEditorDocumentBuilder = apply { + val safeLevel = level.coerceIn(1, 6) + if (safeLevel != level) { + lastErrorMessage = "Heading level must be between 1 and 6" + } + blocks += Block.heading(safeLevel, text) + } + + public fun todo(text: String, checked: Boolean): CascadeEditorDocumentBuilder = apply { + blocks += Block.todo(text, checked) + } + + public fun bulletList(text: String): CascadeEditorDocumentBuilder = apply { + blocks += Block.bulletList(text) + } + + public fun numberedList(text: String, number: Int): CascadeEditorDocumentBuilder = apply { + val safeNumber = number.coerceAtLeast(1) + if (safeNumber != number) { + lastErrorMessage = "Numbered list number must be >= 1" + } + blocks += Block.numberedList(text, safeNumber) + } + + public fun quote(text: String): CascadeEditorDocumentBuilder = apply { + blocks += Block( + id = BlockId.generate(), + type = BlockType.Quote, + content = BlockContent.Text(text), + ) + } + + public fun code(text: String): CascadeEditorDocumentBuilder = apply { + blocks += Block( + id = BlockId.generate(), + type = BlockType.Code, + content = BlockContent.Text(text), + ) + } + + public fun divider(): CascadeEditorDocumentBuilder = apply { + blocks += Block.divider() + } + + public fun customBlock(typeId: String, payloadJson: String): CascadeEditorDocumentBuilder = apply { + val payload = parseJsonObjectPayloadSafely(payloadJson) + if (payload.errorMessage != null) { + lastErrorMessage = payload.errorMessage + } + blocks += Block( + id = BlockId.generate(), + type = NativeDocumentBlockType(typeId), + content = BlockContent.Custom(typeId, payload.data), + ) + } + + public fun buildJson(): String = DocumentSchema.encodeToString(blocks) +} + +internal data class NativeDocumentBlockType( + override val typeId: String, +) : CustomBlockType { + override val displayName: String = typeId + override val supportsText: Boolean = false + override val isConvertible: Boolean = false +} diff --git a/editor-ios-sdk/src/iosMain/kotlin/io/github/linreal/cascade/ios/model/CascadeJson.kt b/editor-ios-sdk/src/iosMain/kotlin/io/github/linreal/cascade/ios/model/CascadeJson.kt new file mode 100644 index 0000000..dcc3c38 --- /dev/null +++ b/editor-ios-sdk/src/iosMain/kotlin/io/github/linreal/cascade/ios/model/CascadeJson.kt @@ -0,0 +1,90 @@ +package io.github.linreal.cascade.ios.model + +import kotlinx.serialization.json.Json +import kotlinx.serialization.json.JsonArray +import kotlinx.serialization.json.JsonElement +import kotlinx.serialization.json.JsonNull +import kotlinx.serialization.json.JsonObject +import kotlinx.serialization.json.JsonPrimitive +import kotlinx.serialization.json.booleanOrNull +import kotlinx.serialization.json.buildJsonArray +import kotlinx.serialization.json.buildJsonObject +import kotlinx.serialization.json.doubleOrNull +import kotlinx.serialization.json.longOrNull + +internal fun parseJsonObjectPayload(payloadJson: String): Map { + val element = Json.parseToJsonElement(payloadJson) + require(element is JsonObject) { "Custom block payload must be a JSON object" } + return element.toCascadeMap() +} + +internal data class CascadePayloadParseResult( + val data: Map, + val errorMessage: String?, +) + +internal fun parseJsonObjectPayloadSafely(payloadJson: String): CascadePayloadParseResult = try { + val element = Json.parseToJsonElement(payloadJson) + if (element is JsonObject) { + CascadePayloadParseResult(data = element.toCascadeMap(), errorMessage = null) + } else { + CascadePayloadParseResult( + data = emptyMap(), + errorMessage = "Custom block payload must be a JSON object", + ) + } +} catch (exception: Exception) { + val reason = exception.message + ?.lineSequence() + ?.firstOrNull() + ?.takeIf { it.isNotBlank() } + ?: "parse failed" + CascadePayloadParseResult( + data = emptyMap(), + errorMessage = "Invalid custom block payload JSON: $reason", + ) +} + +internal fun JsonObject.toCascadeMap(): Map = + entries.associate { (key, value) -> key to value.toCascadeValue() } + +private fun JsonElement.toCascadeValue(): Any? = when (this) { + JsonNull -> null + is JsonObject -> toCascadeMap() + is JsonArray -> map { it.toCascadeValue() } + is JsonPrimitive -> when { + isString -> content + booleanOrNull != null -> booleanOrNull + longOrNull != null -> longOrNull + doubleOrNull != null -> doubleOrNull?.takeIf { it.isFinite() } ?: content + else -> content + } +} + +/** Serializes a coerced payload map back to a JSON object string. */ +internal fun Map.toCascadeJsonString(): String = toCascadeJsonObject().toString() + +private fun Map.toCascadeJsonObject(): JsonObject = buildJsonObject { + for ((key, value) in this@toCascadeJsonObject) { + put(key, value.toCascadeJsonElement()) + } +} + +private fun Any?.toCascadeJsonElement(): JsonElement = when (this) { + null -> JsonNull + is String -> JsonPrimitive(this) + is Boolean -> JsonPrimitive(this) + is Int -> JsonPrimitive(this) + is Long -> JsonPrimitive(this) + is Float -> JsonPrimitive(this) + is Double -> JsonPrimitive(this.takeIf { it.isFinite() }) + is List<*> -> buildJsonArray { + for (item in this@toCascadeJsonElement) add(item.toCascadeJsonElement()) + } + is Map<*, *> -> buildJsonObject { + for ((key, value) in this@toCascadeJsonElement) { + if (key is String) put(key, value.toCascadeJsonElement()) + } + } + else -> JsonPrimitive(toString()) +} diff --git a/editor-ios-sdk/src/iosMain/kotlin/io/github/linreal/cascade/ios/model/CascadeRichTextSnapshot.kt b/editor-ios-sdk/src/iosMain/kotlin/io/github/linreal/cascade/ios/model/CascadeRichTextSnapshot.kt new file mode 100644 index 0000000..d82c958 --- /dev/null +++ b/editor-ios-sdk/src/iosMain/kotlin/io/github/linreal/cascade/ios/model/CascadeRichTextSnapshot.kt @@ -0,0 +1,41 @@ +@file:OptIn(ExperimentalObjCName::class) + +package io.github.linreal.cascade.ios.model + +import kotlin.experimental.ExperimentalObjCName +import kotlin.native.ObjCName + +@ObjCName("CascadeSpanKind", exact = true) +public enum class CascadeSpanKind { + bold, + italic, + underline, + @ObjCName(name = "strikeThrough", swiftName = "strikeThrough") + strikeThrough, + @ObjCName(name = "inlineCode", swiftName = "inlineCode") + inlineCode, + highlight, + link, +} + +@ObjCName("CascadeRichTextSpan", exact = true) +public data class CascadeRichTextSpan( + public val start: Int, + public val end: Int, + public val kind: CascadeSpanKind, + public val argb: Long = 0L, + public val url: String? = null, +) + +@ObjCName("CascadeRichTextBlock", exact = true) +public data class CascadeRichTextBlock( + public val blockId: String, + public val typeId: String, + public val text: String, + public val spans: List, +) + +@ObjCName("CascadeRichTextSnapshot", exact = true) +public data class CascadeRichTextSnapshot( + public val blocks: List, +) diff --git a/editor-ios-sdk/src/iosMain/kotlin/io/github/linreal/cascade/ios/slash/CascadeSlashCommand.kt b/editor-ios-sdk/src/iosMain/kotlin/io/github/linreal/cascade/ios/slash/CascadeSlashCommand.kt new file mode 100644 index 0000000..fcf586d --- /dev/null +++ b/editor-ios-sdk/src/iosMain/kotlin/io/github/linreal/cascade/ios/slash/CascadeSlashCommand.kt @@ -0,0 +1,64 @@ +@file:OptIn(ExperimentalObjCName::class) + +package io.github.linreal.cascade.ios.slash + +import kotlin.experimental.ExperimentalObjCName +import kotlin.native.ObjCName + +/** + * Outcome a native slash-command handler returns. + * + * Construct one of the three shared cases: [done], [keepOpen], or [failure]. + * From Swift these are reached through the companion, e.g. `.companion.done` or + * `.companion.failure(message: "…")`. + */ +@ObjCName("CascadeSlashCommandResult", exact = true) +public class CascadeSlashCommandResult private constructor( + internal val kind: Kind, + internal val failureMessage: String?, +) { + internal enum class Kind { Done, KeepOpen, Failure } + + public companion object { + /** The command finished; the slash menu should close. */ + public val done: CascadeSlashCommandResult = CascadeSlashCommandResult(Kind.Done, null) + + /** The command finished but the slash menu should stay open. */ + public val keepOpen: CascadeSlashCommandResult = CascadeSlashCommandResult(Kind.KeepOpen, null) + + /** + * The command failed; the slash menu closes and [message], when present, is + * reported through + * [CascadeEditorController.onInternalError][io.github.linreal.cascade.ios.controller.CascadeEditorController.onInternalError]. + */ + public fun failure(message: String? = null): CascadeSlashCommandResult = + CascadeSlashCommandResult(Kind.Failure, message) + } +} + +/** + * Swift-facing description of a native slash command. + * + * A command is turned into a slash-menu action whose synchronous [handler] runs + * when the user selects it. The handler receives a [CascadeSlashCommandContext] + * scoped to the block that owns the `/` trigger and returns a + * [CascadeSlashCommandResult]. + * + * @property id Unique id. Registering an id that already exists (a prior native + * command or a built-in) overrides it — see + * [CascadeEditorController.registerSlashCommand][io.github.linreal.cascade.ios.controller.CascadeEditorController.registerSlashCommand]. + * @property title Human-readable name shown in the slash menu. + * @property description Short description shown in the slash menu. + * @property keywords Extra search terms for the slash menu. + * @property handler Synchronous work performed when the command is chosen. It owns + * the query text (the `/…` token is left in place for it to edit or remove via + * [CascadeSlashCommandContext.replaceQueryText]). + */ +@ObjCName("CascadeSlashCommand", exact = true) +public class CascadeSlashCommand public constructor( + public val id: String, + public val title: String, + public val description: String, + public val keywords: List = emptyList(), + public val handler: (CascadeSlashCommandContext) -> CascadeSlashCommandResult, +) diff --git a/editor-ios-sdk/src/iosMain/kotlin/io/github/linreal/cascade/ios/slash/CascadeSlashCommandContext.kt b/editor-ios-sdk/src/iosMain/kotlin/io/github/linreal/cascade/ios/slash/CascadeSlashCommandContext.kt new file mode 100644 index 0000000..3689c5e --- /dev/null +++ b/editor-ios-sdk/src/iosMain/kotlin/io/github/linreal/cascade/ios/slash/CascadeSlashCommandContext.kt @@ -0,0 +1,90 @@ +@file:OptIn(ExperimentalObjCName::class) + +package io.github.linreal.cascade.ios.slash + +import io.github.linreal.cascade.editor.core.Block +import io.github.linreal.cascade.editor.core.BlockId +import io.github.linreal.cascade.editor.slash.SlashCommandEditor +import io.github.linreal.cascade.ios.block.CascadeBlockBuildOutcome +import kotlin.experimental.ExperimentalObjCName +import kotlin.native.ObjCName + +/** + * Curated editor handle handed to a native slash-command handler during execution. + * + * It is a thin wrapper over the editor's slash execution surface, scoped to the + * anchor block that owns the `/` trigger. It is valid only for the duration of the + * handler call; do not retain it. + */ +@ObjCName("CascadeSlashCommandContext", exact = true) +public class CascadeSlashCommandContext internal constructor( + private val editor: SlashCommandEditor, + private val anchorBlockId: BlockId, + private val buildBlock: (typeId: String, payloadJson: String) -> CascadeBlockBuildOutcome, + private val reportError: (String) -> Unit, +) { + + /** + * Replaces the `/…` query token in the anchor block with [replacement]. + * Passing an empty string removes the token. + */ + public fun replaceQueryText(replacement: String) { + editor.replaceQueryText(replacement) + } + + /** + * Replaces the entire visible text of the anchor block. + * + * @param cursorPosition Target cursor offset in the new text. A negative value + * places the cursor at the end. + */ + public fun updateAnchorText(text: String, cursorPosition: Int) { + editor.updateAnchorText(text, cursorPosition.takeIf { it >= 0 }) + } + + /** + * Inserts a block of [typeId] carrying [payloadJson] immediately after the anchor. + * + * Returns `false` (and reports the reason through the controller's + * `onInternalError`) when [payloadJson] is not a valid JSON object or [typeId] + * is neither a built-in nor a registered native type; the document is not mutated. + */ + public fun insertBlockAfterAnchor(typeId: String, payloadJson: String): Boolean = + insert(typeId, payloadJson) { block -> editor.insertBlockAfterAnchor(block) } + + /** + * Inserts a block of [typeId] carrying [payloadJson] immediately before the anchor, + * leaving focus on the anchor. Same rejection semantics as [insertBlockAfterAnchor]. + */ + public fun insertBlockBeforeAnchor(typeId: String, payloadJson: String): Boolean = + insert(typeId, payloadJson) { block -> editor.insertBlockBeforeAnchor(block) } + + /** Moves editor focus to the anchor block. */ + public fun focusAnchor() { + editor.focusBlock(anchorBlockId) + } + + /** Closes the slash menu. */ + public fun closeMenu() { + editor.closeMenu() + } + + private inline fun insert( + typeId: String, + payloadJson: String, + place: (Block) -> Unit, + ): Boolean = when (val outcome = buildBlock(typeId, payloadJson)) { + is CascadeBlockBuildOutcome.Success -> { + place(outcome.block) + true + } + is CascadeBlockBuildOutcome.InvalidPayload -> { + reportError(outcome.message) + false + } + is CascadeBlockBuildOutcome.UnknownType -> { + reportError(outcome.message) + false + } + } +} diff --git a/editor-ios-sdk/src/iosMain/kotlin/io/github/linreal/cascade/ios/toolbar/CascadeToolbarState.kt b/editor-ios-sdk/src/iosMain/kotlin/io/github/linreal/cascade/ios/toolbar/CascadeToolbarState.kt new file mode 100644 index 0000000..6e5853a --- /dev/null +++ b/editor-ios-sdk/src/iosMain/kotlin/io/github/linreal/cascade/ios/toolbar/CascadeToolbarState.kt @@ -0,0 +1,53 @@ +@file:OptIn(ExperimentalObjCName::class) + +package io.github.linreal.cascade.ios.toolbar + +import io.github.linreal.cascade.editor.richtext.StyleStatus +import kotlin.experimental.ExperimentalObjCName +import kotlin.native.ObjCName + +@ObjCName("CascadeStyleState", exact = true) +public enum class CascadeStyleState { + active, + mixed, + inactive, +} + +@ObjCName("CascadeToolbarState", exact = true) +public data class CascadeToolbarState( + public val focused: Boolean, + public val canFormat: Boolean, + public val bold: CascadeStyleState, + public val italic: CascadeStyleState, + public val underline: CascadeStyleState, + public val strikeThrough: CascadeStyleState, + public val inlineCode: CascadeStyleState, + public val highlight: CascadeStyleState, + public val canIndentForward: Boolean, + public val canIndentBackward: Boolean, + public val canLink: Boolean, + public val existingUrl: String?, +) { + public companion object { + public val Empty: CascadeToolbarState = CascadeToolbarState( + focused = false, + canFormat = false, + bold = CascadeStyleState.inactive, + italic = CascadeStyleState.inactive, + underline = CascadeStyleState.inactive, + strikeThrough = CascadeStyleState.inactive, + inlineCode = CascadeStyleState.inactive, + highlight = CascadeStyleState.inactive, + canIndentForward = false, + canIndentBackward = false, + canLink = false, + existingUrl = null, + ) + } +} + +internal fun StyleStatus.toCascadeStyleState(): CascadeStyleState = when (this) { + StyleStatus.FullyActive -> CascadeStyleState.active + StyleStatus.Partial -> CascadeStyleState.mixed + StyleStatus.Absent -> CascadeStyleState.inactive +} diff --git a/editor-ios-sdk/src/iosSimulatorArm64Test/kotlin/io/github/linreal/cascade/ios/block/NativeCustomBlockTest.kt b/editor-ios-sdk/src/iosSimulatorArm64Test/kotlin/io/github/linreal/cascade/ios/block/NativeCustomBlockTest.kt new file mode 100644 index 0000000..f7bad33 --- /dev/null +++ b/editor-ios-sdk/src/iosSimulatorArm64Test/kotlin/io/github/linreal/cascade/ios/block/NativeCustomBlockTest.kt @@ -0,0 +1,378 @@ +package io.github.linreal.cascade.ios.block + +import io.github.linreal.cascade.editor.action.DeleteBlock +import io.github.linreal.cascade.editor.action.FocusBlock +import io.github.linreal.cascade.editor.action.InsertBlockAfter +import io.github.linreal.cascade.editor.action.InsertBlockBefore +import io.github.linreal.cascade.editor.action.ReplaceBlock +import io.github.linreal.cascade.editor.core.Block +import io.github.linreal.cascade.editor.core.BlockContent +import io.github.linreal.cascade.editor.core.BlockId +import io.github.linreal.cascade.editor.core.UnknownBlockType +import io.github.linreal.cascade.editor.registry.BlockRenderScope +import io.github.linreal.cascade.editor.state.BlockSpanStates +import io.github.linreal.cascade.editor.state.BlockTextStates +import io.github.linreal.cascade.editor.state.EditorState +import io.github.linreal.cascade.editor.state.EditorStateHolder +import io.github.linreal.cascade.editor.ui.CascadeEditorConfig +import io.github.linreal.cascade.ios.controller.CascadeEditorController +import io.github.linreal.cascade.ios.model.CascadeEditorDocumentBuilder +import platform.UIKit.UIViewController +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertFalse +import kotlin.test.assertIs +import kotlin.test.assertNotNull +import kotlin.test.assertSame +import kotlin.test.assertTrue + +class NativeCustomBlockTest { + + @Test + fun registeredCustomBlockDecodesToNativeTypeAndRoundTripsPayload() { + val controller = CascadeEditorController() + controller.registerBlock(tableRegistration()) + + val json = CascadeEditorDocumentBuilder() + .customBlock("table", """{"rows":2,"header":true}""") + .buildJson() + + val loadResult = controller.loadJson(json) + assertTrue(loadResult.success) + + // A non-text block gets a trailing editable paragraph appended by the editor. + assertEquals(2, controller.stateHolder.state.blocks.size) + val block = controller.stateHolder.state.blocks.first() + val type = assertIs(block.type) + assertEquals("table", type.typeId) + + val data = assertIs(block.content).data + assertEquals(2L, data["rows"]) + assertEquals(true, data["header"]) + + // Re-export and reload: type + payload survive the round-trip. + val reloaded = CascadeEditorController() + reloaded.registerBlock(tableRegistration()) + reloaded.loadJson(controller.exportJson()) + val reloadedType = assertIs(reloaded.stateHolder.state.blocks.first().type) + assertEquals("table", reloadedType.typeId) + assertEquals( + 2L, + assertIs(reloaded.stateHolder.state.blocks.first().content).data["rows"], + ) + } + + @Test + fun unregisteredCustomTypeStaysUnknownBlockType() { + val controller = CascadeEditorController() + val json = CascadeEditorDocumentBuilder() + .customBlock("table", """{"rows":1}""") + .buildJson() + + controller.loadJson(json) + + assertIs(controller.stateHolder.state.blocks.first().type) + } + + @Test + fun updatePayloadJsonMergesFieldAndUndoRevertsIt() { + val controller = CascadeEditorController() + controller.registerBlock(tableRegistration()) + controller.loadJson( + CascadeEditorDocumentBuilder() + .customBlock("table", """{"rows":2,"header":true}""") + .buildJson(), + ) + controller.mounted = true + val blockId = controller.stateHolder.state.blocks.first().id + val context = context(controller, blockId) + + val result = context.updatePayloadJson("""{"rows":5}""") + + assertEquals(CascadeCustomBlockMutationResult.success, result) + val afterData = assertIs( + controller.stateHolder.state.getBlock(blockId)!!.content, + ).data + assertEquals(5L, afterData["rows"]) + assertEquals(true, afterData["header"], "merge preserves untouched fields") + + controller.undo() + + val revertedData = assertIs( + controller.stateHolder.state.getBlock(blockId)!!.content, + ).data + assertEquals(2L, revertedData["rows"]) + } + + @Test + fun replacePayloadJsonReplacesEntirePayload() { + val controller = CascadeEditorController() + controller.registerBlock(tableRegistration()) + controller.loadJson( + CascadeEditorDocumentBuilder() + .customBlock("table", """{"rows":2,"header":true}""") + .buildJson(), + ) + val blockId = controller.stateHolder.state.blocks.first().id + val context = context(controller, blockId) + + val result = context.replacePayloadJson("""{"rows":9}""") + + assertEquals(CascadeCustomBlockMutationResult.success, result) + val data = assertIs( + controller.stateHolder.state.getBlock(blockId)!!.content, + ).data + assertEquals(9L, data["rows"]) + assertFalse(data.containsKey("header"), "replace drops fields not present in the new payload") + } + + @Test + fun mutationNoOpsAndReportsReadOnly() { + val controller = CascadeEditorController() + controller.registerBlock(tableRegistration()) + controller.loadJson( + CascadeEditorDocumentBuilder().customBlock("table", """{"rows":2}""").buildJson(), + ) + val blockId = controller.stateHolder.state.blocks.first().id + val context = context(controller, blockId, readOnly = true, canUpdate = false) + + val result = context.updatePayloadJson("""{"rows":7}""") + + assertEquals(CascadeCustomBlockMutationResult.readOnly, result) + assertEquals( + 2L, + assertIs(controller.stateHolder.state.getBlock(blockId)!!.content).data["rows"], + ) + } + + @Test + fun invalidPayloadIsRejectedBeforeMutatingDocument() { + val controller = CascadeEditorController() + controller.registerBlock(tableRegistration()) + controller.loadJson( + CascadeEditorDocumentBuilder().customBlock("table", """{"rows":2}""").buildJson(), + ) + var internalError: String? = null + controller.onInternalError = { message -> internalError = message } + val blockId = controller.stateHolder.state.blocks.first().id + val context = context(controller, blockId) + + val result = context.updatePayloadJson("not json at all") + + assertEquals(CascadeCustomBlockMutationResult.invalidPayload, result) + assertEquals( + 2L, + assertIs(controller.stateHolder.state.getBlock(blockId)!!.content).data["rows"], + ) + assertTrue(assertNotNull(internalError).contains("payload", ignoreCase = true)) + } + + @Test + fun setPreferredHeightClampsOutOfRangeValues() { + assertEquals(MIN_BLOCK_HEIGHT, clampBlockHeight(-5.0)) + assertEquals(MAX_BLOCK_HEIGHT, clampBlockHeight(1e12)) + assertEquals(DEFAULT_BLOCK_HEIGHT, clampBlockHeight(Double.NaN)) + + val controller = CascadeEditorController() + controller.registerBlock(tableRegistration()) + controller.loadJson( + CascadeEditorDocumentBuilder().customBlock("table", """{"rows":1}""").buildJson(), + ) + val blockId = controller.stateHolder.state.blocks.first().id + val applied = mutableListOf() + val context = context(controller, blockId, onPreferredHeight = { applied += it }) + + context.setPreferredHeight(-42.0) + context.setPreferredHeight(1e9) + + assertEquals(listOf(MIN_BLOCK_HEIGHT, MAX_BLOCK_HEIGHT), applied) + } + + @Test + fun duplicateRegistrationLastWinsAndWarns() { + val controller = CascadeEditorController() + var internalError: String? = null + controller.onInternalError = { message -> internalError = message } + + controller.registerBlock(tableRegistration(displayName = "First")) + controller.registerBlock(tableRegistration(displayName = "Second")) + + assertEquals("Second", controller.registry.getDescriptor("table")?.displayName) + assertSame( + controller.registry.getRenderer("table"), + controller.registry.getRenderer("table"), + ) + assertTrue(assertNotNull(internalError).contains("table")) + } + + @Test + fun registeringReservedBuiltInTypeIdIsRejectedAndDoesNotOverwriteBuiltIn() { + val controller = CascadeEditorController() + var internalError: String? = null + controller.onInternalError = { message -> internalError = message } + val originalParagraph = controller.registry.getDescriptor("paragraph") + + controller.registerBlock( + CascadeCustomBlockRegistration( + typeId = "paragraph", + displayName = "Hijacked", + description = "should be rejected", + ) { UIViewController() }, + ) + + // Built-in descriptor untouched, no native registration recorded, warning surfaced. + assertSame(originalParagraph, controller.registry.getDescriptor("paragraph")) + assertFalse(controller.nativeRegistrations.containsKey("paragraph")) + assertTrue(assertNotNull(internalError).contains("reserved", ignoreCase = true)) + } + + @Test + fun registeringReservedDividerAndHeadingFamilyIsRejected() { + val controller = CascadeEditorController() + + controller.registerBlock( + CascadeCustomBlockRegistration(typeId = "divider", displayName = "D", description = "") { + UIViewController() + }, + ) + // heading_9 is not a seeded descriptor, but the document decoder still resolves + // the whole heading_ family as built-in, so it must be reserved too. + controller.registerBlock( + CascadeCustomBlockRegistration(typeId = "heading_9", displayName = "H9", description = "") { + UIViewController() + }, + ) + + assertFalse(controller.nativeRegistrations.containsKey("divider")) + assertFalse(controller.nativeRegistrations.containsKey("heading_9")) + } + + @Test + fun onChangeExceptionsAreContainedAndReported() { + val controller = CascadeEditorController() + controller.registerBlock(tableRegistration()) + controller.loadJson( + CascadeEditorDocumentBuilder().customBlock("table", "{}").buildJson(), + ) + var internalError: String? = null + controller.onInternalError = { message -> internalError = message } + val blockId = controller.stateHolder.state.blocks.first().id + val context = context(controller, blockId) + context.onChange = { throw IllegalStateException("native onChange blew up") } + + // A throwing native onChange must be contained (no exception escapes here). + context.fireOnChange() + + assertTrue(assertNotNull(internalError).contains("onChange")) + } + + @Test + fun contextIsDarkFollowsControllerDarkMode() { + val controller = CascadeEditorController( + CascadeEditorDocumentBuilder().customBlock("table", "{}").buildJson(), + ) + val blockId = controller.stateHolder.state.blocks.first().id + val context = context(controller, blockId) + + assertFalse(context.isDark) + + controller.setDarkMode(true) + assertTrue(context.isDark) + + controller.setDarkMode(false) + assertFalse(context.isDark) + } + + private fun context( + controller: CascadeEditorController, + blockId: BlockId, + readOnly: Boolean = false, + canUpdate: Boolean = true, + onPreferredHeight: (Double) -> Unit = {}, + ): CascadeCustomBlockContext = CascadeCustomBlockContext( + blockId = blockId.value, + typeId = "table", + scope = TestBlockRenderScope( + stateHolder = controller.stateHolder, + textStates = controller.textStates, + spanStates = controller.spanStates, + readOnly = readOnly, + canUpdate = canUpdate, + ), + reportError = { message -> controller.onInternalError?.invoke(message) }, + // Mirrors the provider NativeCustomBlockRenderer wires in production. + isDarkProvider = { controller.configurationSnapshot.value.isDark }, + applyPreferredHeight = onPreferredHeight, + buildBlock = { typeId, payloadJson -> + buildInsertableBlock(typeId, payloadJson, controller.registry) { it == "table" } + }, + ) + + private fun tableRegistration(displayName: String = "Table"): CascadeCustomBlockRegistration = + CascadeCustomBlockRegistration( + typeId = "table", + displayName = displayName, + description = "A table block", + ) { UIViewController() } +} + +/** + * A faithful [BlockRenderScope] over the controller's real state holder. Routes + * every mutation through the same [EditorStateHolder.dispatchStructuralAction] + * history primitive the production [DefaultBlockRenderScope] uses, so undo/redo + * exercised here is the editor's real history behavior. + */ +private class TestBlockRenderScope( + private val stateHolder: EditorStateHolder, + private val textStates: BlockTextStates, + private val spanStates: BlockSpanStates, + override val readOnly: Boolean, + private val canUpdate: Boolean, +) : BlockRenderScope { + override val state: EditorState get() = stateHolder.state + override val config: CascadeEditorConfig = CascadeEditorConfig.Default + override val canUpdateBlock: Boolean get() = canUpdate + override val canEditBlockStructure: Boolean get() = canUpdate + override val canSelectBlocks: Boolean = true + override val canDragBlocks: Boolean = true + + override fun getBlock(blockId: BlockId): Block? = stateHolder.state.getBlock(blockId) + + override fun updateBlock(blockId: BlockId, transform: (Block) -> Block) { + if (!canUpdate) return + val current = stateHolder.state.getBlock(blockId) ?: return + val replacement = transform(current).copy(id = current.id) + if (replacement == current) return + stateHolder.dispatchStructuralAction(ReplaceBlock(blockId, replacement), textStates, spanStates) + } + + override fun replaceBlock(blockId: BlockId, block: Block) { + if (!canUpdate) return + val current = stateHolder.state.getBlock(blockId) ?: return + if (block == current) return + stateHolder.dispatchStructuralAction(ReplaceBlock(blockId, block), textStates, spanStates) + } + + override fun insertBlockBefore(blockId: BlockId, block: Block) { + if (!canUpdate) return + if (stateHolder.state.getBlock(blockId) == null) return + stateHolder.dispatchStructuralAction(InsertBlockBefore(block, blockId), textStates, spanStates) + } + + override fun insertBlockAfter(blockId: BlockId, block: Block) { + if (!canUpdate) return + if (stateHolder.state.getBlock(blockId) == null) return + stateHolder.dispatchStructuralAction(InsertBlockAfter(block, blockId), textStates, spanStates) + } + + override fun deleteBlock(blockId: BlockId) { + if (!canUpdate) return + if (stateHolder.state.getBlock(blockId) == null) return + stateHolder.dispatchStructuralAction(DeleteBlock(blockId), textStates, spanStates) + } + + override fun focusBlock(blockId: BlockId?) { + if (blockId != null && stateHolder.state.getBlock(blockId) == null) return + stateHolder.dispatch(FocusBlock(blockId)) + } +} diff --git a/editor-ios-sdk/src/iosSimulatorArm64Test/kotlin/io/github/linreal/cascade/ios/controller/CascadeEditorControllerTest.kt b/editor-ios-sdk/src/iosSimulatorArm64Test/kotlin/io/github/linreal/cascade/ios/controller/CascadeEditorControllerTest.kt new file mode 100644 index 0000000..f600703 --- /dev/null +++ b/editor-ios-sdk/src/iosSimulatorArm64Test/kotlin/io/github/linreal/cascade/ios/controller/CascadeEditorControllerTest.kt @@ -0,0 +1,546 @@ +package io.github.linreal.cascade.ios.controller + +import io.github.linreal.cascade.editor.action.FocusBlock +import io.github.linreal.cascade.editor.action.SelectBlock +import io.github.linreal.cascade.editor.core.Block +import io.github.linreal.cascade.editor.core.BlockContent +import io.github.linreal.cascade.editor.core.BlockType +import io.github.linreal.cascade.editor.core.SpanStyle +import io.github.linreal.cascade.editor.core.TextSpan +import io.github.linreal.cascade.editor.htmlserialization.HtmlDecodeWarning +import io.github.linreal.cascade.editor.registry.BlockDescriptor +import io.github.linreal.cascade.editor.serialization.DocumentSchema +import io.github.linreal.cascade.editor.theme.CascadeEditorTheme +import io.github.linreal.cascade.editor.ui.LinkPopupSlot +import io.github.linreal.cascade.ios.model.CascadeEditorDocumentBuilder +import io.github.linreal.cascade.ios.model.CascadeSpanKind +import io.github.linreal.cascade.ios.toolbar.CascadeToolbarState +import platform.Foundation.NSDate +import platform.Foundation.NSRunLoop +import platform.Foundation.NSThread +import platform.Foundation.dateWithTimeIntervalSinceNow +import platform.Foundation.runUntilDate +import platform.darwin.DISPATCH_QUEUE_PRIORITY_DEFAULT +import platform.darwin.DISPATCH_TIME_FOREVER +import platform.darwin.dispatch_async +import platform.darwin.dispatch_get_global_queue +import platform.darwin.dispatch_semaphore_create +import platform.darwin.dispatch_semaphore_signal +import platform.darwin.dispatch_semaphore_wait +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertFalse +import kotlin.test.assertNotEquals +import kotlin.test.assertNotNull +import kotlin.test.assertNull +import kotlin.test.assertSame +import kotlin.test.assertTrue + +class CascadeEditorControllerTest { + @Test + fun defaultConstructorsUseDefaultConfiguration() { + val configuration = CascadeEditorConfiguration() + val emptyController = CascadeEditorController() + val jsonController = CascadeEditorController(initialJson = CascadeEditorDocumentBuilder().paragraph("Seed").buildJson()) + + assertEquals(CascadeToolbarMode.builtIn, configuration.toolbarMode) + assertEquals(CascadeCrashPolicy.containAndReport, configuration.crashPolicy) + assertEquals(configuration, emptyController.configuration) + assertEquals("Seed", jsonController.exportPlainText()) + } + + @Test + fun toolbarAndHistoryCommandsAreUnavailableBeforeMount() { + val controller = CascadeEditorController( + initialJson = CascadeEditorDocumentBuilder().paragraph("Seed").buildJson(), + ) + + controller.undo() + controller.redo() + controller.toggleBold() + controller.toggleHighlight(argb = 0xFF00FF00L) + controller.indentForward() + controller.applyLink(url = "example.com", title = "Example") + controller.removeLink() + + assertEquals(CascadeToolbarState.Empty, controller.toolbarState) + assertFalse(controller.canUndo) + assertFalse(controller.canRedo) + assertEquals("Seed", controller.exportPlainText()) + } + + @Test + fun toggleHighlightDelegatesCallerArgbWhenMounted() { + val controller = CascadeEditorController() + var highlightedArgb: Long? = null + controller.mounted = true + controller.toolbarActions = CascadeToolbarActions( + toggleBold = {}, + toggleItalic = {}, + toggleUnderline = {}, + toggleStrikeThrough = {}, + toggleInlineCode = {}, + toggleHighlight = { argb -> highlightedArgb = argb }, + indentForward = {}, + indentBackward = {}, + applyLink = { _, _ -> }, + removeLink = {}, + ) + + controller.toggleHighlight(argb = 0xFF00FF00L) + + assertEquals(0xFF00FF00L, highlightedArgb) + } + + @Test + fun loadAndExportJsonRoundTrip() { + val json = CascadeEditorDocumentBuilder() + .paragraph("Hello") + .heading(2, "World") + .buildJson() + val controller = CascadeEditorController(initialJson = null) + + val result = controller.loadJson(json) + + assertTrue(result.success) + assertEquals(jsonDocumentText(json), jsonDocumentText(controller.exportJson())) + } + + @Test + fun loadJsonDefersCallbacksToHostObserverWhenMounted() { + val json = CascadeEditorDocumentBuilder() + .paragraph("Mounted") + .buildJson() + val controller = CascadeEditorController(initialJson = null) + var documentChanges = 0 + var stateChanges = 0 + controller.onDocumentChanged = { documentChanges++ } + controller.onStateChanged = { stateChanges++ } + controller.mounted = true + + val result = controller.loadJson(json) + + assertTrue(result.success) + assertEquals("Mounted", controller.exportPlainText()) + assertEquals(0, documentChanges) + assertEquals(0, stateChanges) + } + + @Test + fun loadJsonNotifiesDirectlyWhenUnmounted() { + val json = CascadeEditorDocumentBuilder() + .paragraph("Unmounted") + .buildJson() + val controller = CascadeEditorController(initialJson = null) + var documentChanges = 0 + var stateChanges = 0 + controller.onDocumentChanged = { documentChanges++ } + controller.onStateChanged = { stateChanges++ } + + val result = controller.loadJson(json) + + assertTrue(result.success) + assertEquals("Unmounted", controller.exportPlainText()) + assertEquals(1, documentChanges) + assertEquals(1, stateChanges) + } + + @Test + fun deleteSelectedOrFocusedDefersCallbacksToHostObserverWhenMounted() { + val controller = CascadeEditorController( + initialJson = CascadeEditorDocumentBuilder() + .paragraph("Delete") + .paragraph("Keep") + .buildJson(), + ) + controller.stateHolder.dispatch(FocusBlock(controller.stateHolder.state.blocks.first().id)) + var documentChanges = 0 + var stateChanges = 0 + controller.onDocumentChanged = { documentChanges++ } + controller.onStateChanged = { stateChanges++ } + controller.mounted = true + + controller.deleteSelectedOrFocused() + + assertEquals("Keep", controller.exportPlainText()) + assertEquals(0, documentChanges) + assertEquals(0, stateChanges) + } + + @Test + fun deleteSelectedOrFocusedNotifiesDirectlyWhenUnmounted() { + val controller = CascadeEditorController( + initialJson = CascadeEditorDocumentBuilder() + .paragraph("Delete") + .paragraph("Keep") + .buildJson(), + ) + controller.stateHolder.dispatch(FocusBlock(controller.stateHolder.state.blocks.first().id)) + var documentChanges = 0 + var stateChanges = 0 + controller.onDocumentChanged = { documentChanges++ } + controller.onStateChanged = { stateChanges++ } + + controller.deleteSelectedOrFocused() + + assertEquals("Keep", controller.exportPlainText()) + assertEquals(1, documentChanges) + assertEquals(1, stateChanges) + } + + @Test + fun clearFocusDefersStateCallbackToHostObserverWhenMounted() { + val controller = CascadeEditorController( + initialJson = CascadeEditorDocumentBuilder().paragraph("Focused").buildJson(), + ) + controller.stateHolder.dispatch(FocusBlock(controller.stateHolder.state.blocks.first().id)) + var stateChanges = 0 + controller.onStateChanged = { stateChanges++ } + controller.mounted = true + + controller.clearFocus() + + assertEquals(0, stateChanges) + } + + @Test + fun clearFocusNotifiesDirectlyWhenUnmounted() { + val controller = CascadeEditorController( + initialJson = CascadeEditorDocumentBuilder().paragraph("Focused").buildJson(), + ) + controller.stateHolder.dispatch(FocusBlock(controller.stateHolder.state.blocks.first().id)) + var stateChanges = 0 + controller.onStateChanged = { stateChanges++ } + + controller.clearFocus() + + assertEquals(1, stateChanges) + } + + @Test + fun malformedJsonReturnsWarningInsteadOfThrowing() { + val controller = CascadeEditorController(initialJson = null) + + val result = controller.loadJson("{") + + assertFalse(result.success) + assertTrue(result.warningMessages.isNotEmpty()) + } + + @Test + fun failedLoadJsonPreservesTheCurrentDocument() { + val controller = CascadeEditorController( + initialJson = CascadeEditorDocumentBuilder().paragraph("Keep me").buildJson(), + ) + var documentChanges = 0 + controller.onDocumentChanged = { documentChanges++ } + + val result = controller.loadJson("{ not json") + + assertFalse(result.success) + // A payload that failed to parse must not destroy the loaded document, + // and a load that changed nothing must not signal a document change. + assertEquals("Keep me", controller.exportPlainText()) + assertEquals(0, documentChanges) + } + + @Test + fun exportPlainTextOmitsNonTextBlocks() { + val json = CascadeEditorDocumentBuilder() + .paragraph("One") + .divider() + .paragraph("Two") + .customBlock("metric", """{"label":"Revenue"}""") + .paragraph("Three") + .buildJson() + val controller = CascadeEditorController(initialJson = json) + + // Dividers and custom blocks carry no user-visible text and must not + // contribute blank lines to the plain-text export. + assertEquals("One\nTwo\nThree", controller.exportPlainText()) + // Rich text still exposes every block as a typed run. + assertEquals(5, controller.exportRichText().blocks.size) + } + + @Test + fun offMainExportHopsToMainAndReturnsTheRealDocument() { + val controller = CascadeEditorController( + initialJson = CascadeEditorDocumentBuilder().paragraph("Background").buildJson(), + ) + var exported: String? = null + dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT.toLong(), 0u)) { + exported = controller.exportPlainText() + } + + // The off-main export dispatch_syncs onto the main queue; pumping the + // main run loop services that hop (blocking the main thread on the + // background caller — like runOffMain does — would deadlock it). + drainMainQueue { exported != null } + + assertEquals("Background", exported) + } + + @Test + fun plainTextAndRichTextExportUseDocumentOrder() { + val json = CascadeEditorDocumentBuilder() + .paragraph("One") + .paragraph("Two") + .buildJson() + val controller = CascadeEditorController(initialJson = json) + + assertEquals("One\nTwo", controller.exportPlainText()) + assertEquals(listOf("One", "Two"), controller.exportRichText().blocks.map { it.text }) + } + + @Test + fun richTextExportMapsSupportedSpansAndOmitsCustomSpans() { + val json = DocumentSchema.encodeToString( + listOf( + Block.paragraph( + text = "Styled link custom", + spans = listOf( + TextSpan(0, 6, SpanStyle.Bold), + TextSpan(7, 11, SpanStyle.Link("https://example.com")), + TextSpan(12, 18, SpanStyle.Custom("native-only")), + ), + ), + ), + ) + val controller = CascadeEditorController(initialJson = json) + + val block = controller.exportRichText().blocks.first() + + assertEquals("Styled link custom", block.text) + assertEquals(listOf(CascadeSpanKind.bold, CascadeSpanKind.link), block.spans.map { it.kind }) + assertEquals("https://example.com", block.spans[1].url) + } + + @Test + fun deleteSelectedOrFocusedNoOpsWhenReadOnly() { + val json = CascadeEditorDocumentBuilder() + .paragraph("Keep me") + .buildJson() + val controller = CascadeEditorController( + initialJson = json, + configuration = CascadeEditorConfiguration().copy(readOnly = true), + ) + val focusedBlockId = controller.stateHolder.state.blocks.first().id + controller.stateHolder.dispatch(FocusBlock(focusedBlockId)) + + controller.deleteSelectedOrFocused() + + assertEquals("Keep me", controller.exportPlainText()) + } + + @Test + fun loadHtmlDecoderExceptionWarningIsFailure() { + val warnings = listOf( + HtmlDecodeWarning.DecoderException( + tag = "custom", + message = "boom", + charOffset = 0, + ), + ) + + assertFalse(warnings.isSuccessfulHtmlLoad()) + } + + @Test + fun richTextExportClampsOutOfRangeSnapshotSpans() { + val json = DocumentSchema.encodeToString( + listOf( + Block.paragraph( + text = "Clip", + spans = listOf( + TextSpan(1, 99, SpanStyle.Bold), + TextSpan(8, 12, SpanStyle.Italic), + ), + ), + ), + ) + val controller = CascadeEditorController(initialJson = json) + + val spans = controller.exportRichText().blocks.first().spans + + assertEquals(1, spans.size) + assertEquals(CascadeSpanKind.bold, spans.single().kind) + assertEquals(1, spans.single().start) + assertEquals(4, spans.single().end) + } + + @Test + fun documentChangedCallbackExceptionsAreContained() { + val controller = CascadeEditorController() + var internalError: String? = null + controller.onDocumentChanged = { error("callback failed") } + controller.onInternalError = { message -> internalError = message } + + val result = controller.loadJson(CascadeEditorDocumentBuilder().paragraph("Safe").buildJson()) + + assertTrue(result.success) + assertEquals("Safe", controller.exportPlainText()) + assertTrue(assertNotNull(internalError).contains("onDocumentChanged")) + } + + @Test + fun offMainConfigurationGetterReportsInternalErrorAndReturnsDefaultConfiguration() { + val controller = CascadeEditorController( + initialJson = null, + configuration = CascadeEditorConfiguration().copy(readOnly = true), + ) + var internalError: String? = null + var deliveredOnMainThread: Boolean? = null + controller.onInternalError = { message -> + internalError = message + deliveredOnMainThread = NSThread.isMainThread + } + + val configuration = runOffMain { + controller.configuration + } + + assertEquals(CascadeEditorConfiguration(), configuration) + // The misuse report is marshaled onto the main thread, so it is not yet + // delivered when the off-main call returns; it arrives once the main queue drains. + assertNull(internalError, "off-main error must not be delivered synchronously off-main") + drainMainQueue { internalError != null } + assertEquals("CascadeEditorController must be used on the main thread", internalError) + assertEquals(true, deliveredOnMainThread, "callbacks must be delivered on the main thread") + } + + @Test + fun builtInToolbarUsesDefaultLinkPopup() { + assertEquals(LinkPopupSlot.Default, CascadeToolbarMode.builtIn.toEditorLinkPopupSlot()) + assertEquals(LinkPopupSlot.None, CascadeToolbarMode.none.toEditorLinkPopupSlot()) + } + + @Test + fun hasSelectionStaysConsistentWithSelectedBlockCount() { + val controller = CascadeEditorController( + initialJson = CascadeEditorDocumentBuilder() + .paragraph("One") + .paragraph("Two") + .buildJson(), + ) + val firstBlockId = controller.stateHolder.state.blocks.first().id + + controller.stateHolder.dispatch(SelectBlock(firstBlockId)) + assertTrue(controller.hasSelection) + assertEquals(1, controller.selectedBlockCount) + + controller.clearSelection() + assertFalse(controller.hasSelection) + assertEquals(0, controller.selectedBlockCount) + } + + @Test + fun offMainHasSelectionReportsInternalErrorAndReturnsFalse() { + val controller = CascadeEditorController( + initialJson = CascadeEditorDocumentBuilder().paragraph("One").buildJson(), + ) + controller.stateHolder.dispatch(SelectBlock(controller.stateHolder.state.blocks.first().id)) + var internalError: String? = null + var deliveredOnMainThread: Boolean? = null + controller.onInternalError = { message -> + internalError = message + deliveredOnMainThread = NSThread.isMainThread + } + + val hasSelection = runOffMain { controller.hasSelection } + + assertFalse(hasSelection) + assertNull(internalError, "off-main error must not be delivered synchronously off-main") + drainMainQueue { internalError != null } + assertEquals("CascadeEditorController must be used on the main thread", internalError) + assertEquals(true, deliveredOnMainThread, "callbacks must be delivered on the main thread") + } + + @Test + fun documentChangeSignalReflectsRuntimeTextEditsWithoutSerialization() { + val controller = CascadeEditorController( + initialJson = CascadeEditorDocumentBuilder().paragraph("Hello").buildJson(), + ) + val blockId = controller.stateHolder.state.blocks.first().id + controller.textStates.getOrCreate(blockId, "Hello") + + val before = controller.currentDocumentBlocks() + controller.textStates.setText(blockId, "Hello world") + val after = controller.currentDocumentBlocks() + + // The change signal is the resolved block list — no JSON encoding — and it + // reflects runtime text edits that never touch EditorState identity. + assertNotEquals(before, after) + assertEquals(0, controller.selectedBlockCount) + } + + @Test + fun controllerOwnsStableRegistriesSeededWithBuiltIns() { + val controller = CascadeEditorController() + val registryInstance = controller.registry + val slashInstance = controller.slashRegistry + + // Seeded from createEditorRegistry(); slash registry starts empty (built-ins + // are merged in by the hosted editor). + assertTrue(controller.registry.isRegistered("paragraph")) + assertTrue(controller.slashRegistry.getRootItems().isEmpty()) + + // A registration made before first mount survives on the same stable instance. + controller.registry.registerDescriptor( + BlockDescriptor( + typeId = "stub-block", + displayName = "Stub", + description = "", + factory = { id -> Block(id, BlockType.Paragraph, BlockContent.Text("")) }, + ), + ) + + assertSame(registryInstance, controller.registry) + assertSame(slashInstance, controller.slashRegistry) + assertTrue(controller.registry.isRegistered("stub-block")) + } + + @Test + fun setDarkModeSwitchesTheResolvedEditorTheme() { + val controller = CascadeEditorController() + + // configurationSnapshot + resolveEditorTheme is exactly what the hosted + // view recomposes the mounted theme from, so asserting through them pins + // live dark-mode switching headlessly. + assertEquals(CascadeEditorTheme.light(), controller.configurationSnapshot.value.resolveEditorTheme()) + + controller.setDarkMode(true) + assertEquals(CascadeEditorTheme.dark(), controller.configurationSnapshot.value.resolveEditorTheme()) + + controller.setDarkMode(false) + assertEquals(CascadeEditorTheme.light(), controller.configurationSnapshot.value.resolveEditorTheme()) + } + + private fun jsonDocumentText(json: String): String = + CascadeEditorController(initialJson = json).exportPlainText() + + /** + * Pumps the main run loop (the test runs on the main thread) until [until] holds or + * the timeout elapses, so blocks dispatched to the main queue — e.g. an off-main + * error report marshaled back onto main — get a chance to execute. + */ + private fun drainMainQueue(timeoutSeconds: Double = 2.0, until: () -> Boolean) { + val runLoop = NSRunLoop.mainRunLoop + var elapsed = 0.0 + val step = 0.02 + while (!until() && elapsed < timeoutSeconds) { + runLoop.runUntilDate(NSDate.dateWithTimeIntervalSinceNow(step)) + elapsed += step + } + } + + private fun runOffMain(block: () -> T): T { + val semaphore = dispatch_semaphore_create(0) + var result: Result? = null + dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT.toLong(), 0u)) { + result = runCatching(block) + dispatch_semaphore_signal(semaphore) + } + dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER) + return result!!.getOrThrow() + } +} diff --git a/editor-ios-sdk/src/iosSimulatorArm64Test/kotlin/io/github/linreal/cascade/ios/fixtures/GoldenParityTest.kt b/editor-ios-sdk/src/iosSimulatorArm64Test/kotlin/io/github/linreal/cascade/ios/fixtures/GoldenParityTest.kt new file mode 100644 index 0000000..825333d --- /dev/null +++ b/editor-ios-sdk/src/iosSimulatorArm64Test/kotlin/io/github/linreal/cascade/ios/fixtures/GoldenParityTest.kt @@ -0,0 +1,419 @@ +@file:OptIn(ExperimentalForeignApi::class) + +package io.github.linreal.cascade.ios.fixtures + +import io.github.linreal.cascade.editor.core.Block +import io.github.linreal.cascade.editor.core.BlockContent +import io.github.linreal.cascade.editor.core.BlockId +import io.github.linreal.cascade.editor.core.CustomBlockType +import io.github.linreal.cascade.editor.serialization.DocumentSchema +import io.github.linreal.cascade.ios.model.CascadeEditorDocumentBuilder +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertNotNull +import kotlinx.cinterop.ExperimentalForeignApi +import kotlinx.cinterop.toKString +import kotlinx.serialization.json.Json +import kotlinx.serialization.json.JsonArray +import kotlinx.serialization.json.JsonObject +import kotlinx.serialization.json.JsonPrimitive +import kotlinx.serialization.json.buildJsonArray +import kotlinx.serialization.json.buildJsonObject +import kotlinx.serialization.json.intOrNull +import kotlinx.serialization.json.jsonObject +import platform.Foundation.NSString +import platform.Foundation.NSUTF8StringEncoding +import platform.Foundation.stringWithContentsOfFile +import platform.posix.getenv + +/** + * Golden parity between the committed canonical fixtures, the KMP sample's seed + * documents, and the iOS-facing [CascadeEditorDocumentBuilder]. + * + * Fixtures (committed under `src/commonTest/resources/`, directory provided by the + * Gradle test task through the `CASCADE_FIXTURES_DIR` environment variable): + * - `editor_demo_document.json` — the editor-demo seed; a canonical copy of the KMP + * sample's `default_document.json` with its authored block ids intentionally preserved. + * - `comments_composer_document.json` — the comments composer seed (one empty paragraph). + * - `custom_blocks_document.json` — the custom-blocks demo seed, mirroring the KMP + * sample's `CustomBlocksScreen.buildDemoBlocks()` data. + * + * ## Normalization rules + * + * "Semantically equivalent" is not byte equality. Both sides of every comparison are + * projected through [normalizeDocument] before comparing: + * - **Block ids** are dropped when `ignoreIds = true` (generated ids are volatile); + * comparisons against fixtures with intentionally authored ids keep them. + * - **Type objects**: default-omitted params are materialized (`todo` without + * `checked` → `checked: false`; `numbered_list` without `number` → `number: 1`), + * and the serializer's `custom: true` marker flag is dropped — registered-codec + * output (`{"typeId": "table"}`) and the codec-less fallback + * (`{"typeId": "table", "custom": true}`) decode to the same block. + * - **Attributes**: omitted entirely when `indentationLevel` is absent or `0` + * (the encoder's canonical default omission). + * - **Text content**: `kind` and `text` are kept; the schema-internal `version` + * field is dropped (only v1 exists); `spans` are kept verbatim (order is canonical). + * - **Custom content**: `kind` and `data` are compared exactly, including nested + * lists/maps — custom payload parity is the point of the custom-blocks fixture. + * + * The **builder projection** ([Projection.Builder]) additionally drops `spans` and + * `attributes` from both sides: the document builder deliberately authors neither + * inline formatting nor indentation this milestone, so builder comparisons cover + * block sequence, types, type params, text, and custom payloads. Full-fidelity + * span/indentation parity for the editor-demo document is guaranteed by the + * fixture-vs-sample-file comparison and the decode/encode round-trip instead. + */ +class GoldenParityTest { + + private enum class Projection { + /** Full semantic form: everything except volatile ids and marker/default noise. */ + Document, + + /** [Document] minus spans and indentation attributes — the builder-expressible subset. */ + Builder, + } + + // Fixture access + + private fun environmentValue(name: String): String? = getenv(name)?.toKString() + + private fun readFile(directoryVariable: String, fileName: String): String { + val directory = assertNotNull( + environmentValue(directoryVariable), + "Missing $directoryVariable environment variable; " + + "expected the Gradle test task to pass it via SIMCTL_CHILD_$directoryVariable", + ) + val content = NSString.stringWithContentsOfFile( + "$directory/$fileName", + encoding = NSUTF8StringEncoding, + error = null, + ) + return assertNotNull(content, "Could not read $directory/$fileName") + } + + private fun readFixture(fileName: String): String = + readFile("CASCADE_FIXTURES_DIR", fileName) + + // Editor demo document + + @Test + fun editorDemoFixtureMatchesKmpSampleDefaultDocument() { + val fixture = readFixture("editor_demo_document.json") + val sampleDocument = readFile("CASCADE_SAMPLE_FILES_DIR", "default_document.json") + + assertEquals( + normalizeDocument(sampleDocument, ignoreIds = false), + normalizeDocument(fixture, ignoreIds = false), + "editor_demo_document.json drifted from the KMP sample's default_document.json", + ) + } + + @Test + fun editorDemoFixtureRoundTripsThroughDocumentSchema() { + val fixture = readFixture("editor_demo_document.json") + val reEncoded = DocumentSchema.encodeToString(DocumentSchema.decodeFromString(fixture)) + + assertEquals( + normalizeDocument(fixture, ignoreIds = false), + normalizeDocument(reEncoded, ignoreIds = false), + "editor_demo_document.json is not canonical DocumentSchema JSON", + ) + } + + @Test + fun editorDemoFixtureReconstructedByIosBuilder() { + val builderJson = CascadeEditorDocumentBuilder() + .heading(1, "Welcome to Cascade Editor") + .paragraph( + "A block-based document editor for Compose Multiplatform. " + + "Everything you see here is editable — try it out!" + ) + .divider() + .heading(2, "Try These") + .todo("Mix bold, italic, underline, strikethrough, code, and highlights in any block.", checked = false) + .todo("Tap here and start typing", checked = false) + .todo("Select text, then use the toolbar to make it bold or italic", checked = false) + .todo("Type / to open slash commands (or just use / icon from the toolbar)", checked = false) + .todo("Use indentation to group related tasks", checked = false) + .todo("Subtasks can sit under a parent todo", checked = false) + .todo("Deeper todo levels stay attached to the outline", checked = false) + .todo("Outdent again when the group is done", checked = false) + .todo("Hold and drag any block to reorder it", checked = false) + .todo("Long-press a block to select it, then tap others to multi-select and delete", checked = false) + .todo("Press Enter at the end of this line to create a new block", checked = false) + .heading(2, "Block Types") + .bulletList("Bullet lists for unordered content") + .bulletList("Nest ideas without numbering") + .numberedList("Numbered lists auto-increment", number = 1) + .numberedList("Indented numbered items keep their own sequence", number = 1) + .numberedList("Deeper levels can explain a step in detail", number = 1) + .numberedList("Sibling nested items continue at the same depth", number = 2) + .numberedList("Delete or reorder and every level renumbers", number = 2) + .quote("The best way to predict the future is to invent it. — Alan Kay") + .code("fun greet(name: String) {\n println(\"Hello, \$name!\")\n}") + .divider() + .paragraph("Your changes are saved automatically. Hit Reset in the toolbar to start fresh.") + .buildJson() + + assertEquals( + normalizeDocument(readFixture("editor_demo_document.json"), ignoreIds = true, Projection.Builder), + normalizeDocument(builderJson, ignoreIds = true, Projection.Builder), + ) + } + + // Comments composer document + + @Test + fun commentsComposerFixtureMatchesKmpComposerSeed() { + // CommentsScreenModel seeds/resets its composer with exactly this encoding. + val kmpComposerSeed = DocumentSchema.encodeToString(listOf(Block.paragraph())) + + assertEquals( + normalizeDocument(readFixture("comments_composer_document.json"), ignoreIds = true), + normalizeDocument(kmpComposerSeed, ignoreIds = true), + ) + } + + @Test + fun commentsComposerFixtureReconstructedByIosBuilder() { + val builderJson = CascadeEditorDocumentBuilder() + .paragraph("") + .buildJson() + + assertEquals( + normalizeDocument(readFixture("comments_composer_document.json"), ignoreIds = true), + normalizeDocument(builderJson, ignoreIds = true), + ) + } + + // Custom blocks document + + @Test + fun customBlocksFixtureReconstructedByIosBuilder() { + val builderJson = CascadeEditorDocumentBuilder() + .heading(1, "Custom Blocks & Commands") + .paragraph("This demo shows how to extend CascadeEditor with custom block types and slash commands.") + .heading(2, "Interactive Tables") + .paragraph("Table blocks are implemented by the sample app with public custom block APIs.") + .customBlock( + "table", + """ + { + "rows": [ + ["Name", "Role", "Status"], + ["Ada", "Engineer", "Active"], + ["Linus", "Maintainer", "Review"] + ], + "headerRow": true + } + """.trimIndent(), + ) + .paragraph("Type /table to insert another table.") + .divider() + .heading(2, "Metric Cards") + .paragraph( + "Metric cards are non-editable custom blocks — perfect for dashboards and status displays:" + ) + .customBlock("metric", """{"value":"2,847","label":"Downloads","trend":"up","trendValue":"12.5%"}""") + .customBlock("metric", """{"value":"99.9%","label":"Uptime","trend":"up","trendValue":"0.1%"}""") + .customBlock("metric", """{"value":"142ms","label":"Avg Latency","trend":"down","trendValue":"23%"}""") + .paragraph("Type /metric to insert a new metric card.") + .divider() + .heading(2, "Color Palettes") + .paragraph( + "Color palette blocks showcase full Compose rendering — circles, hex labels, and layout:" + ) + .customBlock("palette", """{"name":"Ocean Breeze","colors":"0077B6,00B4D8,90E0EF,CAF0F8"}""") + .customBlock("palette", """{"name":"Sunset Warmth","colors":"FF6B6B,FFA06B,FFD93D,6BCB77"}""") + .paragraph("Type /palette to insert a new color palette.") + .divider() + .heading(2, "Custom Slash Commands") + .paragraph("Type /timestamp to insert the current date and time.") + .paragraph("Type /lorem to insert placeholder text.") + .paragraph("These custom commands coexist with all built-in commands in the slash popup.") + .divider() + .heading(2, "Try It Out") + .paragraph("Click on any empty paragraph and type / to see all available commands:") + .paragraph("") + .paragraph("") + .buildJson() + + assertEquals( + normalizeDocument(readFixture("custom_blocks_document.json"), ignoreIds = true), + normalizeDocument(builderJson, ignoreIds = true), + ) + } + + @Test + fun customBlocksFixtureMatchesKmpSampleDemoBlocks() { + val kmpDemoJson = DocumentSchema.encodeToString(buildKmpDemoBlocks()) + + assertEquals( + normalizeDocument(readFixture("custom_blocks_document.json"), ignoreIds = true), + normalizeDocument(kmpDemoJson, ignoreIds = true), + ) + } + + /** + * Mirrors the KMP sample's demo document (`CustomBlocksScreen.buildDemoBlocks()` + * plus `SampleTableModel.default()`) using the same `:editor` primitives. The + * sample's builders are private Compose-importing screen code, so the data is + * reproduced here verbatim; drift in the sample surfaces as a fixture mismatch. + */ + private fun buildKmpDemoBlocks(): List = listOf( + Block.heading(1, "Custom Blocks & Commands"), + Block.paragraph( + "This demo shows how to extend CascadeEditor with custom block types and slash commands." + ), + Block.heading(2, "Interactive Tables"), + Block.paragraph( + "Table blocks are implemented by the sample app with public custom block APIs." + ), + customDataBlock( + typeId = "table", + data = mapOf( + "rows" to listOf( + listOf("Name", "Role", "Status"), + listOf("Ada", "Engineer", "Active"), + listOf("Linus", "Maintainer", "Review"), + ), + "headerRow" to true, + ), + ), + Block.paragraph("Type /table to insert another table."), + Block.divider(), + Block.heading(2, "Metric Cards"), + Block.paragraph( + "Metric cards are non-editable custom blocks — perfect for dashboards and status displays:" + ), + metricBlock("2,847", "Downloads", "up", "12.5%"), + metricBlock("99.9%", "Uptime", "up", "0.1%"), + metricBlock("142ms", "Avg Latency", "down", "23%"), + Block.paragraph("Type /metric to insert a new metric card."), + Block.divider(), + Block.heading(2, "Color Palettes"), + Block.paragraph( + "Color palette blocks showcase full Compose rendering — circles, hex labels, and layout:" + ), + paletteBlock("Ocean Breeze", listOf("0077B6", "00B4D8", "90E0EF", "CAF0F8")), + paletteBlock("Sunset Warmth", listOf("FF6B6B", "FFA06B", "FFD93D", "6BCB77")), + Block.paragraph("Type /palette to insert a new color palette."), + Block.divider(), + Block.heading(2, "Custom Slash Commands"), + Block.paragraph("Type /timestamp to insert the current date and time."), + Block.paragraph("Type /lorem to insert placeholder text."), + Block.paragraph( + "These custom commands coexist with all built-in commands in the slash popup." + ), + Block.divider(), + Block.heading(2, "Try It Out"), + Block.paragraph("Click on any empty paragraph and type / to see all available commands:"), + Block.paragraph(""), + Block.paragraph(""), + ) + + private fun metricBlock(value: String, label: String, trend: String, trendValue: String): Block = + customDataBlock( + typeId = "metric", + data = mapOf( + "value" to value, + "label" to label, + "trend" to trend, + "trendValue" to trendValue, + ), + ) + + private fun paletteBlock(name: String, colors: List): Block = + customDataBlock( + typeId = "palette", + data = mapOf( + "name" to name, + "colors" to colors.joinToString(","), + ), + ) + + private fun customDataBlock(typeId: String, data: Map): Block = Block( + id = BlockId.generate(), + type = KmpSampleCustomType(typeId), + content = BlockContent.Custom(typeId = typeId, data = data), + ) + + private data class KmpSampleCustomType(override val typeId: String) : CustomBlockType { + override val displayName: String = typeId + override val supportsText: Boolean = false + override val isConvertible: Boolean = false + } + + // Normalization + + private fun normalizeDocument( + jsonString: String, + ignoreIds: Boolean, + projection: Projection = Projection.Document, + ): JsonObject { + val root = Json.parseToJsonElement(jsonString).jsonObject + return buildJsonObject { + root["version"]?.let { put("version", it) } + put( + "blocks", + buildJsonArray { + (root["blocks"] as? JsonArray)?.forEach { block -> + add(normalizeBlock(block.jsonObject, ignoreIds, projection)) + } + }, + ) + } + } + + private fun normalizeBlock( + block: JsonObject, + ignoreIds: Boolean, + projection: Projection, + ): JsonObject = buildJsonObject { + if (!ignoreIds) { + block["id"]?.let { put("id", it) } + } + put("type", normalizeType(assertNotNull(block["type"], "Block without type: $block").jsonObject)) + if (projection == Projection.Document) { + normalizeAttributes(block["attributes"])?.let { put("attributes", it) } + } + put("content", normalizeContent(block["content"] as? JsonObject, projection)) + } + + private fun normalizeType(type: JsonObject): JsonObject = buildJsonObject { + for ((key, value) in type) { + if (key == "custom") continue + put(key, value) + } + when ((type["typeId"] as? JsonPrimitive)?.content) { + "todo" -> if ("checked" !in type) put("checked", JsonPrimitive(false)) + "numbered_list" -> if ("number" !in type) put("number", JsonPrimitive(1)) + } + } + + private fun normalizeAttributes(attributes: kotlinx.serialization.json.JsonElement?): JsonObject? { + val json = attributes as? JsonObject ?: return null + val indentationLevel = (json["indentationLevel"] as? JsonPrimitive)?.intOrNull ?: 0 + if (indentationLevel == 0) return null + return buildJsonObject { put("indentationLevel", JsonPrimitive(indentationLevel)) } + } + + private fun normalizeContent(content: JsonObject?, projection: Projection): JsonObject { + val kind = (content?.get("kind") as? JsonPrimitive)?.content ?: "empty" + return when (kind) { + "empty" -> buildJsonObject { put("kind", JsonPrimitive("empty")) } + "text" -> buildJsonObject { + put("kind", JsonPrimitive("text")) + put("text", content?.get("text") ?: JsonPrimitive("")) + if (projection == Projection.Document) { + put("spans", content?.get("spans") ?: JsonArray(emptyList())) + } + } + + else -> buildJsonObject { + put("kind", JsonPrimitive(kind)) + put("data", content?.get("data") ?: JsonObject(emptyMap())) + } + } + } +} diff --git a/editor-ios-sdk/src/iosSimulatorArm64Test/kotlin/io/github/linreal/cascade/ios/localization/CascadeLocalizationTest.kt b/editor-ios-sdk/src/iosSimulatorArm64Test/kotlin/io/github/linreal/cascade/ios/localization/CascadeLocalizationTest.kt new file mode 100644 index 0000000..090f020 --- /dev/null +++ b/editor-ios-sdk/src/iosSimulatorArm64Test/kotlin/io/github/linreal/cascade/ios/localization/CascadeLocalizationTest.kt @@ -0,0 +1,115 @@ +package io.github.linreal.cascade.ios.localization + +import io.github.linreal.cascade.editor.richtext.LinkValidationError +import io.github.linreal.cascade.editor.theme.CascadeEditorBlockStrings +import io.github.linreal.cascade.editor.theme.CascadeEditorStrings +import io.github.linreal.cascade.ios.controller.CascadeEditorController +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertNotNull + +/** + * The resolved-strings states asserted here are exactly what `makeViewController` + * passes to the hosted editor's `strings`/`blockStrings` parameters, so these + * tests pin the full Swift-facing localization path headlessly. + */ +class CascadeLocalizationTest { + + @Test + fun controllerDefaultsToBuiltInEnglishStrings() { + val controller = CascadeEditorController() + + assertEquals(CascadeEditorStrings.default(), controller.resolvedStrings.value) + assertEquals(CascadeEditorBlockStrings.default(), controller.resolvedBlockStrings.value) + } + + @Test + fun emptyLocalizationResolvesToDefaults() { + val controller = CascadeEditorController() + + controller.setLocalization(CascadeEditorLocalization()) + + assertEquals(CascadeEditorStrings.default(), controller.resolvedStrings.value) + assertEquals(CascadeEditorBlockStrings.default(), controller.resolvedBlockStrings.value) + } + + @Test + fun localizedChromeStringsReachTheResolvedSet() { + val controller = CascadeEditorController() + val strings = CascadeLocalizedStrings().apply { + back = "‹ Zurück" + bold = "Fett" + italic = "Kursiv" + linkApply = "Link anwenden" + linkValidationBlankUrl = "Bitte URL eingeben." + unsupportedBlock = { typeId -> "Nicht unterstützter Block: $typeId" } + } + + controller.setLocalization(CascadeEditorLocalization(strings)) + + val resolved = controller.resolvedStrings.value + assertEquals("‹ Zurück", resolved.back) + assertEquals("Fett", resolved.bold) + assertEquals("Kursiv", resolved.italic) + assertEquals("Link anwenden", resolved.linkApply) + assertEquals("Bitte URL eingeben.", resolved.linkValidationError(LinkValidationError.Blank)) + assertEquals("Nicht unterstützter Block: table", resolved.unsupportedBlock("table")) + // Unset fields keep the built-in English defaults. + val defaults = CascadeEditorStrings.default() + assertEquals(defaults.underline, resolved.underline) + assertEquals(defaults.hideKeyboard, resolved.hideKeyboard) + assertEquals(defaults.linkCancel, resolved.linkCancel) + } + + @Test + fun localizedBlockStringsMergeOverDefaultsAndCarryCustomTypes() { + val controller = CascadeEditorController() + + controller.setLocalization( + CascadeEditorLocalization( + blockStrings = listOf( + CascadeLocalizedBlockStrings( + typeId = "paragraph", + displayName = "Absatz", + description = "Einfacher Textabsatz", + keywords = listOf("text", "absatz"), + ), + CascadeLocalizedBlockStrings( + typeId = "table", + displayName = "Tabelle", + description = "Interaktive Tabelle", + ), + ), + ), + ) + + val resolved = controller.resolvedBlockStrings.value + val paragraph = assertNotNull(resolved.forType("paragraph")) + assertEquals("Absatz", paragraph.displayName) + assertEquals("Einfacher Textabsatz", paragraph.description) + assertEquals(listOf("text", "absatz"), paragraph.keywords) + // A natively registered custom type id localizes through the same surface. + val table = assertNotNull(resolved.forType("table")) + assertEquals("Tabelle", table.displayName) + // Types without an override keep the built-in entry. + assertEquals( + CascadeEditorBlockStrings.default().forType("todo"), + resolved.forType("todo"), + ) + } + + @Test + fun localizationIsSnapshottedWhenApplied() { + val controller = CascadeEditorController() + val strings = CascadeLocalizedStrings().apply { bold = "Fett" } + controller.setLocalization(CascadeEditorLocalization(strings)) + + // Mutating the bag after applying must not leak into the resolved set... + strings.bold = "Gras" + assertEquals("Fett", controller.resolvedStrings.value.bold) + + // ...until it is applied again. + controller.setLocalization(CascadeEditorLocalization(strings)) + assertEquals("Gras", controller.resolvedStrings.value.bold) + } +} diff --git a/editor-ios-sdk/src/iosSimulatorArm64Test/kotlin/io/github/linreal/cascade/ios/model/CascadeDocumentBuilderTest.kt b/editor-ios-sdk/src/iosSimulatorArm64Test/kotlin/io/github/linreal/cascade/ios/model/CascadeDocumentBuilderTest.kt new file mode 100644 index 0000000..742c816 --- /dev/null +++ b/editor-ios-sdk/src/iosSimulatorArm64Test/kotlin/io/github/linreal/cascade/ios/model/CascadeDocumentBuilderTest.kt @@ -0,0 +1,137 @@ +package io.github.linreal.cascade.ios.model + +import io.github.linreal.cascade.editor.core.BlockContent +import io.github.linreal.cascade.editor.core.BlockType +import io.github.linreal.cascade.editor.serialization.DocumentSchema +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertIs +import kotlin.test.assertNull +import kotlin.test.assertTrue + +class CascadeDocumentBuilderTest { + @Test + fun buildsBuiltInBlocks() { + val json = CascadeEditorDocumentBuilder() + .heading(1, "Title") + .paragraph("Body") + .todo("Ship", checked = true) + .divider() + .buildJson() + + val blocks = DocumentSchema.decodeFromString(json) + + assertIs(blocks[0].type) + assertEquals("Title", (blocks[0].content as BlockContent.Text).text) + assertIs(blocks[1].type) + assertEquals("Body", (blocks[1].content as BlockContent.Text).text) + val todo = assertIs(blocks[2].type) + assertEquals(true, todo.checked) + assertEquals("Ship", (blocks[2].content as BlockContent.Text).text) + assertIs(blocks[3].type) + } + + @Test + fun buildsCustomBlockFromPayloadJsonObject() { + val json = CascadeEditorDocumentBuilder() + .customBlock("metric", """{"value":"99.9%","label":"Uptime","trend":"up"}""") + .buildJson() + + val block = DocumentSchema.decodeFromString(json).single() + val content = block.content as BlockContent.Custom + + assertEquals("metric", block.type.typeId) + assertEquals("metric", content.typeId) + assertEquals("99.9%", content.data["value"]) + assertEquals("Uptime", content.data["label"]) + } + + @Test + fun customBlockPreservesNonFiniteJsonNumberAsString() { + val json = CascadeEditorDocumentBuilder() + .customBlock("metric", """{"value":1e999999}""") + .buildJson() + + val block = DocumentSchema.decodeFromString(json).single() + val content = block.content as BlockContent.Custom + val value = assertIs(content.data["value"]) + + assertEquals("1e999999", value) + } + + @Test + fun clampsInvalidHeadingLevelAndRecordsError() { + val builder = CascadeEditorDocumentBuilder() + + val result = runCatching { + builder.heading(99, "Oversized") + builder.buildJson() + } + + assertTrue(result.isSuccess) + assertEquals("Heading level must be between 1 and 6", builder.lastErrorMessage) + val block = DocumentSchema.decodeFromString(result.getOrThrow()).single() + val heading = assertIs(block.type) + assertEquals(6, heading.level) + assertEquals("Oversized", (block.content as BlockContent.Text).text) + } + + @Test + fun clampsInvalidNumberedListNumberAndRecordsError() { + val builder = CascadeEditorDocumentBuilder() + + val result = runCatching { + builder.numberedList("First", number = 0) + builder.buildJson() + } + + assertTrue(result.isSuccess) + assertEquals("Numbered list number must be >= 1", builder.lastErrorMessage) + val block = DocumentSchema.decodeFromString(result.getOrThrow()).single() + val numberedList = assertIs(block.type) + assertEquals(1, numberedList.number) + assertEquals("First", (block.content as BlockContent.Text).text) + } + + @Test + fun customBlockUsesEmptyPayloadForNonObjectJsonAndRecordsError() { + val builder = CascadeEditorDocumentBuilder() + + val result = runCatching { + builder.customBlock("metric", """["not-an-object"]""") + builder.buildJson() + } + + assertTrue(result.isSuccess) + assertEquals("Custom block payload must be a JSON object", builder.lastErrorMessage) + val content = DocumentSchema.decodeFromString(result.getOrThrow()).single().content as BlockContent.Custom + assertEquals("metric", content.typeId) + assertEquals(emptyMap(), content.data) + } + + @Test + fun customBlockUsesEmptyPayloadForMalformedJsonAndRecordsParseError() { + val builder = CascadeEditorDocumentBuilder() + + val result = runCatching { + builder.customBlock("metric", """{"value":""") + builder.buildJson() + } + + assertTrue(result.isSuccess) + assertTrue(builder.lastErrorMessage?.startsWith("Invalid custom block payload JSON: ") == true) + val content = DocumentSchema.decodeFromString(result.getOrThrow()).single().content as BlockContent.Custom + assertEquals("metric", content.typeId) + assertEquals(emptyMap(), content.data) + } + + @Test + fun clearLastErrorResetsBuilderErrorMessage() { + val builder = CascadeEditorDocumentBuilder() + .heading(0, "Clamped") + + assertEquals("Heading level must be between 1 and 6", builder.lastErrorMessage) + assertTrue(builder.clearLastError() === builder) + assertNull(builder.lastErrorMessage) + } +} diff --git a/editor-ios-sdk/src/iosSimulatorArm64Test/kotlin/io/github/linreal/cascade/ios/slash/NativeSlashCommandTest.kt b/editor-ios-sdk/src/iosSimulatorArm64Test/kotlin/io/github/linreal/cascade/ios/slash/NativeSlashCommandTest.kt new file mode 100644 index 0000000..e5bcb89 --- /dev/null +++ b/editor-ios-sdk/src/iosSimulatorArm64Test/kotlin/io/github/linreal/cascade/ios/slash/NativeSlashCommandTest.kt @@ -0,0 +1,273 @@ +package io.github.linreal.cascade.ios.slash + +import io.github.linreal.cascade.editor.action.FocusBlock +import io.github.linreal.cascade.editor.action.InsertBlockAfter +import io.github.linreal.cascade.editor.action.InsertBlockBefore +import io.github.linreal.cascade.editor.action.ReplaceBlock +import io.github.linreal.cascade.editor.action.UpdateBlockContent +import io.github.linreal.cascade.editor.core.Block +import io.github.linreal.cascade.editor.core.BlockContent +import io.github.linreal.cascade.editor.core.BlockId +import io.github.linreal.cascade.editor.slash.SlashCommandAction +import io.github.linreal.cascade.editor.slash.SlashCommandContext +import io.github.linreal.cascade.editor.slash.SlashCommandEditor +import io.github.linreal.cascade.editor.slash.SlashCommandResult +import io.github.linreal.cascade.editor.slash.builtInBlockSlashCommandId +import io.github.linreal.cascade.editor.state.SlashQueryRange +import io.github.linreal.cascade.ios.block.CascadeCustomBlockRegistration +import io.github.linreal.cascade.ios.block.NativeCustomBlockType +import io.github.linreal.cascade.ios.controller.CascadeEditorController +import io.github.linreal.cascade.ios.model.CascadeEditorDocumentBuilder +import kotlinx.coroutines.runBlocking +import platform.UIKit.UIViewController +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertIs +import kotlin.test.assertNotNull +import kotlin.test.assertNull +import kotlin.test.assertTrue + +class NativeSlashCommandTest { + + @Test + fun textCommandReplacesAnchorQueryTextAndReturnsDone() { + val (controller, anchorId) = controllerWithAnchor("/timestamp") + controller.registerSlashCommand( + CascadeSlashCommand( + id = "timestamp", + title = "Timestamp", + description = "Insert the current timestamp", + ) { context -> + context.replaceQueryText("2026-07-09") + CascadeSlashCommandResult.done + }, + ) + + val result = execute(controller, "timestamp", anchorId, SlashQueryRange(0, TIMESTAMP_LEN)) + + assertEquals(SlashCommandResult.Done, result) + assertEquals("2026-07-09", controller.textStates.getVisibleText(anchorId)) + } + + @Test + fun blockCommandInsertsCustomBlockAfterAnchorWithPayload() { + val (controller, anchorId) = controllerWithAnchor("hello") + controller.registerBlock(tableRegistration()) + controller.registerSlashCommand( + CascadeSlashCommand( + id = "insert-table", + title = "Table", + description = "Insert a table", + ) { context -> + context.insertBlockAfterAnchor("table", """{"rows":3}""") + CascadeSlashCommandResult.done + }, + ) + + val result = execute(controller, "insert-table", anchorId, SlashQueryRange(0, 0)) + + assertEquals(SlashCommandResult.Done, result) + val blocks = controller.stateHolder.state.blocks + val inserted = blocks[blocks.indexOfFirst { it.id == anchorId } + 1] + assertEquals("table", assertIs(inserted.type).typeId) + assertEquals(3L, assertIs(inserted.content).data["rows"]) + } + + @Test + fun blockCommandWithInvalidPayloadIsRejectedAndNotMutated() { + val (controller, anchorId) = controllerWithAnchor("hi") + controller.registerBlock(tableRegistration()) + var internalError: String? = null + controller.onInternalError = { message -> internalError = message } + var insertReturned: Boolean? = null + controller.registerSlashCommand( + CascadeSlashCommand(id = "bad-insert", title = "Bad", description = "d") { context -> + insertReturned = context.insertBlockAfterAnchor("table", "not json at all") + CascadeSlashCommandResult.done + }, + ) + val blocksBefore = controller.stateHolder.state.blocks.size + + execute(controller, "bad-insert", anchorId, SlashQueryRange(0, 0)) + + assertEquals(false, insertReturned) + assertEquals(blocksBefore, controller.stateHolder.state.blocks.size, "document must not be mutated") + assertTrue(assertNotNull(internalError).contains("payload", ignoreCase = true)) + } + + @Test + fun handlerFailureReportsMessageAndReturnsFailure() { + val (controller, anchorId) = controllerWithAnchor("hi") + var internalError: String? = null + controller.onInternalError = { message -> internalError = message } + controller.registerSlashCommand( + CascadeSlashCommand( + id = "boom", + title = "Boom", + description = "Always fails", + ) { CascadeSlashCommandResult.failure("boom") }, + ) + + val result = execute(controller, "boom", anchorId, SlashQueryRange(0, 0)) + + assertEquals("boom", assertIs(result).message) + assertTrue(assertNotNull(internalError).contains("boom")) + } + + @Test + fun builtInAndNativeCommandsCoexist() { + val controller = CascadeEditorController() + var internalError: String? = null + controller.onInternalError = { message -> internalError = message } + + val builtInIdsBefore = controller.builtInSlashCommandIds() + controller.registerSlashCommand( + CascadeSlashCommand(id = "timestamp", title = "Timestamp", description = "d") { + CascadeSlashCommandResult.done + }, + ) + + assertNull(internalError, "a non-colliding registration must not warn") + assertTrue(builtInIdsBefore.contains(builtInBlockSlashCommandId("paragraph"))) + assertEquals( + builtInIdsBefore, + controller.builtInSlashCommandIds(), + "registering a native command must not remove built-in commands", + ) + assertTrue(controller.slashRegistry.getRootItems().any { it.id.value == "timestamp" }) + } + + @Test + fun registeringExistingBuiltInIdOverridesAndWarns() { + val controller = CascadeEditorController() + var internalError: String? = null + controller.onInternalError = { message -> internalError = message } + val builtInId = builtInBlockSlashCommandId("paragraph").value + + controller.registerSlashCommand( + CascadeSlashCommand(id = builtInId, title = "Custom Paragraph", description = "d") { + CascadeSlashCommandResult.done + }, + ) + + assertTrue(assertNotNull(internalError).contains(builtInId)) + val overriding = controller.slashRegistry.getRootItems().single { it.id.value == builtInId } + assertEquals("Custom Paragraph", overriding.title) + } + + @Test + fun focusAnchorMovesFocusToAnchorBlock() { + val (controller, anchorId) = controllerWithAnchor("focus me") + controller.registerSlashCommand( + CascadeSlashCommand(id = "focus", title = "Focus", description = "d") { context -> + context.focusAnchor() + CascadeSlashCommandResult.done + }, + ) + + execute(controller, "focus", anchorId, SlashQueryRange(0, 0)) + + assertEquals(anchorId, controller.stateHolder.state.focusedBlockId) + } + + private fun controllerWithAnchor(text: String): Pair { + val controller = CascadeEditorController() + controller.loadJson(CascadeEditorDocumentBuilder().paragraph(text).buildJson()) + val anchorId = controller.stateHolder.state.blocks.first().id + // A slash command only ever runs on a mounted, focused block, which always + // has a runtime text state; seed it so the headless test mirrors that. + controller.textStates.getOrCreate(anchorId, text) + return controller to anchorId + } + + private fun execute( + controller: CascadeEditorController, + commandId: String, + anchorId: BlockId, + queryRange: SlashQueryRange, + ): SlashCommandResult { + val action = controller.slashRegistry.getRootItems() + .single { it.id.value == commandId } as SlashCommandAction + val editor = TestSlashCommandEditor(controller, anchorId, queryRange) + val context = SlashCommandContext( + anchorBlockId = anchorId, + query = commandId, + queryRange = queryRange, + editor = editor, + ) + return runBlocking { action.onExecute(context) } + } + + private fun tableRegistration(): CascadeCustomBlockRegistration = + CascadeCustomBlockRegistration( + typeId = "table", + displayName = "Table", + description = "A table block", + ) { UIViewController() } + + private companion object { + const val TIMESTAMP_LEN: Int = 10 // "/timestamp".length + } +} + +/** + * A [SlashCommandEditor] over the controller's real state holder, mirroring the + * production host's dispatch behavior so slash execution is exercised against + * real editor state without a mounted Compose tree. + */ +private class TestSlashCommandEditor( + private val controller: CascadeEditorController, + private val anchorBlockId: BlockId, + private val queryRange: SlashQueryRange, +) : SlashCommandEditor { + + private val stateHolder get() = controller.stateHolder + private val textStates get() = controller.textStates + + override fun getAnchorBlock(): Block? = stateHolder.state.getBlock(anchorBlockId) + + override fun getAnchorVisibleText(): String? = textStates.getVisibleText(anchorBlockId) + + override fun replaceQueryText(replacement: String) { + val visible = textStates.getVisibleText(anchorBlockId) + ?: (getAnchorBlock()?.content as? BlockContent.Text)?.text + ?: return + val start = queryRange.start.coerceIn(0, visible.length) + val end = queryRange.endExclusive.coerceIn(start, visible.length) + val newText = visible.substring(0, start) + replacement + visible.substring(end) + textStates.setText(anchorBlockId, newText, start + replacement.length) + stateHolder.dispatch(UpdateBlockContent(anchorBlockId, BlockContent.Text(newText, emptyList()))) + } + + override fun updateAnchorText(text: String, cursorPosition: Int?) { + textStates.setText(anchorBlockId, text, cursorPosition) + stateHolder.dispatch(UpdateBlockContent(anchorBlockId, BlockContent.Text(text, emptyList()))) + } + + override fun replaceAnchorBlock( + block: Block, + preserveAnchorId: Boolean, + requestFocus: Boolean, + cursorPosition: Int?, + ) { + val effective = if (preserveAnchorId) Block(anchorBlockId, block.type, block.content) else block + stateHolder.dispatch(ReplaceBlock(anchorBlockId, effective)) + } + + override fun insertBlockAfterAnchor(block: Block, requestFocus: Boolean, cursorPosition: Int?) { + if (getAnchorBlock() == null) return + stateHolder.dispatch(InsertBlockAfter(block, anchorBlockId)) + } + + override fun insertBlockBeforeAnchor(block: Block) { + if (getAnchorBlock() == null) return + stateHolder.dispatch(InsertBlockBefore(block, anchorBlockId)) + } + + override fun focusBlock(blockId: BlockId, cursorPosition: Int?) { + if (stateHolder.state.getBlock(blockId) == null) return + stateHolder.dispatch(FocusBlock(blockId)) + } + + override fun closeMenu() = Unit +} diff --git a/editor-ios-sdk/src/iosSimulatorArm64Test/kotlin/io/github/linreal/cascade/ios/toolbar/CascadeToolbarStateTest.kt b/editor-ios-sdk/src/iosSimulatorArm64Test/kotlin/io/github/linreal/cascade/ios/toolbar/CascadeToolbarStateTest.kt new file mode 100644 index 0000000..a94e3e9 --- /dev/null +++ b/editor-ios-sdk/src/iosSimulatorArm64Test/kotlin/io/github/linreal/cascade/ios/toolbar/CascadeToolbarStateTest.kt @@ -0,0 +1,30 @@ +package io.github.linreal.cascade.ios.toolbar + +import io.github.linreal.cascade.editor.richtext.StyleStatus +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertFalse +import kotlin.test.assertNull + +class CascadeToolbarStateTest { + @Test + fun mapsStyleStatusToTriState() { + assertEquals(CascadeStyleState.active, StyleStatus.FullyActive.toCascadeStyleState()) + assertEquals(CascadeStyleState.mixed, StyleStatus.Partial.toCascadeStyleState()) + assertEquals(CascadeStyleState.inactive, StyleStatus.Absent.toCascadeStyleState()) + } + + @Test + fun emptyToolbarStateIsUnavailable() { + val empty = CascadeToolbarState.Empty + + assertFalse(empty.focused) + assertFalse(empty.canFormat) + assertEquals(CascadeStyleState.inactive, empty.bold) + assertEquals(CascadeStyleState.inactive, empty.highlight) + assertFalse(empty.canIndentForward) + assertFalse(empty.canIndentBackward) + assertFalse(empty.canLink) + assertNull(empty.existingUrl) + } +} diff --git a/editor/api/android/editor.api b/editor/api/android/editor.api new file mode 100644 index 0000000..afbb082 --- /dev/null +++ b/editor/api/android/editor.api @@ -0,0 +1,3062 @@ +public final class io/github/linreal/cascade/editor/CascadeError { + public static final field $stable I + public fun (Ljava/lang/String;Ljava/lang/Throwable;)V + public final fun component1 ()Ljava/lang/String; + public final fun component2 ()Ljava/lang/Throwable; + public final fun copy (Ljava/lang/String;Ljava/lang/Throwable;)Lio/github/linreal/cascade/editor/CascadeError; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/CascadeError;Ljava/lang/String;Ljava/lang/Throwable;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/CascadeError; + public fun equals (Ljava/lang/Object;)Z + public final fun getCause ()Ljava/lang/Throwable; + public final fun getContext ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/CrashPolicy : java/lang/Enum { + public static final field ContainAndReport Lio/github/linreal/cascade/editor/CrashPolicy; + public static final field Rethrow Lio/github/linreal/cascade/editor/CrashPolicy; + public static fun getEntries ()Lkotlin/enums/EnumEntries; + public static fun valueOf (Ljava/lang/String;)Lio/github/linreal/cascade/editor/CrashPolicy; + public static fun values ()[Lio/github/linreal/cascade/editor/CrashPolicy; +} + +public final class io/github/linreal/cascade/editor/action/AddBlockRangeToSelection : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public synthetic fun (Ljava/lang/String;Ljava/lang/String;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1--4CzayM ()Ljava/lang/String; + public final fun component2--4CzayM ()Ljava/lang/String; + public final fun copy-uwJGxUo (Ljava/lang/String;Ljava/lang/String;)Lio/github/linreal/cascade/editor/action/AddBlockRangeToSelection; + public static synthetic fun copy-uwJGxUo$default (Lio/github/linreal/cascade/editor/action/AddBlockRangeToSelection;Ljava/lang/String;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/action/AddBlockRangeToSelection; + public fun equals (Ljava/lang/Object;)Z + public final fun getFromId--4CzayM ()Ljava/lang/String; + public final fun getToId--4CzayM ()Ljava/lang/String; + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/ApplySpanStyle : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public synthetic fun (Ljava/lang/String;IILio/github/linreal/cascade/editor/core/SpanStyle;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1--4CzayM ()Ljava/lang/String; + public final fun component2 ()I + public final fun component3 ()I + public final fun component4 ()Lio/github/linreal/cascade/editor/core/SpanStyle; + public final fun copy-PeeSg0I (Ljava/lang/String;IILio/github/linreal/cascade/editor/core/SpanStyle;)Lio/github/linreal/cascade/editor/action/ApplySpanStyle; + public static synthetic fun copy-PeeSg0I$default (Lio/github/linreal/cascade/editor/action/ApplySpanStyle;Ljava/lang/String;IILio/github/linreal/cascade/editor/core/SpanStyle;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/action/ApplySpanStyle; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlockId--4CzayM ()Ljava/lang/String; + public final fun getRangeEnd ()I + public final fun getRangeStart ()I + public final fun getStyle ()Lio/github/linreal/cascade/editor/core/SpanStyle; + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/CancelDrag : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/action/CancelDrag; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/ClearFocus : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/action/ClearFocus; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/ClearSelection : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/action/ClearSelection; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/CloseSlashCommand : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/action/CloseSlashCommand; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/CompleteDrag : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/action/CompleteDrag; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/ConvertBlockType : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public synthetic fun (Ljava/lang/String;Lio/github/linreal/cascade/editor/core/BlockType;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1--4CzayM ()Ljava/lang/String; + public final fun component2 ()Lio/github/linreal/cascade/editor/core/BlockType; + public final fun copy-7OMXkl4 (Ljava/lang/String;Lio/github/linreal/cascade/editor/core/BlockType;)Lio/github/linreal/cascade/editor/action/ConvertBlockType; + public static synthetic fun copy-7OMXkl4$default (Lio/github/linreal/cascade/editor/action/ConvertBlockType;Ljava/lang/String;Lio/github/linreal/cascade/editor/core/BlockType;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/action/ConvertBlockType; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlockId--4CzayM ()Ljava/lang/String; + public final fun getNewType ()Lio/github/linreal/cascade/editor/core/BlockType; + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/DeleteBlock : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public synthetic fun (Ljava/lang/String;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1--4CzayM ()Ljava/lang/String; + public final fun copy-SDe6QqM (Ljava/lang/String;)Lio/github/linreal/cascade/editor/action/DeleteBlock; + public static synthetic fun copy-SDe6QqM$default (Lio/github/linreal/cascade/editor/action/DeleteBlock;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/action/DeleteBlock; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlockId--4CzayM ()Ljava/lang/String; + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/DeleteBlocks : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public fun (Ljava/util/Set;)V + public final fun component1 ()Ljava/util/Set; + public final fun copy (Ljava/util/Set;)Lio/github/linreal/cascade/editor/action/DeleteBlocks; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/action/DeleteBlocks;Ljava/util/Set;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/action/DeleteBlocks; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlockIds ()Ljava/util/Set; + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/DeleteSelectedOrFocused : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/action/DeleteSelectedOrFocused; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public abstract interface class io/github/linreal/cascade/editor/action/EditorAction { + public abstract fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; +} + +public final class io/github/linreal/cascade/editor/action/FocusBlock : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public synthetic fun (Ljava/lang/String;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1-ticUwL4 ()Ljava/lang/String; + public final fun copy-pWxEiPs (Ljava/lang/String;)Lio/github/linreal/cascade/editor/action/FocusBlock; + public static synthetic fun copy-pWxEiPs$default (Lio/github/linreal/cascade/editor/action/FocusBlock;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/action/FocusBlock; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlockId-ticUwL4 ()Ljava/lang/String; + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/FocusNextBlock : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/action/FocusNextBlock; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/FocusPreviousBlock : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/action/FocusPreviousBlock; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/HighlightSlashCommand : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public synthetic fun (Ljava/lang/String;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1-YhkQzo8 ()Ljava/lang/String; + public final fun copy-505l8FM (Ljava/lang/String;)Lio/github/linreal/cascade/editor/action/HighlightSlashCommand; + public static synthetic fun copy-505l8FM$default (Lio/github/linreal/cascade/editor/action/HighlightSlashCommand;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/action/HighlightSlashCommand; + public fun equals (Ljava/lang/Object;)Z + public final fun getCommandId-YhkQzo8 ()Ljava/lang/String; + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/IndentBackward : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/action/IndentBackward; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/IndentForward : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/action/IndentForward; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/InsertBlock : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public fun (Lio/github/linreal/cascade/editor/core/Block;Ljava/lang/Integer;)V + public synthetic fun (Lio/github/linreal/cascade/editor/core/Block;Ljava/lang/Integer;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()Lio/github/linreal/cascade/editor/core/Block; + public final fun component2 ()Ljava/lang/Integer; + public final fun copy (Lio/github/linreal/cascade/editor/core/Block;Ljava/lang/Integer;)Lio/github/linreal/cascade/editor/action/InsertBlock; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/action/InsertBlock;Lio/github/linreal/cascade/editor/core/Block;Ljava/lang/Integer;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/action/InsertBlock; + public fun equals (Ljava/lang/Object;)Z + public final fun getAtIndex ()Ljava/lang/Integer; + public final fun getBlock ()Lio/github/linreal/cascade/editor/core/Block; + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/InsertBlockAfter : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public synthetic fun (Lio/github/linreal/cascade/editor/core/Block;Ljava/lang/String;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()Lio/github/linreal/cascade/editor/core/Block; + public final fun component2-ticUwL4 ()Ljava/lang/String; + public final fun copy-kAZpsYI (Lio/github/linreal/cascade/editor/core/Block;Ljava/lang/String;)Lio/github/linreal/cascade/editor/action/InsertBlockAfter; + public static synthetic fun copy-kAZpsYI$default (Lio/github/linreal/cascade/editor/action/InsertBlockAfter;Lio/github/linreal/cascade/editor/core/Block;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/action/InsertBlockAfter; + public fun equals (Ljava/lang/Object;)Z + public final fun getAfterBlockId-ticUwL4 ()Ljava/lang/String; + public final fun getBlock ()Lio/github/linreal/cascade/editor/core/Block; + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/InsertBlockBefore : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public synthetic fun (Lio/github/linreal/cascade/editor/core/Block;Ljava/lang/String;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()Lio/github/linreal/cascade/editor/core/Block; + public final fun component2-ticUwL4 ()Ljava/lang/String; + public final fun copy-kAZpsYI (Lio/github/linreal/cascade/editor/core/Block;Ljava/lang/String;)Lio/github/linreal/cascade/editor/action/InsertBlockBefore; + public static synthetic fun copy-kAZpsYI$default (Lio/github/linreal/cascade/editor/action/InsertBlockBefore;Lio/github/linreal/cascade/editor/core/Block;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/action/InsertBlockBefore; + public fun equals (Ljava/lang/Object;)Z + public final fun getBeforeBlockId-ticUwL4 ()Ljava/lang/String; + public final fun getBlock ()Lio/github/linreal/cascade/editor/core/Block; + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/MergeBlocks : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public synthetic fun (Ljava/lang/String;Ljava/lang/String;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1--4CzayM ()Ljava/lang/String; + public final fun component2--4CzayM ()Ljava/lang/String; + public final fun copy-uwJGxUo (Ljava/lang/String;Ljava/lang/String;)Lio/github/linreal/cascade/editor/action/MergeBlocks; + public static synthetic fun copy-uwJGxUo$default (Lio/github/linreal/cascade/editor/action/MergeBlocks;Ljava/lang/String;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/action/MergeBlocks; + public fun equals (Ljava/lang/Object;)Z + public final fun getSourceId--4CzayM ()Ljava/lang/String; + public final fun getTargetId--4CzayM ()Ljava/lang/String; + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/MoveBlocks : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public fun (Ljava/util/Set;I)V + public final fun component1 ()Ljava/util/Set; + public final fun component2 ()I + public final fun copy (Ljava/util/Set;I)Lio/github/linreal/cascade/editor/action/MoveBlocks; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/action/MoveBlocks;Ljava/util/Set;IILjava/lang/Object;)Lio/github/linreal/cascade/editor/action/MoveBlocks; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlockIds ()Ljava/util/Set; + public final fun getToIndex ()I + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/NavigateSlashBack : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/action/NavigateSlashBack; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/NavigateSlashSubmenu : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public synthetic fun (Ljava/lang/String;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1-6BJIqV4 ()Ljava/lang/String; + public final fun copy-t5i0Ytw (Ljava/lang/String;)Lio/github/linreal/cascade/editor/action/NavigateSlashSubmenu; + public static synthetic fun copy-t5i0Ytw$default (Lio/github/linreal/cascade/editor/action/NavigateSlashSubmenu;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/action/NavigateSlashSubmenu; + public fun equals (Ljava/lang/Object;)Z + public final fun getSubmenuId-6BJIqV4 ()Ljava/lang/String; + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/OpenSlashCommand : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public synthetic fun (Ljava/lang/String;Lio/github/linreal/cascade/editor/state/SlashQueryRange;Ljava/lang/String;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public synthetic fun (Ljava/lang/String;Lio/github/linreal/cascade/editor/state/SlashQueryRange;Ljava/lang/String;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1--4CzayM ()Ljava/lang/String; + public final fun component2 ()Lio/github/linreal/cascade/editor/state/SlashQueryRange; + public final fun component3 ()Ljava/lang/String; + public final fun copy-p1zP0qE (Ljava/lang/String;Lio/github/linreal/cascade/editor/state/SlashQueryRange;Ljava/lang/String;)Lio/github/linreal/cascade/editor/action/OpenSlashCommand; + public static synthetic fun copy-p1zP0qE$default (Lio/github/linreal/cascade/editor/action/OpenSlashCommand;Ljava/lang/String;Lio/github/linreal/cascade/editor/state/SlashQueryRange;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/action/OpenSlashCommand; + public fun equals (Ljava/lang/Object;)Z + public final fun getAnchorBlockId--4CzayM ()Ljava/lang/String; + public final fun getInitialQuery ()Ljava/lang/String; + public final fun getQueryRange ()Lio/github/linreal/cascade/editor/state/SlashQueryRange; + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/RemoveSpanStyle : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public synthetic fun (Ljava/lang/String;IILio/github/linreal/cascade/editor/core/SpanStyle;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1--4CzayM ()Ljava/lang/String; + public final fun component2 ()I + public final fun component3 ()I + public final fun component4 ()Lio/github/linreal/cascade/editor/core/SpanStyle; + public final fun copy-PeeSg0I (Ljava/lang/String;IILio/github/linreal/cascade/editor/core/SpanStyle;)Lio/github/linreal/cascade/editor/action/RemoveSpanStyle; + public static synthetic fun copy-PeeSg0I$default (Lio/github/linreal/cascade/editor/action/RemoveSpanStyle;Ljava/lang/String;IILio/github/linreal/cascade/editor/core/SpanStyle;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/action/RemoveSpanStyle; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlockId--4CzayM ()Ljava/lang/String; + public final fun getRangeEnd ()I + public final fun getRangeStart ()I + public final fun getStyle ()Lio/github/linreal/cascade/editor/core/SpanStyle; + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/ReplaceBlock : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public synthetic fun (Ljava/lang/String;Lio/github/linreal/cascade/editor/core/Block;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1--4CzayM ()Ljava/lang/String; + public final fun component2 ()Lio/github/linreal/cascade/editor/core/Block; + public final fun copy-7OMXkl4 (Ljava/lang/String;Lio/github/linreal/cascade/editor/core/Block;)Lio/github/linreal/cascade/editor/action/ReplaceBlock; + public static synthetic fun copy-7OMXkl4$default (Lio/github/linreal/cascade/editor/action/ReplaceBlock;Ljava/lang/String;Lio/github/linreal/cascade/editor/core/Block;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/action/ReplaceBlock; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlockId--4CzayM ()Ljava/lang/String; + public final fun getNewBlock ()Lio/github/linreal/cascade/editor/core/Block; + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/SelectAll : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/action/SelectAll; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/SelectBlock : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public synthetic fun (Ljava/lang/String;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1--4CzayM ()Ljava/lang/String; + public final fun copy-SDe6QqM (Ljava/lang/String;)Lio/github/linreal/cascade/editor/action/SelectBlock; + public static synthetic fun copy-SDe6QqM$default (Lio/github/linreal/cascade/editor/action/SelectBlock;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/action/SelectBlock; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlockId--4CzayM ()Ljava/lang/String; + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/SelectBlockRange : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public synthetic fun (Ljava/lang/String;Ljava/lang/String;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1--4CzayM ()Ljava/lang/String; + public final fun component2--4CzayM ()Ljava/lang/String; + public final fun copy-uwJGxUo (Ljava/lang/String;Ljava/lang/String;)Lio/github/linreal/cascade/editor/action/SelectBlockRange; + public static synthetic fun copy-uwJGxUo$default (Lio/github/linreal/cascade/editor/action/SelectBlockRange;Ljava/lang/String;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/action/SelectBlockRange; + public fun equals (Ljava/lang/Object;)Z + public final fun getFromId--4CzayM ()Ljava/lang/String; + public final fun getToId--4CzayM ()Ljava/lang/String; + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/SplitBlock : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public synthetic fun (Ljava/lang/String;ILjava/lang/String;Ljava/lang/String;Ljava/util/List;Ljava/lang/String;Ljava/util/List;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public synthetic fun (Ljava/lang/String;ILjava/lang/String;Ljava/lang/String;Ljava/util/List;Ljava/lang/String;Ljava/util/List;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1--4CzayM ()Ljava/lang/String; + public final fun component2 ()I + public final fun component3 ()Ljava/lang/String; + public final fun component4-ticUwL4 ()Ljava/lang/String; + public final fun component5 ()Ljava/util/List; + public final fun component6 ()Ljava/lang/String; + public final fun component7 ()Ljava/util/List; + public final fun copy-BD9ZTBs (Ljava/lang/String;ILjava/lang/String;Ljava/lang/String;Ljava/util/List;Ljava/lang/String;Ljava/util/List;)Lio/github/linreal/cascade/editor/action/SplitBlock; + public static synthetic fun copy-BD9ZTBs$default (Lio/github/linreal/cascade/editor/action/SplitBlock;Ljava/lang/String;ILjava/lang/String;Ljava/lang/String;Ljava/util/List;Ljava/lang/String;Ljava/util/List;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/action/SplitBlock; + public fun equals (Ljava/lang/Object;)Z + public final fun getAtPosition ()I + public final fun getBlockId--4CzayM ()Ljava/lang/String; + public final fun getNewBlockId-ticUwL4 ()Ljava/lang/String; + public final fun getNewBlockSpans ()Ljava/util/List; + public final fun getNewBlockText ()Ljava/lang/String; + public final fun getSourceBlockSpans ()Ljava/util/List; + public final fun getSourceBlockText ()Ljava/lang/String; + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/StartDrag : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public synthetic fun (Ljava/lang/String;FLkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1--4CzayM ()Ljava/lang/String; + public final fun component2 ()F + public final fun copy-7OMXkl4 (Ljava/lang/String;F)Lio/github/linreal/cascade/editor/action/StartDrag; + public static synthetic fun copy-7OMXkl4$default (Lio/github/linreal/cascade/editor/action/StartDrag;Ljava/lang/String;FILjava/lang/Object;)Lio/github/linreal/cascade/editor/action/StartDrag; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlockId--4CzayM ()Ljava/lang/String; + public final fun getTouchOffsetY ()F + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/ToggleBlockSelection : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public synthetic fun (Ljava/lang/String;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1--4CzayM ()Ljava/lang/String; + public final fun copy-SDe6QqM (Ljava/lang/String;)Lio/github/linreal/cascade/editor/action/ToggleBlockSelection; + public static synthetic fun copy-SDe6QqM$default (Lio/github/linreal/cascade/editor/action/ToggleBlockSelection;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/action/ToggleBlockSelection; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlockId--4CzayM ()Ljava/lang/String; + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/ToggleTodo : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public synthetic fun (Ljava/lang/String;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1--4CzayM ()Ljava/lang/String; + public final fun copy-SDe6QqM (Ljava/lang/String;)Lio/github/linreal/cascade/editor/action/ToggleTodo; + public static synthetic fun copy-SDe6QqM$default (Lio/github/linreal/cascade/editor/action/ToggleTodo;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/action/ToggleTodo; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlockId--4CzayM ()Ljava/lang/String; + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/UpdateBlockContent : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public synthetic fun (Ljava/lang/String;Lio/github/linreal/cascade/editor/core/BlockContent;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1--4CzayM ()Ljava/lang/String; + public final fun component2 ()Lio/github/linreal/cascade/editor/core/BlockContent; + public final fun copy-7OMXkl4 (Ljava/lang/String;Lio/github/linreal/cascade/editor/core/BlockContent;)Lio/github/linreal/cascade/editor/action/UpdateBlockContent; + public static synthetic fun copy-7OMXkl4$default (Lio/github/linreal/cascade/editor/action/UpdateBlockContent;Ljava/lang/String;Lio/github/linreal/cascade/editor/core/BlockContent;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/action/UpdateBlockContent; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlockId--4CzayM ()Ljava/lang/String; + public final fun getContent ()Lio/github/linreal/cascade/editor/core/BlockContent; + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/UpdateBlockText : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public synthetic fun (Ljava/lang/String;Ljava/lang/String;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1--4CzayM ()Ljava/lang/String; + public final fun component2 ()Ljava/lang/String; + public final fun copy-7OMXkl4 (Ljava/lang/String;Ljava/lang/String;)Lio/github/linreal/cascade/editor/action/UpdateBlockText; + public static synthetic fun copy-7OMXkl4$default (Lio/github/linreal/cascade/editor/action/UpdateBlockText;Ljava/lang/String;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/action/UpdateBlockText; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlockId--4CzayM ()Ljava/lang/String; + public final fun getText ()Ljava/lang/String; + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/UpdateDragTarget : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public fun (Ljava/lang/Integer;Ljava/lang/Integer;)V + public synthetic fun (Ljava/lang/Integer;Ljava/lang/Integer;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()Ljava/lang/Integer; + public final fun component2 ()Ljava/lang/Integer; + public final fun copy (Ljava/lang/Integer;Ljava/lang/Integer;)Lio/github/linreal/cascade/editor/action/UpdateDragTarget; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/action/UpdateDragTarget;Ljava/lang/Integer;Ljava/lang/Integer;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/action/UpdateDragTarget; + public fun equals (Ljava/lang/Object;)Z + public final fun getFutureRootIndentationLevel ()Ljava/lang/Integer; + public final fun getTargetIndex ()Ljava/lang/Integer; + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/UpdateSlashCommandSession : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public fun (Ljava/lang/String;Lio/github/linreal/cascade/editor/state/SlashQueryRange;)V + public final fun component1 ()Ljava/lang/String; + public final fun component2 ()Lio/github/linreal/cascade/editor/state/SlashQueryRange; + public final fun copy (Ljava/lang/String;Lio/github/linreal/cascade/editor/state/SlashQueryRange;)Lio/github/linreal/cascade/editor/action/UpdateSlashCommandSession; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/action/UpdateSlashCommandSession;Ljava/lang/String;Lio/github/linreal/cascade/editor/state/SlashQueryRange;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/action/UpdateSlashCommandSession; + public fun equals (Ljava/lang/Object;)Z + public final fun getQuery ()Ljava/lang/String; + public final fun getQueryRange ()Lio/github/linreal/cascade/editor/state/SlashQueryRange; + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/core/Block { + public static final field $stable I + public static final field Companion Lio/github/linreal/cascade/editor/core/Block$Companion; + public synthetic fun (Ljava/lang/String;Lio/github/linreal/cascade/editor/core/BlockType;Lio/github/linreal/cascade/editor/core/BlockContent;Lio/github/linreal/cascade/editor/core/BlockAttributes;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public synthetic fun (Ljava/lang/String;Lio/github/linreal/cascade/editor/core/BlockType;Lio/github/linreal/cascade/editor/core/BlockContent;Lio/github/linreal/cascade/editor/core/BlockAttributes;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1--4CzayM ()Ljava/lang/String; + public final fun component2 ()Lio/github/linreal/cascade/editor/core/BlockType; + public final fun component3 ()Lio/github/linreal/cascade/editor/core/BlockContent; + public final fun component4 ()Lio/github/linreal/cascade/editor/core/BlockAttributes; + public final fun copy-PeeSg0I (Ljava/lang/String;Lio/github/linreal/cascade/editor/core/BlockType;Lio/github/linreal/cascade/editor/core/BlockContent;Lio/github/linreal/cascade/editor/core/BlockAttributes;)Lio/github/linreal/cascade/editor/core/Block; + public static synthetic fun copy-PeeSg0I$default (Lio/github/linreal/cascade/editor/core/Block;Ljava/lang/String;Lio/github/linreal/cascade/editor/core/BlockType;Lio/github/linreal/cascade/editor/core/BlockContent;Lio/github/linreal/cascade/editor/core/BlockAttributes;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/core/Block; + public fun equals (Ljava/lang/Object;)Z + public final fun getAttributes ()Lio/github/linreal/cascade/editor/core/BlockAttributes; + public final fun getContent ()Lio/github/linreal/cascade/editor/core/BlockContent; + public final fun getId--4CzayM ()Ljava/lang/String; + public final fun getType ()Lio/github/linreal/cascade/editor/core/BlockType; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; + public final fun withAttributes (Lio/github/linreal/cascade/editor/core/BlockAttributes;)Lio/github/linreal/cascade/editor/core/Block; + public final fun withContent (Lio/github/linreal/cascade/editor/core/BlockContent;)Lio/github/linreal/cascade/editor/core/Block; + public final fun withType (Lio/github/linreal/cascade/editor/core/BlockType;)Lio/github/linreal/cascade/editor/core/Block; +} + +public final class io/github/linreal/cascade/editor/core/Block$Companion { + public final fun bulletList (Ljava/lang/String;)Lio/github/linreal/cascade/editor/core/Block; + public static synthetic fun bulletList$default (Lio/github/linreal/cascade/editor/core/Block$Companion;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/core/Block; + public final fun divider ()Lio/github/linreal/cascade/editor/core/Block; + public final fun heading (ILjava/lang/String;)Lio/github/linreal/cascade/editor/core/Block; + public static synthetic fun heading$default (Lio/github/linreal/cascade/editor/core/Block$Companion;ILjava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/core/Block; + public final fun numberedList (Ljava/lang/String;I)Lio/github/linreal/cascade/editor/core/Block; + public static synthetic fun numberedList$default (Lio/github/linreal/cascade/editor/core/Block$Companion;Ljava/lang/String;IILjava/lang/Object;)Lio/github/linreal/cascade/editor/core/Block; + public final fun paragraph (Ljava/lang/String;Ljava/util/List;)Lio/github/linreal/cascade/editor/core/Block; + public static synthetic fun paragraph$default (Lio/github/linreal/cascade/editor/core/Block$Companion;Ljava/lang/String;Ljava/util/List;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/core/Block; + public final fun todo (Ljava/lang/String;Z)Lio/github/linreal/cascade/editor/core/Block; + public static synthetic fun todo$default (Lio/github/linreal/cascade/editor/core/Block$Companion;Ljava/lang/String;ZILjava/lang/Object;)Lio/github/linreal/cascade/editor/core/Block; +} + +public final class io/github/linreal/cascade/editor/core/BlockAttributes { + public static final field $stable I + public static final field Companion Lio/github/linreal/cascade/editor/core/BlockAttributes$Companion; + public static final field MAX_INDENTATION_LEVEL I + public static final field MIN_INDENTATION_LEVEL I + public fun ()V + public fun (I)V + public synthetic fun (IILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()I + public final fun copy (I)Lio/github/linreal/cascade/editor/core/BlockAttributes; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/core/BlockAttributes;IILjava/lang/Object;)Lio/github/linreal/cascade/editor/core/BlockAttributes; + public fun equals (Ljava/lang/Object;)Z + public final fun getIndentationLevel ()I + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/core/BlockAttributes$Companion { + public final fun getDefault ()Lio/github/linreal/cascade/editor/core/BlockAttributes; +} + +public abstract interface class io/github/linreal/cascade/editor/core/BlockContent { +} + +public final class io/github/linreal/cascade/editor/core/BlockContent$Custom : io/github/linreal/cascade/editor/core/BlockContent { + public static final field $stable I + public fun (Ljava/lang/String;Ljava/util/Map;)V + public synthetic fun (Ljava/lang/String;Ljava/util/Map;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()Ljava/lang/String; + public final fun component2 ()Ljava/util/Map; + public final fun copy (Ljava/lang/String;Ljava/util/Map;)Lio/github/linreal/cascade/editor/core/BlockContent$Custom; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/core/BlockContent$Custom;Ljava/lang/String;Ljava/util/Map;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/core/BlockContent$Custom; + public fun equals (Ljava/lang/Object;)Z + public final fun getData ()Ljava/util/Map; + public final fun getTypeId ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/core/BlockContent$Empty : io/github/linreal/cascade/editor/core/BlockContent { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/core/BlockContent$Empty; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/core/BlockContent$Text : io/github/linreal/cascade/editor/core/BlockContent { + public static final field $stable I + public fun (Ljava/lang/String;Ljava/util/List;)V + public synthetic fun (Ljava/lang/String;Ljava/util/List;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()Ljava/lang/String; + public final fun component2 ()Ljava/util/List; + public final fun copy (Ljava/lang/String;Ljava/util/List;)Lio/github/linreal/cascade/editor/core/BlockContent$Text; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/core/BlockContent$Text;Ljava/lang/String;Ljava/util/List;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/core/BlockContent$Text; + public fun equals (Ljava/lang/Object;)Z + public final fun getSpans ()Ljava/util/List; + public final fun getText ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/core/BlockId { + public static final field Companion Lio/github/linreal/cascade/editor/core/BlockId$Companion; + public static final synthetic fun box-impl (Ljava/lang/String;)Lio/github/linreal/cascade/editor/core/BlockId; + public static fun constructor-impl (Ljava/lang/String;)Ljava/lang/String; + public fun equals (Ljava/lang/Object;)Z + public static fun equals-impl (Ljava/lang/String;Ljava/lang/Object;)Z + public static final fun equals-impl0 (Ljava/lang/String;Ljava/lang/String;)Z + public final fun getValue ()Ljava/lang/String; + public fun hashCode ()I + public static fun hashCode-impl (Ljava/lang/String;)I + public fun toString ()Ljava/lang/String; + public static fun toString-impl (Ljava/lang/String;)Ljava/lang/String; + public final synthetic fun unbox-impl ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/core/BlockId$Companion { + public final fun generate--4CzayM ()Ljava/lang/String; +} + +public abstract interface class io/github/linreal/cascade/editor/core/BlockType { + public abstract fun getDisplayName ()Ljava/lang/String; + public fun getSupportsIndentation ()Z + public fun getSupportsSpans ()Z + public fun getSupportsText ()Z + public abstract fun getTypeId ()Ljava/lang/String; + public fun isConvertible ()Z +} + +public final class io/github/linreal/cascade/editor/core/BlockType$BulletList : io/github/linreal/cascade/editor/core/BlockType { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/core/BlockType$BulletList; + public fun equals (Ljava/lang/Object;)Z + public fun getDisplayName ()Ljava/lang/String; + public fun getSupportsIndentation ()Z + public fun getSupportsSpans ()Z + public fun getSupportsText ()Z + public fun getTypeId ()Ljava/lang/String; + public fun hashCode ()I + public fun isConvertible ()Z + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/core/BlockType$Code : io/github/linreal/cascade/editor/core/BlockType { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/core/BlockType$Code; + public fun equals (Ljava/lang/Object;)Z + public fun getDisplayName ()Ljava/lang/String; + public fun getSupportsIndentation ()Z + public fun getSupportsSpans ()Z + public fun getSupportsText ()Z + public fun getTypeId ()Ljava/lang/String; + public fun hashCode ()I + public fun isConvertible ()Z + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/core/BlockType$DefaultImpls { + public static fun getSupportsIndentation (Lio/github/linreal/cascade/editor/core/BlockType;)Z + public static fun getSupportsSpans (Lio/github/linreal/cascade/editor/core/BlockType;)Z + public static fun getSupportsText (Lio/github/linreal/cascade/editor/core/BlockType;)Z + public static fun isConvertible (Lio/github/linreal/cascade/editor/core/BlockType;)Z +} + +public final class io/github/linreal/cascade/editor/core/BlockType$Divider : io/github/linreal/cascade/editor/core/BlockType { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/core/BlockType$Divider; + public fun equals (Ljava/lang/Object;)Z + public fun getDisplayName ()Ljava/lang/String; + public fun getSupportsIndentation ()Z + public fun getSupportsSpans ()Z + public fun getSupportsText ()Z + public fun getTypeId ()Ljava/lang/String; + public fun hashCode ()I + public fun isConvertible ()Z + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/core/BlockType$Heading : io/github/linreal/cascade/editor/core/BlockType { + public static final field $stable I + public fun (I)V + public final fun component1 ()I + public final fun copy (I)Lio/github/linreal/cascade/editor/core/BlockType$Heading; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/core/BlockType$Heading;IILjava/lang/Object;)Lio/github/linreal/cascade/editor/core/BlockType$Heading; + public fun equals (Ljava/lang/Object;)Z + public fun getDisplayName ()Ljava/lang/String; + public final fun getLevel ()I + public fun getSupportsIndentation ()Z + public fun getSupportsSpans ()Z + public fun getSupportsText ()Z + public fun getTypeId ()Ljava/lang/String; + public fun hashCode ()I + public fun isConvertible ()Z + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/core/BlockType$NumberedList : io/github/linreal/cascade/editor/core/BlockType { + public static final field $stable I + public fun ()V + public fun (I)V + public synthetic fun (IILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()I + public final fun copy (I)Lio/github/linreal/cascade/editor/core/BlockType$NumberedList; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/core/BlockType$NumberedList;IILjava/lang/Object;)Lio/github/linreal/cascade/editor/core/BlockType$NumberedList; + public fun equals (Ljava/lang/Object;)Z + public fun getDisplayName ()Ljava/lang/String; + public final fun getNumber ()I + public fun getSupportsIndentation ()Z + public fun getSupportsSpans ()Z + public fun getSupportsText ()Z + public fun getTypeId ()Ljava/lang/String; + public fun hashCode ()I + public fun isConvertible ()Z + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/core/BlockType$Paragraph : io/github/linreal/cascade/editor/core/BlockType { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/core/BlockType$Paragraph; + public fun equals (Ljava/lang/Object;)Z + public fun getDisplayName ()Ljava/lang/String; + public fun getSupportsIndentation ()Z + public fun getSupportsSpans ()Z + public fun getSupportsText ()Z + public fun getTypeId ()Ljava/lang/String; + public fun hashCode ()I + public fun isConvertible ()Z + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/core/BlockType$Quote : io/github/linreal/cascade/editor/core/BlockType { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/core/BlockType$Quote; + public fun equals (Ljava/lang/Object;)Z + public fun getDisplayName ()Ljava/lang/String; + public fun getSupportsIndentation ()Z + public fun getSupportsSpans ()Z + public fun getSupportsText ()Z + public fun getTypeId ()Ljava/lang/String; + public fun hashCode ()I + public fun isConvertible ()Z + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/core/BlockType$Todo : io/github/linreal/cascade/editor/core/BlockType { + public static final field $stable I + public fun ()V + public fun (Z)V + public synthetic fun (ZILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()Z + public final fun copy (Z)Lio/github/linreal/cascade/editor/core/BlockType$Todo; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/core/BlockType$Todo;ZILjava/lang/Object;)Lio/github/linreal/cascade/editor/core/BlockType$Todo; + public fun equals (Ljava/lang/Object;)Z + public final fun getChecked ()Z + public fun getDisplayName ()Ljava/lang/String; + public fun getSupportsIndentation ()Z + public fun getSupportsSpans ()Z + public fun getSupportsText ()Z + public fun getTypeId ()Ljava/lang/String; + public fun hashCode ()I + public fun isConvertible ()Z + public fun toString ()Ljava/lang/String; +} + +public abstract interface class io/github/linreal/cascade/editor/core/CustomBlockType : io/github/linreal/cascade/editor/core/BlockType { +} + +public final class io/github/linreal/cascade/editor/core/CustomBlockType$DefaultImpls { + public static fun getSupportsIndentation (Lio/github/linreal/cascade/editor/core/CustomBlockType;)Z + public static fun getSupportsSpans (Lio/github/linreal/cascade/editor/core/CustomBlockType;)Z + public static fun getSupportsText (Lio/github/linreal/cascade/editor/core/CustomBlockType;)Z + public static fun isConvertible (Lio/github/linreal/cascade/editor/core/CustomBlockType;)Z +} + +public abstract interface class io/github/linreal/cascade/editor/core/SpanStyle { + public static final field Companion Lio/github/linreal/cascade/editor/core/SpanStyle$Companion; +} + +public final class io/github/linreal/cascade/editor/core/SpanStyle$Bold : io/github/linreal/cascade/editor/core/SpanStyle { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/core/SpanStyle$Bold; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/core/SpanStyle$Companion { + public final fun kindKey (Lio/github/linreal/cascade/editor/core/SpanStyle;)Ljava/lang/Object; + public final fun kindMatches (Lio/github/linreal/cascade/editor/core/SpanStyle;Lio/github/linreal/cascade/editor/core/SpanStyle;)Z +} + +public final class io/github/linreal/cascade/editor/core/SpanStyle$Custom : io/github/linreal/cascade/editor/core/SpanStyle { + public static final field $stable I + public fun (Ljava/lang/String;Ljava/lang/String;)V + public synthetic fun (Ljava/lang/String;Ljava/lang/String;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()Ljava/lang/String; + public final fun component2 ()Ljava/lang/String; + public final fun copy (Ljava/lang/String;Ljava/lang/String;)Lio/github/linreal/cascade/editor/core/SpanStyle$Custom; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/core/SpanStyle$Custom;Ljava/lang/String;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/core/SpanStyle$Custom; + public fun equals (Ljava/lang/Object;)Z + public final fun getPayload ()Ljava/lang/String; + public final fun getTypeId ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/core/SpanStyle$Highlight : io/github/linreal/cascade/editor/core/SpanStyle { + public static final field $stable I + public fun (J)V + public final fun component1 ()J + public final fun copy (J)Lio/github/linreal/cascade/editor/core/SpanStyle$Highlight; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/core/SpanStyle$Highlight;JILjava/lang/Object;)Lio/github/linreal/cascade/editor/core/SpanStyle$Highlight; + public fun equals (Ljava/lang/Object;)Z + public final fun getColorArgb ()J + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/core/SpanStyle$InlineCode : io/github/linreal/cascade/editor/core/SpanStyle { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/core/SpanStyle$InlineCode; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/core/SpanStyle$Italic : io/github/linreal/cascade/editor/core/SpanStyle { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/core/SpanStyle$Italic; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/core/SpanStyle$Link : io/github/linreal/cascade/editor/core/SpanStyle { + public static final field $stable I + public fun (Ljava/lang/String;)V + public final fun component1 ()Ljava/lang/String; + public final fun copy (Ljava/lang/String;)Lio/github/linreal/cascade/editor/core/SpanStyle$Link; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/core/SpanStyle$Link;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/core/SpanStyle$Link; + public fun equals (Ljava/lang/Object;)Z + public final fun getUrl ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/core/SpanStyle$StrikeThrough : io/github/linreal/cascade/editor/core/SpanStyle { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/core/SpanStyle$StrikeThrough; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/core/SpanStyle$Underline : io/github/linreal/cascade/editor/core/SpanStyle { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/core/SpanStyle$Underline; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/core/TextSpan { + public static final field $stable I + public fun (IILio/github/linreal/cascade/editor/core/SpanStyle;)V + public final fun component1 ()I + public final fun component2 ()I + public final fun component3 ()Lio/github/linreal/cascade/editor/core/SpanStyle; + public final fun copy (IILio/github/linreal/cascade/editor/core/SpanStyle;)Lio/github/linreal/cascade/editor/core/TextSpan; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/core/TextSpan;IILio/github/linreal/cascade/editor/core/SpanStyle;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/core/TextSpan; + public fun equals (Ljava/lang/Object;)Z + public final fun getEnd ()I + public final fun getStart ()I + public final fun getStyle ()Lio/github/linreal/cascade/editor/core/SpanStyle; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/core/UnknownBlockType : io/github/linreal/cascade/editor/core/CustomBlockType { + public static final field $stable I + public fun (Ljava/lang/String;Ljava/lang/String;)V + public final fun component1 ()Ljava/lang/String; + public final fun component2 ()Ljava/lang/String; + public final fun copy (Ljava/lang/String;Ljava/lang/String;)Lio/github/linreal/cascade/editor/core/UnknownBlockType; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/core/UnknownBlockType;Ljava/lang/String;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/core/UnknownBlockType; + public fun equals (Ljava/lang/Object;)Z + public fun getDisplayName ()Ljava/lang/String; + public final fun getRawTypeJson ()Ljava/lang/String; + public fun getSupportsIndentation ()Z + public fun getSupportsSpans ()Z + public fun getSupportsText ()Z + public fun getTypeId ()Ljava/lang/String; + public fun hashCode ()I + public fun isConvertible ()Z + public fun toString ()Ljava/lang/String; +} + +public abstract interface class io/github/linreal/cascade/editor/htmlserialization/BlockEncoder { + public abstract fun encode (Lio/github/linreal/cascade/editor/htmlserialization/HtmlEncodeContext;Lio/github/linreal/cascade/editor/core/Block;Lio/github/linreal/cascade/editor/core/BlockContent;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlEmit; +} + +public abstract interface class io/github/linreal/cascade/editor/htmlserialization/BlockGroupEncoder { + public abstract fun encodeGroup (Lio/github/linreal/cascade/editor/htmlserialization/HtmlEncodeContext;Ljava/util/List;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlEmit; + public abstract fun groupKey (Lio/github/linreal/cascade/editor/core/Block;)Ljava/lang/Object; +} + +public abstract interface class io/github/linreal/cascade/editor/htmlserialization/BlockSeparator { +} + +public final class io/github/linreal/cascade/editor/htmlserialization/BlockSeparator$BlockTags : io/github/linreal/cascade/editor/htmlserialization/BlockSeparator { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/htmlserialization/BlockSeparator$BlockTags; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/BlockSeparator$Newline : io/github/linreal/cascade/editor/htmlserialization/BlockSeparator { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/htmlserialization/BlockSeparator$Newline; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/DefaultBlockEncodersKt { + public static final fun openTagWithCascadeIndentation (Ljava/lang/String;Lio/github/linreal/cascade/editor/core/Block;)Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/DefaultListOutlineEncoderKt { + public static final field CASCADE_INDENT_CLASS_PREFIX Ljava/lang/String; +} + +public abstract interface class io/github/linreal/cascade/editor/htmlserialization/EntityDecode { +} + +public final class io/github/linreal/cascade/editor/htmlserialization/EntityDecode$None : io/github/linreal/cascade/editor/htmlserialization/EntityDecode { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/htmlserialization/EntityDecode$None; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/EntityDecode$Standard : io/github/linreal/cascade/editor/htmlserialization/EntityDecode { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/htmlserialization/EntityDecode$Standard; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public abstract interface annotation class io/github/linreal/cascade/editor/htmlserialization/ExperimentalCascadeHtmlApi : java/lang/annotation/Annotation { +} + +public final class io/github/linreal/cascade/editor/htmlserialization/Html { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/htmlserialization/Html; + public final fun escapeAttr (Ljava/lang/String;)Ljava/lang/String; + public final fun escapeText (Ljava/lang/String;)Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/HtmlDecodeLimits { + public static final field $stable I + public static final field Companion Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeLimits$Companion; + public static final field DEFAULT_MAX_INPUT_CHARS I + public fun ()V + public fun (I)V + public synthetic fun (IILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()I + public final fun copy (I)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeLimits; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeLimits;IILjava/lang/Object;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeLimits; + public fun equals (Ljava/lang/Object;)Z + public final fun getMaxInputChars ()I + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/HtmlDecodeLimits$Companion { + public final fun getDefault ()Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeLimits; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/HtmlDecodeResult { + public static final field $stable I + public fun (Ljava/util/List;Ljava/util/List;)V + public final fun component1 ()Ljava/util/List; + public final fun component2 ()Ljava/util/List; + public final fun copy (Ljava/util/List;Ljava/util/List;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeResult; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeResult;Ljava/util/List;Ljava/util/List;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeResult; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlocks ()Ljava/util/List; + public final fun getWarnings ()Ljava/util/List; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public abstract class io/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning { + public static final field $stable I + public abstract fun getCharOffset ()I +} + +public final class io/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$BlockInInlineContext : io/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning { + public static final field $stable I + public fun (Ljava/lang/String;I)V + public final fun component1 ()Ljava/lang/String; + public final fun component2 ()I + public final fun copy (Ljava/lang/String;I)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$BlockInInlineContext; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$BlockInInlineContext;Ljava/lang/String;IILjava/lang/Object;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$BlockInInlineContext; + public fun equals (Ljava/lang/Object;)Z + public fun getCharOffset ()I + public final fun getTag ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$DecoderException : io/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning { + public static final field $stable I + public fun (Ljava/lang/String;Ljava/lang/String;I)V + public final fun component1 ()Ljava/lang/String; + public final fun component2 ()Ljava/lang/String; + public final fun component3 ()I + public final fun copy (Ljava/lang/String;Ljava/lang/String;I)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$DecoderException; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$DecoderException;Ljava/lang/String;Ljava/lang/String;IILjava/lang/Object;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$DecoderException; + public fun equals (Ljava/lang/Object;)Z + public fun getCharOffset ()I + public final fun getMessage ()Ljava/lang/String; + public final fun getTag ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$DroppedAttribute : io/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning { + public static final field $stable I + public fun (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;I)V + public final fun component1 ()Ljava/lang/String; + public final fun component2 ()Ljava/lang/String; + public final fun component3 ()Ljava/lang/String; + public final fun component4 ()I + public final fun copy (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;I)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$DroppedAttribute; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$DroppedAttribute;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;IILjava/lang/Object;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$DroppedAttribute; + public fun equals (Ljava/lang/Object;)Z + public final fun getAttr ()Ljava/lang/String; + public fun getCharOffset ()I + public final fun getReason ()Ljava/lang/String; + public final fun getTag ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$DroppedContent : io/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning { + public static final field $stable I + public fun (Ljava/lang/String;I)V + public final fun component1 ()Ljava/lang/String; + public final fun component2 ()I + public final fun copy (Ljava/lang/String;I)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$DroppedContent; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$DroppedContent;Ljava/lang/String;IILjava/lang/Object;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$DroppedContent; + public fun equals (Ljava/lang/Object;)Z + public fun getCharOffset ()I + public final fun getReason ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$InputLimitExceeded : io/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning { + public static final field $stable I + public fun (III)V + public synthetic fun (IIIILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()I + public final fun component2 ()I + public final fun component3 ()I + public final fun copy (III)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$InputLimitExceeded; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$InputLimitExceeded;IIIILjava/lang/Object;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$InputLimitExceeded; + public fun equals (Ljava/lang/Object;)Z + public final fun getActual ()I + public fun getCharOffset ()I + public final fun getLimit ()I + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$InvalidAttribute : io/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning { + public static final field $stable I + public fun (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;I)V + public final fun component1 ()Ljava/lang/String; + public final fun component2 ()Ljava/lang/String; + public final fun component3 ()Ljava/lang/String; + public final fun component4 ()Ljava/lang/String; + public final fun component5 ()I + public final fun copy (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;I)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$InvalidAttribute; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$InvalidAttribute;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;IILjava/lang/Object;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$InvalidAttribute; + public fun equals (Ljava/lang/Object;)Z + public final fun getAttr ()Ljava/lang/String; + public fun getCharOffset ()I + public final fun getReason ()Ljava/lang/String; + public final fun getTag ()Ljava/lang/String; + public final fun getValue ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$MismatchedNesting : io/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning { + public static final field $stable I + public fun (Ljava/lang/String;Ljava/lang/String;I)V + public final fun component1 ()Ljava/lang/String; + public final fun component2 ()Ljava/lang/String; + public final fun component3 ()I + public final fun copy (Ljava/lang/String;Ljava/lang/String;I)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$MismatchedNesting; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$MismatchedNesting;Ljava/lang/String;Ljava/lang/String;IILjava/lang/Object;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$MismatchedNesting; + public fun equals (Ljava/lang/Object;)Z + public fun getCharOffset ()I + public final fun getExpected ()Ljava/lang/String; + public final fun getFound ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$StrayClosingTag : io/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning { + public static final field $stable I + public fun (Ljava/lang/String;I)V + public final fun component1 ()Ljava/lang/String; + public final fun component2 ()I + public final fun copy (Ljava/lang/String;I)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$StrayClosingTag; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$StrayClosingTag;Ljava/lang/String;IILjava/lang/Object;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$StrayClosingTag; + public fun equals (Ljava/lang/Object;)Z + public fun getCharOffset ()I + public final fun getTag ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$UnclosedTag : io/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning { + public static final field $stable I + public fun (Ljava/lang/String;I)V + public final fun component1 ()Ljava/lang/String; + public final fun component2 ()I + public final fun copy (Ljava/lang/String;I)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$UnclosedTag; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$UnclosedTag;Ljava/lang/String;IILjava/lang/Object;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$UnclosedTag; + public fun equals (Ljava/lang/Object;)Z + public fun getCharOffset ()I + public final fun getTag ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$UnknownAttribute : io/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning { + public static final field $stable I + public fun (Ljava/lang/String;Ljava/lang/String;I)V + public final fun component1 ()Ljava/lang/String; + public final fun component2 ()Ljava/lang/String; + public final fun component3 ()I + public final fun copy (Ljava/lang/String;Ljava/lang/String;I)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$UnknownAttribute; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$UnknownAttribute;Ljava/lang/String;Ljava/lang/String;IILjava/lang/Object;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$UnknownAttribute; + public fun equals (Ljava/lang/Object;)Z + public final fun getAttr ()Ljava/lang/String; + public fun getCharOffset ()I + public final fun getTag ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$UnknownTag : io/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning { + public static final field $stable I + public fun (Ljava/lang/String;I)V + public final fun component1 ()Ljava/lang/String; + public final fun component2 ()I + public final fun copy (Ljava/lang/String;I)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$UnknownTag; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$UnknownTag;Ljava/lang/String;IILjava/lang/Object;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$UnknownTag; + public fun equals (Ljava/lang/Object;)Z + public fun getCharOffset ()I + public final fun getTag ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public abstract interface class io/github/linreal/cascade/editor/htmlserialization/HtmlEmit { +} + +public final class io/github/linreal/cascade/editor/htmlserialization/HtmlEmit$Raw : io/github/linreal/cascade/editor/htmlserialization/HtmlEmit { + public static final field $stable I + public fun (Ljava/lang/String;)V + public final fun component1 ()Ljava/lang/String; + public final fun copy (Ljava/lang/String;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlEmit$Raw; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/htmlserialization/HtmlEmit$Raw;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlEmit$Raw; + public fun equals (Ljava/lang/Object;)Z + public final fun getHtml ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/HtmlEmit$Skip : io/github/linreal/cascade/editor/htmlserialization/HtmlEmit { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/htmlserialization/HtmlEmit$Skip; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public abstract class io/github/linreal/cascade/editor/htmlserialization/HtmlEncodeContext { + public static final field $stable I + public abstract fun encodeInline (Lio/github/linreal/cascade/editor/core/Block;)Ljava/lang/String; + public abstract fun encodeInlineFragment (Ljava/lang/String;Ljava/util/List;Z)Ljava/lang/String; + public static synthetic fun encodeInlineFragment$default (Lio/github/linreal/cascade/editor/htmlserialization/HtmlEncodeContext;Ljava/lang/String;Ljava/util/List;ZILjava/lang/Object;)Ljava/lang/String; + public abstract fun encodeTextOnly (Lio/github/linreal/cascade/editor/core/Block;)Ljava/lang/String; + public abstract fun escapeAttr (Ljava/lang/String;)Ljava/lang/String; + public abstract fun escapeText (Ljava/lang/String;)Ljava/lang/String; + public abstract fun warn (Lio/github/linreal/cascade/editor/htmlserialization/HtmlEncodeWarning;)V +} + +public final class io/github/linreal/cascade/editor/htmlserialization/HtmlEncodeResult { + public static final field $stable I + public fun (Ljava/lang/String;Ljava/util/List;)V + public final fun component1 ()Ljava/lang/String; + public final fun component2 ()Ljava/util/List; + public final fun copy (Ljava/lang/String;Ljava/util/List;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlEncodeResult; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/htmlserialization/HtmlEncodeResult;Ljava/lang/String;Ljava/util/List;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlEncodeResult; + public fun equals (Ljava/lang/Object;)Z + public final fun getHtml ()Ljava/lang/String; + public final fun getWarnings ()Ljava/util/List; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public abstract class io/github/linreal/cascade/editor/htmlserialization/HtmlEncodeWarning { + public static final field $stable I +} + +public final class io/github/linreal/cascade/editor/htmlserialization/HtmlEncodeWarning$DroppedAttribute : io/github/linreal/cascade/editor/htmlserialization/HtmlEncodeWarning { + public static final field $stable I + public fun (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V + public final fun component1 ()Ljava/lang/String; + public final fun component2 ()Ljava/lang/String; + public final fun component3 ()Ljava/lang/String; + public final fun copy (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlEncodeWarning$DroppedAttribute; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/htmlserialization/HtmlEncodeWarning$DroppedAttribute;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlEncodeWarning$DroppedAttribute; + public fun equals (Ljava/lang/Object;)Z + public final fun getAttr ()Ljava/lang/String; + public final fun getReason ()Ljava/lang/String; + public final fun getTypeId ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/HtmlEncodeWarning$EncoderException : io/github/linreal/cascade/editor/htmlserialization/HtmlEncodeWarning { + public static final field $stable I + public fun (Ljava/lang/String;Ljava/lang/String;)V + public final fun component1 ()Ljava/lang/String; + public final fun component2 ()Ljava/lang/String; + public final fun copy (Ljava/lang/String;Ljava/lang/String;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlEncodeWarning$EncoderException; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/htmlserialization/HtmlEncodeWarning$EncoderException;Ljava/lang/String;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlEncodeWarning$EncoderException; + public fun equals (Ljava/lang/Object;)Z + public final fun getMessage ()Ljava/lang/String; + public final fun getTypeId ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public abstract interface class io/github/linreal/cascade/editor/htmlserialization/HtmlNodeView { + public abstract fun getSourceEndExclusive ()I + public abstract fun getSourceStart ()I +} + +public final class io/github/linreal/cascade/editor/htmlserialization/HtmlNodeView$Element : io/github/linreal/cascade/editor/htmlserialization/HtmlNodeView { + public static final field $stable I + public fun (Ljava/lang/String;Ljava/util/Map;Ljava/util/List;II)V + public final fun component1 ()Ljava/lang/String; + public final fun component2 ()Ljava/util/Map; + public final fun component3 ()Ljava/util/List; + public final fun component4 ()I + public final fun component5 ()I + public final fun copy (Ljava/lang/String;Ljava/util/Map;Ljava/util/List;II)Lio/github/linreal/cascade/editor/htmlserialization/HtmlNodeView$Element; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/htmlserialization/HtmlNodeView$Element;Ljava/lang/String;Ljava/util/Map;Ljava/util/List;IIILjava/lang/Object;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlNodeView$Element; + public fun equals (Ljava/lang/Object;)Z + public final fun getAttrs ()Ljava/util/Map; + public final fun getChildren ()Ljava/util/List; + public fun getSourceEndExclusive ()I + public fun getSourceStart ()I + public final fun getTag ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/HtmlNodeView$Text : io/github/linreal/cascade/editor/htmlserialization/HtmlNodeView { + public static final field $stable I + public fun (Ljava/lang/String;II)V + public final fun component1 ()Ljava/lang/String; + public final fun component2 ()I + public final fun component3 ()I + public final fun copy (Ljava/lang/String;II)Lio/github/linreal/cascade/editor/htmlserialization/HtmlNodeView$Text; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/htmlserialization/HtmlNodeView$Text;Ljava/lang/String;IIILjava/lang/Object;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlNodeView$Text; + public fun equals (Ljava/lang/Object;)Z + public fun getSourceEndExclusive ()I + public fun getSourceStart ()I + public final fun getText ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/HtmlProfile { + public static final field $stable I + public static final field Companion Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile$Companion; + public static final field DEFAULT_HIGHLIGHT_COLOR_ARGB J + public final fun getSupportSet ()Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfileSupportSet; + public final fun tagDecoderFor (Ljava/lang/String;)Lio/github/linreal/cascade/editor/htmlserialization/TagDecoder; + public final fun withBlockEncoderInternal (Lkotlin/reflect/KClass;Lio/github/linreal/cascade/editor/htmlserialization/BlockEncoder;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile; + public final fun withBlockGroupEncoder (Ljava/lang/String;Lio/github/linreal/cascade/editor/htmlserialization/BlockGroupEncoder;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile; + public final fun withCustomBlockEncoder (Ljava/lang/String;Lio/github/linreal/cascade/editor/htmlserialization/BlockEncoder;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile; + public final fun withCustomSpanEncoder (Ljava/lang/String;Lio/github/linreal/cascade/editor/htmlserialization/SpanEncoder;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile; + public final fun withEncoderBlockFallback (Lio/github/linreal/cascade/editor/htmlserialization/BlockEncoder;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile; + public final fun withEncoderSpanFallback (Lio/github/linreal/cascade/editor/htmlserialization/SpanEncoder;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile; + public final fun withParserPolicy (Lio/github/linreal/cascade/editor/htmlserialization/BlockSeparator;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile; + public final fun withParserPolicy (Lio/github/linreal/cascade/editor/htmlserialization/EntityDecode;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile; + public final fun withParserPolicy (Lio/github/linreal/cascade/editor/htmlserialization/InlineRoot;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile; + public final fun withSpanEncoderInternal (Lkotlin/reflect/KClass;Lio/github/linreal/cascade/editor/htmlserialization/SpanEncoder;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile; + public final fun withSupportSet (Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfileSupportSet;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile; + public final fun withTagDecoder (Ljava/lang/String;Lio/github/linreal/cascade/editor/htmlserialization/TagDecoder;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile; + public final fun withUnknownTagPolicy (Lio/github/linreal/cascade/editor/htmlserialization/UnknownTagPolicy;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile; + public final fun withoutBlockGroupEncoder (Ljava/lang/String;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile; + public final fun withoutTagDecoder (Ljava/lang/String;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/HtmlProfile$Companion { + public final fun getDefault ()Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/HtmlProfileSupportSet { + public static final field $stable I + public static final field Companion Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfileSupportSet$Companion; + public fun (Lkotlin/jvm/functions/Function1;Lkotlin/jvm/functions/Function1;)V + public final fun getSupportsBlockPredicate ()Lkotlin/jvm/functions/Function1; + public final fun getSupportsSpanPredicate ()Lkotlin/jvm/functions/Function1; + public final fun supportsBlock (Lio/github/linreal/cascade/editor/core/Block;)Z + public final fun supportsDocument (Ljava/util/List;)Z + public final fun supportsSpan (Lio/github/linreal/cascade/editor/core/SpanStyle;)Z +} + +public final class io/github/linreal/cascade/editor/htmlserialization/HtmlProfileSupportSet$Companion { + public final fun getDefault ()Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfileSupportSet; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/HtmlSchema { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/htmlserialization/HtmlSchema; + public final fun decode (Ljava/lang/String;Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile;)Ljava/util/List; + public final fun decodeWithReport (Ljava/lang/String;Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile;Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeLimits;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeResult; + public static synthetic fun decodeWithReport$default (Lio/github/linreal/cascade/editor/htmlserialization/HtmlSchema;Ljava/lang/String;Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile;Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeLimits;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeResult; + public final fun encode (Ljava/util/List;Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile;)Ljava/lang/String; + public final fun encodeWithReport (Ljava/util/List;Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlEncodeResult; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/HtmlSerializationExtKt { + public static final fun loadFromHtml (Lio/github/linreal/cascade/editor/state/EditorStateHolder;Ljava/lang/String;Lio/github/linreal/cascade/editor/state/BlockTextStates;Lio/github/linreal/cascade/editor/state/BlockSpanStates;Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile;Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeLimits;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeResult; + public static synthetic fun loadFromHtml$default (Lio/github/linreal/cascade/editor/state/EditorStateHolder;Ljava/lang/String;Lio/github/linreal/cascade/editor/state/BlockTextStates;Lio/github/linreal/cascade/editor/state/BlockSpanStates;Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile;Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeLimits;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeResult; + public static final fun toHtml (Lio/github/linreal/cascade/editor/state/EditorStateHolder;Lio/github/linreal/cascade/editor/state/BlockTextStates;Lio/github/linreal/cascade/editor/state/BlockSpanStates;Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile;)Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/HtmlTagPair { + public static final field $stable I + public fun (Ljava/lang/String;Ljava/lang/String;)V + public final fun component1 ()Ljava/lang/String; + public final fun component2 ()Ljava/lang/String; + public final fun copy (Ljava/lang/String;Ljava/lang/String;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlTagPair; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/htmlserialization/HtmlTagPair;Ljava/lang/String;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlTagPair; + public fun equals (Ljava/lang/Object;)Z + public final fun getClose ()Ljava/lang/String; + public final fun getOpen ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/InlineFragment { + public static final field $stable I + public fun (Ljava/lang/String;Ljava/util/List;)V + public final fun component1 ()Ljava/lang/String; + public final fun component2 ()Ljava/util/List; + public final fun copy (Ljava/lang/String;Ljava/util/List;)Lio/github/linreal/cascade/editor/htmlserialization/InlineFragment; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/htmlserialization/InlineFragment;Ljava/lang/String;Ljava/util/List;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/htmlserialization/InlineFragment; + public fun equals (Ljava/lang/Object;)Z + public final fun getSpans ()Ljava/util/List; + public final fun getText ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public abstract interface class io/github/linreal/cascade/editor/htmlserialization/InlineRoot { +} + +public final class io/github/linreal/cascade/editor/htmlserialization/InlineRoot$Drop : io/github/linreal/cascade/editor/htmlserialization/InlineRoot { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/htmlserialization/InlineRoot$Drop; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/InlineRoot$WrapInParagraph : io/github/linreal/cascade/editor/htmlserialization/InlineRoot { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/htmlserialization/InlineRoot$WrapInParagraph; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public abstract interface class io/github/linreal/cascade/editor/htmlserialization/SpanEncoder { + public abstract fun encode (Lio/github/linreal/cascade/editor/core/SpanStyle;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlTagPair; +} + +public abstract class io/github/linreal/cascade/editor/htmlserialization/TagDecodeContext { + public static final field $stable I + public abstract fun collectInlineText (Ljava/util/List;ZZZ)Lio/github/linreal/cascade/editor/htmlserialization/InlineFragment; + public static synthetic fun collectInlineText$default (Lio/github/linreal/cascade/editor/htmlserialization/TagDecodeContext;Ljava/util/List;ZZZILjava/lang/Object;)Lio/github/linreal/cascade/editor/htmlserialization/InlineFragment; + public abstract fun decodeBlocks (Ljava/util/List;)Ljava/util/List; + public abstract fun decodeInline (Ljava/util/List;)Lio/github/linreal/cascade/editor/htmlserialization/InlineFragment; + public abstract fun getCharOffset ()I + public abstract fun getParentTag ()Ljava/lang/String; + public abstract fun getRawSource ()Ljava/lang/String; + public abstract fun isBlockContext ()Z + public abstract fun rawSliceOf (Lio/github/linreal/cascade/editor/htmlserialization/HtmlNodeView;)Ljava/lang/String; + public abstract fun tagDecoderFor (Ljava/lang/String;)Lio/github/linreal/cascade/editor/htmlserialization/TagDecoder; + public abstract fun warn (Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning;)V +} + +public abstract interface class io/github/linreal/cascade/editor/htmlserialization/TagDecodeResult { +} + +public final class io/github/linreal/cascade/editor/htmlserialization/TagDecodeResult$AsBlock : io/github/linreal/cascade/editor/htmlserialization/TagDecodeResult { + public static final field $stable I + public fun (Lio/github/linreal/cascade/editor/core/Block;)V + public final fun component1 ()Lio/github/linreal/cascade/editor/core/Block; + public final fun copy (Lio/github/linreal/cascade/editor/core/Block;)Lio/github/linreal/cascade/editor/htmlserialization/TagDecodeResult$AsBlock; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/htmlserialization/TagDecodeResult$AsBlock;Lio/github/linreal/cascade/editor/core/Block;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/htmlserialization/TagDecodeResult$AsBlock; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlock ()Lio/github/linreal/cascade/editor/core/Block; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/TagDecodeResult$AsBlocks : io/github/linreal/cascade/editor/htmlserialization/TagDecodeResult { + public static final field $stable I + public fun (Ljava/util/List;)V + public final fun component1 ()Ljava/util/List; + public final fun copy (Ljava/util/List;)Lio/github/linreal/cascade/editor/htmlserialization/TagDecodeResult$AsBlocks; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/htmlserialization/TagDecodeResult$AsBlocks;Ljava/util/List;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/htmlserialization/TagDecodeResult$AsBlocks; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlocks ()Ljava/util/List; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/TagDecodeResult$AsText : io/github/linreal/cascade/editor/htmlserialization/TagDecodeResult { + public static final field $stable I + public fun (Ljava/lang/String;Ljava/util/List;)V + public final fun component1 ()Ljava/lang/String; + public final fun component2 ()Ljava/util/List; + public final fun copy (Ljava/lang/String;Ljava/util/List;)Lio/github/linreal/cascade/editor/htmlserialization/TagDecodeResult$AsText; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/htmlserialization/TagDecodeResult$AsText;Ljava/lang/String;Ljava/util/List;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/htmlserialization/TagDecodeResult$AsText; + public fun equals (Ljava/lang/Object;)Z + public final fun getSpans ()Ljava/util/List; + public final fun getText ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/TagDecodeResult$Drop : io/github/linreal/cascade/editor/htmlserialization/TagDecodeResult { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/htmlserialization/TagDecodeResult$Drop; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public abstract interface class io/github/linreal/cascade/editor/htmlserialization/TagDecoder { + public abstract fun decode (Lio/github/linreal/cascade/editor/htmlserialization/TagDecodeContext;Ljava/util/Map;Ljava/util/List;)Lio/github/linreal/cascade/editor/htmlserialization/TagDecodeResult; +} + +public abstract interface class io/github/linreal/cascade/editor/htmlserialization/UnknownTagPolicy { +} + +public final class io/github/linreal/cascade/editor/htmlserialization/UnknownTagPolicy$Custom : io/github/linreal/cascade/editor/htmlserialization/UnknownTagPolicy { + public static final field $stable I + public fun (Lkotlin/jvm/functions/Function2;)V + public final fun component1 ()Lkotlin/jvm/functions/Function2; + public final fun copy (Lkotlin/jvm/functions/Function2;)Lio/github/linreal/cascade/editor/htmlserialization/UnknownTagPolicy$Custom; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/htmlserialization/UnknownTagPolicy$Custom;Lkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/htmlserialization/UnknownTagPolicy$Custom; + public fun equals (Ljava/lang/Object;)Z + public final fun getHandler ()Lkotlin/jvm/functions/Function2; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/UnknownTagPolicy$Preserve : io/github/linreal/cascade/editor/htmlserialization/UnknownTagPolicy { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/htmlserialization/UnknownTagPolicy$Preserve; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/UnknownTagPolicy$Strip : io/github/linreal/cascade/editor/htmlserialization/UnknownTagPolicy { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/htmlserialization/UnknownTagPolicy$Strip; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/UnknownTagPolicy$WarnAndStrip : io/github/linreal/cascade/editor/htmlserialization/UnknownTagPolicy { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/htmlserialization/UnknownTagPolicy$WarnAndStrip; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public abstract interface class io/github/linreal/cascade/editor/indentation/IndentationActions { + public abstract fun indentBackward ()V + public abstract fun indentForward ()V +} + +public final class io/github/linreal/cascade/editor/indentation/IndentationState { + public static final field $stable I + public static final field Companion Lio/github/linreal/cascade/editor/indentation/IndentationState$Companion; + public fun (ZZLjava/util/List;)V + public final fun component1 ()Z + public final fun component2 ()Z + public final fun component3 ()Ljava/util/List; + public final fun copy (ZZLjava/util/List;)Lio/github/linreal/cascade/editor/indentation/IndentationState; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/indentation/IndentationState;ZZLjava/util/List;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/indentation/IndentationState; + public fun equals (Ljava/lang/Object;)Z + public final fun getCanIndentBackward ()Z + public final fun getCanIndentForward ()Z + public final fun getTargetBlockIds ()Ljava/util/List; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/indentation/IndentationState$Companion { + public final fun getEmpty ()Lio/github/linreal/cascade/editor/indentation/IndentationState; +} + +public abstract interface class io/github/linreal/cascade/editor/registry/BlockCallbacks { + public abstract fun dispatch (Lio/github/linreal/cascade/editor/action/EditorAction;)V + public abstract fun onBackspaceAtStart-SDe6QqM (Ljava/lang/String;)V + public abstract fun onClick-SDe6QqM (Ljava/lang/String;)V + public abstract fun onDeleteAtEnd-SDe6QqM (Ljava/lang/String;)V + public abstract fun onDragStart-7OMXkl4 (Ljava/lang/String;F)V + public abstract fun onEnter-7OMXkl4 (Ljava/lang/String;I)V + public abstract fun onFocus-SDe6QqM (Ljava/lang/String;)V + public abstract fun onLongClick-SDe6QqM (Ljava/lang/String;)V + public abstract fun onSlashCommand-p1zP0qE (Ljava/lang/String;Lio/github/linreal/cascade/editor/state/SlashQueryRange;Ljava/lang/String;)V + public static synthetic fun onSlashCommand-p1zP0qE$default (Lio/github/linreal/cascade/editor/registry/BlockCallbacks;Ljava/lang/String;Lio/github/linreal/cascade/editor/state/SlashQueryRange;Ljava/lang/String;ILjava/lang/Object;)V +} + +public final class io/github/linreal/cascade/editor/registry/BlockCallbacks$DefaultImpls { + public static synthetic fun onSlashCommand-p1zP0qE$default (Lio/github/linreal/cascade/editor/registry/BlockCallbacks;Ljava/lang/String;Lio/github/linreal/cascade/editor/state/SlashQueryRange;Ljava/lang/String;ILjava/lang/Object;)V +} + +public final class io/github/linreal/cascade/editor/registry/BlockDescriptor { + public static final field $stable I + public fun (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/util/List;Ljava/lang/String;Lio/github/linreal/cascade/editor/slash/BuiltInSlashCommandSpec;Lkotlin/jvm/functions/Function1;)V + public synthetic fun (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/util/List;Ljava/lang/String;Lio/github/linreal/cascade/editor/slash/BuiltInSlashCommandSpec;Lkotlin/jvm/functions/Function1;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()Ljava/lang/String; + public final fun component2 ()Ljava/lang/String; + public final fun component3 ()Ljava/lang/String; + public final fun component4 ()Ljava/util/List; + public final fun component5 ()Ljava/lang/String; + public final fun component6 ()Lio/github/linreal/cascade/editor/slash/BuiltInSlashCommandSpec; + public final fun component7 ()Lkotlin/jvm/functions/Function1; + public final fun copy (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/util/List;Ljava/lang/String;Lio/github/linreal/cascade/editor/slash/BuiltInSlashCommandSpec;Lkotlin/jvm/functions/Function1;)Lio/github/linreal/cascade/editor/registry/BlockDescriptor; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/registry/BlockDescriptor;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/util/List;Ljava/lang/String;Lio/github/linreal/cascade/editor/slash/BuiltInSlashCommandSpec;Lkotlin/jvm/functions/Function1;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/registry/BlockDescriptor; + public final fun createBlock ()Lio/github/linreal/cascade/editor/core/Block; + public final fun createBlock-SDe6QqM (Ljava/lang/String;)Lio/github/linreal/cascade/editor/core/Block; + public fun equals (Ljava/lang/Object;)Z + public final fun getDescription ()Ljava/lang/String; + public final fun getDisplayName ()Ljava/lang/String; + public final fun getFactory ()Lkotlin/jvm/functions/Function1; + public final fun getIcon ()Ljava/lang/String; + public final fun getKeywords ()Ljava/util/List; + public final fun getSlash ()Lio/github/linreal/cascade/editor/slash/BuiltInSlashCommandSpec; + public final fun getTypeId ()Ljava/lang/String; + public fun hashCode ()I + public final fun matches (Ljava/lang/String;)Z + public final fun relevanceScore (Ljava/lang/String;)I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/registry/BlockRegistry { + public static final field $stable I + public static final field Companion Lio/github/linreal/cascade/editor/registry/BlockRegistry$Companion; + public fun ()V + public final fun createBlock (Ljava/lang/String;)Lio/github/linreal/cascade/editor/core/Block; + public final fun getAllDescriptors ()Ljava/util/List; + public final fun getDescriptor (Ljava/lang/String;)Lio/github/linreal/cascade/editor/registry/BlockDescriptor; + public final fun getRenderer (Lio/github/linreal/cascade/editor/core/BlockType;)Lio/github/linreal/cascade/editor/registry/BlockRenderer; + public final fun getRenderer (Ljava/lang/String;)Lio/github/linreal/cascade/editor/registry/BlockRenderer; + public final fun isRegistered (Ljava/lang/String;)Z + public final fun register (Lio/github/linreal/cascade/editor/registry/BlockDescriptor;Lio/github/linreal/cascade/editor/registry/BlockRenderer;)V + public final fun registerDescriptor (Lio/github/linreal/cascade/editor/registry/BlockDescriptor;)V + public final fun registerRenderer (Ljava/lang/String;Lio/github/linreal/cascade/editor/registry/BlockRenderer;)V + public final fun search (Ljava/lang/String;)Ljava/util/List; + public final fun setUnknownBlockRenderer (Lio/github/linreal/cascade/editor/registry/BlockRenderer;)V +} + +public final class io/github/linreal/cascade/editor/registry/BlockRegistry$Companion { + public final fun create ()Lio/github/linreal/cascade/editor/registry/BlockRegistry; + public final fun createDefault ()Lio/github/linreal/cascade/editor/registry/BlockRegistry; +} + +public abstract interface class io/github/linreal/cascade/editor/registry/BlockRenderScope { + public abstract fun deleteBlock-SDe6QqM (Ljava/lang/String;)V + public abstract fun focusBlock-pWxEiPs (Ljava/lang/String;)V + public abstract fun getBlock-SDe6QqM (Ljava/lang/String;)Lio/github/linreal/cascade/editor/core/Block; + public abstract fun getCanDragBlocks ()Z + public abstract fun getCanEditBlockStructure ()Z + public abstract fun getCanSelectBlocks ()Z + public abstract fun getCanUpdateBlock ()Z + public abstract fun getConfig ()Lio/github/linreal/cascade/editor/ui/CascadeEditorConfig; + public abstract fun getReadOnly ()Z + public abstract fun getState ()Lio/github/linreal/cascade/editor/state/EditorState; + public abstract fun insertBlockAfter-7OMXkl4 (Ljava/lang/String;Lio/github/linreal/cascade/editor/core/Block;)V + public abstract fun insertBlockBefore-7OMXkl4 (Ljava/lang/String;Lio/github/linreal/cascade/editor/core/Block;)V + public abstract fun replaceBlock-7OMXkl4 (Ljava/lang/String;Lio/github/linreal/cascade/editor/core/Block;)V + public abstract fun updateBlock-7OMXkl4 (Ljava/lang/String;Lkotlin/jvm/functions/Function1;)V +} + +public abstract interface class io/github/linreal/cascade/editor/registry/BlockRenderer { + public abstract fun Render (Lio/github/linreal/cascade/editor/core/Block;ZZLandroidx/compose/ui/Modifier;Lio/github/linreal/cascade/editor/registry/BlockCallbacks;Landroidx/compose/runtime/Composer;I)V + public fun getHandlesSelectionVisual ()Z + public fun getSupportsDragPreview ()Z +} + +public final class io/github/linreal/cascade/editor/registry/BlockRenderer$DefaultImpls { + public static fun getHandlesSelectionVisual (Lio/github/linreal/cascade/editor/registry/BlockRenderer;)Z + public static fun getSupportsDragPreview (Lio/github/linreal/cascade/editor/registry/BlockRenderer;)Z +} + +public final class io/github/linreal/cascade/editor/registry/BlockRendererKt { + public static final fun blockRenderer (Lkotlin/jvm/functions/Function7;)Lio/github/linreal/cascade/editor/registry/BlockRenderer; +} + +public class io/github/linreal/cascade/editor/registry/DefaultBlockCallbacks : io/github/linreal/cascade/editor/registry/BlockCallbacks { + public static final field $stable I + public fun (Lkotlin/jvm/functions/Function1;Lkotlin/jvm/functions/Function0;Lio/github/linreal/cascade/editor/state/BlockTextStates;Lio/github/linreal/cascade/editor/state/BlockSpanStates;Lio/github/linreal/cascade/editor/state/EditorStateHolder;)V + public synthetic fun (Lkotlin/jvm/functions/Function1;Lkotlin/jvm/functions/Function0;Lio/github/linreal/cascade/editor/state/BlockTextStates;Lio/github/linreal/cascade/editor/state/BlockSpanStates;Lio/github/linreal/cascade/editor/state/EditorStateHolder;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public fun dispatch (Lio/github/linreal/cascade/editor/action/EditorAction;)V + public fun onBackspaceAtStart-SDe6QqM (Ljava/lang/String;)V + public fun onClick-SDe6QqM (Ljava/lang/String;)V + public fun onDeleteAtEnd-SDe6QqM (Ljava/lang/String;)V + public fun onDragStart-7OMXkl4 (Ljava/lang/String;F)V + public fun onEnter-7OMXkl4 (Ljava/lang/String;I)V + public fun onFocus-SDe6QqM (Ljava/lang/String;)V + public fun onLongClick-SDe6QqM (Ljava/lang/String;)V + public fun onSlashCommand-p1zP0qE (Ljava/lang/String;Lio/github/linreal/cascade/editor/state/SlashQueryRange;Ljava/lang/String;)V +} + +public final class io/github/linreal/cascade/editor/registry/LambdaBlockRenderer : io/github/linreal/cascade/editor/registry/BlockRenderer { + public static final field $stable I + public fun (Lkotlin/jvm/functions/Function7;)V + public fun Render (Lio/github/linreal/cascade/editor/core/Block;ZZLandroidx/compose/ui/Modifier;Lio/github/linreal/cascade/editor/registry/BlockCallbacks;Landroidx/compose/runtime/Composer;I)V + public fun getHandlesSelectionVisual ()Z + public fun getSupportsDragPreview ()Z +} + +public abstract interface class io/github/linreal/cascade/editor/registry/ScopedBlockRenderer : io/github/linreal/cascade/editor/registry/BlockRenderer { + public fun Render (Lio/github/linreal/cascade/editor/core/Block;ZZLandroidx/compose/ui/Modifier;Lio/github/linreal/cascade/editor/registry/BlockCallbacks;Landroidx/compose/runtime/Composer;I)V + public abstract fun Render (Lio/github/linreal/cascade/editor/core/Block;ZZLandroidx/compose/ui/Modifier;Lio/github/linreal/cascade/editor/registry/BlockCallbacks;Lio/github/linreal/cascade/editor/registry/BlockRenderScope;Landroidx/compose/runtime/Composer;I)V +} + +public final class io/github/linreal/cascade/editor/registry/ScopedBlockRenderer$DefaultImpls { + public static fun Render (Lio/github/linreal/cascade/editor/registry/ScopedBlockRenderer;Lio/github/linreal/cascade/editor/core/Block;ZZLandroidx/compose/ui/Modifier;Lio/github/linreal/cascade/editor/registry/BlockCallbacks;Landroidx/compose/runtime/Composer;I)V + public static fun getHandlesSelectionVisual (Lio/github/linreal/cascade/editor/registry/ScopedBlockRenderer;)Z + public static fun getSupportsDragPreview (Lio/github/linreal/cascade/editor/registry/ScopedBlockRenderer;)Z +} + +public abstract interface class io/github/linreal/cascade/editor/richtext/FormattingActions { + public abstract fun applyStyle (Lio/github/linreal/cascade/editor/core/SpanStyle;)V + public abstract fun removeStyle (Lio/github/linreal/cascade/editor/core/SpanStyle;)V + public abstract fun toggleStyle (Lio/github/linreal/cascade/editor/core/SpanStyle;)V +} + +public final class io/github/linreal/cascade/editor/richtext/FormattingState { + public static final field $stable I + public static final field Companion Lio/github/linreal/cascade/editor/richtext/FormattingState$Companion; + public synthetic fun (Ljava/util/Map;ZLjava/lang/String;ZLkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()Ljava/util/Map; + public final fun component2 ()Z + public final fun component3-ticUwL4 ()Ljava/lang/String; + public final fun component4 ()Z + public final fun copy-9Un3DiA (Ljava/util/Map;ZLjava/lang/String;Z)Lio/github/linreal/cascade/editor/richtext/FormattingState; + public static synthetic fun copy-9Un3DiA$default (Lio/github/linreal/cascade/editor/richtext/FormattingState;Ljava/util/Map;ZLjava/lang/String;ZILjava/lang/Object;)Lio/github/linreal/cascade/editor/richtext/FormattingState; + public fun equals (Ljava/lang/Object;)Z + public final fun getCanFormat ()Z + public final fun getFocusedBlockId-ticUwL4 ()Ljava/lang/String; + public final fun getSelectionCollapsed ()Z + public final fun getStyles ()Ljava/util/Map; + public fun hashCode ()I + public final fun styleStatusOf (Lio/github/linreal/cascade/editor/core/SpanStyle;)Lio/github/linreal/cascade/editor/richtext/StyleStatus; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/richtext/FormattingState$Companion { + public final fun getEmpty ()Lio/github/linreal/cascade/editor/richtext/FormattingState; +} + +public final class io/github/linreal/cascade/editor/richtext/LinkActionDispatcher : io/github/linreal/cascade/editor/richtext/LinkActions { + public static final field $stable I + public fun (Lkotlin/jvm/functions/Function1;Lio/github/linreal/cascade/editor/state/BlockTextStates;Lio/github/linreal/cascade/editor/state/BlockSpanStates;Lio/github/linreal/cascade/editor/state/EditorStateHolder;)V + public synthetic fun (Lkotlin/jvm/functions/Function1;Lio/github/linreal/cascade/editor/state/BlockTextStates;Lio/github/linreal/cascade/editor/state/BlockSpanStates;Lio/github/linreal/cascade/editor/state/EditorStateHolder;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public fun applyLink (Lio/github/linreal/cascade/editor/richtext/LinkTarget;Ljava/lang/String;Ljava/lang/String;)Lio/github/linreal/cascade/editor/richtext/LinkValidationResult; + public fun removeLink (Lio/github/linreal/cascade/editor/richtext/LinkTarget;)V +} + +public abstract interface class io/github/linreal/cascade/editor/richtext/LinkActions { + public abstract fun applyLink (Lio/github/linreal/cascade/editor/richtext/LinkTarget;Ljava/lang/String;Ljava/lang/String;)Lio/github/linreal/cascade/editor/richtext/LinkValidationResult; + public static synthetic fun applyLink$default (Lio/github/linreal/cascade/editor/richtext/LinkActions;Lio/github/linreal/cascade/editor/richtext/LinkTarget;Ljava/lang/String;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/richtext/LinkValidationResult; + public abstract fun removeLink (Lio/github/linreal/cascade/editor/richtext/LinkTarget;)V +} + +public final class io/github/linreal/cascade/editor/richtext/LinkActions$DefaultImpls { + public static synthetic fun applyLink$default (Lio/github/linreal/cascade/editor/richtext/LinkActions;Lio/github/linreal/cascade/editor/richtext/LinkTarget;Ljava/lang/String;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/richtext/LinkValidationResult; +} + +public abstract interface class io/github/linreal/cascade/editor/richtext/LinkChromeActions : io/github/linreal/cascade/editor/richtext/LinkActions { + public fun applyLinkAtCurrentTarget (Ljava/lang/String;Ljava/lang/String;)Lio/github/linreal/cascade/editor/richtext/LinkValidationResult; + public static synthetic fun applyLinkAtCurrentTarget$default (Lio/github/linreal/cascade/editor/richtext/LinkChromeActions;Ljava/lang/String;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/richtext/LinkValidationResult; + public abstract fun currentTarget ()Lio/github/linreal/cascade/editor/richtext/LinkTarget; + public fun removeLinkAtCurrentTarget ()V +} + +public final class io/github/linreal/cascade/editor/richtext/LinkChromeActions$DefaultImpls { + public static fun applyLinkAtCurrentTarget (Lio/github/linreal/cascade/editor/richtext/LinkChromeActions;Ljava/lang/String;Ljava/lang/String;)Lio/github/linreal/cascade/editor/richtext/LinkValidationResult; + public static synthetic fun applyLinkAtCurrentTarget$default (Lio/github/linreal/cascade/editor/richtext/LinkChromeActions;Ljava/lang/String;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/richtext/LinkValidationResult; + public static fun removeLinkAtCurrentTarget (Lio/github/linreal/cascade/editor/richtext/LinkChromeActions;)V +} + +public final class io/github/linreal/cascade/editor/richtext/LinkState { + public static final field $stable I + public static final field Companion Lio/github/linreal/cascade/editor/richtext/LinkState$Companion; + public synthetic fun (ZLjava/lang/String;Lio/github/linreal/cascade/editor/richtext/LinkTarget;Ljava/lang/String;ZLjava/lang/String;Lio/github/linreal/cascade/editor/richtext/LinkTarget;Ljava/lang/String;ZZLkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()Z + public final fun component10 ()Z + public final fun component2-ticUwL4 ()Ljava/lang/String; + public final fun component3 ()Lio/github/linreal/cascade/editor/richtext/LinkTarget; + public final fun component4 ()Ljava/lang/String; + public final fun component5 ()Z + public final fun component6 ()Ljava/lang/String; + public final fun component7 ()Lio/github/linreal/cascade/editor/richtext/LinkTarget; + public final fun component8 ()Ljava/lang/String; + public final fun component9 ()Z + public final fun copy-5-aqPgk (ZLjava/lang/String;Lio/github/linreal/cascade/editor/richtext/LinkTarget;Ljava/lang/String;ZLjava/lang/String;Lio/github/linreal/cascade/editor/richtext/LinkTarget;Ljava/lang/String;ZZ)Lio/github/linreal/cascade/editor/richtext/LinkState; + public static synthetic fun copy-5-aqPgk$default (Lio/github/linreal/cascade/editor/richtext/LinkState;ZLjava/lang/String;Lio/github/linreal/cascade/editor/richtext/LinkTarget;Ljava/lang/String;ZLjava/lang/String;Lio/github/linreal/cascade/editor/richtext/LinkTarget;Ljava/lang/String;ZZILjava/lang/Object;)Lio/github/linreal/cascade/editor/richtext/LinkState; + public fun equals (Ljava/lang/Object;)Z + public final fun getCanLink ()Z + public final fun getExistingLinkRange ()Lio/github/linreal/cascade/editor/richtext/LinkTarget; + public final fun getExistingLinkText ()Ljava/lang/String; + public final fun getExistingUrl ()Ljava/lang/String; + public final fun getFocusedBlockId-ticUwL4 ()Ljava/lang/String; + public final fun getIntersectsLink ()Z + public final fun getSelectionCollapsed ()Z + public final fun getTarget ()Lio/github/linreal/cascade/editor/richtext/LinkTarget; + public final fun getTargetText ()Ljava/lang/String; + public fun hashCode ()I + public final fun isInsideLink ()Z + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/richtext/LinkState$Companion { + public final fun getEmpty ()Lio/github/linreal/cascade/editor/richtext/LinkState; +} + +public final class io/github/linreal/cascade/editor/richtext/LinkTarget { + public static final field $stable I + public synthetic fun (Ljava/lang/String;IILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1--4CzayM ()Ljava/lang/String; + public final fun component2 ()I + public final fun component3 ()I + public final fun copy-p1zP0qE (Ljava/lang/String;II)Lio/github/linreal/cascade/editor/richtext/LinkTarget; + public static synthetic fun copy-p1zP0qE$default (Lio/github/linreal/cascade/editor/richtext/LinkTarget;Ljava/lang/String;IIILjava/lang/Object;)Lio/github/linreal/cascade/editor/richtext/LinkTarget; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlockId--4CzayM ()Ljava/lang/String; + public final fun getNormalizedEnd ()I + public final fun getNormalizedStart ()I + public final fun getRangeEnd ()I + public final fun getRangeStart ()I + public fun hashCode ()I + public final fun isCollapsed ()Z + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/richtext/LinkUrlPolicy { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/richtext/LinkUrlPolicy; + public final fun validate (Ljava/lang/String;)Lio/github/linreal/cascade/editor/richtext/LinkValidationResult; +} + +public final class io/github/linreal/cascade/editor/richtext/LinkValidationError : java/lang/Enum { + public static final field Blank Lio/github/linreal/cascade/editor/richtext/LinkValidationError; + public static fun getEntries ()Lkotlin/enums/EnumEntries; + public static fun valueOf (Ljava/lang/String;)Lio/github/linreal/cascade/editor/richtext/LinkValidationError; + public static fun values ()[Lio/github/linreal/cascade/editor/richtext/LinkValidationError; +} + +public abstract interface class io/github/linreal/cascade/editor/richtext/LinkValidationResult { + public abstract fun getError ()Lio/github/linreal/cascade/editor/richtext/LinkValidationError; + public abstract fun getNormalizedUrl ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/richtext/LinkValidationResult$Invalid : io/github/linreal/cascade/editor/richtext/LinkValidationResult { + public static final field $stable I + public fun (Lio/github/linreal/cascade/editor/richtext/LinkValidationError;)V + public final fun component1 ()Lio/github/linreal/cascade/editor/richtext/LinkValidationError; + public final fun copy (Lio/github/linreal/cascade/editor/richtext/LinkValidationError;)Lio/github/linreal/cascade/editor/richtext/LinkValidationResult$Invalid; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/richtext/LinkValidationResult$Invalid;Lio/github/linreal/cascade/editor/richtext/LinkValidationError;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/richtext/LinkValidationResult$Invalid; + public fun equals (Ljava/lang/Object;)Z + public fun getError ()Lio/github/linreal/cascade/editor/richtext/LinkValidationError; + public fun getNormalizedUrl ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/richtext/LinkValidationResult$Valid : io/github/linreal/cascade/editor/richtext/LinkValidationResult { + public static final field $stable I + public fun (Ljava/lang/String;)V + public final fun component1 ()Ljava/lang/String; + public final fun copy (Ljava/lang/String;)Lio/github/linreal/cascade/editor/richtext/LinkValidationResult$Valid; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/richtext/LinkValidationResult$Valid;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/richtext/LinkValidationResult$Valid; + public fun equals (Ljava/lang/Object;)Z + public fun getError ()Lio/github/linreal/cascade/editor/richtext/LinkValidationError; + public fun getNormalizedUrl ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/richtext/SpanActionDispatcher { + public static final field $stable I + public fun (Lkotlin/jvm/functions/Function1;Lio/github/linreal/cascade/editor/state/BlockTextStates;Lio/github/linreal/cascade/editor/state/BlockSpanStates;Lio/github/linreal/cascade/editor/state/EditorStateHolder;)V + public synthetic fun (Lkotlin/jvm/functions/Function1;Lio/github/linreal/cascade/editor/state/BlockTextStates;Lio/github/linreal/cascade/editor/state/BlockSpanStates;Lio/github/linreal/cascade/editor/state/EditorStateHolder;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun applyStyle-PeeSg0I (Ljava/lang/String;IILio/github/linreal/cascade/editor/core/SpanStyle;)V + public final fun removeStyle-PeeSg0I (Ljava/lang/String;IILio/github/linreal/cascade/editor/core/SpanStyle;)V + public final fun toggleStyle-PeeSg0I (Ljava/lang/String;IILio/github/linreal/cascade/editor/core/SpanStyle;)V +} + +public final class io/github/linreal/cascade/editor/richtext/StyleStatus : java/lang/Enum { + public static final field Absent Lio/github/linreal/cascade/editor/richtext/StyleStatus; + public static final field FullyActive Lio/github/linreal/cascade/editor/richtext/StyleStatus; + public static final field Partial Lio/github/linreal/cascade/editor/richtext/StyleStatus; + public static fun getEntries ()Lkotlin/enums/EnumEntries; + public static fun valueOf (Ljava/lang/String;)Lio/github/linreal/cascade/editor/richtext/StyleStatus; + public static fun values ()[Lio/github/linreal/cascade/editor/richtext/StyleStatus; +} + +public abstract interface class io/github/linreal/cascade/editor/serialization/BlockContentCodec { + public abstract fun decodeContent (Ljava/lang/String;Lkotlinx/serialization/json/JsonObject;)Lio/github/linreal/cascade/editor/core/BlockContent; + public abstract fun encodeContent (Lio/github/linreal/cascade/editor/core/BlockContent;)Lkotlinx/serialization/json/JsonObject; +} + +public final class io/github/linreal/cascade/editor/serialization/BlockIdMode : java/lang/Enum { + public static final field Preserve Lio/github/linreal/cascade/editor/serialization/BlockIdMode; + public static final field Regenerate Lio/github/linreal/cascade/editor/serialization/BlockIdMode; + public static fun getEntries ()Lkotlin/enums/EnumEntries; + public static fun valueOf (Ljava/lang/String;)Lio/github/linreal/cascade/editor/serialization/BlockIdMode; + public static fun values ()[Lio/github/linreal/cascade/editor/serialization/BlockIdMode; +} + +public abstract interface class io/github/linreal/cascade/editor/serialization/BlockTypeCodec { + public abstract fun decodeType (Ljava/lang/String;Lkotlinx/serialization/json/JsonObject;)Lio/github/linreal/cascade/editor/core/BlockType; + public abstract fun encodeType (Lio/github/linreal/cascade/editor/core/BlockType;)Lkotlinx/serialization/json/JsonObject; +} + +public final class io/github/linreal/cascade/editor/serialization/CustomDataMode : java/lang/Enum { + public static final field LenientSkipUnsupported Lio/github/linreal/cascade/editor/serialization/CustomDataMode; + public static final field Strict Lio/github/linreal/cascade/editor/serialization/CustomDataMode; + public static fun getEntries ()Lkotlin/enums/EnumEntries; + public static fun valueOf (Ljava/lang/String;)Lio/github/linreal/cascade/editor/serialization/CustomDataMode; + public static fun values ()[Lio/github/linreal/cascade/editor/serialization/CustomDataMode; +} + +public final class io/github/linreal/cascade/editor/serialization/DocumentDecodeOptions { + public static final field $stable I + public fun ()V + public fun (Lio/github/linreal/cascade/editor/serialization/BlockIdMode;Lio/github/linreal/cascade/editor/serialization/DuplicateIdMode;)V + public synthetic fun (Lio/github/linreal/cascade/editor/serialization/BlockIdMode;Lio/github/linreal/cascade/editor/serialization/DuplicateIdMode;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()Lio/github/linreal/cascade/editor/serialization/BlockIdMode; + public final fun component2 ()Lio/github/linreal/cascade/editor/serialization/DuplicateIdMode; + public final fun copy (Lio/github/linreal/cascade/editor/serialization/BlockIdMode;Lio/github/linreal/cascade/editor/serialization/DuplicateIdMode;)Lio/github/linreal/cascade/editor/serialization/DocumentDecodeOptions; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/serialization/DocumentDecodeOptions;Lio/github/linreal/cascade/editor/serialization/BlockIdMode;Lio/github/linreal/cascade/editor/serialization/DuplicateIdMode;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/serialization/DocumentDecodeOptions; + public fun equals (Ljava/lang/Object;)Z + public final fun getDuplicateIdMode ()Lio/github/linreal/cascade/editor/serialization/DuplicateIdMode; + public final fun getIdMode ()Lio/github/linreal/cascade/editor/serialization/BlockIdMode; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/serialization/DocumentDecodeResult { + public static final field $stable I + public fun (Ljava/util/List;Ljava/util/List;)V + public final fun component1 ()Ljava/util/List; + public final fun component2 ()Ljava/util/List; + public final fun copy (Ljava/util/List;Ljava/util/List;)Lio/github/linreal/cascade/editor/serialization/DocumentDecodeResult; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/serialization/DocumentDecodeResult;Ljava/util/List;Ljava/util/List;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/serialization/DocumentDecodeResult; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlocks ()Ljava/util/List; + public final fun getWarnings ()Ljava/util/List; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public abstract class io/github/linreal/cascade/editor/serialization/DocumentDecodeWarning { + public static final field $stable I +} + +public final class io/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$DocumentParseFailed : io/github/linreal/cascade/editor/serialization/DocumentDecodeWarning { + public static final field $stable I + public fun (Ljava/lang/String;)V + public final fun component1 ()Ljava/lang/String; + public final fun copy (Ljava/lang/String;)Lio/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$DocumentParseFailed; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$DocumentParseFailed;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$DocumentParseFailed; + public fun equals (Ljava/lang/Object;)Z + public final fun getReason ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$DuplicateIdRegenerated : io/github/linreal/cascade/editor/serialization/DocumentDecodeWarning { + public static final field $stable I + public fun (ILjava/lang/String;Ljava/lang/String;)V + public final fun component1 ()I + public final fun component2 ()Ljava/lang/String; + public final fun component3 ()Ljava/lang/String; + public final fun copy (ILjava/lang/String;Ljava/lang/String;)Lio/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$DuplicateIdRegenerated; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$DuplicateIdRegenerated;ILjava/lang/String;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$DuplicateIdRegenerated; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlockIndex ()I + public final fun getNewId ()Ljava/lang/String; + public final fun getOriginalId ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$InvalidBlockAttributeParam : io/github/linreal/cascade/editor/serialization/DocumentDecodeWarning { + public static final field $stable I + public fun (ILjava/lang/String;Ljava/lang/String;)V + public final fun component1 ()I + public final fun component2 ()Ljava/lang/String; + public final fun component3 ()Ljava/lang/String; + public final fun copy (ILjava/lang/String;Ljava/lang/String;)Lio/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$InvalidBlockAttributeParam; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$InvalidBlockAttributeParam;ILjava/lang/String;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$InvalidBlockAttributeParam; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlockIndex ()I + public final fun getFallback ()Ljava/lang/String; + public final fun getParam ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$InvalidBlockTypeParam : io/github/linreal/cascade/editor/serialization/DocumentDecodeWarning { + public static final field $stable I + public fun (ILjava/lang/String;Ljava/lang/String;Ljava/lang/String;)V + public final fun component1 ()I + public final fun component2 ()Ljava/lang/String; + public final fun component3 ()Ljava/lang/String; + public final fun component4 ()Ljava/lang/String; + public final fun copy (ILjava/lang/String;Ljava/lang/String;Ljava/lang/String;)Lio/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$InvalidBlockTypeParam; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$InvalidBlockTypeParam;ILjava/lang/String;Ljava/lang/String;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$InvalidBlockTypeParam; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlockIndex ()I + public final fun getFallback ()Ljava/lang/String; + public final fun getParam ()Ljava/lang/String; + public final fun getTypeId ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$MalformedBlockSkipped : io/github/linreal/cascade/editor/serialization/DocumentDecodeWarning { + public static final field $stable I + public fun (ILjava/lang/String;)V + public final fun component1 ()I + public final fun component2 ()Ljava/lang/String; + public final fun copy (ILjava/lang/String;)Lio/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$MalformedBlockSkipped; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$MalformedBlockSkipped;ILjava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$MalformedBlockSkipped; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlockIndex ()I + public final fun getReason ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$MissingIdRegenerated : io/github/linreal/cascade/editor/serialization/DocumentDecodeWarning { + public static final field $stable I + public fun (I)V + public final fun component1 ()I + public final fun copy (I)Lio/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$MissingIdRegenerated; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$MissingIdRegenerated;IILjava/lang/Object;)Lio/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$MissingIdRegenerated; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlockIndex ()I + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$UnknownBlockTypePreserved : io/github/linreal/cascade/editor/serialization/DocumentDecodeWarning { + public static final field $stable I + public fun (ILjava/lang/String;)V + public final fun component1 ()I + public final fun component2 ()Ljava/lang/String; + public final fun copy (ILjava/lang/String;)Lio/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$UnknownBlockTypePreserved; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$UnknownBlockTypePreserved;ILjava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$UnknownBlockTypePreserved; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlockIndex ()I + public final fun getTypeId ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$UnknownContentKind : io/github/linreal/cascade/editor/serialization/DocumentDecodeWarning { + public static final field $stable I + public fun (ILjava/lang/String;)V + public final fun component1 ()I + public final fun component2 ()Ljava/lang/String; + public final fun copy (ILjava/lang/String;)Lio/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$UnknownContentKind; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$UnknownContentKind;ILjava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$UnknownContentKind; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlockIndex ()I + public final fun getKind ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$UnsupportedCustomDataDropped : io/github/linreal/cascade/editor/serialization/DocumentDecodeWarning { + public static final field $stable I + public fun (ILjava/lang/String;Ljava/lang/String;)V + public final fun component1 ()I + public final fun component2 ()Ljava/lang/String; + public final fun component3 ()Ljava/lang/String; + public final fun copy (ILjava/lang/String;Ljava/lang/String;)Lio/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$UnsupportedCustomDataDropped; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$UnsupportedCustomDataDropped;ILjava/lang/String;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$UnsupportedCustomDataDropped; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlockIndex ()I + public final fun getKey ()Ljava/lang/String; + public final fun getValueType ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/serialization/DocumentEncodeOptions { + public static final field $stable I + public fun ()V + public fun (Lio/github/linreal/cascade/editor/serialization/CustomDataMode;)V + public synthetic fun (Lio/github/linreal/cascade/editor/serialization/CustomDataMode;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()Lio/github/linreal/cascade/editor/serialization/CustomDataMode; + public final fun copy (Lio/github/linreal/cascade/editor/serialization/CustomDataMode;)Lio/github/linreal/cascade/editor/serialization/DocumentEncodeOptions; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/serialization/DocumentEncodeOptions;Lio/github/linreal/cascade/editor/serialization/CustomDataMode;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/serialization/DocumentEncodeOptions; + public fun equals (Ljava/lang/Object;)Z + public final fun getCustomDataMode ()Lio/github/linreal/cascade/editor/serialization/CustomDataMode; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/serialization/DocumentSchema { + public static final field $stable I + public static final field CURRENT_VERSION I + public static final field INSTANCE Lio/github/linreal/cascade/editor/serialization/DocumentSchema; + public final fun decode (Lkotlinx/serialization/json/JsonObject;Lio/github/linreal/cascade/editor/serialization/DocumentDecodeOptions;Lio/github/linreal/cascade/editor/serialization/BlockTypeCodec;Lio/github/linreal/cascade/editor/serialization/BlockContentCodec;)Ljava/util/List; + public static synthetic fun decode$default (Lio/github/linreal/cascade/editor/serialization/DocumentSchema;Lkotlinx/serialization/json/JsonObject;Lio/github/linreal/cascade/editor/serialization/DocumentDecodeOptions;Lio/github/linreal/cascade/editor/serialization/BlockTypeCodec;Lio/github/linreal/cascade/editor/serialization/BlockContentCodec;ILjava/lang/Object;)Ljava/util/List; + public final fun decodeFromString (Ljava/lang/String;Lio/github/linreal/cascade/editor/serialization/DocumentDecodeOptions;Lio/github/linreal/cascade/editor/serialization/BlockTypeCodec;Lio/github/linreal/cascade/editor/serialization/BlockContentCodec;)Ljava/util/List; + public static synthetic fun decodeFromString$default (Lio/github/linreal/cascade/editor/serialization/DocumentSchema;Ljava/lang/String;Lio/github/linreal/cascade/editor/serialization/DocumentDecodeOptions;Lio/github/linreal/cascade/editor/serialization/BlockTypeCodec;Lio/github/linreal/cascade/editor/serialization/BlockContentCodec;ILjava/lang/Object;)Ljava/util/List; + public final fun decodeFromStringWithReport (Ljava/lang/String;Lio/github/linreal/cascade/editor/serialization/DocumentDecodeOptions;Lio/github/linreal/cascade/editor/serialization/BlockTypeCodec;Lio/github/linreal/cascade/editor/serialization/BlockContentCodec;)Lio/github/linreal/cascade/editor/serialization/DocumentDecodeResult; + public static synthetic fun decodeFromStringWithReport$default (Lio/github/linreal/cascade/editor/serialization/DocumentSchema;Ljava/lang/String;Lio/github/linreal/cascade/editor/serialization/DocumentDecodeOptions;Lio/github/linreal/cascade/editor/serialization/BlockTypeCodec;Lio/github/linreal/cascade/editor/serialization/BlockContentCodec;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/serialization/DocumentDecodeResult; + public final fun decodeWithReport (Lkotlinx/serialization/json/JsonObject;Lio/github/linreal/cascade/editor/serialization/DocumentDecodeOptions;Lio/github/linreal/cascade/editor/serialization/BlockTypeCodec;Lio/github/linreal/cascade/editor/serialization/BlockContentCodec;)Lio/github/linreal/cascade/editor/serialization/DocumentDecodeResult; + public static synthetic fun decodeWithReport$default (Lio/github/linreal/cascade/editor/serialization/DocumentSchema;Lkotlinx/serialization/json/JsonObject;Lio/github/linreal/cascade/editor/serialization/DocumentDecodeOptions;Lio/github/linreal/cascade/editor/serialization/BlockTypeCodec;Lio/github/linreal/cascade/editor/serialization/BlockContentCodec;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/serialization/DocumentDecodeResult; + public final fun encode (Ljava/util/List;Lio/github/linreal/cascade/editor/serialization/DocumentEncodeOptions;Lio/github/linreal/cascade/editor/serialization/BlockTypeCodec;Lio/github/linreal/cascade/editor/serialization/BlockContentCodec;)Lkotlinx/serialization/json/JsonObject; + public static synthetic fun encode$default (Lio/github/linreal/cascade/editor/serialization/DocumentSchema;Ljava/util/List;Lio/github/linreal/cascade/editor/serialization/DocumentEncodeOptions;Lio/github/linreal/cascade/editor/serialization/BlockTypeCodec;Lio/github/linreal/cascade/editor/serialization/BlockContentCodec;ILjava/lang/Object;)Lkotlinx/serialization/json/JsonObject; + public final fun encodeToString (Ljava/util/List;Lio/github/linreal/cascade/editor/serialization/DocumentEncodeOptions;Lio/github/linreal/cascade/editor/serialization/BlockTypeCodec;Lio/github/linreal/cascade/editor/serialization/BlockContentCodec;)Ljava/lang/String; + public static synthetic fun encodeToString$default (Lio/github/linreal/cascade/editor/serialization/DocumentSchema;Ljava/util/List;Lio/github/linreal/cascade/editor/serialization/DocumentEncodeOptions;Lio/github/linreal/cascade/editor/serialization/BlockTypeCodec;Lio/github/linreal/cascade/editor/serialization/BlockContentCodec;ILjava/lang/Object;)Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/serialization/DocumentSerializationExtKt { + public static final fun loadFromJson (Lio/github/linreal/cascade/editor/state/EditorStateHolder;Ljava/lang/String;Lio/github/linreal/cascade/editor/state/BlockTextStates;Lio/github/linreal/cascade/editor/state/BlockSpanStates;Lio/github/linreal/cascade/editor/serialization/DocumentDecodeOptions;Lio/github/linreal/cascade/editor/serialization/BlockTypeCodec;Lio/github/linreal/cascade/editor/serialization/BlockContentCodec;)Lio/github/linreal/cascade/editor/serialization/DocumentDecodeResult; + public static synthetic fun loadFromJson$default (Lio/github/linreal/cascade/editor/state/EditorStateHolder;Ljava/lang/String;Lio/github/linreal/cascade/editor/state/BlockTextStates;Lio/github/linreal/cascade/editor/state/BlockSpanStates;Lio/github/linreal/cascade/editor/serialization/DocumentDecodeOptions;Lio/github/linreal/cascade/editor/serialization/BlockTypeCodec;Lio/github/linreal/cascade/editor/serialization/BlockContentCodec;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/serialization/DocumentDecodeResult; + public static final fun resolveDocumentBlocks (Lio/github/linreal/cascade/editor/state/EditorStateHolder;Lio/github/linreal/cascade/editor/state/BlockTextStates;Lio/github/linreal/cascade/editor/state/BlockSpanStates;)Ljava/util/List; + public static final fun toJson (Lio/github/linreal/cascade/editor/state/EditorStateHolder;Lio/github/linreal/cascade/editor/state/BlockTextStates;Lio/github/linreal/cascade/editor/state/BlockSpanStates;Lio/github/linreal/cascade/editor/serialization/DocumentEncodeOptions;Lio/github/linreal/cascade/editor/serialization/BlockTypeCodec;Lio/github/linreal/cascade/editor/serialization/BlockContentCodec;)Ljava/lang/String; + public static synthetic fun toJson$default (Lio/github/linreal/cascade/editor/state/EditorStateHolder;Lio/github/linreal/cascade/editor/state/BlockTextStates;Lio/github/linreal/cascade/editor/state/BlockSpanStates;Lio/github/linreal/cascade/editor/serialization/DocumentEncodeOptions;Lio/github/linreal/cascade/editor/serialization/BlockTypeCodec;Lio/github/linreal/cascade/editor/serialization/BlockContentCodec;ILjava/lang/Object;)Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/serialization/DuplicateIdMode : java/lang/Enum { + public static final field FailFast Lio/github/linreal/cascade/editor/serialization/DuplicateIdMode; + public static final field RegenerateLaterDuplicates Lio/github/linreal/cascade/editor/serialization/DuplicateIdMode; + public static fun getEntries ()Lkotlin/enums/EnumEntries; + public static fun valueOf (Ljava/lang/String;)Lio/github/linreal/cascade/editor/serialization/DuplicateIdMode; + public static fun values ()[Lio/github/linreal/cascade/editor/serialization/DuplicateIdMode; +} + +public final class io/github/linreal/cascade/editor/serialization/RichTextSchema { + public static final field $stable I + public static final field CURRENT_VERSION I + public static final field INSTANCE Lio/github/linreal/cascade/editor/serialization/RichTextSchema; + public final fun decode (Lkotlinx/serialization/json/JsonObject;)Lio/github/linreal/cascade/editor/core/BlockContent$Text; + public final fun decodeFromString (Ljava/lang/String;)Lio/github/linreal/cascade/editor/core/BlockContent$Text; + public final fun encode (Lio/github/linreal/cascade/editor/core/BlockContent$Text;)Lkotlinx/serialization/json/JsonObject; + public final fun encodeToString (Lio/github/linreal/cascade/editor/core/BlockContent$Text;)Ljava/lang/String; +} + +public abstract interface class io/github/linreal/cascade/editor/slash/BuiltInBlockSlashBehavior { +} + +public final class io/github/linreal/cascade/editor/slash/BuiltInBlockSlashBehavior$AlwaysInsert : io/github/linreal/cascade/editor/slash/BuiltInBlockSlashBehavior { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/slash/BuiltInBlockSlashBehavior$AlwaysInsert; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/slash/BuiltInBlockSlashBehavior$ConvertInPlace : io/github/linreal/cascade/editor/slash/BuiltInBlockSlashBehavior { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/slash/BuiltInBlockSlashBehavior$ConvertInPlace; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/slash/BuiltInSlashCommandFactoryKt { + public static final field BUILTIN_BLOCK_SLASH_COMMAND_ID_PREFIX Ljava/lang/String; + public static final fun builtInBlockSlashCommandId (Ljava/lang/String;)Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/slash/BuiltInSlashCommandSpec { + public static final field $stable I + public synthetic fun (Lio/github/linreal/cascade/editor/slash/BuiltInBlockSlashBehavior;Ljava/lang/String;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public synthetic fun (Lio/github/linreal/cascade/editor/slash/BuiltInBlockSlashBehavior;Ljava/lang/String;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()Lio/github/linreal/cascade/editor/slash/BuiltInBlockSlashBehavior; + public final fun component2--0eK1zE ()Ljava/lang/String; + public final fun copy-G7SjZIA (Lio/github/linreal/cascade/editor/slash/BuiltInBlockSlashBehavior;Ljava/lang/String;)Lio/github/linreal/cascade/editor/slash/BuiltInSlashCommandSpec; + public static synthetic fun copy-G7SjZIA$default (Lio/github/linreal/cascade/editor/slash/BuiltInSlashCommandSpec;Lio/github/linreal/cascade/editor/slash/BuiltInBlockSlashBehavior;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/slash/BuiltInSlashCommandSpec; + public fun equals (Ljava/lang/Object;)Z + public final fun getBehavior ()Lio/github/linreal/cascade/editor/slash/BuiltInBlockSlashBehavior; + public final fun getIcon--0eK1zE ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/slash/SlashCommandAction : io/github/linreal/cascade/editor/slash/SlashCommandItem { + public static final field $stable I + public synthetic fun (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/util/List;Ljava/lang/String;Lio/github/linreal/cascade/editor/slash/SlashQueryTextPolicy;Lkotlin/jvm/functions/Function2;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public synthetic fun (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/util/List;Ljava/lang/String;Lio/github/linreal/cascade/editor/slash/SlashQueryTextPolicy;Lkotlin/jvm/functions/Function2;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1-6BJIqV4 ()Ljava/lang/String; + public final fun component2 ()Ljava/lang/String; + public final fun component3 ()Ljava/lang/String; + public final fun component4 ()Ljava/util/List; + public final fun component5--0eK1zE ()Ljava/lang/String; + public final fun component6 ()Lio/github/linreal/cascade/editor/slash/SlashQueryTextPolicy; + public final fun component7 ()Lkotlin/jvm/functions/Function2; + public final fun copy-vcqtq9w (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/util/List;Ljava/lang/String;Lio/github/linreal/cascade/editor/slash/SlashQueryTextPolicy;Lkotlin/jvm/functions/Function2;)Lio/github/linreal/cascade/editor/slash/SlashCommandAction; + public static synthetic fun copy-vcqtq9w$default (Lio/github/linreal/cascade/editor/slash/SlashCommandAction;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/util/List;Ljava/lang/String;Lio/github/linreal/cascade/editor/slash/SlashQueryTextPolicy;Lkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/slash/SlashCommandAction; + public fun equals (Ljava/lang/Object;)Z + public fun getDescription ()Ljava/lang/String; + public fun getIcon--0eK1zE ()Ljava/lang/String; + public fun getId-6BJIqV4 ()Ljava/lang/String; + public fun getKeywords ()Ljava/util/List; + public final fun getOnExecute ()Lkotlin/jvm/functions/Function2; + public final fun getQueryTextPolicy ()Lio/github/linreal/cascade/editor/slash/SlashQueryTextPolicy; + public fun getTitle ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/slash/SlashCommandContext { + public static final field $stable I + public synthetic fun (Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/state/SlashQueryRange;Lio/github/linreal/cascade/editor/slash/SlashCommandEditor;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1--4CzayM ()Ljava/lang/String; + public final fun component2 ()Ljava/lang/String; + public final fun component3 ()Lio/github/linreal/cascade/editor/state/SlashQueryRange; + public final fun component4 ()Lio/github/linreal/cascade/editor/slash/SlashCommandEditor; + public final fun copy-PeeSg0I (Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/state/SlashQueryRange;Lio/github/linreal/cascade/editor/slash/SlashCommandEditor;)Lio/github/linreal/cascade/editor/slash/SlashCommandContext; + public static synthetic fun copy-PeeSg0I$default (Lio/github/linreal/cascade/editor/slash/SlashCommandContext;Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/state/SlashQueryRange;Lio/github/linreal/cascade/editor/slash/SlashCommandEditor;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/slash/SlashCommandContext; + public fun equals (Ljava/lang/Object;)Z + public final fun getAnchorBlockId--4CzayM ()Ljava/lang/String; + public final fun getEditor ()Lio/github/linreal/cascade/editor/slash/SlashCommandEditor; + public final fun getQuery ()Ljava/lang/String; + public final fun getQueryRange ()Lio/github/linreal/cascade/editor/state/SlashQueryRange; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public abstract interface class io/github/linreal/cascade/editor/slash/SlashCommandEditor { + public abstract fun closeMenu ()V + public abstract fun focusBlock-7OMXkl4 (Ljava/lang/String;Ljava/lang/Integer;)V + public static synthetic fun focusBlock-7OMXkl4$default (Lio/github/linreal/cascade/editor/slash/SlashCommandEditor;Ljava/lang/String;Ljava/lang/Integer;ILjava/lang/Object;)V + public abstract fun getAnchorBlock ()Lio/github/linreal/cascade/editor/core/Block; + public abstract fun getAnchorVisibleText ()Ljava/lang/String; + public abstract fun insertBlockAfterAnchor (Lio/github/linreal/cascade/editor/core/Block;ZLjava/lang/Integer;)V + public static synthetic fun insertBlockAfterAnchor$default (Lio/github/linreal/cascade/editor/slash/SlashCommandEditor;Lio/github/linreal/cascade/editor/core/Block;ZLjava/lang/Integer;ILjava/lang/Object;)V + public abstract fun insertBlockBeforeAnchor (Lio/github/linreal/cascade/editor/core/Block;)V + public abstract fun replaceAnchorBlock (Lio/github/linreal/cascade/editor/core/Block;ZZLjava/lang/Integer;)V + public static synthetic fun replaceAnchorBlock$default (Lio/github/linreal/cascade/editor/slash/SlashCommandEditor;Lio/github/linreal/cascade/editor/core/Block;ZZLjava/lang/Integer;ILjava/lang/Object;)V + public abstract fun replaceQueryText (Ljava/lang/String;)V + public static synthetic fun replaceQueryText$default (Lio/github/linreal/cascade/editor/slash/SlashCommandEditor;Ljava/lang/String;ILjava/lang/Object;)V + public abstract fun updateAnchorText (Ljava/lang/String;Ljava/lang/Integer;)V + public static synthetic fun updateAnchorText$default (Lio/github/linreal/cascade/editor/slash/SlashCommandEditor;Ljava/lang/String;Ljava/lang/Integer;ILjava/lang/Object;)V +} + +public final class io/github/linreal/cascade/editor/slash/SlashCommandEditor$DefaultImpls { + public static synthetic fun focusBlock-7OMXkl4$default (Lio/github/linreal/cascade/editor/slash/SlashCommandEditor;Ljava/lang/String;Ljava/lang/Integer;ILjava/lang/Object;)V + public static synthetic fun insertBlockAfterAnchor$default (Lio/github/linreal/cascade/editor/slash/SlashCommandEditor;Lio/github/linreal/cascade/editor/core/Block;ZLjava/lang/Integer;ILjava/lang/Object;)V + public static synthetic fun replaceAnchorBlock$default (Lio/github/linreal/cascade/editor/slash/SlashCommandEditor;Lio/github/linreal/cascade/editor/core/Block;ZZLjava/lang/Integer;ILjava/lang/Object;)V + public static synthetic fun replaceQueryText$default (Lio/github/linreal/cascade/editor/slash/SlashCommandEditor;Ljava/lang/String;ILjava/lang/Object;)V + public static synthetic fun updateAnchorText$default (Lio/github/linreal/cascade/editor/slash/SlashCommandEditor;Ljava/lang/String;Ljava/lang/Integer;ILjava/lang/Object;)V +} + +public final class io/github/linreal/cascade/editor/slash/SlashCommandIconKey { + public static final synthetic fun box-impl (Ljava/lang/String;)Lio/github/linreal/cascade/editor/slash/SlashCommandIconKey; + public static fun constructor-impl (Ljava/lang/String;)Ljava/lang/String; + public fun equals (Ljava/lang/Object;)Z + public static fun equals-impl (Ljava/lang/String;Ljava/lang/Object;)Z + public static final fun equals-impl0 (Ljava/lang/String;Ljava/lang/String;)Z + public final fun getValue ()Ljava/lang/String; + public fun hashCode ()I + public static fun hashCode-impl (Ljava/lang/String;)I + public fun toString ()Ljava/lang/String; + public static fun toString-impl (Ljava/lang/String;)Ljava/lang/String; + public final synthetic fun unbox-impl ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/slash/SlashCommandId { + public static final synthetic fun box-impl (Ljava/lang/String;)Lio/github/linreal/cascade/editor/slash/SlashCommandId; + public static fun constructor-impl (Ljava/lang/String;)Ljava/lang/String; + public fun equals (Ljava/lang/Object;)Z + public static fun equals-impl (Ljava/lang/String;Ljava/lang/Object;)Z + public static final fun equals-impl0 (Ljava/lang/String;Ljava/lang/String;)Z + public final fun getValue ()Ljava/lang/String; + public fun hashCode ()I + public static fun hashCode-impl (Ljava/lang/String;)I + public fun toString ()Ljava/lang/String; + public static fun toString-impl (Ljava/lang/String;)Ljava/lang/String; + public final synthetic fun unbox-impl ()Ljava/lang/String; +} + +public abstract interface class io/github/linreal/cascade/editor/slash/SlashCommandItem { + public abstract fun getDescription ()Ljava/lang/String; + public abstract fun getIcon--0eK1zE ()Ljava/lang/String; + public abstract fun getId-6BJIqV4 ()Ljava/lang/String; + public abstract fun getKeywords ()Ljava/util/List; + public abstract fun getTitle ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/slash/SlashCommandMenu : io/github/linreal/cascade/editor/slash/SlashCommandItem { + public static final field $stable I + public synthetic fun (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/util/List;Ljava/lang/String;Ljava/util/List;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public synthetic fun (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/util/List;Ljava/lang/String;Ljava/util/List;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1-6BJIqV4 ()Ljava/lang/String; + public final fun component2 ()Ljava/lang/String; + public final fun component3 ()Ljava/lang/String; + public final fun component4 ()Ljava/util/List; + public final fun component5--0eK1zE ()Ljava/lang/String; + public final fun component6 ()Ljava/util/List; + public final fun copy-q6iIFMo (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/util/List;Ljava/lang/String;Ljava/util/List;)Lio/github/linreal/cascade/editor/slash/SlashCommandMenu; + public static synthetic fun copy-q6iIFMo$default (Lio/github/linreal/cascade/editor/slash/SlashCommandMenu;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/util/List;Ljava/lang/String;Ljava/util/List;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/slash/SlashCommandMenu; + public fun equals (Ljava/lang/Object;)Z + public final fun getChildren ()Ljava/util/List; + public fun getDescription ()Ljava/lang/String; + public fun getIcon--0eK1zE ()Ljava/lang/String; + public fun getId-6BJIqV4 ()Ljava/lang/String; + public fun getKeywords ()Ljava/util/List; + public fun getTitle ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/slash/SlashCommandRegistry { + public static final field $stable I + public fun ()V + public final fun getRootItems ()Ljava/util/List; + public final fun register (Lio/github/linreal/cascade/editor/slash/SlashCommandItem;)V + public final fun search (Ljava/lang/String;Ljava/util/List;)Ljava/util/List; + public static synthetic fun search$default (Lio/github/linreal/cascade/editor/slash/SlashCommandRegistry;Ljava/lang/String;Ljava/util/List;ILjava/lang/Object;)Ljava/util/List; +} + +public abstract interface class io/github/linreal/cascade/editor/slash/SlashCommandResult { +} + +public final class io/github/linreal/cascade/editor/slash/SlashCommandResult$Done : io/github/linreal/cascade/editor/slash/SlashCommandResult { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/slash/SlashCommandResult$Done; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/slash/SlashCommandResult$Failure : io/github/linreal/cascade/editor/slash/SlashCommandResult { + public static final field $stable I + public fun ()V + public fun (Ljava/lang/String;)V + public synthetic fun (Ljava/lang/String;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()Ljava/lang/String; + public final fun copy (Ljava/lang/String;)Lio/github/linreal/cascade/editor/slash/SlashCommandResult$Failure; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/slash/SlashCommandResult$Failure;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/slash/SlashCommandResult$Failure; + public fun equals (Ljava/lang/Object;)Z + public final fun getMessage ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/slash/SlashCommandResult$KeepOpen : io/github/linreal/cascade/editor/slash/SlashCommandResult { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/slash/SlashCommandResult$KeepOpen; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/slash/SlashQueryTextPolicy : java/lang/Enum { + public static final field KeepText Lio/github/linreal/cascade/editor/slash/SlashQueryTextPolicy; + public static final field RemoveBeforeExecute Lio/github/linreal/cascade/editor/slash/SlashQueryTextPolicy; + public static fun getEntries ()Lkotlin/enums/EnumEntries; + public static fun valueOf (Ljava/lang/String;)Lio/github/linreal/cascade/editor/slash/SlashQueryTextPolicy; + public static fun values ()[Lio/github/linreal/cascade/editor/slash/SlashQueryTextPolicy; +} + +public final class io/github/linreal/cascade/editor/state/BlockSpanStates { + public static final field $stable I + public fun ()V + public final fun activeStylesAt-7OMXkl4 (Ljava/lang/String;I)Ljava/util/Set; + public final fun adjustForRangeReplacement-PeeSg0I (Ljava/lang/String;III)V + public final fun adjustForUserEdit-PeeSg0I (Ljava/lang/String;III)V + public final fun applyStyle-aGoj3o0 (Ljava/lang/String;IILio/github/linreal/cascade/editor/core/SpanStyle;I)V + public final fun cleanup (Ljava/util/Set;)V + public final fun clear ()V + public final fun clearPendingStyles-SDe6QqM (Ljava/lang/String;)V + public final fun get-SDe6QqM (Ljava/lang/String;)Landroidx/compose/runtime/State; + public final fun getOrCreate-p1zP0qE (Ljava/lang/String;Ljava/util/List;I)Landroidx/compose/runtime/State; + public static synthetic fun getOrCreate-p1zP0qE$default (Lio/github/linreal/cascade/editor/state/BlockSpanStates;Ljava/lang/String;Ljava/util/List;IILjava/lang/Object;)Landroidx/compose/runtime/State; + public final fun getPendingStyles-SDe6QqM (Ljava/lang/String;)Ljava/util/Set; + public final fun getSpans-SDe6QqM (Ljava/lang/String;)Ljava/util/List; + public final fun mergeInto-S_bWWxk (Ljava/lang/String;Ljava/lang/String;I)V + public final fun queryStyleStatus-PeeSg0I (Ljava/lang/String;IILio/github/linreal/cascade/editor/core/SpanStyle;)Lio/github/linreal/cascade/editor/richtext/StyleStatus; + public final fun remove-SDe6QqM (Ljava/lang/String;)V + public final fun removeLinkSpans-p1zP0qE (Ljava/lang/String;II)V + public final fun removeStyle-PeeSg0I (Ljava/lang/String;IILio/github/linreal/cascade/editor/core/SpanStyle;)V + public final fun resolveStylesForInsertion-7OMXkl4 (Ljava/lang/String;I)Ljava/util/Set; + public final fun set-p1zP0qE (Ljava/lang/String;Ljava/util/List;I)V + public final fun setPendingStyles-7OMXkl4 (Ljava/lang/String;Ljava/util/Set;)V + public final fun split-S_bWWxk (Ljava/lang/String;Ljava/lang/String;I)V + public final fun toggleStyle-aGoj3o0 (Ljava/lang/String;IILio/github/linreal/cascade/editor/core/SpanStyle;I)V +} + +public final class io/github/linreal/cascade/editor/state/BlockTextStates { + public static final field $stable I + public fun ()V + public final fun cleanup (Ljava/util/Set;)V + public final fun clear ()V + public final fun consumeProgrammaticCommit-SDe6QqM (Ljava/lang/String;)Ljava/lang/String; + public final fun extractAllText ()Ljava/util/Map; + public final fun get-SDe6QqM (Ljava/lang/String;)Landroidx/compose/foundation/text/input/TextFieldState; + public final fun getOrCreate-p1zP0qE (Ljava/lang/String;Ljava/lang/String;I)Landroidx/compose/foundation/text/input/TextFieldState; + public static synthetic fun getOrCreate-p1zP0qE$default (Lio/github/linreal/cascade/editor/state/BlockTextStates;Ljava/lang/String;Ljava/lang/String;IILjava/lang/Object;)Landroidx/compose/foundation/text/input/TextFieldState; + public final fun getSelection-UXP-uLA (Ljava/lang/String;)Landroidx/compose/ui/text/TextRange; + public final fun getVisibleText-SDe6QqM (Ljava/lang/String;)Ljava/lang/String; + public final fun mergeInto-uwJGxUo (Ljava/lang/String;Ljava/lang/String;)Ljava/lang/Integer; + public final fun remove-SDe6QqM (Ljava/lang/String;)V + public final fun replaceVisibleRange-aGoj3o0 (Ljava/lang/String;IILjava/lang/String;Ljava/lang/Integer;)Ljava/lang/String; + public static synthetic fun replaceVisibleRange-aGoj3o0$default (Lio/github/linreal/cascade/editor/state/BlockTextStates;Ljava/lang/String;IILjava/lang/String;Ljava/lang/Integer;ILjava/lang/Object;)Ljava/lang/String; + public final fun setCursorPosition-7OMXkl4 (Ljava/lang/String;I)V + public final fun setSelection-5Jeh78Y (Ljava/lang/String;J)V + public final fun setText-p1zP0qE (Ljava/lang/String;Ljava/lang/String;Ljava/lang/Integer;)V + public static synthetic fun setText-p1zP0qE$default (Lio/github/linreal/cascade/editor/state/BlockTextStates;Ljava/lang/String;Ljava/lang/String;Ljava/lang/Integer;ILjava/lang/Object;)V +} + +public final class io/github/linreal/cascade/editor/state/DragState { + public static final field $stable I + public synthetic fun (Ljava/util/Set;Ljava/lang/Integer;FILjava/util/List;Ljava/util/List;Ljava/util/Set;Ljava/util/List;Ljava/util/Set;Ljava/util/List;Ljava/lang/String;ILjava/lang/Boolean;Ljava/util/Map;Ljava/util/Map;Ljava/util/Map;IILkotlin/jvm/internal/DefaultConstructorMarker;)V + public synthetic fun (Ljava/util/Set;Ljava/lang/Integer;FILjava/util/List;Ljava/util/List;Ljava/util/Set;Ljava/util/List;Ljava/util/Set;Ljava/util/List;Ljava/lang/String;ILjava/lang/Boolean;Ljava/util/Map;Ljava/util/Map;Ljava/util/Map;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()Ljava/util/Set; + public final fun component10 ()Ljava/util/List; + public final fun component11-ticUwL4 ()Ljava/lang/String; + public final fun component12 ()I + public final fun component13 ()Ljava/lang/Boolean; + public final fun component14 ()Ljava/util/Map; + public final fun component15 ()Ljava/util/Map; + public final fun component16 ()Ljava/util/Map; + public final fun component17 ()I + public final fun component2 ()Ljava/lang/Integer; + public final fun component3 ()F + public final fun component4 ()I + public final fun component5 ()Ljava/util/List; + public final fun component6 ()Ljava/util/List; + public final fun component7 ()Ljava/util/Set; + public final fun component8 ()Ljava/util/List; + public final fun component9 ()Ljava/util/Set; + public final fun copy-tU_prow (Ljava/util/Set;Ljava/lang/Integer;FILjava/util/List;Ljava/util/List;Ljava/util/Set;Ljava/util/List;Ljava/util/Set;Ljava/util/List;Ljava/lang/String;ILjava/lang/Boolean;Ljava/util/Map;Ljava/util/Map;Ljava/util/Map;I)Lio/github/linreal/cascade/editor/state/DragState; + public static synthetic fun copy-tU_prow$default (Lio/github/linreal/cascade/editor/state/DragState;Ljava/util/Set;Ljava/lang/Integer;FILjava/util/List;Ljava/util/List;Ljava/util/Set;Ljava/util/List;Ljava/util/Set;Ljava/util/List;Ljava/lang/String;ILjava/lang/Boolean;Ljava/util/Map;Ljava/util/Map;Ljava/util/Map;IILjava/lang/Object;)Lio/github/linreal/cascade/editor/state/DragState; + public fun equals (Ljava/lang/Object;)Z + public final fun getDragRootIds ()Ljava/util/List; + public final fun getDraggingBlockIds ()Ljava/util/Set; + public final fun getFutureRootIndentationLevel ()I + public final fun getInitialTouchOffsetY ()F + public final fun getOriginalRootIndentationLevels ()Ljava/util/Map; + public final fun getPayloadBlockIdSet ()Ljava/util/Set; + public final fun getPayloadBlockIds ()Ljava/util/List; + public final fun getPayloadBlockIndexSet ()Ljava/util/Set; + public final fun getPayloadBlockIndices ()Ljava/util/List; + public final fun getPayloadIndexRanges ()Ljava/util/List; + public final fun getPayloadRelativeDepthOffsets ()Ljava/util/Map; + public final fun getPayloadRootIdsByBlockId ()Ljava/util/Map; + public final fun getPrimaryBlockOriginalIndex ()I + public final fun getPrimaryRootId-ticUwL4 ()Ljava/lang/String; + public final fun getPrimaryRootOriginalIndex ()I + public final fun getPrimaryRootSupportsIndentation ()Ljava/lang/Boolean; + public final fun getTargetIndex ()Ljava/lang/Integer; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/state/EditorState { + public static final field $stable I + public static final field Companion Lio/github/linreal/cascade/editor/state/EditorState$Companion; + public synthetic fun (Ljava/util/List;Ljava/lang/String;Ljava/util/Set;Lio/github/linreal/cascade/editor/state/DragState;Lio/github/linreal/cascade/editor/state/SlashCommandState;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()Ljava/util/List; + public final fun component2-ticUwL4 ()Ljava/lang/String; + public final fun component3 ()Ljava/util/Set; + public final fun component4 ()Lio/github/linreal/cascade/editor/state/DragState; + public final fun component5 ()Lio/github/linreal/cascade/editor/state/SlashCommandState; + public final fun copy-KjmYf4Q (Ljava/util/List;Ljava/lang/String;Ljava/util/Set;Lio/github/linreal/cascade/editor/state/DragState;Lio/github/linreal/cascade/editor/state/SlashCommandState;)Lio/github/linreal/cascade/editor/state/EditorState; + public static synthetic fun copy-KjmYf4Q$default (Lio/github/linreal/cascade/editor/state/EditorState;Ljava/util/List;Ljava/lang/String;Ljava/util/Set;Lio/github/linreal/cascade/editor/state/DragState;Lio/github/linreal/cascade/editor/state/SlashCommandState;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlock-SDe6QqM (Ljava/lang/String;)Lio/github/linreal/cascade/editor/core/Block; + public final fun getBlocks ()Ljava/util/List; + public final fun getDragState ()Lio/github/linreal/cascade/editor/state/DragState; + public final fun getFocusedBlock ()Lio/github/linreal/cascade/editor/core/Block; + public final fun getFocusedBlockId-ticUwL4 ()Ljava/lang/String; + public final fun getHasSelection ()Z + public final fun getHasSingleSelection ()Z + public final fun getSelectedBlockIds ()Ljava/util/Set; + public final fun getSelectedBlocks ()Ljava/util/List; + public final fun getSlashCommandState ()Lio/github/linreal/cascade/editor/state/SlashCommandState; + public fun hashCode ()I + public final fun indexOfBlock-SDe6QqM (Ljava/lang/String;)I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/state/EditorState$Companion { + public final fun getEmpty ()Lio/github/linreal/cascade/editor/state/EditorState; + public final fun withBlocks (Ljava/util/List;)Lio/github/linreal/cascade/editor/state/EditorState; +} + +public final class io/github/linreal/cascade/editor/state/EditorStateHolder { + public static final field $stable I + public fun ()V + public fun (Lio/github/linreal/cascade/editor/state/EditorState;)V + public synthetic fun (Lio/github/linreal/cascade/editor/state/EditorState;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun dispatch (Lio/github/linreal/cascade/editor/action/EditorAction;)V + public final fun dispatchStructuralAction (Lio/github/linreal/cascade/editor/action/EditorAction;Lio/github/linreal/cascade/editor/state/BlockTextStates;Lio/github/linreal/cascade/editor/state/BlockSpanStates;)V + public static synthetic fun dispatchStructuralAction$default (Lio/github/linreal/cascade/editor/state/EditorStateHolder;Lio/github/linreal/cascade/editor/action/EditorAction;Lio/github/linreal/cascade/editor/state/BlockTextStates;Lio/github/linreal/cascade/editor/state/BlockSpanStates;ILjava/lang/Object;)V + public final fun getCanRedo ()Z + public final fun getCanUndo ()Z + public final fun getState ()Lio/github/linreal/cascade/editor/state/EditorState; + public final fun redo ()V + public final fun setState (Lio/github/linreal/cascade/editor/state/EditorState;)V + public final fun undo ()V +} + +public final class io/github/linreal/cascade/editor/state/EditorStateHolderKt { + public static final fun rememberEditorState (Lio/github/linreal/cascade/editor/state/EditorState;Landroidx/compose/runtime/Composer;I)Lio/github/linreal/cascade/editor/state/EditorStateHolder; + public static final fun rememberEditorState (Ljava/util/List;Landroidx/compose/runtime/Composer;II)Lio/github/linreal/cascade/editor/state/EditorStateHolder; +} + +public final class io/github/linreal/cascade/editor/state/SlashCommandState { + public static final field $stable I + public synthetic fun (Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/state/SlashQueryRange;Ljava/util/List;Ljava/lang/String;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public synthetic fun (Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/state/SlashQueryRange;Ljava/util/List;Ljava/lang/String;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1--4CzayM ()Ljava/lang/String; + public final fun component2 ()Ljava/lang/String; + public final fun component3 ()Lio/github/linreal/cascade/editor/state/SlashQueryRange; + public final fun component4 ()Ljava/util/List; + public final fun component5-YhkQzo8 ()Ljava/lang/String; + public final fun copy-vLkuX3Y (Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/state/SlashQueryRange;Ljava/util/List;Ljava/lang/String;)Lio/github/linreal/cascade/editor/state/SlashCommandState; + public static synthetic fun copy-vLkuX3Y$default (Lio/github/linreal/cascade/editor/state/SlashCommandState;Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/state/SlashQueryRange;Ljava/util/List;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/state/SlashCommandState; + public fun equals (Ljava/lang/Object;)Z + public final fun getAnchorBlockId--4CzayM ()Ljava/lang/String; + public final fun getHighlightedCommandId-YhkQzo8 ()Ljava/lang/String; + public final fun getNavigationPath ()Ljava/util/List; + public final fun getQuery ()Ljava/lang/String; + public final fun getQueryRange ()Lio/github/linreal/cascade/editor/state/SlashQueryRange; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/state/SlashQueryRange { + public static final field $stable I + public fun (II)V + public final fun component1 ()I + public final fun component2 ()I + public final fun copy (II)Lio/github/linreal/cascade/editor/state/SlashQueryRange; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/state/SlashQueryRange;IIILjava/lang/Object;)Lio/github/linreal/cascade/editor/state/SlashQueryRange; + public fun equals (Ljava/lang/Object;)Z + public final fun getEndExclusive ()I + public final fun getStart ()I + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/theme/BlockLocalizedStrings { + public static final field $stable I + public fun (Ljava/lang/String;Ljava/lang/String;Ljava/util/List;)V + public synthetic fun (Ljava/lang/String;Ljava/lang/String;Ljava/util/List;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()Ljava/lang/String; + public final fun component2 ()Ljava/lang/String; + public final fun component3 ()Ljava/util/List; + public final fun copy (Ljava/lang/String;Ljava/lang/String;Ljava/util/List;)Lio/github/linreal/cascade/editor/theme/BlockLocalizedStrings; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/theme/BlockLocalizedStrings;Ljava/lang/String;Ljava/lang/String;Ljava/util/List;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/theme/BlockLocalizedStrings; + public fun equals (Ljava/lang/Object;)Z + public final fun getDescription ()Ljava/lang/String; + public final fun getDisplayName ()Ljava/lang/String; + public final fun getKeywords ()Ljava/util/List; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/theme/CascadeEditorBlockStrings { + public static final field $stable I + public static final field Companion Lio/github/linreal/cascade/editor/theme/CascadeEditorBlockStrings$Companion; + public fun (Ljava/util/Map;)V + public final fun component1 ()Ljava/util/Map; + public final fun copy (Ljava/util/Map;)Lio/github/linreal/cascade/editor/theme/CascadeEditorBlockStrings; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/theme/CascadeEditorBlockStrings;Ljava/util/Map;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/theme/CascadeEditorBlockStrings; + public fun equals (Ljava/lang/Object;)Z + public final fun forType (Ljava/lang/String;)Lio/github/linreal/cascade/editor/theme/BlockLocalizedStrings; + public final fun getBlocks ()Ljava/util/Map; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/theme/CascadeEditorBlockStrings$Companion { + public final fun default ()Lio/github/linreal/cascade/editor/theme/CascadeEditorBlockStrings; +} + +public final class io/github/linreal/cascade/editor/theme/CascadeEditorColors { + public static final field $stable I + public static final field Companion Lio/github/linreal/cascade/editor/theme/CascadeEditorColors$Companion; + public synthetic fun (JJJJJJJJJJJJJJJJJJJJJJJJILkotlin/jvm/internal/DefaultConstructorMarker;)V + public synthetic fun (JJJJJJJJJJJJJJJJJJJJJJJJLkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1-0d7_KjU ()J + public final fun component10-0d7_KjU ()J + public final fun component11-0d7_KjU ()J + public final fun component12-0d7_KjU ()J + public final fun component13-0d7_KjU ()J + public final fun component14-0d7_KjU ()J + public final fun component15-0d7_KjU ()J + public final fun component16-0d7_KjU ()J + public final fun component17-0d7_KjU ()J + public final fun component18-0d7_KjU ()J + public final fun component19-0d7_KjU ()J + public final fun component2-0d7_KjU ()J + public final fun component20-0d7_KjU ()J + public final fun component21-0d7_KjU ()J + public final fun component22-0d7_KjU ()J + public final fun component23-0d7_KjU ()J + public final fun component24-0d7_KjU ()J + public final fun component3-0d7_KjU ()J + public final fun component4-0d7_KjU ()J + public final fun component5-0d7_KjU ()J + public final fun component6-0d7_KjU ()J + public final fun component7-0d7_KjU ()J + public final fun component8-0d7_KjU ()J + public final fun component9-0d7_KjU ()J + public final fun copy-KKJ9vVU (JJJJJJJJJJJJJJJJJJJJJJJJ)Lio/github/linreal/cascade/editor/theme/CascadeEditorColors; + public static synthetic fun copy-KKJ9vVU$default (Lio/github/linreal/cascade/editor/theme/CascadeEditorColors;JJJJJJJJJJJJJJJJJJJJJJJJILjava/lang/Object;)Lio/github/linreal/cascade/editor/theme/CascadeEditorColors; + public fun equals (Ljava/lang/Object;)Z + public final fun getCodeBlockBackground-0d7_KjU ()J + public final fun getContentDivider-0d7_KjU ()J + public final fun getCursor-0d7_KjU ()J + public final fun getError-0d7_KjU ()J + public final fun getHighlight-0d7_KjU ()J + public final fun getInlineCodeBackground-0d7_KjU ()J + public final fun getLinkText-0d7_KjU ()J + public final fun getOnPrimary-0d7_KjU ()J + public final fun getPopupBackground-0d7_KjU ()J + public final fun getPrimary-0d7_KjU ()J + public final fun getQuoteBackground-0d7_KjU ()J + public final fun getQuoteBorder-0d7_KjU ()J + public final fun getSelectionOverlay-0d7_KjU ()J + public final fun getSlashChevron-0d7_KjU ()J + public final fun getSlashItemTitle-0d7_KjU ()J + public final fun getSlashSelectedItem-0d7_KjU ()J + public final fun getText-0d7_KjU ()J + public final fun getTextSelectionBackground-0d7_KjU ()J + public final fun getToolbarBackground-0d7_KjU ()J + public final fun getToolbarIcon-0d7_KjU ()J + public final fun getToolbarIconDisabled-0d7_KjU ()J + public final fun getUiDivider-0d7_KjU ()J + public final fun getUnknownBlockBackground-0d7_KjU ()J + public final fun getUnknownBlockText-0d7_KjU ()J + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/theme/CascadeEditorColors$Companion { + public final fun dark ()Lio/github/linreal/cascade/editor/theme/CascadeEditorColors; + public final fun light ()Lio/github/linreal/cascade/editor/theme/CascadeEditorColors; +} + +public final class io/github/linreal/cascade/editor/theme/CascadeEditorDimensions { + public static final field $stable I + public static final field Companion Lio/github/linreal/cascade/editor/theme/CascadeEditorDimensions$Companion; + public synthetic fun (FFLkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1-D9Ej5fM ()F + public final fun component2-D9Ej5fM ()F + public final fun copy-YgX7TsA (FF)Lio/github/linreal/cascade/editor/theme/CascadeEditorDimensions; + public static synthetic fun copy-YgX7TsA$default (Lio/github/linreal/cascade/editor/theme/CascadeEditorDimensions;FFILjava/lang/Object;)Lio/github/linreal/cascade/editor/theme/CascadeEditorDimensions; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlockHorizontalPadding-D9Ej5fM ()F + public final fun getIndentUnit-D9Ej5fM ()F + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/theme/CascadeEditorDimensions$Companion { + public final fun default ()Lio/github/linreal/cascade/editor/theme/CascadeEditorDimensions; +} + +public final class io/github/linreal/cascade/editor/theme/CascadeEditorStrings { + public static final field $stable I + public static final field Companion Lio/github/linreal/cascade/editor/theme/CascadeEditorStrings$Companion; + public fun (Ljava/lang/String;Lkotlin/jvm/functions/Function1;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lkotlin/jvm/functions/Function1;)V + public synthetic fun (Ljava/lang/String;Lkotlin/jvm/functions/Function1;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lkotlin/jvm/functions/Function1;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()Ljava/lang/String; + public final fun component10 ()Ljava/lang/String; + public final fun component11 ()Ljava/lang/String; + public final fun component12 ()Ljava/lang/String; + public final fun component13 ()Ljava/lang/String; + public final fun component14 ()Ljava/lang/String; + public final fun component15 ()Ljava/lang/String; + public final fun component16 ()Ljava/lang/String; + public final fun component17 ()Ljava/lang/String; + public final fun component18 ()Ljava/lang/String; + public final fun component19 ()Lkotlin/jvm/functions/Function1; + public final fun component2 ()Lkotlin/jvm/functions/Function1; + public final fun component3 ()Ljava/lang/String; + public final fun component4 ()Ljava/lang/String; + public final fun component5 ()Ljava/lang/String; + public final fun component6 ()Ljava/lang/String; + public final fun component7 ()Ljava/lang/String; + public final fun component8 ()Ljava/lang/String; + public final fun component9 ()Ljava/lang/String; + public final fun copy (Ljava/lang/String;Lkotlin/jvm/functions/Function1;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lkotlin/jvm/functions/Function1;)Lio/github/linreal/cascade/editor/theme/CascadeEditorStrings; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/theme/CascadeEditorStrings;Ljava/lang/String;Lkotlin/jvm/functions/Function1;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lkotlin/jvm/functions/Function1;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/theme/CascadeEditorStrings; + public fun equals (Ljava/lang/Object;)Z + public final fun getBack ()Ljava/lang/String; + public final fun getBold ()Ljava/lang/String; + public final fun getHideKeyboard ()Ljava/lang/String; + public final fun getHighlight ()Ljava/lang/String; + public final fun getIndentBackward ()Ljava/lang/String; + public final fun getIndentForward ()Ljava/lang/String; + public final fun getInlineCode ()Ljava/lang/String; + public final fun getItalic ()Ljava/lang/String; + public final fun getLink ()Ljava/lang/String; + public final fun getLinkApply ()Ljava/lang/String; + public final fun getLinkCancel ()Ljava/lang/String; + public final fun getLinkRemove ()Ljava/lang/String; + public final fun getLinkTitle ()Ljava/lang/String; + public final fun getLinkUrl ()Ljava/lang/String; + public final fun getLinkValidationError ()Lkotlin/jvm/functions/Function1; + public final fun getSlashCommand ()Ljava/lang/String; + public final fun getStrikethrough ()Ljava/lang/String; + public final fun getUnderline ()Ljava/lang/String; + public final fun getUnsupportedBlock ()Lkotlin/jvm/functions/Function1; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/theme/CascadeEditorStrings$Companion { + public final fun default ()Lio/github/linreal/cascade/editor/theme/CascadeEditorStrings; +} + +public final class io/github/linreal/cascade/editor/theme/CascadeEditorTheme { + public static final field $stable I + public static final field Companion Lio/github/linreal/cascade/editor/theme/CascadeEditorTheme$Companion; + public fun (Lio/github/linreal/cascade/editor/theme/CascadeEditorColors;Lio/github/linreal/cascade/editor/theme/CascadeEditorTypography;Lio/github/linreal/cascade/editor/theme/CascadeEditorDimensions;)V + public synthetic fun (Lio/github/linreal/cascade/editor/theme/CascadeEditorColors;Lio/github/linreal/cascade/editor/theme/CascadeEditorTypography;Lio/github/linreal/cascade/editor/theme/CascadeEditorDimensions;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()Lio/github/linreal/cascade/editor/theme/CascadeEditorColors; + public final fun component2 ()Lio/github/linreal/cascade/editor/theme/CascadeEditorTypography; + public final fun component3 ()Lio/github/linreal/cascade/editor/theme/CascadeEditorDimensions; + public final fun copy (Lio/github/linreal/cascade/editor/theme/CascadeEditorColors;Lio/github/linreal/cascade/editor/theme/CascadeEditorTypography;Lio/github/linreal/cascade/editor/theme/CascadeEditorDimensions;)Lio/github/linreal/cascade/editor/theme/CascadeEditorTheme; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/theme/CascadeEditorTheme;Lio/github/linreal/cascade/editor/theme/CascadeEditorColors;Lio/github/linreal/cascade/editor/theme/CascadeEditorTypography;Lio/github/linreal/cascade/editor/theme/CascadeEditorDimensions;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/theme/CascadeEditorTheme; + public fun equals (Ljava/lang/Object;)Z + public final fun getColors ()Lio/github/linreal/cascade/editor/theme/CascadeEditorColors; + public final fun getDimensions ()Lio/github/linreal/cascade/editor/theme/CascadeEditorDimensions; + public final fun getTypography ()Lio/github/linreal/cascade/editor/theme/CascadeEditorTypography; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/theme/CascadeEditorTheme$Companion { + public final fun dark ()Lio/github/linreal/cascade/editor/theme/CascadeEditorTheme; + public final fun light ()Lio/github/linreal/cascade/editor/theme/CascadeEditorTheme; +} + +public final class io/github/linreal/cascade/editor/theme/CascadeEditorTypography { + public static final field $stable I + public static final field Companion Lio/github/linreal/cascade/editor/theme/CascadeEditorTypography$Companion; + public fun (Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;)V + public final fun component1 ()Landroidx/compose/ui/text/TextStyle; + public final fun component10 ()Landroidx/compose/ui/text/TextStyle; + public final fun component11 ()Landroidx/compose/ui/text/TextStyle; + public final fun component2 ()Landroidx/compose/ui/text/TextStyle; + public final fun component3 ()Landroidx/compose/ui/text/TextStyle; + public final fun component4 ()Landroidx/compose/ui/text/TextStyle; + public final fun component5 ()Landroidx/compose/ui/text/TextStyle; + public final fun component6 ()Landroidx/compose/ui/text/TextStyle; + public final fun component7 ()Landroidx/compose/ui/text/TextStyle; + public final fun component8 ()Landroidx/compose/ui/text/TextStyle; + public final fun component9 ()Landroidx/compose/ui/text/TextStyle; + public final fun copy (Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;)Lio/github/linreal/cascade/editor/theme/CascadeEditorTypography; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/theme/CascadeEditorTypography;Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/theme/CascadeEditorTypography; + public fun equals (Ljava/lang/Object;)Z + public final fun getBody ()Landroidx/compose/ui/text/TextStyle; + public final fun getCode ()Landroidx/compose/ui/text/TextStyle; + public final fun getHeading1 ()Landroidx/compose/ui/text/TextStyle; + public final fun getHeading2 ()Landroidx/compose/ui/text/TextStyle; + public final fun getHeading3 ()Landroidx/compose/ui/text/TextStyle; + public final fun getHeading4 ()Landroidx/compose/ui/text/TextStyle; + public final fun getHeading5 ()Landroidx/compose/ui/text/TextStyle; + public final fun getHeading6 ()Landroidx/compose/ui/text/TextStyle; + public final fun getSlashBackButton ()Landroidx/compose/ui/text/TextStyle; + public final fun getSlashItemTitle ()Landroidx/compose/ui/text/TextStyle; + public final fun getToolbarButton ()Landroidx/compose/ui/text/TextStyle; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/theme/CascadeEditorTypography$Companion { + public final fun default ()Lio/github/linreal/cascade/editor/theme/CascadeEditorTypography; +} + +public final class io/github/linreal/cascade/editor/ui/BackspaceAwareTextEditKt { + public static final fun BackspaceAwareTextField (Landroidx/compose/foundation/text/input/TextFieldState;Landroidx/compose/ui/Modifier;Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/graphics/Brush;Landroidx/compose/foundation/text/input/OutputTransformation;Landroidx/compose/ui/focus/FocusRequester;Lkotlin/jvm/functions/Function0;Lkotlin/jvm/functions/Function1;ZLkotlin/jvm/functions/Function2;Landroidx/compose/runtime/Composer;II)V + public static final fun selectedVisibleText (Landroidx/compose/foundation/text/input/TextFieldState;)Ljava/lang/String; + public static final fun visibleCursorPosition (Landroidx/compose/foundation/text/input/TextFieldState;)I + public static final fun visibleSelection (Landroidx/compose/foundation/text/input/TextFieldState;)J + public static final fun visibleText (Landroidx/compose/foundation/text/input/TextFieldState;)Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/ui/BlockGestureModifierKt { + public static final fun draggableAfterLongPress (Landroidx/compose/ui/Modifier;Ljava/lang/Object;ZLjava/lang/Long;Lkotlin/jvm/functions/Function1;Lkotlin/jvm/functions/Function1;Lkotlin/jvm/functions/Function0;Lkotlin/jvm/functions/Function0;)Landroidx/compose/ui/Modifier; + public static synthetic fun draggableAfterLongPress$default (Landroidx/compose/ui/Modifier;Ljava/lang/Object;ZLjava/lang/Long;Lkotlin/jvm/functions/Function1;Lkotlin/jvm/functions/Function1;Lkotlin/jvm/functions/Function0;Lkotlin/jvm/functions/Function0;ILjava/lang/Object;)Landroidx/compose/ui/Modifier; +} + +public final class io/github/linreal/cascade/editor/ui/CascadeEditorConfig { + public static final field $stable I + public static final field Companion Lio/github/linreal/cascade/editor/ui/CascadeEditorConfig$Companion; + public fun ()V + public fun (ZZZLio/github/linreal/cascade/editor/CrashPolicy;Lkotlin/jvm/functions/Function1;)V + public synthetic fun (ZZZLio/github/linreal/cascade/editor/CrashPolicy;Lkotlin/jvm/functions/Function1;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()Z + public final fun component2 ()Z + public final fun component3 ()Z + public final fun component4 ()Lio/github/linreal/cascade/editor/CrashPolicy; + public final fun component5 ()Lkotlin/jvm/functions/Function1; + public final fun copy (ZZZLio/github/linreal/cascade/editor/CrashPolicy;Lkotlin/jvm/functions/Function1;)Lio/github/linreal/cascade/editor/ui/CascadeEditorConfig; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/ui/CascadeEditorConfig;ZZZLio/github/linreal/cascade/editor/CrashPolicy;Lkotlin/jvm/functions/Function1;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/ui/CascadeEditorConfig; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlockDraggingEnabled ()Z + public final fun getBlockSelectionEnabled ()Z + public final fun getCrashPolicy ()Lio/github/linreal/cascade/editor/CrashPolicy; + public final fun getOnInternalError ()Lkotlin/jvm/functions/Function1; + public final fun getReadOnly ()Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/ui/CascadeEditorConfig$Companion { + public final fun getDefault ()Lio/github/linreal/cascade/editor/ui/CascadeEditorConfig; +} + +public final class io/github/linreal/cascade/editor/ui/CascadeEditorKt { + public static final fun CascadeEditor (Lio/github/linreal/cascade/editor/state/EditorStateHolder;Lio/github/linreal/cascade/editor/state/BlockTextStates;Lio/github/linreal/cascade/editor/state/BlockSpanStates;Lio/github/linreal/cascade/editor/registry/BlockRegistry;Lio/github/linreal/cascade/editor/slash/SlashCommandRegistry;Lio/github/linreal/cascade/editor/ui/SlashCommandSlot;Lio/github/linreal/cascade/editor/theme/CascadeEditorTheme;Lio/github/linreal/cascade/editor/theme/CascadeEditorStrings;Lio/github/linreal/cascade/editor/theme/CascadeEditorBlockStrings;Landroidx/compose/ui/Modifier;Lio/github/linreal/cascade/editor/ui/ToolbarSlot;Lio/github/linreal/cascade/editor/ui/LinkPopupSlot;Lkotlin/jvm/functions/Function1;Lkotlin/jvm/functions/Function1;Lio/github/linreal/cascade/editor/ui/CascadeEditorConfig;Landroidx/compose/runtime/Composer;III)V +} + +public abstract interface class io/github/linreal/cascade/editor/ui/CascadeEditorToolbarController { + public abstract fun getFormattingActions ()Lio/github/linreal/cascade/editor/richtext/FormattingActions; + public abstract fun getFormattingState ()Landroidx/compose/runtime/State; + public abstract fun getIndentationActions ()Lio/github/linreal/cascade/editor/indentation/IndentationActions; + public abstract fun getIndentationState ()Landroidx/compose/runtime/State; + public abstract fun getLinkActions ()Lio/github/linreal/cascade/editor/richtext/LinkChromeActions; + public abstract fun getLinkState ()Landroidx/compose/runtime/State; +} + +public final class io/github/linreal/cascade/editor/ui/CascadeEditorToolbarControllerKt { + public static final fun rememberCascadeEditorToolbarController (Lio/github/linreal/cascade/editor/state/EditorStateHolder;Lio/github/linreal/cascade/editor/state/BlockTextStates;Lio/github/linreal/cascade/editor/state/BlockSpanStates;Ljava/util/List;Lio/github/linreal/cascade/editor/ui/CascadeEditorConfig;Landroidx/compose/runtime/Composer;II)Lio/github/linreal/cascade/editor/ui/CascadeEditorToolbarController; +} + +public final class io/github/linreal/cascade/editor/ui/EditorRegistryKt { + public static final fun createEditorRegistry ()Lio/github/linreal/cascade/editor/registry/BlockRegistry; + public static final fun registerBuiltInRenderers (Lio/github/linreal/cascade/editor/registry/BlockRegistry;)V +} + +public final class io/github/linreal/cascade/editor/ui/HideKeyboardToolbarButtonKt { + public static final fun HideKeyboardToolbarButton (Lkotlin/jvm/functions/Function0;Landroidx/compose/ui/Modifier;Landroidx/compose/runtime/Composer;II)V +} + +public abstract interface class io/github/linreal/cascade/editor/ui/LinkPopupActions { + public abstract fun apply ()V + public abstract fun dismiss ()V + public abstract fun remove ()V + public abstract fun updateTitle (Ljava/lang/String;)V + public abstract fun updateUrl (Ljava/lang/String;)V +} + +public abstract interface class io/github/linreal/cascade/editor/ui/LinkPopupSlot { +} + +public final class io/github/linreal/cascade/editor/ui/LinkPopupSlot$Custom : io/github/linreal/cascade/editor/ui/LinkPopupSlot { + public static final field $stable I + public fun (Lkotlin/jvm/functions/Function4;)V + public final fun getContent ()Lkotlin/jvm/functions/Function4; +} + +public final class io/github/linreal/cascade/editor/ui/LinkPopupSlot$Default : io/github/linreal/cascade/editor/ui/LinkPopupSlot { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/ui/LinkPopupSlot$Default; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/ui/LinkPopupSlot$None : io/github/linreal/cascade/editor/ui/LinkPopupSlot { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/ui/LinkPopupSlot$None; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/ui/LinkPopupState { + public static final field $stable I + public fun (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/richtext/LinkValidationError;Ljava/lang/String;ZZ)V + public final fun component1 ()Ljava/lang/String; + public final fun component2 ()Ljava/lang/String; + public final fun component3 ()Ljava/lang/String; + public final fun component4 ()Lio/github/linreal/cascade/editor/richtext/LinkValidationError; + public final fun component5 ()Ljava/lang/String; + public final fun component6 ()Z + public final fun component7 ()Z + public final fun copy (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/richtext/LinkValidationError;Ljava/lang/String;ZZ)Lio/github/linreal/cascade/editor/ui/LinkPopupState; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/ui/LinkPopupState;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/richtext/LinkValidationError;Ljava/lang/String;ZZILjava/lang/Object;)Lio/github/linreal/cascade/editor/ui/LinkPopupState; + public fun equals (Ljava/lang/Object;)Z + public final fun getCanApply ()Z + public final fun getCanRemove ()Z + public final fun getExistingUrl ()Ljava/lang/String; + public final fun getNormalizedUrl ()Ljava/lang/String; + public final fun getTitle ()Ljava/lang/String; + public final fun getUrl ()Ljava/lang/String; + public final fun getValidationError ()Lio/github/linreal/cascade/editor/richtext/LinkValidationError; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/ui/LocalBlockSpanStatesKt { + public static final fun getLocalBlockSpanStates ()Landroidx/compose/runtime/ProvidableCompositionLocal; +} + +public final class io/github/linreal/cascade/editor/ui/LocalBlockTextStatesKt { + public static final fun getLocalBlockTextStates ()Landroidx/compose/runtime/ProvidableCompositionLocal; +} + +public final class io/github/linreal/cascade/editor/ui/LocalCascadeEditorConfigKt { + public static final fun getLocalCascadeEditorConfig ()Landroidx/compose/runtime/ProvidableCompositionLocal; +} + +public final class io/github/linreal/cascade/editor/ui/LocalFormattingActionsKt { + public static final fun getLocalFormattingActions ()Landroidx/compose/runtime/ProvidableCompositionLocal; +} + +public final class io/github/linreal/cascade/editor/ui/LocalIndentationActionsKt { + public static final fun getLocalIndentationActions ()Landroidx/compose/runtime/ProvidableCompositionLocal; +} + +public final class io/github/linreal/cascade/editor/ui/LocalIndentationStateKt { + public static final fun getLocalIndentationState ()Landroidx/compose/runtime/ProvidableCompositionLocal; +} + +public final class io/github/linreal/cascade/editor/ui/LocalLinkActionsKt { + public static final fun getLocalLinkActions ()Landroidx/compose/runtime/ProvidableCompositionLocal; +} + +public final class io/github/linreal/cascade/editor/ui/LocalLinkStateKt { + public static final fun getLocalLinkState ()Landroidx/compose/runtime/ProvidableCompositionLocal; +} + +public final class io/github/linreal/cascade/editor/ui/LocalSpanActionDispatcherKt { + public static final fun getLocalSpanActionDispatcher ()Landroidx/compose/runtime/ProvidableCompositionLocal; +} + +public final class io/github/linreal/cascade/editor/ui/RichTextToolbarConfig { + public static final field $stable I + public static final field Companion Lio/github/linreal/cascade/editor/ui/RichTextToolbarConfig$Companion; + public fun (Ljava/util/List;ZZ)V + public synthetic fun (Ljava/util/List;ZZILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()Ljava/util/List; + public final fun component2 ()Z + public final fun component3 ()Z + public final fun copy (Ljava/util/List;ZZ)Lio/github/linreal/cascade/editor/ui/RichTextToolbarConfig; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/ui/RichTextToolbarConfig;Ljava/util/List;ZZILjava/lang/Object;)Lio/github/linreal/cascade/editor/ui/RichTextToolbarConfig; + public fun equals (Ljava/lang/Object;)Z + public final fun getButtons ()Ljava/util/List; + public final fun getShowIndentation ()Z + public final fun getShowLink ()Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/ui/RichTextToolbarConfig$Companion { + public final fun getDefault ()Lio/github/linreal/cascade/editor/ui/RichTextToolbarConfig; +} + +public abstract interface class io/github/linreal/cascade/editor/ui/SlashCommandSlot { +} + +public final class io/github/linreal/cascade/editor/ui/SlashCommandSlot$Default : io/github/linreal/cascade/editor/ui/SlashCommandSlot { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/ui/SlashCommandSlot$Default; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/ui/SlashCommandSlot$None : io/github/linreal/cascade/editor/ui/SlashCommandSlot { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/ui/SlashCommandSlot$None; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/ui/ToolbarButtonSpec { + public static final field $stable I + public fun (Lio/github/linreal/cascade/editor/core/SpanStyle;Ljava/lang/String;)V + public final fun component1 ()Lio/github/linreal/cascade/editor/core/SpanStyle; + public final fun component2 ()Ljava/lang/String; + public final fun copy (Lio/github/linreal/cascade/editor/core/SpanStyle;Ljava/lang/String;)Lio/github/linreal/cascade/editor/ui/ToolbarButtonSpec; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/ui/ToolbarButtonSpec;Lio/github/linreal/cascade/editor/core/SpanStyle;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/ui/ToolbarButtonSpec; + public fun equals (Ljava/lang/Object;)Z + public final fun getLabel ()Ljava/lang/String; + public final fun getStyle ()Lio/github/linreal/cascade/editor/core/SpanStyle; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public abstract interface class io/github/linreal/cascade/editor/ui/ToolbarSlot { +} + +public final class io/github/linreal/cascade/editor/ui/ToolbarSlot$Custom : io/github/linreal/cascade/editor/ui/ToolbarSlot { + public static final field $stable I + public fun (Ljava/util/List;Lkotlin/jvm/functions/Function4;)V + public synthetic fun (Ljava/util/List;Lkotlin/jvm/functions/Function4;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()Ljava/util/List; + public final fun component2 ()Lkotlin/jvm/functions/Function4; + public final fun copy (Ljava/util/List;Lkotlin/jvm/functions/Function4;)Lio/github/linreal/cascade/editor/ui/ToolbarSlot$Custom; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/ui/ToolbarSlot$Custom;Ljava/util/List;Lkotlin/jvm/functions/Function4;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/ui/ToolbarSlot$Custom; + public fun equals (Ljava/lang/Object;)Z + public final fun getContent ()Lkotlin/jvm/functions/Function4; + public final fun getTrackedStyles ()Ljava/util/List; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/ui/ToolbarSlot$Default : io/github/linreal/cascade/editor/ui/ToolbarSlot { + public static final field $stable I + public fun ()V + public fun (Lio/github/linreal/cascade/editor/ui/RichTextToolbarConfig;)V + public synthetic fun (Lio/github/linreal/cascade/editor/ui/RichTextToolbarConfig;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()Lio/github/linreal/cascade/editor/ui/RichTextToolbarConfig; + public final fun copy (Lio/github/linreal/cascade/editor/ui/RichTextToolbarConfig;)Lio/github/linreal/cascade/editor/ui/ToolbarSlot$Default; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/ui/ToolbarSlot$Default;Lio/github/linreal/cascade/editor/ui/RichTextToolbarConfig;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/ui/ToolbarSlot$Default; + public fun equals (Ljava/lang/Object;)Z + public final fun getConfig ()Lio/github/linreal/cascade/editor/ui/RichTextToolbarConfig; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/ui/ToolbarSlot$None : io/github/linreal/cascade/editor/ui/ToolbarSlot { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/ui/ToolbarSlot$None; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/ui/renderers/DividerBlockRenderer : io/github/linreal/cascade/editor/registry/BlockRenderer { + public static final field $stable I + public fun ()V + public fun Render (Lio/github/linreal/cascade/editor/core/Block;ZZLandroidx/compose/ui/Modifier;Lio/github/linreal/cascade/editor/registry/BlockCallbacks;Landroidx/compose/runtime/Composer;I)V + public fun getHandlesSelectionVisual ()Z + public fun getSupportsDragPreview ()Z +} + +public final class io/github/linreal/cascade/editor/ui/renderers/TextBlockRenderer : io/github/linreal/cascade/editor/registry/BlockRenderer { + public static final field $stable I + public fun ()V + public fun Render (Lio/github/linreal/cascade/editor/core/Block;ZZLandroidx/compose/ui/Modifier;Lio/github/linreal/cascade/editor/registry/BlockCallbacks;Landroidx/compose/runtime/Composer;I)V + public fun getHandlesSelectionVisual ()Z + public fun getSupportsDragPreview ()Z +} + +public final class io/github/linreal/cascade/editor/ui/renderers/TodoBlockRenderer : io/github/linreal/cascade/editor/registry/BlockRenderer { + public static final field $stable I + public fun ()V + public fun Render (Lio/github/linreal/cascade/editor/core/Block;ZZLandroidx/compose/ui/Modifier;Lio/github/linreal/cascade/editor/registry/BlockCallbacks;Landroidx/compose/runtime/Composer;I)V + public fun getHandlesSelectionVisual ()Z + public fun getSupportsDragPreview ()Z +} + +public final class io/github/linreal/cascade/editor/ui/utils/Dividers { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/ui/utils/Dividers; + public final fun Horizontal-DxzAY5Q (JLandroidx/compose/ui/Modifier;FLandroidx/compose/runtime/Composer;II)V + public final fun Vertical-KfjZ6_A (JLandroidx/compose/ui/Modifier;FFLandroidx/compose/runtime/Composer;II)V +} + +public final class io/github/linreal/cascade/editor/ui/utils/DragUtilsKt { + public static final fun calculateDropIndicatorY (Landroidx/compose/foundation/lazy/LazyListLayoutInfo;Ljava/lang/Integer;)Ljava/lang/Float; + public static final fun calculateDropTargetIndex (Landroidx/compose/foundation/lazy/LazyListLayoutInfo;FI)Ljava/lang/Integer; + public static final fun convertVisualGapToMoveBlocksIndex (III)Ljava/lang/Integer; +} + +public final class io/github/linreal/cascade/editor/ui/utils/Spacers { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/ui/utils/Spacers; + public final fun FillHorizontalSpacer (Landroidx/compose/foundation/layout/RowScope;Landroidx/compose/runtime/Composer;I)V + public final fun FillVerticalSpacer (Landroidx/compose/foundation/layout/ColumnScope;Landroidx/compose/runtime/Composer;I)V + public final fun Horizontal-8Feqmps (FLandroidx/compose/runtime/Composer;I)V + public final fun UiSpacer-ixp7dh8 (FFLandroidx/compose/runtime/Composer;II)V + public final fun Vertical-8Feqmps (FLandroidx/compose/runtime/Composer;I)V +} + diff --git a/editor/api/desktop/editor.api b/editor/api/desktop/editor.api new file mode 100644 index 0000000..afbb082 --- /dev/null +++ b/editor/api/desktop/editor.api @@ -0,0 +1,3062 @@ +public final class io/github/linreal/cascade/editor/CascadeError { + public static final field $stable I + public fun (Ljava/lang/String;Ljava/lang/Throwable;)V + public final fun component1 ()Ljava/lang/String; + public final fun component2 ()Ljava/lang/Throwable; + public final fun copy (Ljava/lang/String;Ljava/lang/Throwable;)Lio/github/linreal/cascade/editor/CascadeError; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/CascadeError;Ljava/lang/String;Ljava/lang/Throwable;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/CascadeError; + public fun equals (Ljava/lang/Object;)Z + public final fun getCause ()Ljava/lang/Throwable; + public final fun getContext ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/CrashPolicy : java/lang/Enum { + public static final field ContainAndReport Lio/github/linreal/cascade/editor/CrashPolicy; + public static final field Rethrow Lio/github/linreal/cascade/editor/CrashPolicy; + public static fun getEntries ()Lkotlin/enums/EnumEntries; + public static fun valueOf (Ljava/lang/String;)Lio/github/linreal/cascade/editor/CrashPolicy; + public static fun values ()[Lio/github/linreal/cascade/editor/CrashPolicy; +} + +public final class io/github/linreal/cascade/editor/action/AddBlockRangeToSelection : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public synthetic fun (Ljava/lang/String;Ljava/lang/String;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1--4CzayM ()Ljava/lang/String; + public final fun component2--4CzayM ()Ljava/lang/String; + public final fun copy-uwJGxUo (Ljava/lang/String;Ljava/lang/String;)Lio/github/linreal/cascade/editor/action/AddBlockRangeToSelection; + public static synthetic fun copy-uwJGxUo$default (Lio/github/linreal/cascade/editor/action/AddBlockRangeToSelection;Ljava/lang/String;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/action/AddBlockRangeToSelection; + public fun equals (Ljava/lang/Object;)Z + public final fun getFromId--4CzayM ()Ljava/lang/String; + public final fun getToId--4CzayM ()Ljava/lang/String; + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/ApplySpanStyle : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public synthetic fun (Ljava/lang/String;IILio/github/linreal/cascade/editor/core/SpanStyle;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1--4CzayM ()Ljava/lang/String; + public final fun component2 ()I + public final fun component3 ()I + public final fun component4 ()Lio/github/linreal/cascade/editor/core/SpanStyle; + public final fun copy-PeeSg0I (Ljava/lang/String;IILio/github/linreal/cascade/editor/core/SpanStyle;)Lio/github/linreal/cascade/editor/action/ApplySpanStyle; + public static synthetic fun copy-PeeSg0I$default (Lio/github/linreal/cascade/editor/action/ApplySpanStyle;Ljava/lang/String;IILio/github/linreal/cascade/editor/core/SpanStyle;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/action/ApplySpanStyle; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlockId--4CzayM ()Ljava/lang/String; + public final fun getRangeEnd ()I + public final fun getRangeStart ()I + public final fun getStyle ()Lio/github/linreal/cascade/editor/core/SpanStyle; + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/CancelDrag : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/action/CancelDrag; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/ClearFocus : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/action/ClearFocus; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/ClearSelection : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/action/ClearSelection; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/CloseSlashCommand : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/action/CloseSlashCommand; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/CompleteDrag : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/action/CompleteDrag; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/ConvertBlockType : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public synthetic fun (Ljava/lang/String;Lio/github/linreal/cascade/editor/core/BlockType;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1--4CzayM ()Ljava/lang/String; + public final fun component2 ()Lio/github/linreal/cascade/editor/core/BlockType; + public final fun copy-7OMXkl4 (Ljava/lang/String;Lio/github/linreal/cascade/editor/core/BlockType;)Lio/github/linreal/cascade/editor/action/ConvertBlockType; + public static synthetic fun copy-7OMXkl4$default (Lio/github/linreal/cascade/editor/action/ConvertBlockType;Ljava/lang/String;Lio/github/linreal/cascade/editor/core/BlockType;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/action/ConvertBlockType; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlockId--4CzayM ()Ljava/lang/String; + public final fun getNewType ()Lio/github/linreal/cascade/editor/core/BlockType; + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/DeleteBlock : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public synthetic fun (Ljava/lang/String;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1--4CzayM ()Ljava/lang/String; + public final fun copy-SDe6QqM (Ljava/lang/String;)Lio/github/linreal/cascade/editor/action/DeleteBlock; + public static synthetic fun copy-SDe6QqM$default (Lio/github/linreal/cascade/editor/action/DeleteBlock;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/action/DeleteBlock; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlockId--4CzayM ()Ljava/lang/String; + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/DeleteBlocks : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public fun (Ljava/util/Set;)V + public final fun component1 ()Ljava/util/Set; + public final fun copy (Ljava/util/Set;)Lio/github/linreal/cascade/editor/action/DeleteBlocks; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/action/DeleteBlocks;Ljava/util/Set;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/action/DeleteBlocks; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlockIds ()Ljava/util/Set; + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/DeleteSelectedOrFocused : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/action/DeleteSelectedOrFocused; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public abstract interface class io/github/linreal/cascade/editor/action/EditorAction { + public abstract fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; +} + +public final class io/github/linreal/cascade/editor/action/FocusBlock : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public synthetic fun (Ljava/lang/String;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1-ticUwL4 ()Ljava/lang/String; + public final fun copy-pWxEiPs (Ljava/lang/String;)Lio/github/linreal/cascade/editor/action/FocusBlock; + public static synthetic fun copy-pWxEiPs$default (Lio/github/linreal/cascade/editor/action/FocusBlock;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/action/FocusBlock; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlockId-ticUwL4 ()Ljava/lang/String; + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/FocusNextBlock : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/action/FocusNextBlock; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/FocusPreviousBlock : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/action/FocusPreviousBlock; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/HighlightSlashCommand : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public synthetic fun (Ljava/lang/String;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1-YhkQzo8 ()Ljava/lang/String; + public final fun copy-505l8FM (Ljava/lang/String;)Lio/github/linreal/cascade/editor/action/HighlightSlashCommand; + public static synthetic fun copy-505l8FM$default (Lio/github/linreal/cascade/editor/action/HighlightSlashCommand;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/action/HighlightSlashCommand; + public fun equals (Ljava/lang/Object;)Z + public final fun getCommandId-YhkQzo8 ()Ljava/lang/String; + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/IndentBackward : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/action/IndentBackward; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/IndentForward : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/action/IndentForward; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/InsertBlock : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public fun (Lio/github/linreal/cascade/editor/core/Block;Ljava/lang/Integer;)V + public synthetic fun (Lio/github/linreal/cascade/editor/core/Block;Ljava/lang/Integer;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()Lio/github/linreal/cascade/editor/core/Block; + public final fun component2 ()Ljava/lang/Integer; + public final fun copy (Lio/github/linreal/cascade/editor/core/Block;Ljava/lang/Integer;)Lio/github/linreal/cascade/editor/action/InsertBlock; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/action/InsertBlock;Lio/github/linreal/cascade/editor/core/Block;Ljava/lang/Integer;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/action/InsertBlock; + public fun equals (Ljava/lang/Object;)Z + public final fun getAtIndex ()Ljava/lang/Integer; + public final fun getBlock ()Lio/github/linreal/cascade/editor/core/Block; + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/InsertBlockAfter : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public synthetic fun (Lio/github/linreal/cascade/editor/core/Block;Ljava/lang/String;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()Lio/github/linreal/cascade/editor/core/Block; + public final fun component2-ticUwL4 ()Ljava/lang/String; + public final fun copy-kAZpsYI (Lio/github/linreal/cascade/editor/core/Block;Ljava/lang/String;)Lio/github/linreal/cascade/editor/action/InsertBlockAfter; + public static synthetic fun copy-kAZpsYI$default (Lio/github/linreal/cascade/editor/action/InsertBlockAfter;Lio/github/linreal/cascade/editor/core/Block;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/action/InsertBlockAfter; + public fun equals (Ljava/lang/Object;)Z + public final fun getAfterBlockId-ticUwL4 ()Ljava/lang/String; + public final fun getBlock ()Lio/github/linreal/cascade/editor/core/Block; + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/InsertBlockBefore : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public synthetic fun (Lio/github/linreal/cascade/editor/core/Block;Ljava/lang/String;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()Lio/github/linreal/cascade/editor/core/Block; + public final fun component2-ticUwL4 ()Ljava/lang/String; + public final fun copy-kAZpsYI (Lio/github/linreal/cascade/editor/core/Block;Ljava/lang/String;)Lio/github/linreal/cascade/editor/action/InsertBlockBefore; + public static synthetic fun copy-kAZpsYI$default (Lio/github/linreal/cascade/editor/action/InsertBlockBefore;Lio/github/linreal/cascade/editor/core/Block;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/action/InsertBlockBefore; + public fun equals (Ljava/lang/Object;)Z + public final fun getBeforeBlockId-ticUwL4 ()Ljava/lang/String; + public final fun getBlock ()Lio/github/linreal/cascade/editor/core/Block; + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/MergeBlocks : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public synthetic fun (Ljava/lang/String;Ljava/lang/String;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1--4CzayM ()Ljava/lang/String; + public final fun component2--4CzayM ()Ljava/lang/String; + public final fun copy-uwJGxUo (Ljava/lang/String;Ljava/lang/String;)Lio/github/linreal/cascade/editor/action/MergeBlocks; + public static synthetic fun copy-uwJGxUo$default (Lio/github/linreal/cascade/editor/action/MergeBlocks;Ljava/lang/String;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/action/MergeBlocks; + public fun equals (Ljava/lang/Object;)Z + public final fun getSourceId--4CzayM ()Ljava/lang/String; + public final fun getTargetId--4CzayM ()Ljava/lang/String; + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/MoveBlocks : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public fun (Ljava/util/Set;I)V + public final fun component1 ()Ljava/util/Set; + public final fun component2 ()I + public final fun copy (Ljava/util/Set;I)Lio/github/linreal/cascade/editor/action/MoveBlocks; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/action/MoveBlocks;Ljava/util/Set;IILjava/lang/Object;)Lio/github/linreal/cascade/editor/action/MoveBlocks; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlockIds ()Ljava/util/Set; + public final fun getToIndex ()I + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/NavigateSlashBack : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/action/NavigateSlashBack; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/NavigateSlashSubmenu : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public synthetic fun (Ljava/lang/String;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1-6BJIqV4 ()Ljava/lang/String; + public final fun copy-t5i0Ytw (Ljava/lang/String;)Lio/github/linreal/cascade/editor/action/NavigateSlashSubmenu; + public static synthetic fun copy-t5i0Ytw$default (Lio/github/linreal/cascade/editor/action/NavigateSlashSubmenu;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/action/NavigateSlashSubmenu; + public fun equals (Ljava/lang/Object;)Z + public final fun getSubmenuId-6BJIqV4 ()Ljava/lang/String; + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/OpenSlashCommand : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public synthetic fun (Ljava/lang/String;Lio/github/linreal/cascade/editor/state/SlashQueryRange;Ljava/lang/String;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public synthetic fun (Ljava/lang/String;Lio/github/linreal/cascade/editor/state/SlashQueryRange;Ljava/lang/String;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1--4CzayM ()Ljava/lang/String; + public final fun component2 ()Lio/github/linreal/cascade/editor/state/SlashQueryRange; + public final fun component3 ()Ljava/lang/String; + public final fun copy-p1zP0qE (Ljava/lang/String;Lio/github/linreal/cascade/editor/state/SlashQueryRange;Ljava/lang/String;)Lio/github/linreal/cascade/editor/action/OpenSlashCommand; + public static synthetic fun copy-p1zP0qE$default (Lio/github/linreal/cascade/editor/action/OpenSlashCommand;Ljava/lang/String;Lio/github/linreal/cascade/editor/state/SlashQueryRange;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/action/OpenSlashCommand; + public fun equals (Ljava/lang/Object;)Z + public final fun getAnchorBlockId--4CzayM ()Ljava/lang/String; + public final fun getInitialQuery ()Ljava/lang/String; + public final fun getQueryRange ()Lio/github/linreal/cascade/editor/state/SlashQueryRange; + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/RemoveSpanStyle : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public synthetic fun (Ljava/lang/String;IILio/github/linreal/cascade/editor/core/SpanStyle;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1--4CzayM ()Ljava/lang/String; + public final fun component2 ()I + public final fun component3 ()I + public final fun component4 ()Lio/github/linreal/cascade/editor/core/SpanStyle; + public final fun copy-PeeSg0I (Ljava/lang/String;IILio/github/linreal/cascade/editor/core/SpanStyle;)Lio/github/linreal/cascade/editor/action/RemoveSpanStyle; + public static synthetic fun copy-PeeSg0I$default (Lio/github/linreal/cascade/editor/action/RemoveSpanStyle;Ljava/lang/String;IILio/github/linreal/cascade/editor/core/SpanStyle;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/action/RemoveSpanStyle; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlockId--4CzayM ()Ljava/lang/String; + public final fun getRangeEnd ()I + public final fun getRangeStart ()I + public final fun getStyle ()Lio/github/linreal/cascade/editor/core/SpanStyle; + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/ReplaceBlock : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public synthetic fun (Ljava/lang/String;Lio/github/linreal/cascade/editor/core/Block;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1--4CzayM ()Ljava/lang/String; + public final fun component2 ()Lio/github/linreal/cascade/editor/core/Block; + public final fun copy-7OMXkl4 (Ljava/lang/String;Lio/github/linreal/cascade/editor/core/Block;)Lio/github/linreal/cascade/editor/action/ReplaceBlock; + public static synthetic fun copy-7OMXkl4$default (Lio/github/linreal/cascade/editor/action/ReplaceBlock;Ljava/lang/String;Lio/github/linreal/cascade/editor/core/Block;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/action/ReplaceBlock; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlockId--4CzayM ()Ljava/lang/String; + public final fun getNewBlock ()Lio/github/linreal/cascade/editor/core/Block; + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/SelectAll : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/action/SelectAll; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/SelectBlock : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public synthetic fun (Ljava/lang/String;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1--4CzayM ()Ljava/lang/String; + public final fun copy-SDe6QqM (Ljava/lang/String;)Lio/github/linreal/cascade/editor/action/SelectBlock; + public static synthetic fun copy-SDe6QqM$default (Lio/github/linreal/cascade/editor/action/SelectBlock;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/action/SelectBlock; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlockId--4CzayM ()Ljava/lang/String; + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/SelectBlockRange : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public synthetic fun (Ljava/lang/String;Ljava/lang/String;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1--4CzayM ()Ljava/lang/String; + public final fun component2--4CzayM ()Ljava/lang/String; + public final fun copy-uwJGxUo (Ljava/lang/String;Ljava/lang/String;)Lio/github/linreal/cascade/editor/action/SelectBlockRange; + public static synthetic fun copy-uwJGxUo$default (Lio/github/linreal/cascade/editor/action/SelectBlockRange;Ljava/lang/String;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/action/SelectBlockRange; + public fun equals (Ljava/lang/Object;)Z + public final fun getFromId--4CzayM ()Ljava/lang/String; + public final fun getToId--4CzayM ()Ljava/lang/String; + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/SplitBlock : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public synthetic fun (Ljava/lang/String;ILjava/lang/String;Ljava/lang/String;Ljava/util/List;Ljava/lang/String;Ljava/util/List;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public synthetic fun (Ljava/lang/String;ILjava/lang/String;Ljava/lang/String;Ljava/util/List;Ljava/lang/String;Ljava/util/List;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1--4CzayM ()Ljava/lang/String; + public final fun component2 ()I + public final fun component3 ()Ljava/lang/String; + public final fun component4-ticUwL4 ()Ljava/lang/String; + public final fun component5 ()Ljava/util/List; + public final fun component6 ()Ljava/lang/String; + public final fun component7 ()Ljava/util/List; + public final fun copy-BD9ZTBs (Ljava/lang/String;ILjava/lang/String;Ljava/lang/String;Ljava/util/List;Ljava/lang/String;Ljava/util/List;)Lio/github/linreal/cascade/editor/action/SplitBlock; + public static synthetic fun copy-BD9ZTBs$default (Lio/github/linreal/cascade/editor/action/SplitBlock;Ljava/lang/String;ILjava/lang/String;Ljava/lang/String;Ljava/util/List;Ljava/lang/String;Ljava/util/List;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/action/SplitBlock; + public fun equals (Ljava/lang/Object;)Z + public final fun getAtPosition ()I + public final fun getBlockId--4CzayM ()Ljava/lang/String; + public final fun getNewBlockId-ticUwL4 ()Ljava/lang/String; + public final fun getNewBlockSpans ()Ljava/util/List; + public final fun getNewBlockText ()Ljava/lang/String; + public final fun getSourceBlockSpans ()Ljava/util/List; + public final fun getSourceBlockText ()Ljava/lang/String; + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/StartDrag : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public synthetic fun (Ljava/lang/String;FLkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1--4CzayM ()Ljava/lang/String; + public final fun component2 ()F + public final fun copy-7OMXkl4 (Ljava/lang/String;F)Lio/github/linreal/cascade/editor/action/StartDrag; + public static synthetic fun copy-7OMXkl4$default (Lio/github/linreal/cascade/editor/action/StartDrag;Ljava/lang/String;FILjava/lang/Object;)Lio/github/linreal/cascade/editor/action/StartDrag; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlockId--4CzayM ()Ljava/lang/String; + public final fun getTouchOffsetY ()F + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/ToggleBlockSelection : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public synthetic fun (Ljava/lang/String;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1--4CzayM ()Ljava/lang/String; + public final fun copy-SDe6QqM (Ljava/lang/String;)Lio/github/linreal/cascade/editor/action/ToggleBlockSelection; + public static synthetic fun copy-SDe6QqM$default (Lio/github/linreal/cascade/editor/action/ToggleBlockSelection;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/action/ToggleBlockSelection; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlockId--4CzayM ()Ljava/lang/String; + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/ToggleTodo : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public synthetic fun (Ljava/lang/String;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1--4CzayM ()Ljava/lang/String; + public final fun copy-SDe6QqM (Ljava/lang/String;)Lio/github/linreal/cascade/editor/action/ToggleTodo; + public static synthetic fun copy-SDe6QqM$default (Lio/github/linreal/cascade/editor/action/ToggleTodo;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/action/ToggleTodo; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlockId--4CzayM ()Ljava/lang/String; + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/UpdateBlockContent : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public synthetic fun (Ljava/lang/String;Lio/github/linreal/cascade/editor/core/BlockContent;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1--4CzayM ()Ljava/lang/String; + public final fun component2 ()Lio/github/linreal/cascade/editor/core/BlockContent; + public final fun copy-7OMXkl4 (Ljava/lang/String;Lio/github/linreal/cascade/editor/core/BlockContent;)Lio/github/linreal/cascade/editor/action/UpdateBlockContent; + public static synthetic fun copy-7OMXkl4$default (Lio/github/linreal/cascade/editor/action/UpdateBlockContent;Ljava/lang/String;Lio/github/linreal/cascade/editor/core/BlockContent;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/action/UpdateBlockContent; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlockId--4CzayM ()Ljava/lang/String; + public final fun getContent ()Lio/github/linreal/cascade/editor/core/BlockContent; + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/UpdateBlockText : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public synthetic fun (Ljava/lang/String;Ljava/lang/String;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1--4CzayM ()Ljava/lang/String; + public final fun component2 ()Ljava/lang/String; + public final fun copy-7OMXkl4 (Ljava/lang/String;Ljava/lang/String;)Lio/github/linreal/cascade/editor/action/UpdateBlockText; + public static synthetic fun copy-7OMXkl4$default (Lio/github/linreal/cascade/editor/action/UpdateBlockText;Ljava/lang/String;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/action/UpdateBlockText; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlockId--4CzayM ()Ljava/lang/String; + public final fun getText ()Ljava/lang/String; + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/UpdateDragTarget : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public fun (Ljava/lang/Integer;Ljava/lang/Integer;)V + public synthetic fun (Ljava/lang/Integer;Ljava/lang/Integer;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()Ljava/lang/Integer; + public final fun component2 ()Ljava/lang/Integer; + public final fun copy (Ljava/lang/Integer;Ljava/lang/Integer;)Lio/github/linreal/cascade/editor/action/UpdateDragTarget; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/action/UpdateDragTarget;Ljava/lang/Integer;Ljava/lang/Integer;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/action/UpdateDragTarget; + public fun equals (Ljava/lang/Object;)Z + public final fun getFutureRootIndentationLevel ()Ljava/lang/Integer; + public final fun getTargetIndex ()Ljava/lang/Integer; + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/action/UpdateSlashCommandSession : io/github/linreal/cascade/editor/action/EditorAction { + public static final field $stable I + public fun (Ljava/lang/String;Lio/github/linreal/cascade/editor/state/SlashQueryRange;)V + public final fun component1 ()Ljava/lang/String; + public final fun component2 ()Lio/github/linreal/cascade/editor/state/SlashQueryRange; + public final fun copy (Ljava/lang/String;Lio/github/linreal/cascade/editor/state/SlashQueryRange;)Lio/github/linreal/cascade/editor/action/UpdateSlashCommandSession; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/action/UpdateSlashCommandSession;Ljava/lang/String;Lio/github/linreal/cascade/editor/state/SlashQueryRange;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/action/UpdateSlashCommandSession; + public fun equals (Ljava/lang/Object;)Z + public final fun getQuery ()Ljava/lang/String; + public final fun getQueryRange ()Lio/github/linreal/cascade/editor/state/SlashQueryRange; + public fun hashCode ()I + public fun reduce (Lio/github/linreal/cascade/editor/state/EditorState;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/core/Block { + public static final field $stable I + public static final field Companion Lio/github/linreal/cascade/editor/core/Block$Companion; + public synthetic fun (Ljava/lang/String;Lio/github/linreal/cascade/editor/core/BlockType;Lio/github/linreal/cascade/editor/core/BlockContent;Lio/github/linreal/cascade/editor/core/BlockAttributes;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public synthetic fun (Ljava/lang/String;Lio/github/linreal/cascade/editor/core/BlockType;Lio/github/linreal/cascade/editor/core/BlockContent;Lio/github/linreal/cascade/editor/core/BlockAttributes;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1--4CzayM ()Ljava/lang/String; + public final fun component2 ()Lio/github/linreal/cascade/editor/core/BlockType; + public final fun component3 ()Lio/github/linreal/cascade/editor/core/BlockContent; + public final fun component4 ()Lio/github/linreal/cascade/editor/core/BlockAttributes; + public final fun copy-PeeSg0I (Ljava/lang/String;Lio/github/linreal/cascade/editor/core/BlockType;Lio/github/linreal/cascade/editor/core/BlockContent;Lio/github/linreal/cascade/editor/core/BlockAttributes;)Lio/github/linreal/cascade/editor/core/Block; + public static synthetic fun copy-PeeSg0I$default (Lio/github/linreal/cascade/editor/core/Block;Ljava/lang/String;Lio/github/linreal/cascade/editor/core/BlockType;Lio/github/linreal/cascade/editor/core/BlockContent;Lio/github/linreal/cascade/editor/core/BlockAttributes;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/core/Block; + public fun equals (Ljava/lang/Object;)Z + public final fun getAttributes ()Lio/github/linreal/cascade/editor/core/BlockAttributes; + public final fun getContent ()Lio/github/linreal/cascade/editor/core/BlockContent; + public final fun getId--4CzayM ()Ljava/lang/String; + public final fun getType ()Lio/github/linreal/cascade/editor/core/BlockType; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; + public final fun withAttributes (Lio/github/linreal/cascade/editor/core/BlockAttributes;)Lio/github/linreal/cascade/editor/core/Block; + public final fun withContent (Lio/github/linreal/cascade/editor/core/BlockContent;)Lio/github/linreal/cascade/editor/core/Block; + public final fun withType (Lio/github/linreal/cascade/editor/core/BlockType;)Lio/github/linreal/cascade/editor/core/Block; +} + +public final class io/github/linreal/cascade/editor/core/Block$Companion { + public final fun bulletList (Ljava/lang/String;)Lio/github/linreal/cascade/editor/core/Block; + public static synthetic fun bulletList$default (Lio/github/linreal/cascade/editor/core/Block$Companion;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/core/Block; + public final fun divider ()Lio/github/linreal/cascade/editor/core/Block; + public final fun heading (ILjava/lang/String;)Lio/github/linreal/cascade/editor/core/Block; + public static synthetic fun heading$default (Lio/github/linreal/cascade/editor/core/Block$Companion;ILjava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/core/Block; + public final fun numberedList (Ljava/lang/String;I)Lio/github/linreal/cascade/editor/core/Block; + public static synthetic fun numberedList$default (Lio/github/linreal/cascade/editor/core/Block$Companion;Ljava/lang/String;IILjava/lang/Object;)Lio/github/linreal/cascade/editor/core/Block; + public final fun paragraph (Ljava/lang/String;Ljava/util/List;)Lio/github/linreal/cascade/editor/core/Block; + public static synthetic fun paragraph$default (Lio/github/linreal/cascade/editor/core/Block$Companion;Ljava/lang/String;Ljava/util/List;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/core/Block; + public final fun todo (Ljava/lang/String;Z)Lio/github/linreal/cascade/editor/core/Block; + public static synthetic fun todo$default (Lio/github/linreal/cascade/editor/core/Block$Companion;Ljava/lang/String;ZILjava/lang/Object;)Lio/github/linreal/cascade/editor/core/Block; +} + +public final class io/github/linreal/cascade/editor/core/BlockAttributes { + public static final field $stable I + public static final field Companion Lio/github/linreal/cascade/editor/core/BlockAttributes$Companion; + public static final field MAX_INDENTATION_LEVEL I + public static final field MIN_INDENTATION_LEVEL I + public fun ()V + public fun (I)V + public synthetic fun (IILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()I + public final fun copy (I)Lio/github/linreal/cascade/editor/core/BlockAttributes; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/core/BlockAttributes;IILjava/lang/Object;)Lio/github/linreal/cascade/editor/core/BlockAttributes; + public fun equals (Ljava/lang/Object;)Z + public final fun getIndentationLevel ()I + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/core/BlockAttributes$Companion { + public final fun getDefault ()Lio/github/linreal/cascade/editor/core/BlockAttributes; +} + +public abstract interface class io/github/linreal/cascade/editor/core/BlockContent { +} + +public final class io/github/linreal/cascade/editor/core/BlockContent$Custom : io/github/linreal/cascade/editor/core/BlockContent { + public static final field $stable I + public fun (Ljava/lang/String;Ljava/util/Map;)V + public synthetic fun (Ljava/lang/String;Ljava/util/Map;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()Ljava/lang/String; + public final fun component2 ()Ljava/util/Map; + public final fun copy (Ljava/lang/String;Ljava/util/Map;)Lio/github/linreal/cascade/editor/core/BlockContent$Custom; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/core/BlockContent$Custom;Ljava/lang/String;Ljava/util/Map;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/core/BlockContent$Custom; + public fun equals (Ljava/lang/Object;)Z + public final fun getData ()Ljava/util/Map; + public final fun getTypeId ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/core/BlockContent$Empty : io/github/linreal/cascade/editor/core/BlockContent { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/core/BlockContent$Empty; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/core/BlockContent$Text : io/github/linreal/cascade/editor/core/BlockContent { + public static final field $stable I + public fun (Ljava/lang/String;Ljava/util/List;)V + public synthetic fun (Ljava/lang/String;Ljava/util/List;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()Ljava/lang/String; + public final fun component2 ()Ljava/util/List; + public final fun copy (Ljava/lang/String;Ljava/util/List;)Lio/github/linreal/cascade/editor/core/BlockContent$Text; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/core/BlockContent$Text;Ljava/lang/String;Ljava/util/List;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/core/BlockContent$Text; + public fun equals (Ljava/lang/Object;)Z + public final fun getSpans ()Ljava/util/List; + public final fun getText ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/core/BlockId { + public static final field Companion Lio/github/linreal/cascade/editor/core/BlockId$Companion; + public static final synthetic fun box-impl (Ljava/lang/String;)Lio/github/linreal/cascade/editor/core/BlockId; + public static fun constructor-impl (Ljava/lang/String;)Ljava/lang/String; + public fun equals (Ljava/lang/Object;)Z + public static fun equals-impl (Ljava/lang/String;Ljava/lang/Object;)Z + public static final fun equals-impl0 (Ljava/lang/String;Ljava/lang/String;)Z + public final fun getValue ()Ljava/lang/String; + public fun hashCode ()I + public static fun hashCode-impl (Ljava/lang/String;)I + public fun toString ()Ljava/lang/String; + public static fun toString-impl (Ljava/lang/String;)Ljava/lang/String; + public final synthetic fun unbox-impl ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/core/BlockId$Companion { + public final fun generate--4CzayM ()Ljava/lang/String; +} + +public abstract interface class io/github/linreal/cascade/editor/core/BlockType { + public abstract fun getDisplayName ()Ljava/lang/String; + public fun getSupportsIndentation ()Z + public fun getSupportsSpans ()Z + public fun getSupportsText ()Z + public abstract fun getTypeId ()Ljava/lang/String; + public fun isConvertible ()Z +} + +public final class io/github/linreal/cascade/editor/core/BlockType$BulletList : io/github/linreal/cascade/editor/core/BlockType { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/core/BlockType$BulletList; + public fun equals (Ljava/lang/Object;)Z + public fun getDisplayName ()Ljava/lang/String; + public fun getSupportsIndentation ()Z + public fun getSupportsSpans ()Z + public fun getSupportsText ()Z + public fun getTypeId ()Ljava/lang/String; + public fun hashCode ()I + public fun isConvertible ()Z + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/core/BlockType$Code : io/github/linreal/cascade/editor/core/BlockType { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/core/BlockType$Code; + public fun equals (Ljava/lang/Object;)Z + public fun getDisplayName ()Ljava/lang/String; + public fun getSupportsIndentation ()Z + public fun getSupportsSpans ()Z + public fun getSupportsText ()Z + public fun getTypeId ()Ljava/lang/String; + public fun hashCode ()I + public fun isConvertible ()Z + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/core/BlockType$DefaultImpls { + public static fun getSupportsIndentation (Lio/github/linreal/cascade/editor/core/BlockType;)Z + public static fun getSupportsSpans (Lio/github/linreal/cascade/editor/core/BlockType;)Z + public static fun getSupportsText (Lio/github/linreal/cascade/editor/core/BlockType;)Z + public static fun isConvertible (Lio/github/linreal/cascade/editor/core/BlockType;)Z +} + +public final class io/github/linreal/cascade/editor/core/BlockType$Divider : io/github/linreal/cascade/editor/core/BlockType { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/core/BlockType$Divider; + public fun equals (Ljava/lang/Object;)Z + public fun getDisplayName ()Ljava/lang/String; + public fun getSupportsIndentation ()Z + public fun getSupportsSpans ()Z + public fun getSupportsText ()Z + public fun getTypeId ()Ljava/lang/String; + public fun hashCode ()I + public fun isConvertible ()Z + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/core/BlockType$Heading : io/github/linreal/cascade/editor/core/BlockType { + public static final field $stable I + public fun (I)V + public final fun component1 ()I + public final fun copy (I)Lio/github/linreal/cascade/editor/core/BlockType$Heading; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/core/BlockType$Heading;IILjava/lang/Object;)Lio/github/linreal/cascade/editor/core/BlockType$Heading; + public fun equals (Ljava/lang/Object;)Z + public fun getDisplayName ()Ljava/lang/String; + public final fun getLevel ()I + public fun getSupportsIndentation ()Z + public fun getSupportsSpans ()Z + public fun getSupportsText ()Z + public fun getTypeId ()Ljava/lang/String; + public fun hashCode ()I + public fun isConvertible ()Z + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/core/BlockType$NumberedList : io/github/linreal/cascade/editor/core/BlockType { + public static final field $stable I + public fun ()V + public fun (I)V + public synthetic fun (IILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()I + public final fun copy (I)Lio/github/linreal/cascade/editor/core/BlockType$NumberedList; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/core/BlockType$NumberedList;IILjava/lang/Object;)Lio/github/linreal/cascade/editor/core/BlockType$NumberedList; + public fun equals (Ljava/lang/Object;)Z + public fun getDisplayName ()Ljava/lang/String; + public final fun getNumber ()I + public fun getSupportsIndentation ()Z + public fun getSupportsSpans ()Z + public fun getSupportsText ()Z + public fun getTypeId ()Ljava/lang/String; + public fun hashCode ()I + public fun isConvertible ()Z + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/core/BlockType$Paragraph : io/github/linreal/cascade/editor/core/BlockType { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/core/BlockType$Paragraph; + public fun equals (Ljava/lang/Object;)Z + public fun getDisplayName ()Ljava/lang/String; + public fun getSupportsIndentation ()Z + public fun getSupportsSpans ()Z + public fun getSupportsText ()Z + public fun getTypeId ()Ljava/lang/String; + public fun hashCode ()I + public fun isConvertible ()Z + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/core/BlockType$Quote : io/github/linreal/cascade/editor/core/BlockType { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/core/BlockType$Quote; + public fun equals (Ljava/lang/Object;)Z + public fun getDisplayName ()Ljava/lang/String; + public fun getSupportsIndentation ()Z + public fun getSupportsSpans ()Z + public fun getSupportsText ()Z + public fun getTypeId ()Ljava/lang/String; + public fun hashCode ()I + public fun isConvertible ()Z + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/core/BlockType$Todo : io/github/linreal/cascade/editor/core/BlockType { + public static final field $stable I + public fun ()V + public fun (Z)V + public synthetic fun (ZILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()Z + public final fun copy (Z)Lio/github/linreal/cascade/editor/core/BlockType$Todo; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/core/BlockType$Todo;ZILjava/lang/Object;)Lio/github/linreal/cascade/editor/core/BlockType$Todo; + public fun equals (Ljava/lang/Object;)Z + public final fun getChecked ()Z + public fun getDisplayName ()Ljava/lang/String; + public fun getSupportsIndentation ()Z + public fun getSupportsSpans ()Z + public fun getSupportsText ()Z + public fun getTypeId ()Ljava/lang/String; + public fun hashCode ()I + public fun isConvertible ()Z + public fun toString ()Ljava/lang/String; +} + +public abstract interface class io/github/linreal/cascade/editor/core/CustomBlockType : io/github/linreal/cascade/editor/core/BlockType { +} + +public final class io/github/linreal/cascade/editor/core/CustomBlockType$DefaultImpls { + public static fun getSupportsIndentation (Lio/github/linreal/cascade/editor/core/CustomBlockType;)Z + public static fun getSupportsSpans (Lio/github/linreal/cascade/editor/core/CustomBlockType;)Z + public static fun getSupportsText (Lio/github/linreal/cascade/editor/core/CustomBlockType;)Z + public static fun isConvertible (Lio/github/linreal/cascade/editor/core/CustomBlockType;)Z +} + +public abstract interface class io/github/linreal/cascade/editor/core/SpanStyle { + public static final field Companion Lio/github/linreal/cascade/editor/core/SpanStyle$Companion; +} + +public final class io/github/linreal/cascade/editor/core/SpanStyle$Bold : io/github/linreal/cascade/editor/core/SpanStyle { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/core/SpanStyle$Bold; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/core/SpanStyle$Companion { + public final fun kindKey (Lio/github/linreal/cascade/editor/core/SpanStyle;)Ljava/lang/Object; + public final fun kindMatches (Lio/github/linreal/cascade/editor/core/SpanStyle;Lio/github/linreal/cascade/editor/core/SpanStyle;)Z +} + +public final class io/github/linreal/cascade/editor/core/SpanStyle$Custom : io/github/linreal/cascade/editor/core/SpanStyle { + public static final field $stable I + public fun (Ljava/lang/String;Ljava/lang/String;)V + public synthetic fun (Ljava/lang/String;Ljava/lang/String;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()Ljava/lang/String; + public final fun component2 ()Ljava/lang/String; + public final fun copy (Ljava/lang/String;Ljava/lang/String;)Lio/github/linreal/cascade/editor/core/SpanStyle$Custom; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/core/SpanStyle$Custom;Ljava/lang/String;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/core/SpanStyle$Custom; + public fun equals (Ljava/lang/Object;)Z + public final fun getPayload ()Ljava/lang/String; + public final fun getTypeId ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/core/SpanStyle$Highlight : io/github/linreal/cascade/editor/core/SpanStyle { + public static final field $stable I + public fun (J)V + public final fun component1 ()J + public final fun copy (J)Lio/github/linreal/cascade/editor/core/SpanStyle$Highlight; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/core/SpanStyle$Highlight;JILjava/lang/Object;)Lio/github/linreal/cascade/editor/core/SpanStyle$Highlight; + public fun equals (Ljava/lang/Object;)Z + public final fun getColorArgb ()J + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/core/SpanStyle$InlineCode : io/github/linreal/cascade/editor/core/SpanStyle { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/core/SpanStyle$InlineCode; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/core/SpanStyle$Italic : io/github/linreal/cascade/editor/core/SpanStyle { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/core/SpanStyle$Italic; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/core/SpanStyle$Link : io/github/linreal/cascade/editor/core/SpanStyle { + public static final field $stable I + public fun (Ljava/lang/String;)V + public final fun component1 ()Ljava/lang/String; + public final fun copy (Ljava/lang/String;)Lio/github/linreal/cascade/editor/core/SpanStyle$Link; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/core/SpanStyle$Link;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/core/SpanStyle$Link; + public fun equals (Ljava/lang/Object;)Z + public final fun getUrl ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/core/SpanStyle$StrikeThrough : io/github/linreal/cascade/editor/core/SpanStyle { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/core/SpanStyle$StrikeThrough; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/core/SpanStyle$Underline : io/github/linreal/cascade/editor/core/SpanStyle { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/core/SpanStyle$Underline; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/core/TextSpan { + public static final field $stable I + public fun (IILio/github/linreal/cascade/editor/core/SpanStyle;)V + public final fun component1 ()I + public final fun component2 ()I + public final fun component3 ()Lio/github/linreal/cascade/editor/core/SpanStyle; + public final fun copy (IILio/github/linreal/cascade/editor/core/SpanStyle;)Lio/github/linreal/cascade/editor/core/TextSpan; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/core/TextSpan;IILio/github/linreal/cascade/editor/core/SpanStyle;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/core/TextSpan; + public fun equals (Ljava/lang/Object;)Z + public final fun getEnd ()I + public final fun getStart ()I + public final fun getStyle ()Lio/github/linreal/cascade/editor/core/SpanStyle; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/core/UnknownBlockType : io/github/linreal/cascade/editor/core/CustomBlockType { + public static final field $stable I + public fun (Ljava/lang/String;Ljava/lang/String;)V + public final fun component1 ()Ljava/lang/String; + public final fun component2 ()Ljava/lang/String; + public final fun copy (Ljava/lang/String;Ljava/lang/String;)Lio/github/linreal/cascade/editor/core/UnknownBlockType; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/core/UnknownBlockType;Ljava/lang/String;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/core/UnknownBlockType; + public fun equals (Ljava/lang/Object;)Z + public fun getDisplayName ()Ljava/lang/String; + public final fun getRawTypeJson ()Ljava/lang/String; + public fun getSupportsIndentation ()Z + public fun getSupportsSpans ()Z + public fun getSupportsText ()Z + public fun getTypeId ()Ljava/lang/String; + public fun hashCode ()I + public fun isConvertible ()Z + public fun toString ()Ljava/lang/String; +} + +public abstract interface class io/github/linreal/cascade/editor/htmlserialization/BlockEncoder { + public abstract fun encode (Lio/github/linreal/cascade/editor/htmlserialization/HtmlEncodeContext;Lio/github/linreal/cascade/editor/core/Block;Lio/github/linreal/cascade/editor/core/BlockContent;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlEmit; +} + +public abstract interface class io/github/linreal/cascade/editor/htmlserialization/BlockGroupEncoder { + public abstract fun encodeGroup (Lio/github/linreal/cascade/editor/htmlserialization/HtmlEncodeContext;Ljava/util/List;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlEmit; + public abstract fun groupKey (Lio/github/linreal/cascade/editor/core/Block;)Ljava/lang/Object; +} + +public abstract interface class io/github/linreal/cascade/editor/htmlserialization/BlockSeparator { +} + +public final class io/github/linreal/cascade/editor/htmlserialization/BlockSeparator$BlockTags : io/github/linreal/cascade/editor/htmlserialization/BlockSeparator { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/htmlserialization/BlockSeparator$BlockTags; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/BlockSeparator$Newline : io/github/linreal/cascade/editor/htmlserialization/BlockSeparator { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/htmlserialization/BlockSeparator$Newline; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/DefaultBlockEncodersKt { + public static final fun openTagWithCascadeIndentation (Ljava/lang/String;Lio/github/linreal/cascade/editor/core/Block;)Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/DefaultListOutlineEncoderKt { + public static final field CASCADE_INDENT_CLASS_PREFIX Ljava/lang/String; +} + +public abstract interface class io/github/linreal/cascade/editor/htmlserialization/EntityDecode { +} + +public final class io/github/linreal/cascade/editor/htmlserialization/EntityDecode$None : io/github/linreal/cascade/editor/htmlserialization/EntityDecode { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/htmlserialization/EntityDecode$None; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/EntityDecode$Standard : io/github/linreal/cascade/editor/htmlserialization/EntityDecode { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/htmlserialization/EntityDecode$Standard; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public abstract interface annotation class io/github/linreal/cascade/editor/htmlserialization/ExperimentalCascadeHtmlApi : java/lang/annotation/Annotation { +} + +public final class io/github/linreal/cascade/editor/htmlserialization/Html { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/htmlserialization/Html; + public final fun escapeAttr (Ljava/lang/String;)Ljava/lang/String; + public final fun escapeText (Ljava/lang/String;)Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/HtmlDecodeLimits { + public static final field $stable I + public static final field Companion Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeLimits$Companion; + public static final field DEFAULT_MAX_INPUT_CHARS I + public fun ()V + public fun (I)V + public synthetic fun (IILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()I + public final fun copy (I)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeLimits; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeLimits;IILjava/lang/Object;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeLimits; + public fun equals (Ljava/lang/Object;)Z + public final fun getMaxInputChars ()I + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/HtmlDecodeLimits$Companion { + public final fun getDefault ()Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeLimits; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/HtmlDecodeResult { + public static final field $stable I + public fun (Ljava/util/List;Ljava/util/List;)V + public final fun component1 ()Ljava/util/List; + public final fun component2 ()Ljava/util/List; + public final fun copy (Ljava/util/List;Ljava/util/List;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeResult; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeResult;Ljava/util/List;Ljava/util/List;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeResult; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlocks ()Ljava/util/List; + public final fun getWarnings ()Ljava/util/List; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public abstract class io/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning { + public static final field $stable I + public abstract fun getCharOffset ()I +} + +public final class io/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$BlockInInlineContext : io/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning { + public static final field $stable I + public fun (Ljava/lang/String;I)V + public final fun component1 ()Ljava/lang/String; + public final fun component2 ()I + public final fun copy (Ljava/lang/String;I)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$BlockInInlineContext; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$BlockInInlineContext;Ljava/lang/String;IILjava/lang/Object;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$BlockInInlineContext; + public fun equals (Ljava/lang/Object;)Z + public fun getCharOffset ()I + public final fun getTag ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$DecoderException : io/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning { + public static final field $stable I + public fun (Ljava/lang/String;Ljava/lang/String;I)V + public final fun component1 ()Ljava/lang/String; + public final fun component2 ()Ljava/lang/String; + public final fun component3 ()I + public final fun copy (Ljava/lang/String;Ljava/lang/String;I)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$DecoderException; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$DecoderException;Ljava/lang/String;Ljava/lang/String;IILjava/lang/Object;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$DecoderException; + public fun equals (Ljava/lang/Object;)Z + public fun getCharOffset ()I + public final fun getMessage ()Ljava/lang/String; + public final fun getTag ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$DroppedAttribute : io/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning { + public static final field $stable I + public fun (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;I)V + public final fun component1 ()Ljava/lang/String; + public final fun component2 ()Ljava/lang/String; + public final fun component3 ()Ljava/lang/String; + public final fun component4 ()I + public final fun copy (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;I)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$DroppedAttribute; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$DroppedAttribute;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;IILjava/lang/Object;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$DroppedAttribute; + public fun equals (Ljava/lang/Object;)Z + public final fun getAttr ()Ljava/lang/String; + public fun getCharOffset ()I + public final fun getReason ()Ljava/lang/String; + public final fun getTag ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$DroppedContent : io/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning { + public static final field $stable I + public fun (Ljava/lang/String;I)V + public final fun component1 ()Ljava/lang/String; + public final fun component2 ()I + public final fun copy (Ljava/lang/String;I)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$DroppedContent; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$DroppedContent;Ljava/lang/String;IILjava/lang/Object;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$DroppedContent; + public fun equals (Ljava/lang/Object;)Z + public fun getCharOffset ()I + public final fun getReason ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$InputLimitExceeded : io/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning { + public static final field $stable I + public fun (III)V + public synthetic fun (IIIILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()I + public final fun component2 ()I + public final fun component3 ()I + public final fun copy (III)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$InputLimitExceeded; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$InputLimitExceeded;IIIILjava/lang/Object;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$InputLimitExceeded; + public fun equals (Ljava/lang/Object;)Z + public final fun getActual ()I + public fun getCharOffset ()I + public final fun getLimit ()I + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$InvalidAttribute : io/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning { + public static final field $stable I + public fun (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;I)V + public final fun component1 ()Ljava/lang/String; + public final fun component2 ()Ljava/lang/String; + public final fun component3 ()Ljava/lang/String; + public final fun component4 ()Ljava/lang/String; + public final fun component5 ()I + public final fun copy (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;I)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$InvalidAttribute; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$InvalidAttribute;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;IILjava/lang/Object;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$InvalidAttribute; + public fun equals (Ljava/lang/Object;)Z + public final fun getAttr ()Ljava/lang/String; + public fun getCharOffset ()I + public final fun getReason ()Ljava/lang/String; + public final fun getTag ()Ljava/lang/String; + public final fun getValue ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$MismatchedNesting : io/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning { + public static final field $stable I + public fun (Ljava/lang/String;Ljava/lang/String;I)V + public final fun component1 ()Ljava/lang/String; + public final fun component2 ()Ljava/lang/String; + public final fun component3 ()I + public final fun copy (Ljava/lang/String;Ljava/lang/String;I)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$MismatchedNesting; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$MismatchedNesting;Ljava/lang/String;Ljava/lang/String;IILjava/lang/Object;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$MismatchedNesting; + public fun equals (Ljava/lang/Object;)Z + public fun getCharOffset ()I + public final fun getExpected ()Ljava/lang/String; + public final fun getFound ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$StrayClosingTag : io/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning { + public static final field $stable I + public fun (Ljava/lang/String;I)V + public final fun component1 ()Ljava/lang/String; + public final fun component2 ()I + public final fun copy (Ljava/lang/String;I)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$StrayClosingTag; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$StrayClosingTag;Ljava/lang/String;IILjava/lang/Object;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$StrayClosingTag; + public fun equals (Ljava/lang/Object;)Z + public fun getCharOffset ()I + public final fun getTag ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$UnclosedTag : io/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning { + public static final field $stable I + public fun (Ljava/lang/String;I)V + public final fun component1 ()Ljava/lang/String; + public final fun component2 ()I + public final fun copy (Ljava/lang/String;I)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$UnclosedTag; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$UnclosedTag;Ljava/lang/String;IILjava/lang/Object;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$UnclosedTag; + public fun equals (Ljava/lang/Object;)Z + public fun getCharOffset ()I + public final fun getTag ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$UnknownAttribute : io/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning { + public static final field $stable I + public fun (Ljava/lang/String;Ljava/lang/String;I)V + public final fun component1 ()Ljava/lang/String; + public final fun component2 ()Ljava/lang/String; + public final fun component3 ()I + public final fun copy (Ljava/lang/String;Ljava/lang/String;I)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$UnknownAttribute; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$UnknownAttribute;Ljava/lang/String;Ljava/lang/String;IILjava/lang/Object;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$UnknownAttribute; + public fun equals (Ljava/lang/Object;)Z + public final fun getAttr ()Ljava/lang/String; + public fun getCharOffset ()I + public final fun getTag ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$UnknownTag : io/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning { + public static final field $stable I + public fun (Ljava/lang/String;I)V + public final fun component1 ()Ljava/lang/String; + public final fun component2 ()I + public final fun copy (Ljava/lang/String;I)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$UnknownTag; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$UnknownTag;Ljava/lang/String;IILjava/lang/Object;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning$UnknownTag; + public fun equals (Ljava/lang/Object;)Z + public fun getCharOffset ()I + public final fun getTag ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public abstract interface class io/github/linreal/cascade/editor/htmlserialization/HtmlEmit { +} + +public final class io/github/linreal/cascade/editor/htmlserialization/HtmlEmit$Raw : io/github/linreal/cascade/editor/htmlserialization/HtmlEmit { + public static final field $stable I + public fun (Ljava/lang/String;)V + public final fun component1 ()Ljava/lang/String; + public final fun copy (Ljava/lang/String;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlEmit$Raw; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/htmlserialization/HtmlEmit$Raw;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlEmit$Raw; + public fun equals (Ljava/lang/Object;)Z + public final fun getHtml ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/HtmlEmit$Skip : io/github/linreal/cascade/editor/htmlserialization/HtmlEmit { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/htmlserialization/HtmlEmit$Skip; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public abstract class io/github/linreal/cascade/editor/htmlserialization/HtmlEncodeContext { + public static final field $stable I + public abstract fun encodeInline (Lio/github/linreal/cascade/editor/core/Block;)Ljava/lang/String; + public abstract fun encodeInlineFragment (Ljava/lang/String;Ljava/util/List;Z)Ljava/lang/String; + public static synthetic fun encodeInlineFragment$default (Lio/github/linreal/cascade/editor/htmlserialization/HtmlEncodeContext;Ljava/lang/String;Ljava/util/List;ZILjava/lang/Object;)Ljava/lang/String; + public abstract fun encodeTextOnly (Lio/github/linreal/cascade/editor/core/Block;)Ljava/lang/String; + public abstract fun escapeAttr (Ljava/lang/String;)Ljava/lang/String; + public abstract fun escapeText (Ljava/lang/String;)Ljava/lang/String; + public abstract fun warn (Lio/github/linreal/cascade/editor/htmlserialization/HtmlEncodeWarning;)V +} + +public final class io/github/linreal/cascade/editor/htmlserialization/HtmlEncodeResult { + public static final field $stable I + public fun (Ljava/lang/String;Ljava/util/List;)V + public final fun component1 ()Ljava/lang/String; + public final fun component2 ()Ljava/util/List; + public final fun copy (Ljava/lang/String;Ljava/util/List;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlEncodeResult; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/htmlserialization/HtmlEncodeResult;Ljava/lang/String;Ljava/util/List;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlEncodeResult; + public fun equals (Ljava/lang/Object;)Z + public final fun getHtml ()Ljava/lang/String; + public final fun getWarnings ()Ljava/util/List; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public abstract class io/github/linreal/cascade/editor/htmlserialization/HtmlEncodeWarning { + public static final field $stable I +} + +public final class io/github/linreal/cascade/editor/htmlserialization/HtmlEncodeWarning$DroppedAttribute : io/github/linreal/cascade/editor/htmlserialization/HtmlEncodeWarning { + public static final field $stable I + public fun (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V + public final fun component1 ()Ljava/lang/String; + public final fun component2 ()Ljava/lang/String; + public final fun component3 ()Ljava/lang/String; + public final fun copy (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlEncodeWarning$DroppedAttribute; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/htmlserialization/HtmlEncodeWarning$DroppedAttribute;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlEncodeWarning$DroppedAttribute; + public fun equals (Ljava/lang/Object;)Z + public final fun getAttr ()Ljava/lang/String; + public final fun getReason ()Ljava/lang/String; + public final fun getTypeId ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/HtmlEncodeWarning$EncoderException : io/github/linreal/cascade/editor/htmlserialization/HtmlEncodeWarning { + public static final field $stable I + public fun (Ljava/lang/String;Ljava/lang/String;)V + public final fun component1 ()Ljava/lang/String; + public final fun component2 ()Ljava/lang/String; + public final fun copy (Ljava/lang/String;Ljava/lang/String;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlEncodeWarning$EncoderException; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/htmlserialization/HtmlEncodeWarning$EncoderException;Ljava/lang/String;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlEncodeWarning$EncoderException; + public fun equals (Ljava/lang/Object;)Z + public final fun getMessage ()Ljava/lang/String; + public final fun getTypeId ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public abstract interface class io/github/linreal/cascade/editor/htmlserialization/HtmlNodeView { + public abstract fun getSourceEndExclusive ()I + public abstract fun getSourceStart ()I +} + +public final class io/github/linreal/cascade/editor/htmlserialization/HtmlNodeView$Element : io/github/linreal/cascade/editor/htmlserialization/HtmlNodeView { + public static final field $stable I + public fun (Ljava/lang/String;Ljava/util/Map;Ljava/util/List;II)V + public final fun component1 ()Ljava/lang/String; + public final fun component2 ()Ljava/util/Map; + public final fun component3 ()Ljava/util/List; + public final fun component4 ()I + public final fun component5 ()I + public final fun copy (Ljava/lang/String;Ljava/util/Map;Ljava/util/List;II)Lio/github/linreal/cascade/editor/htmlserialization/HtmlNodeView$Element; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/htmlserialization/HtmlNodeView$Element;Ljava/lang/String;Ljava/util/Map;Ljava/util/List;IIILjava/lang/Object;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlNodeView$Element; + public fun equals (Ljava/lang/Object;)Z + public final fun getAttrs ()Ljava/util/Map; + public final fun getChildren ()Ljava/util/List; + public fun getSourceEndExclusive ()I + public fun getSourceStart ()I + public final fun getTag ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/HtmlNodeView$Text : io/github/linreal/cascade/editor/htmlserialization/HtmlNodeView { + public static final field $stable I + public fun (Ljava/lang/String;II)V + public final fun component1 ()Ljava/lang/String; + public final fun component2 ()I + public final fun component3 ()I + public final fun copy (Ljava/lang/String;II)Lio/github/linreal/cascade/editor/htmlserialization/HtmlNodeView$Text; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/htmlserialization/HtmlNodeView$Text;Ljava/lang/String;IIILjava/lang/Object;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlNodeView$Text; + public fun equals (Ljava/lang/Object;)Z + public fun getSourceEndExclusive ()I + public fun getSourceStart ()I + public final fun getText ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/HtmlProfile { + public static final field $stable I + public static final field Companion Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile$Companion; + public static final field DEFAULT_HIGHLIGHT_COLOR_ARGB J + public final fun getSupportSet ()Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfileSupportSet; + public final fun tagDecoderFor (Ljava/lang/String;)Lio/github/linreal/cascade/editor/htmlserialization/TagDecoder; + public final fun withBlockEncoderInternal (Lkotlin/reflect/KClass;Lio/github/linreal/cascade/editor/htmlserialization/BlockEncoder;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile; + public final fun withBlockGroupEncoder (Ljava/lang/String;Lio/github/linreal/cascade/editor/htmlserialization/BlockGroupEncoder;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile; + public final fun withCustomBlockEncoder (Ljava/lang/String;Lio/github/linreal/cascade/editor/htmlserialization/BlockEncoder;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile; + public final fun withCustomSpanEncoder (Ljava/lang/String;Lio/github/linreal/cascade/editor/htmlserialization/SpanEncoder;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile; + public final fun withEncoderBlockFallback (Lio/github/linreal/cascade/editor/htmlserialization/BlockEncoder;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile; + public final fun withEncoderSpanFallback (Lio/github/linreal/cascade/editor/htmlserialization/SpanEncoder;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile; + public final fun withParserPolicy (Lio/github/linreal/cascade/editor/htmlserialization/BlockSeparator;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile; + public final fun withParserPolicy (Lio/github/linreal/cascade/editor/htmlserialization/EntityDecode;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile; + public final fun withParserPolicy (Lio/github/linreal/cascade/editor/htmlserialization/InlineRoot;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile; + public final fun withSpanEncoderInternal (Lkotlin/reflect/KClass;Lio/github/linreal/cascade/editor/htmlserialization/SpanEncoder;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile; + public final fun withSupportSet (Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfileSupportSet;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile; + public final fun withTagDecoder (Ljava/lang/String;Lio/github/linreal/cascade/editor/htmlserialization/TagDecoder;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile; + public final fun withUnknownTagPolicy (Lio/github/linreal/cascade/editor/htmlserialization/UnknownTagPolicy;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile; + public final fun withoutBlockGroupEncoder (Ljava/lang/String;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile; + public final fun withoutTagDecoder (Ljava/lang/String;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/HtmlProfile$Companion { + public final fun getDefault ()Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/HtmlProfileSupportSet { + public static final field $stable I + public static final field Companion Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfileSupportSet$Companion; + public fun (Lkotlin/jvm/functions/Function1;Lkotlin/jvm/functions/Function1;)V + public final fun getSupportsBlockPredicate ()Lkotlin/jvm/functions/Function1; + public final fun getSupportsSpanPredicate ()Lkotlin/jvm/functions/Function1; + public final fun supportsBlock (Lio/github/linreal/cascade/editor/core/Block;)Z + public final fun supportsDocument (Ljava/util/List;)Z + public final fun supportsSpan (Lio/github/linreal/cascade/editor/core/SpanStyle;)Z +} + +public final class io/github/linreal/cascade/editor/htmlserialization/HtmlProfileSupportSet$Companion { + public final fun getDefault ()Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfileSupportSet; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/HtmlSchema { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/htmlserialization/HtmlSchema; + public final fun decode (Ljava/lang/String;Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile;)Ljava/util/List; + public final fun decodeWithReport (Ljava/lang/String;Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile;Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeLimits;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeResult; + public static synthetic fun decodeWithReport$default (Lio/github/linreal/cascade/editor/htmlserialization/HtmlSchema;Ljava/lang/String;Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile;Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeLimits;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeResult; + public final fun encode (Ljava/util/List;Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile;)Ljava/lang/String; + public final fun encodeWithReport (Ljava/util/List;Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlEncodeResult; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/HtmlSerializationExtKt { + public static final fun loadFromHtml (Lio/github/linreal/cascade/editor/state/EditorStateHolder;Ljava/lang/String;Lio/github/linreal/cascade/editor/state/BlockTextStates;Lio/github/linreal/cascade/editor/state/BlockSpanStates;Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile;Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeLimits;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeResult; + public static synthetic fun loadFromHtml$default (Lio/github/linreal/cascade/editor/state/EditorStateHolder;Ljava/lang/String;Lio/github/linreal/cascade/editor/state/BlockTextStates;Lio/github/linreal/cascade/editor/state/BlockSpanStates;Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile;Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeLimits;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeResult; + public static final fun toHtml (Lio/github/linreal/cascade/editor/state/EditorStateHolder;Lio/github/linreal/cascade/editor/state/BlockTextStates;Lio/github/linreal/cascade/editor/state/BlockSpanStates;Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile;)Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/HtmlTagPair { + public static final field $stable I + public fun (Ljava/lang/String;Ljava/lang/String;)V + public final fun component1 ()Ljava/lang/String; + public final fun component2 ()Ljava/lang/String; + public final fun copy (Ljava/lang/String;Ljava/lang/String;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlTagPair; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/htmlserialization/HtmlTagPair;Ljava/lang/String;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlTagPair; + public fun equals (Ljava/lang/Object;)Z + public final fun getClose ()Ljava/lang/String; + public final fun getOpen ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/InlineFragment { + public static final field $stable I + public fun (Ljava/lang/String;Ljava/util/List;)V + public final fun component1 ()Ljava/lang/String; + public final fun component2 ()Ljava/util/List; + public final fun copy (Ljava/lang/String;Ljava/util/List;)Lio/github/linreal/cascade/editor/htmlserialization/InlineFragment; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/htmlserialization/InlineFragment;Ljava/lang/String;Ljava/util/List;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/htmlserialization/InlineFragment; + public fun equals (Ljava/lang/Object;)Z + public final fun getSpans ()Ljava/util/List; + public final fun getText ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public abstract interface class io/github/linreal/cascade/editor/htmlserialization/InlineRoot { +} + +public final class io/github/linreal/cascade/editor/htmlserialization/InlineRoot$Drop : io/github/linreal/cascade/editor/htmlserialization/InlineRoot { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/htmlserialization/InlineRoot$Drop; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/InlineRoot$WrapInParagraph : io/github/linreal/cascade/editor/htmlserialization/InlineRoot { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/htmlserialization/InlineRoot$WrapInParagraph; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public abstract interface class io/github/linreal/cascade/editor/htmlserialization/SpanEncoder { + public abstract fun encode (Lio/github/linreal/cascade/editor/core/SpanStyle;)Lio/github/linreal/cascade/editor/htmlserialization/HtmlTagPair; +} + +public abstract class io/github/linreal/cascade/editor/htmlserialization/TagDecodeContext { + public static final field $stable I + public abstract fun collectInlineText (Ljava/util/List;ZZZ)Lio/github/linreal/cascade/editor/htmlserialization/InlineFragment; + public static synthetic fun collectInlineText$default (Lio/github/linreal/cascade/editor/htmlserialization/TagDecodeContext;Ljava/util/List;ZZZILjava/lang/Object;)Lio/github/linreal/cascade/editor/htmlserialization/InlineFragment; + public abstract fun decodeBlocks (Ljava/util/List;)Ljava/util/List; + public abstract fun decodeInline (Ljava/util/List;)Lio/github/linreal/cascade/editor/htmlserialization/InlineFragment; + public abstract fun getCharOffset ()I + public abstract fun getParentTag ()Ljava/lang/String; + public abstract fun getRawSource ()Ljava/lang/String; + public abstract fun isBlockContext ()Z + public abstract fun rawSliceOf (Lio/github/linreal/cascade/editor/htmlserialization/HtmlNodeView;)Ljava/lang/String; + public abstract fun tagDecoderFor (Ljava/lang/String;)Lio/github/linreal/cascade/editor/htmlserialization/TagDecoder; + public abstract fun warn (Lio/github/linreal/cascade/editor/htmlserialization/HtmlDecodeWarning;)V +} + +public abstract interface class io/github/linreal/cascade/editor/htmlserialization/TagDecodeResult { +} + +public final class io/github/linreal/cascade/editor/htmlserialization/TagDecodeResult$AsBlock : io/github/linreal/cascade/editor/htmlserialization/TagDecodeResult { + public static final field $stable I + public fun (Lio/github/linreal/cascade/editor/core/Block;)V + public final fun component1 ()Lio/github/linreal/cascade/editor/core/Block; + public final fun copy (Lio/github/linreal/cascade/editor/core/Block;)Lio/github/linreal/cascade/editor/htmlserialization/TagDecodeResult$AsBlock; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/htmlserialization/TagDecodeResult$AsBlock;Lio/github/linreal/cascade/editor/core/Block;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/htmlserialization/TagDecodeResult$AsBlock; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlock ()Lio/github/linreal/cascade/editor/core/Block; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/TagDecodeResult$AsBlocks : io/github/linreal/cascade/editor/htmlserialization/TagDecodeResult { + public static final field $stable I + public fun (Ljava/util/List;)V + public final fun component1 ()Ljava/util/List; + public final fun copy (Ljava/util/List;)Lio/github/linreal/cascade/editor/htmlserialization/TagDecodeResult$AsBlocks; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/htmlserialization/TagDecodeResult$AsBlocks;Ljava/util/List;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/htmlserialization/TagDecodeResult$AsBlocks; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlocks ()Ljava/util/List; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/TagDecodeResult$AsText : io/github/linreal/cascade/editor/htmlserialization/TagDecodeResult { + public static final field $stable I + public fun (Ljava/lang/String;Ljava/util/List;)V + public final fun component1 ()Ljava/lang/String; + public final fun component2 ()Ljava/util/List; + public final fun copy (Ljava/lang/String;Ljava/util/List;)Lio/github/linreal/cascade/editor/htmlserialization/TagDecodeResult$AsText; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/htmlserialization/TagDecodeResult$AsText;Ljava/lang/String;Ljava/util/List;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/htmlserialization/TagDecodeResult$AsText; + public fun equals (Ljava/lang/Object;)Z + public final fun getSpans ()Ljava/util/List; + public final fun getText ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/TagDecodeResult$Drop : io/github/linreal/cascade/editor/htmlserialization/TagDecodeResult { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/htmlserialization/TagDecodeResult$Drop; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public abstract interface class io/github/linreal/cascade/editor/htmlserialization/TagDecoder { + public abstract fun decode (Lio/github/linreal/cascade/editor/htmlserialization/TagDecodeContext;Ljava/util/Map;Ljava/util/List;)Lio/github/linreal/cascade/editor/htmlserialization/TagDecodeResult; +} + +public abstract interface class io/github/linreal/cascade/editor/htmlserialization/UnknownTagPolicy { +} + +public final class io/github/linreal/cascade/editor/htmlserialization/UnknownTagPolicy$Custom : io/github/linreal/cascade/editor/htmlserialization/UnknownTagPolicy { + public static final field $stable I + public fun (Lkotlin/jvm/functions/Function2;)V + public final fun component1 ()Lkotlin/jvm/functions/Function2; + public final fun copy (Lkotlin/jvm/functions/Function2;)Lio/github/linreal/cascade/editor/htmlserialization/UnknownTagPolicy$Custom; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/htmlserialization/UnknownTagPolicy$Custom;Lkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/htmlserialization/UnknownTagPolicy$Custom; + public fun equals (Ljava/lang/Object;)Z + public final fun getHandler ()Lkotlin/jvm/functions/Function2; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/UnknownTagPolicy$Preserve : io/github/linreal/cascade/editor/htmlserialization/UnknownTagPolicy { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/htmlserialization/UnknownTagPolicy$Preserve; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/UnknownTagPolicy$Strip : io/github/linreal/cascade/editor/htmlserialization/UnknownTagPolicy { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/htmlserialization/UnknownTagPolicy$Strip; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/htmlserialization/UnknownTagPolicy$WarnAndStrip : io/github/linreal/cascade/editor/htmlserialization/UnknownTagPolicy { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/htmlserialization/UnknownTagPolicy$WarnAndStrip; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public abstract interface class io/github/linreal/cascade/editor/indentation/IndentationActions { + public abstract fun indentBackward ()V + public abstract fun indentForward ()V +} + +public final class io/github/linreal/cascade/editor/indentation/IndentationState { + public static final field $stable I + public static final field Companion Lio/github/linreal/cascade/editor/indentation/IndentationState$Companion; + public fun (ZZLjava/util/List;)V + public final fun component1 ()Z + public final fun component2 ()Z + public final fun component3 ()Ljava/util/List; + public final fun copy (ZZLjava/util/List;)Lio/github/linreal/cascade/editor/indentation/IndentationState; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/indentation/IndentationState;ZZLjava/util/List;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/indentation/IndentationState; + public fun equals (Ljava/lang/Object;)Z + public final fun getCanIndentBackward ()Z + public final fun getCanIndentForward ()Z + public final fun getTargetBlockIds ()Ljava/util/List; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/indentation/IndentationState$Companion { + public final fun getEmpty ()Lio/github/linreal/cascade/editor/indentation/IndentationState; +} + +public abstract interface class io/github/linreal/cascade/editor/registry/BlockCallbacks { + public abstract fun dispatch (Lio/github/linreal/cascade/editor/action/EditorAction;)V + public abstract fun onBackspaceAtStart-SDe6QqM (Ljava/lang/String;)V + public abstract fun onClick-SDe6QqM (Ljava/lang/String;)V + public abstract fun onDeleteAtEnd-SDe6QqM (Ljava/lang/String;)V + public abstract fun onDragStart-7OMXkl4 (Ljava/lang/String;F)V + public abstract fun onEnter-7OMXkl4 (Ljava/lang/String;I)V + public abstract fun onFocus-SDe6QqM (Ljava/lang/String;)V + public abstract fun onLongClick-SDe6QqM (Ljava/lang/String;)V + public abstract fun onSlashCommand-p1zP0qE (Ljava/lang/String;Lio/github/linreal/cascade/editor/state/SlashQueryRange;Ljava/lang/String;)V + public static synthetic fun onSlashCommand-p1zP0qE$default (Lio/github/linreal/cascade/editor/registry/BlockCallbacks;Ljava/lang/String;Lio/github/linreal/cascade/editor/state/SlashQueryRange;Ljava/lang/String;ILjava/lang/Object;)V +} + +public final class io/github/linreal/cascade/editor/registry/BlockCallbacks$DefaultImpls { + public static synthetic fun onSlashCommand-p1zP0qE$default (Lio/github/linreal/cascade/editor/registry/BlockCallbacks;Ljava/lang/String;Lio/github/linreal/cascade/editor/state/SlashQueryRange;Ljava/lang/String;ILjava/lang/Object;)V +} + +public final class io/github/linreal/cascade/editor/registry/BlockDescriptor { + public static final field $stable I + public fun (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/util/List;Ljava/lang/String;Lio/github/linreal/cascade/editor/slash/BuiltInSlashCommandSpec;Lkotlin/jvm/functions/Function1;)V + public synthetic fun (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/util/List;Ljava/lang/String;Lio/github/linreal/cascade/editor/slash/BuiltInSlashCommandSpec;Lkotlin/jvm/functions/Function1;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()Ljava/lang/String; + public final fun component2 ()Ljava/lang/String; + public final fun component3 ()Ljava/lang/String; + public final fun component4 ()Ljava/util/List; + public final fun component5 ()Ljava/lang/String; + public final fun component6 ()Lio/github/linreal/cascade/editor/slash/BuiltInSlashCommandSpec; + public final fun component7 ()Lkotlin/jvm/functions/Function1; + public final fun copy (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/util/List;Ljava/lang/String;Lio/github/linreal/cascade/editor/slash/BuiltInSlashCommandSpec;Lkotlin/jvm/functions/Function1;)Lio/github/linreal/cascade/editor/registry/BlockDescriptor; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/registry/BlockDescriptor;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/util/List;Ljava/lang/String;Lio/github/linreal/cascade/editor/slash/BuiltInSlashCommandSpec;Lkotlin/jvm/functions/Function1;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/registry/BlockDescriptor; + public final fun createBlock ()Lio/github/linreal/cascade/editor/core/Block; + public final fun createBlock-SDe6QqM (Ljava/lang/String;)Lio/github/linreal/cascade/editor/core/Block; + public fun equals (Ljava/lang/Object;)Z + public final fun getDescription ()Ljava/lang/String; + public final fun getDisplayName ()Ljava/lang/String; + public final fun getFactory ()Lkotlin/jvm/functions/Function1; + public final fun getIcon ()Ljava/lang/String; + public final fun getKeywords ()Ljava/util/List; + public final fun getSlash ()Lio/github/linreal/cascade/editor/slash/BuiltInSlashCommandSpec; + public final fun getTypeId ()Ljava/lang/String; + public fun hashCode ()I + public final fun matches (Ljava/lang/String;)Z + public final fun relevanceScore (Ljava/lang/String;)I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/registry/BlockRegistry { + public static final field $stable I + public static final field Companion Lio/github/linreal/cascade/editor/registry/BlockRegistry$Companion; + public fun ()V + public final fun createBlock (Ljava/lang/String;)Lio/github/linreal/cascade/editor/core/Block; + public final fun getAllDescriptors ()Ljava/util/List; + public final fun getDescriptor (Ljava/lang/String;)Lio/github/linreal/cascade/editor/registry/BlockDescriptor; + public final fun getRenderer (Lio/github/linreal/cascade/editor/core/BlockType;)Lio/github/linreal/cascade/editor/registry/BlockRenderer; + public final fun getRenderer (Ljava/lang/String;)Lio/github/linreal/cascade/editor/registry/BlockRenderer; + public final fun isRegistered (Ljava/lang/String;)Z + public final fun register (Lio/github/linreal/cascade/editor/registry/BlockDescriptor;Lio/github/linreal/cascade/editor/registry/BlockRenderer;)V + public final fun registerDescriptor (Lio/github/linreal/cascade/editor/registry/BlockDescriptor;)V + public final fun registerRenderer (Ljava/lang/String;Lio/github/linreal/cascade/editor/registry/BlockRenderer;)V + public final fun search (Ljava/lang/String;)Ljava/util/List; + public final fun setUnknownBlockRenderer (Lio/github/linreal/cascade/editor/registry/BlockRenderer;)V +} + +public final class io/github/linreal/cascade/editor/registry/BlockRegistry$Companion { + public final fun create ()Lio/github/linreal/cascade/editor/registry/BlockRegistry; + public final fun createDefault ()Lio/github/linreal/cascade/editor/registry/BlockRegistry; +} + +public abstract interface class io/github/linreal/cascade/editor/registry/BlockRenderScope { + public abstract fun deleteBlock-SDe6QqM (Ljava/lang/String;)V + public abstract fun focusBlock-pWxEiPs (Ljava/lang/String;)V + public abstract fun getBlock-SDe6QqM (Ljava/lang/String;)Lio/github/linreal/cascade/editor/core/Block; + public abstract fun getCanDragBlocks ()Z + public abstract fun getCanEditBlockStructure ()Z + public abstract fun getCanSelectBlocks ()Z + public abstract fun getCanUpdateBlock ()Z + public abstract fun getConfig ()Lio/github/linreal/cascade/editor/ui/CascadeEditorConfig; + public abstract fun getReadOnly ()Z + public abstract fun getState ()Lio/github/linreal/cascade/editor/state/EditorState; + public abstract fun insertBlockAfter-7OMXkl4 (Ljava/lang/String;Lio/github/linreal/cascade/editor/core/Block;)V + public abstract fun insertBlockBefore-7OMXkl4 (Ljava/lang/String;Lio/github/linreal/cascade/editor/core/Block;)V + public abstract fun replaceBlock-7OMXkl4 (Ljava/lang/String;Lio/github/linreal/cascade/editor/core/Block;)V + public abstract fun updateBlock-7OMXkl4 (Ljava/lang/String;Lkotlin/jvm/functions/Function1;)V +} + +public abstract interface class io/github/linreal/cascade/editor/registry/BlockRenderer { + public abstract fun Render (Lio/github/linreal/cascade/editor/core/Block;ZZLandroidx/compose/ui/Modifier;Lio/github/linreal/cascade/editor/registry/BlockCallbacks;Landroidx/compose/runtime/Composer;I)V + public fun getHandlesSelectionVisual ()Z + public fun getSupportsDragPreview ()Z +} + +public final class io/github/linreal/cascade/editor/registry/BlockRenderer$DefaultImpls { + public static fun getHandlesSelectionVisual (Lio/github/linreal/cascade/editor/registry/BlockRenderer;)Z + public static fun getSupportsDragPreview (Lio/github/linreal/cascade/editor/registry/BlockRenderer;)Z +} + +public final class io/github/linreal/cascade/editor/registry/BlockRendererKt { + public static final fun blockRenderer (Lkotlin/jvm/functions/Function7;)Lio/github/linreal/cascade/editor/registry/BlockRenderer; +} + +public class io/github/linreal/cascade/editor/registry/DefaultBlockCallbacks : io/github/linreal/cascade/editor/registry/BlockCallbacks { + public static final field $stable I + public fun (Lkotlin/jvm/functions/Function1;Lkotlin/jvm/functions/Function0;Lio/github/linreal/cascade/editor/state/BlockTextStates;Lio/github/linreal/cascade/editor/state/BlockSpanStates;Lio/github/linreal/cascade/editor/state/EditorStateHolder;)V + public synthetic fun (Lkotlin/jvm/functions/Function1;Lkotlin/jvm/functions/Function0;Lio/github/linreal/cascade/editor/state/BlockTextStates;Lio/github/linreal/cascade/editor/state/BlockSpanStates;Lio/github/linreal/cascade/editor/state/EditorStateHolder;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public fun dispatch (Lio/github/linreal/cascade/editor/action/EditorAction;)V + public fun onBackspaceAtStart-SDe6QqM (Ljava/lang/String;)V + public fun onClick-SDe6QqM (Ljava/lang/String;)V + public fun onDeleteAtEnd-SDe6QqM (Ljava/lang/String;)V + public fun onDragStart-7OMXkl4 (Ljava/lang/String;F)V + public fun onEnter-7OMXkl4 (Ljava/lang/String;I)V + public fun onFocus-SDe6QqM (Ljava/lang/String;)V + public fun onLongClick-SDe6QqM (Ljava/lang/String;)V + public fun onSlashCommand-p1zP0qE (Ljava/lang/String;Lio/github/linreal/cascade/editor/state/SlashQueryRange;Ljava/lang/String;)V +} + +public final class io/github/linreal/cascade/editor/registry/LambdaBlockRenderer : io/github/linreal/cascade/editor/registry/BlockRenderer { + public static final field $stable I + public fun (Lkotlin/jvm/functions/Function7;)V + public fun Render (Lio/github/linreal/cascade/editor/core/Block;ZZLandroidx/compose/ui/Modifier;Lio/github/linreal/cascade/editor/registry/BlockCallbacks;Landroidx/compose/runtime/Composer;I)V + public fun getHandlesSelectionVisual ()Z + public fun getSupportsDragPreview ()Z +} + +public abstract interface class io/github/linreal/cascade/editor/registry/ScopedBlockRenderer : io/github/linreal/cascade/editor/registry/BlockRenderer { + public fun Render (Lio/github/linreal/cascade/editor/core/Block;ZZLandroidx/compose/ui/Modifier;Lio/github/linreal/cascade/editor/registry/BlockCallbacks;Landroidx/compose/runtime/Composer;I)V + public abstract fun Render (Lio/github/linreal/cascade/editor/core/Block;ZZLandroidx/compose/ui/Modifier;Lio/github/linreal/cascade/editor/registry/BlockCallbacks;Lio/github/linreal/cascade/editor/registry/BlockRenderScope;Landroidx/compose/runtime/Composer;I)V +} + +public final class io/github/linreal/cascade/editor/registry/ScopedBlockRenderer$DefaultImpls { + public static fun Render (Lio/github/linreal/cascade/editor/registry/ScopedBlockRenderer;Lio/github/linreal/cascade/editor/core/Block;ZZLandroidx/compose/ui/Modifier;Lio/github/linreal/cascade/editor/registry/BlockCallbacks;Landroidx/compose/runtime/Composer;I)V + public static fun getHandlesSelectionVisual (Lio/github/linreal/cascade/editor/registry/ScopedBlockRenderer;)Z + public static fun getSupportsDragPreview (Lio/github/linreal/cascade/editor/registry/ScopedBlockRenderer;)Z +} + +public abstract interface class io/github/linreal/cascade/editor/richtext/FormattingActions { + public abstract fun applyStyle (Lio/github/linreal/cascade/editor/core/SpanStyle;)V + public abstract fun removeStyle (Lio/github/linreal/cascade/editor/core/SpanStyle;)V + public abstract fun toggleStyle (Lio/github/linreal/cascade/editor/core/SpanStyle;)V +} + +public final class io/github/linreal/cascade/editor/richtext/FormattingState { + public static final field $stable I + public static final field Companion Lio/github/linreal/cascade/editor/richtext/FormattingState$Companion; + public synthetic fun (Ljava/util/Map;ZLjava/lang/String;ZLkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()Ljava/util/Map; + public final fun component2 ()Z + public final fun component3-ticUwL4 ()Ljava/lang/String; + public final fun component4 ()Z + public final fun copy-9Un3DiA (Ljava/util/Map;ZLjava/lang/String;Z)Lio/github/linreal/cascade/editor/richtext/FormattingState; + public static synthetic fun copy-9Un3DiA$default (Lio/github/linreal/cascade/editor/richtext/FormattingState;Ljava/util/Map;ZLjava/lang/String;ZILjava/lang/Object;)Lio/github/linreal/cascade/editor/richtext/FormattingState; + public fun equals (Ljava/lang/Object;)Z + public final fun getCanFormat ()Z + public final fun getFocusedBlockId-ticUwL4 ()Ljava/lang/String; + public final fun getSelectionCollapsed ()Z + public final fun getStyles ()Ljava/util/Map; + public fun hashCode ()I + public final fun styleStatusOf (Lio/github/linreal/cascade/editor/core/SpanStyle;)Lio/github/linreal/cascade/editor/richtext/StyleStatus; + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/richtext/FormattingState$Companion { + public final fun getEmpty ()Lio/github/linreal/cascade/editor/richtext/FormattingState; +} + +public final class io/github/linreal/cascade/editor/richtext/LinkActionDispatcher : io/github/linreal/cascade/editor/richtext/LinkActions { + public static final field $stable I + public fun (Lkotlin/jvm/functions/Function1;Lio/github/linreal/cascade/editor/state/BlockTextStates;Lio/github/linreal/cascade/editor/state/BlockSpanStates;Lio/github/linreal/cascade/editor/state/EditorStateHolder;)V + public synthetic fun (Lkotlin/jvm/functions/Function1;Lio/github/linreal/cascade/editor/state/BlockTextStates;Lio/github/linreal/cascade/editor/state/BlockSpanStates;Lio/github/linreal/cascade/editor/state/EditorStateHolder;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public fun applyLink (Lio/github/linreal/cascade/editor/richtext/LinkTarget;Ljava/lang/String;Ljava/lang/String;)Lio/github/linreal/cascade/editor/richtext/LinkValidationResult; + public fun removeLink (Lio/github/linreal/cascade/editor/richtext/LinkTarget;)V +} + +public abstract interface class io/github/linreal/cascade/editor/richtext/LinkActions { + public abstract fun applyLink (Lio/github/linreal/cascade/editor/richtext/LinkTarget;Ljava/lang/String;Ljava/lang/String;)Lio/github/linreal/cascade/editor/richtext/LinkValidationResult; + public static synthetic fun applyLink$default (Lio/github/linreal/cascade/editor/richtext/LinkActions;Lio/github/linreal/cascade/editor/richtext/LinkTarget;Ljava/lang/String;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/richtext/LinkValidationResult; + public abstract fun removeLink (Lio/github/linreal/cascade/editor/richtext/LinkTarget;)V +} + +public final class io/github/linreal/cascade/editor/richtext/LinkActions$DefaultImpls { + public static synthetic fun applyLink$default (Lio/github/linreal/cascade/editor/richtext/LinkActions;Lio/github/linreal/cascade/editor/richtext/LinkTarget;Ljava/lang/String;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/richtext/LinkValidationResult; +} + +public abstract interface class io/github/linreal/cascade/editor/richtext/LinkChromeActions : io/github/linreal/cascade/editor/richtext/LinkActions { + public fun applyLinkAtCurrentTarget (Ljava/lang/String;Ljava/lang/String;)Lio/github/linreal/cascade/editor/richtext/LinkValidationResult; + public static synthetic fun applyLinkAtCurrentTarget$default (Lio/github/linreal/cascade/editor/richtext/LinkChromeActions;Ljava/lang/String;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/richtext/LinkValidationResult; + public abstract fun currentTarget ()Lio/github/linreal/cascade/editor/richtext/LinkTarget; + public fun removeLinkAtCurrentTarget ()V +} + +public final class io/github/linreal/cascade/editor/richtext/LinkChromeActions$DefaultImpls { + public static fun applyLinkAtCurrentTarget (Lio/github/linreal/cascade/editor/richtext/LinkChromeActions;Ljava/lang/String;Ljava/lang/String;)Lio/github/linreal/cascade/editor/richtext/LinkValidationResult; + public static synthetic fun applyLinkAtCurrentTarget$default (Lio/github/linreal/cascade/editor/richtext/LinkChromeActions;Ljava/lang/String;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/richtext/LinkValidationResult; + public static fun removeLinkAtCurrentTarget (Lio/github/linreal/cascade/editor/richtext/LinkChromeActions;)V +} + +public final class io/github/linreal/cascade/editor/richtext/LinkState { + public static final field $stable I + public static final field Companion Lio/github/linreal/cascade/editor/richtext/LinkState$Companion; + public synthetic fun (ZLjava/lang/String;Lio/github/linreal/cascade/editor/richtext/LinkTarget;Ljava/lang/String;ZLjava/lang/String;Lio/github/linreal/cascade/editor/richtext/LinkTarget;Ljava/lang/String;ZZLkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()Z + public final fun component10 ()Z + public final fun component2-ticUwL4 ()Ljava/lang/String; + public final fun component3 ()Lio/github/linreal/cascade/editor/richtext/LinkTarget; + public final fun component4 ()Ljava/lang/String; + public final fun component5 ()Z + public final fun component6 ()Ljava/lang/String; + public final fun component7 ()Lio/github/linreal/cascade/editor/richtext/LinkTarget; + public final fun component8 ()Ljava/lang/String; + public final fun component9 ()Z + public final fun copy-5-aqPgk (ZLjava/lang/String;Lio/github/linreal/cascade/editor/richtext/LinkTarget;Ljava/lang/String;ZLjava/lang/String;Lio/github/linreal/cascade/editor/richtext/LinkTarget;Ljava/lang/String;ZZ)Lio/github/linreal/cascade/editor/richtext/LinkState; + public static synthetic fun copy-5-aqPgk$default (Lio/github/linreal/cascade/editor/richtext/LinkState;ZLjava/lang/String;Lio/github/linreal/cascade/editor/richtext/LinkTarget;Ljava/lang/String;ZLjava/lang/String;Lio/github/linreal/cascade/editor/richtext/LinkTarget;Ljava/lang/String;ZZILjava/lang/Object;)Lio/github/linreal/cascade/editor/richtext/LinkState; + public fun equals (Ljava/lang/Object;)Z + public final fun getCanLink ()Z + public final fun getExistingLinkRange ()Lio/github/linreal/cascade/editor/richtext/LinkTarget; + public final fun getExistingLinkText ()Ljava/lang/String; + public final fun getExistingUrl ()Ljava/lang/String; + public final fun getFocusedBlockId-ticUwL4 ()Ljava/lang/String; + public final fun getIntersectsLink ()Z + public final fun getSelectionCollapsed ()Z + public final fun getTarget ()Lio/github/linreal/cascade/editor/richtext/LinkTarget; + public final fun getTargetText ()Ljava/lang/String; + public fun hashCode ()I + public final fun isInsideLink ()Z + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/richtext/LinkState$Companion { + public final fun getEmpty ()Lio/github/linreal/cascade/editor/richtext/LinkState; +} + +public final class io/github/linreal/cascade/editor/richtext/LinkTarget { + public static final field $stable I + public synthetic fun (Ljava/lang/String;IILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1--4CzayM ()Ljava/lang/String; + public final fun component2 ()I + public final fun component3 ()I + public final fun copy-p1zP0qE (Ljava/lang/String;II)Lio/github/linreal/cascade/editor/richtext/LinkTarget; + public static synthetic fun copy-p1zP0qE$default (Lio/github/linreal/cascade/editor/richtext/LinkTarget;Ljava/lang/String;IIILjava/lang/Object;)Lio/github/linreal/cascade/editor/richtext/LinkTarget; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlockId--4CzayM ()Ljava/lang/String; + public final fun getNormalizedEnd ()I + public final fun getNormalizedStart ()I + public final fun getRangeEnd ()I + public final fun getRangeStart ()I + public fun hashCode ()I + public final fun isCollapsed ()Z + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/richtext/LinkUrlPolicy { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/richtext/LinkUrlPolicy; + public final fun validate (Ljava/lang/String;)Lio/github/linreal/cascade/editor/richtext/LinkValidationResult; +} + +public final class io/github/linreal/cascade/editor/richtext/LinkValidationError : java/lang/Enum { + public static final field Blank Lio/github/linreal/cascade/editor/richtext/LinkValidationError; + public static fun getEntries ()Lkotlin/enums/EnumEntries; + public static fun valueOf (Ljava/lang/String;)Lio/github/linreal/cascade/editor/richtext/LinkValidationError; + public static fun values ()[Lio/github/linreal/cascade/editor/richtext/LinkValidationError; +} + +public abstract interface class io/github/linreal/cascade/editor/richtext/LinkValidationResult { + public abstract fun getError ()Lio/github/linreal/cascade/editor/richtext/LinkValidationError; + public abstract fun getNormalizedUrl ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/richtext/LinkValidationResult$Invalid : io/github/linreal/cascade/editor/richtext/LinkValidationResult { + public static final field $stable I + public fun (Lio/github/linreal/cascade/editor/richtext/LinkValidationError;)V + public final fun component1 ()Lio/github/linreal/cascade/editor/richtext/LinkValidationError; + public final fun copy (Lio/github/linreal/cascade/editor/richtext/LinkValidationError;)Lio/github/linreal/cascade/editor/richtext/LinkValidationResult$Invalid; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/richtext/LinkValidationResult$Invalid;Lio/github/linreal/cascade/editor/richtext/LinkValidationError;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/richtext/LinkValidationResult$Invalid; + public fun equals (Ljava/lang/Object;)Z + public fun getError ()Lio/github/linreal/cascade/editor/richtext/LinkValidationError; + public fun getNormalizedUrl ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/richtext/LinkValidationResult$Valid : io/github/linreal/cascade/editor/richtext/LinkValidationResult { + public static final field $stable I + public fun (Ljava/lang/String;)V + public final fun component1 ()Ljava/lang/String; + public final fun copy (Ljava/lang/String;)Lio/github/linreal/cascade/editor/richtext/LinkValidationResult$Valid; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/richtext/LinkValidationResult$Valid;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/richtext/LinkValidationResult$Valid; + public fun equals (Ljava/lang/Object;)Z + public fun getError ()Lio/github/linreal/cascade/editor/richtext/LinkValidationError; + public fun getNormalizedUrl ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/richtext/SpanActionDispatcher { + public static final field $stable I + public fun (Lkotlin/jvm/functions/Function1;Lio/github/linreal/cascade/editor/state/BlockTextStates;Lio/github/linreal/cascade/editor/state/BlockSpanStates;Lio/github/linreal/cascade/editor/state/EditorStateHolder;)V + public synthetic fun (Lkotlin/jvm/functions/Function1;Lio/github/linreal/cascade/editor/state/BlockTextStates;Lio/github/linreal/cascade/editor/state/BlockSpanStates;Lio/github/linreal/cascade/editor/state/EditorStateHolder;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun applyStyle-PeeSg0I (Ljava/lang/String;IILio/github/linreal/cascade/editor/core/SpanStyle;)V + public final fun removeStyle-PeeSg0I (Ljava/lang/String;IILio/github/linreal/cascade/editor/core/SpanStyle;)V + public final fun toggleStyle-PeeSg0I (Ljava/lang/String;IILio/github/linreal/cascade/editor/core/SpanStyle;)V +} + +public final class io/github/linreal/cascade/editor/richtext/StyleStatus : java/lang/Enum { + public static final field Absent Lio/github/linreal/cascade/editor/richtext/StyleStatus; + public static final field FullyActive Lio/github/linreal/cascade/editor/richtext/StyleStatus; + public static final field Partial Lio/github/linreal/cascade/editor/richtext/StyleStatus; + public static fun getEntries ()Lkotlin/enums/EnumEntries; + public static fun valueOf (Ljava/lang/String;)Lio/github/linreal/cascade/editor/richtext/StyleStatus; + public static fun values ()[Lio/github/linreal/cascade/editor/richtext/StyleStatus; +} + +public abstract interface class io/github/linreal/cascade/editor/serialization/BlockContentCodec { + public abstract fun decodeContent (Ljava/lang/String;Lkotlinx/serialization/json/JsonObject;)Lio/github/linreal/cascade/editor/core/BlockContent; + public abstract fun encodeContent (Lio/github/linreal/cascade/editor/core/BlockContent;)Lkotlinx/serialization/json/JsonObject; +} + +public final class io/github/linreal/cascade/editor/serialization/BlockIdMode : java/lang/Enum { + public static final field Preserve Lio/github/linreal/cascade/editor/serialization/BlockIdMode; + public static final field Regenerate Lio/github/linreal/cascade/editor/serialization/BlockIdMode; + public static fun getEntries ()Lkotlin/enums/EnumEntries; + public static fun valueOf (Ljava/lang/String;)Lio/github/linreal/cascade/editor/serialization/BlockIdMode; + public static fun values ()[Lio/github/linreal/cascade/editor/serialization/BlockIdMode; +} + +public abstract interface class io/github/linreal/cascade/editor/serialization/BlockTypeCodec { + public abstract fun decodeType (Ljava/lang/String;Lkotlinx/serialization/json/JsonObject;)Lio/github/linreal/cascade/editor/core/BlockType; + public abstract fun encodeType (Lio/github/linreal/cascade/editor/core/BlockType;)Lkotlinx/serialization/json/JsonObject; +} + +public final class io/github/linreal/cascade/editor/serialization/CustomDataMode : java/lang/Enum { + public static final field LenientSkipUnsupported Lio/github/linreal/cascade/editor/serialization/CustomDataMode; + public static final field Strict Lio/github/linreal/cascade/editor/serialization/CustomDataMode; + public static fun getEntries ()Lkotlin/enums/EnumEntries; + public static fun valueOf (Ljava/lang/String;)Lio/github/linreal/cascade/editor/serialization/CustomDataMode; + public static fun values ()[Lio/github/linreal/cascade/editor/serialization/CustomDataMode; +} + +public final class io/github/linreal/cascade/editor/serialization/DocumentDecodeOptions { + public static final field $stable I + public fun ()V + public fun (Lio/github/linreal/cascade/editor/serialization/BlockIdMode;Lio/github/linreal/cascade/editor/serialization/DuplicateIdMode;)V + public synthetic fun (Lio/github/linreal/cascade/editor/serialization/BlockIdMode;Lio/github/linreal/cascade/editor/serialization/DuplicateIdMode;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()Lio/github/linreal/cascade/editor/serialization/BlockIdMode; + public final fun component2 ()Lio/github/linreal/cascade/editor/serialization/DuplicateIdMode; + public final fun copy (Lio/github/linreal/cascade/editor/serialization/BlockIdMode;Lio/github/linreal/cascade/editor/serialization/DuplicateIdMode;)Lio/github/linreal/cascade/editor/serialization/DocumentDecodeOptions; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/serialization/DocumentDecodeOptions;Lio/github/linreal/cascade/editor/serialization/BlockIdMode;Lio/github/linreal/cascade/editor/serialization/DuplicateIdMode;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/serialization/DocumentDecodeOptions; + public fun equals (Ljava/lang/Object;)Z + public final fun getDuplicateIdMode ()Lio/github/linreal/cascade/editor/serialization/DuplicateIdMode; + public final fun getIdMode ()Lio/github/linreal/cascade/editor/serialization/BlockIdMode; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/serialization/DocumentDecodeResult { + public static final field $stable I + public fun (Ljava/util/List;Ljava/util/List;)V + public final fun component1 ()Ljava/util/List; + public final fun component2 ()Ljava/util/List; + public final fun copy (Ljava/util/List;Ljava/util/List;)Lio/github/linreal/cascade/editor/serialization/DocumentDecodeResult; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/serialization/DocumentDecodeResult;Ljava/util/List;Ljava/util/List;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/serialization/DocumentDecodeResult; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlocks ()Ljava/util/List; + public final fun getWarnings ()Ljava/util/List; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public abstract class io/github/linreal/cascade/editor/serialization/DocumentDecodeWarning { + public static final field $stable I +} + +public final class io/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$DocumentParseFailed : io/github/linreal/cascade/editor/serialization/DocumentDecodeWarning { + public static final field $stable I + public fun (Ljava/lang/String;)V + public final fun component1 ()Ljava/lang/String; + public final fun copy (Ljava/lang/String;)Lio/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$DocumentParseFailed; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$DocumentParseFailed;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$DocumentParseFailed; + public fun equals (Ljava/lang/Object;)Z + public final fun getReason ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$DuplicateIdRegenerated : io/github/linreal/cascade/editor/serialization/DocumentDecodeWarning { + public static final field $stable I + public fun (ILjava/lang/String;Ljava/lang/String;)V + public final fun component1 ()I + public final fun component2 ()Ljava/lang/String; + public final fun component3 ()Ljava/lang/String; + public final fun copy (ILjava/lang/String;Ljava/lang/String;)Lio/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$DuplicateIdRegenerated; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$DuplicateIdRegenerated;ILjava/lang/String;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$DuplicateIdRegenerated; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlockIndex ()I + public final fun getNewId ()Ljava/lang/String; + public final fun getOriginalId ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$InvalidBlockAttributeParam : io/github/linreal/cascade/editor/serialization/DocumentDecodeWarning { + public static final field $stable I + public fun (ILjava/lang/String;Ljava/lang/String;)V + public final fun component1 ()I + public final fun component2 ()Ljava/lang/String; + public final fun component3 ()Ljava/lang/String; + public final fun copy (ILjava/lang/String;Ljava/lang/String;)Lio/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$InvalidBlockAttributeParam; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$InvalidBlockAttributeParam;ILjava/lang/String;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$InvalidBlockAttributeParam; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlockIndex ()I + public final fun getFallback ()Ljava/lang/String; + public final fun getParam ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$InvalidBlockTypeParam : io/github/linreal/cascade/editor/serialization/DocumentDecodeWarning { + public static final field $stable I + public fun (ILjava/lang/String;Ljava/lang/String;Ljava/lang/String;)V + public final fun component1 ()I + public final fun component2 ()Ljava/lang/String; + public final fun component3 ()Ljava/lang/String; + public final fun component4 ()Ljava/lang/String; + public final fun copy (ILjava/lang/String;Ljava/lang/String;Ljava/lang/String;)Lio/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$InvalidBlockTypeParam; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$InvalidBlockTypeParam;ILjava/lang/String;Ljava/lang/String;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$InvalidBlockTypeParam; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlockIndex ()I + public final fun getFallback ()Ljava/lang/String; + public final fun getParam ()Ljava/lang/String; + public final fun getTypeId ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$MalformedBlockSkipped : io/github/linreal/cascade/editor/serialization/DocumentDecodeWarning { + public static final field $stable I + public fun (ILjava/lang/String;)V + public final fun component1 ()I + public final fun component2 ()Ljava/lang/String; + public final fun copy (ILjava/lang/String;)Lio/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$MalformedBlockSkipped; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$MalformedBlockSkipped;ILjava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$MalformedBlockSkipped; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlockIndex ()I + public final fun getReason ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$MissingIdRegenerated : io/github/linreal/cascade/editor/serialization/DocumentDecodeWarning { + public static final field $stable I + public fun (I)V + public final fun component1 ()I + public final fun copy (I)Lio/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$MissingIdRegenerated; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$MissingIdRegenerated;IILjava/lang/Object;)Lio/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$MissingIdRegenerated; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlockIndex ()I + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$UnknownBlockTypePreserved : io/github/linreal/cascade/editor/serialization/DocumentDecodeWarning { + public static final field $stable I + public fun (ILjava/lang/String;)V + public final fun component1 ()I + public final fun component2 ()Ljava/lang/String; + public final fun copy (ILjava/lang/String;)Lio/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$UnknownBlockTypePreserved; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$UnknownBlockTypePreserved;ILjava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$UnknownBlockTypePreserved; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlockIndex ()I + public final fun getTypeId ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$UnknownContentKind : io/github/linreal/cascade/editor/serialization/DocumentDecodeWarning { + public static final field $stable I + public fun (ILjava/lang/String;)V + public final fun component1 ()I + public final fun component2 ()Ljava/lang/String; + public final fun copy (ILjava/lang/String;)Lio/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$UnknownContentKind; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$UnknownContentKind;ILjava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$UnknownContentKind; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlockIndex ()I + public final fun getKind ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$UnsupportedCustomDataDropped : io/github/linreal/cascade/editor/serialization/DocumentDecodeWarning { + public static final field $stable I + public fun (ILjava/lang/String;Ljava/lang/String;)V + public final fun component1 ()I + public final fun component2 ()Ljava/lang/String; + public final fun component3 ()Ljava/lang/String; + public final fun copy (ILjava/lang/String;Ljava/lang/String;)Lio/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$UnsupportedCustomDataDropped; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$UnsupportedCustomDataDropped;ILjava/lang/String;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/serialization/DocumentDecodeWarning$UnsupportedCustomDataDropped; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlockIndex ()I + public final fun getKey ()Ljava/lang/String; + public final fun getValueType ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/serialization/DocumentEncodeOptions { + public static final field $stable I + public fun ()V + public fun (Lio/github/linreal/cascade/editor/serialization/CustomDataMode;)V + public synthetic fun (Lio/github/linreal/cascade/editor/serialization/CustomDataMode;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()Lio/github/linreal/cascade/editor/serialization/CustomDataMode; + public final fun copy (Lio/github/linreal/cascade/editor/serialization/CustomDataMode;)Lio/github/linreal/cascade/editor/serialization/DocumentEncodeOptions; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/serialization/DocumentEncodeOptions;Lio/github/linreal/cascade/editor/serialization/CustomDataMode;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/serialization/DocumentEncodeOptions; + public fun equals (Ljava/lang/Object;)Z + public final fun getCustomDataMode ()Lio/github/linreal/cascade/editor/serialization/CustomDataMode; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/serialization/DocumentSchema { + public static final field $stable I + public static final field CURRENT_VERSION I + public static final field INSTANCE Lio/github/linreal/cascade/editor/serialization/DocumentSchema; + public final fun decode (Lkotlinx/serialization/json/JsonObject;Lio/github/linreal/cascade/editor/serialization/DocumentDecodeOptions;Lio/github/linreal/cascade/editor/serialization/BlockTypeCodec;Lio/github/linreal/cascade/editor/serialization/BlockContentCodec;)Ljava/util/List; + public static synthetic fun decode$default (Lio/github/linreal/cascade/editor/serialization/DocumentSchema;Lkotlinx/serialization/json/JsonObject;Lio/github/linreal/cascade/editor/serialization/DocumentDecodeOptions;Lio/github/linreal/cascade/editor/serialization/BlockTypeCodec;Lio/github/linreal/cascade/editor/serialization/BlockContentCodec;ILjava/lang/Object;)Ljava/util/List; + public final fun decodeFromString (Ljava/lang/String;Lio/github/linreal/cascade/editor/serialization/DocumentDecodeOptions;Lio/github/linreal/cascade/editor/serialization/BlockTypeCodec;Lio/github/linreal/cascade/editor/serialization/BlockContentCodec;)Ljava/util/List; + public static synthetic fun decodeFromString$default (Lio/github/linreal/cascade/editor/serialization/DocumentSchema;Ljava/lang/String;Lio/github/linreal/cascade/editor/serialization/DocumentDecodeOptions;Lio/github/linreal/cascade/editor/serialization/BlockTypeCodec;Lio/github/linreal/cascade/editor/serialization/BlockContentCodec;ILjava/lang/Object;)Ljava/util/List; + public final fun decodeFromStringWithReport (Ljava/lang/String;Lio/github/linreal/cascade/editor/serialization/DocumentDecodeOptions;Lio/github/linreal/cascade/editor/serialization/BlockTypeCodec;Lio/github/linreal/cascade/editor/serialization/BlockContentCodec;)Lio/github/linreal/cascade/editor/serialization/DocumentDecodeResult; + public static synthetic fun decodeFromStringWithReport$default (Lio/github/linreal/cascade/editor/serialization/DocumentSchema;Ljava/lang/String;Lio/github/linreal/cascade/editor/serialization/DocumentDecodeOptions;Lio/github/linreal/cascade/editor/serialization/BlockTypeCodec;Lio/github/linreal/cascade/editor/serialization/BlockContentCodec;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/serialization/DocumentDecodeResult; + public final fun decodeWithReport (Lkotlinx/serialization/json/JsonObject;Lio/github/linreal/cascade/editor/serialization/DocumentDecodeOptions;Lio/github/linreal/cascade/editor/serialization/BlockTypeCodec;Lio/github/linreal/cascade/editor/serialization/BlockContentCodec;)Lio/github/linreal/cascade/editor/serialization/DocumentDecodeResult; + public static synthetic fun decodeWithReport$default (Lio/github/linreal/cascade/editor/serialization/DocumentSchema;Lkotlinx/serialization/json/JsonObject;Lio/github/linreal/cascade/editor/serialization/DocumentDecodeOptions;Lio/github/linreal/cascade/editor/serialization/BlockTypeCodec;Lio/github/linreal/cascade/editor/serialization/BlockContentCodec;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/serialization/DocumentDecodeResult; + public final fun encode (Ljava/util/List;Lio/github/linreal/cascade/editor/serialization/DocumentEncodeOptions;Lio/github/linreal/cascade/editor/serialization/BlockTypeCodec;Lio/github/linreal/cascade/editor/serialization/BlockContentCodec;)Lkotlinx/serialization/json/JsonObject; + public static synthetic fun encode$default (Lio/github/linreal/cascade/editor/serialization/DocumentSchema;Ljava/util/List;Lio/github/linreal/cascade/editor/serialization/DocumentEncodeOptions;Lio/github/linreal/cascade/editor/serialization/BlockTypeCodec;Lio/github/linreal/cascade/editor/serialization/BlockContentCodec;ILjava/lang/Object;)Lkotlinx/serialization/json/JsonObject; + public final fun encodeToString (Ljava/util/List;Lio/github/linreal/cascade/editor/serialization/DocumentEncodeOptions;Lio/github/linreal/cascade/editor/serialization/BlockTypeCodec;Lio/github/linreal/cascade/editor/serialization/BlockContentCodec;)Ljava/lang/String; + public static synthetic fun encodeToString$default (Lio/github/linreal/cascade/editor/serialization/DocumentSchema;Ljava/util/List;Lio/github/linreal/cascade/editor/serialization/DocumentEncodeOptions;Lio/github/linreal/cascade/editor/serialization/BlockTypeCodec;Lio/github/linreal/cascade/editor/serialization/BlockContentCodec;ILjava/lang/Object;)Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/serialization/DocumentSerializationExtKt { + public static final fun loadFromJson (Lio/github/linreal/cascade/editor/state/EditorStateHolder;Ljava/lang/String;Lio/github/linreal/cascade/editor/state/BlockTextStates;Lio/github/linreal/cascade/editor/state/BlockSpanStates;Lio/github/linreal/cascade/editor/serialization/DocumentDecodeOptions;Lio/github/linreal/cascade/editor/serialization/BlockTypeCodec;Lio/github/linreal/cascade/editor/serialization/BlockContentCodec;)Lio/github/linreal/cascade/editor/serialization/DocumentDecodeResult; + public static synthetic fun loadFromJson$default (Lio/github/linreal/cascade/editor/state/EditorStateHolder;Ljava/lang/String;Lio/github/linreal/cascade/editor/state/BlockTextStates;Lio/github/linreal/cascade/editor/state/BlockSpanStates;Lio/github/linreal/cascade/editor/serialization/DocumentDecodeOptions;Lio/github/linreal/cascade/editor/serialization/BlockTypeCodec;Lio/github/linreal/cascade/editor/serialization/BlockContentCodec;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/serialization/DocumentDecodeResult; + public static final fun resolveDocumentBlocks (Lio/github/linreal/cascade/editor/state/EditorStateHolder;Lio/github/linreal/cascade/editor/state/BlockTextStates;Lio/github/linreal/cascade/editor/state/BlockSpanStates;)Ljava/util/List; + public static final fun toJson (Lio/github/linreal/cascade/editor/state/EditorStateHolder;Lio/github/linreal/cascade/editor/state/BlockTextStates;Lio/github/linreal/cascade/editor/state/BlockSpanStates;Lio/github/linreal/cascade/editor/serialization/DocumentEncodeOptions;Lio/github/linreal/cascade/editor/serialization/BlockTypeCodec;Lio/github/linreal/cascade/editor/serialization/BlockContentCodec;)Ljava/lang/String; + public static synthetic fun toJson$default (Lio/github/linreal/cascade/editor/state/EditorStateHolder;Lio/github/linreal/cascade/editor/state/BlockTextStates;Lio/github/linreal/cascade/editor/state/BlockSpanStates;Lio/github/linreal/cascade/editor/serialization/DocumentEncodeOptions;Lio/github/linreal/cascade/editor/serialization/BlockTypeCodec;Lio/github/linreal/cascade/editor/serialization/BlockContentCodec;ILjava/lang/Object;)Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/serialization/DuplicateIdMode : java/lang/Enum { + public static final field FailFast Lio/github/linreal/cascade/editor/serialization/DuplicateIdMode; + public static final field RegenerateLaterDuplicates Lio/github/linreal/cascade/editor/serialization/DuplicateIdMode; + public static fun getEntries ()Lkotlin/enums/EnumEntries; + public static fun valueOf (Ljava/lang/String;)Lio/github/linreal/cascade/editor/serialization/DuplicateIdMode; + public static fun values ()[Lio/github/linreal/cascade/editor/serialization/DuplicateIdMode; +} + +public final class io/github/linreal/cascade/editor/serialization/RichTextSchema { + public static final field $stable I + public static final field CURRENT_VERSION I + public static final field INSTANCE Lio/github/linreal/cascade/editor/serialization/RichTextSchema; + public final fun decode (Lkotlinx/serialization/json/JsonObject;)Lio/github/linreal/cascade/editor/core/BlockContent$Text; + public final fun decodeFromString (Ljava/lang/String;)Lio/github/linreal/cascade/editor/core/BlockContent$Text; + public final fun encode (Lio/github/linreal/cascade/editor/core/BlockContent$Text;)Lkotlinx/serialization/json/JsonObject; + public final fun encodeToString (Lio/github/linreal/cascade/editor/core/BlockContent$Text;)Ljava/lang/String; +} + +public abstract interface class io/github/linreal/cascade/editor/slash/BuiltInBlockSlashBehavior { +} + +public final class io/github/linreal/cascade/editor/slash/BuiltInBlockSlashBehavior$AlwaysInsert : io/github/linreal/cascade/editor/slash/BuiltInBlockSlashBehavior { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/slash/BuiltInBlockSlashBehavior$AlwaysInsert; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/slash/BuiltInBlockSlashBehavior$ConvertInPlace : io/github/linreal/cascade/editor/slash/BuiltInBlockSlashBehavior { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/slash/BuiltInBlockSlashBehavior$ConvertInPlace; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/slash/BuiltInSlashCommandFactoryKt { + public static final field BUILTIN_BLOCK_SLASH_COMMAND_ID_PREFIX Ljava/lang/String; + public static final fun builtInBlockSlashCommandId (Ljava/lang/String;)Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/slash/BuiltInSlashCommandSpec { + public static final field $stable I + public synthetic fun (Lio/github/linreal/cascade/editor/slash/BuiltInBlockSlashBehavior;Ljava/lang/String;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public synthetic fun (Lio/github/linreal/cascade/editor/slash/BuiltInBlockSlashBehavior;Ljava/lang/String;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()Lio/github/linreal/cascade/editor/slash/BuiltInBlockSlashBehavior; + public final fun component2--0eK1zE ()Ljava/lang/String; + public final fun copy-G7SjZIA (Lio/github/linreal/cascade/editor/slash/BuiltInBlockSlashBehavior;Ljava/lang/String;)Lio/github/linreal/cascade/editor/slash/BuiltInSlashCommandSpec; + public static synthetic fun copy-G7SjZIA$default (Lio/github/linreal/cascade/editor/slash/BuiltInSlashCommandSpec;Lio/github/linreal/cascade/editor/slash/BuiltInBlockSlashBehavior;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/slash/BuiltInSlashCommandSpec; + public fun equals (Ljava/lang/Object;)Z + public final fun getBehavior ()Lio/github/linreal/cascade/editor/slash/BuiltInBlockSlashBehavior; + public final fun getIcon--0eK1zE ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/slash/SlashCommandAction : io/github/linreal/cascade/editor/slash/SlashCommandItem { + public static final field $stable I + public synthetic fun (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/util/List;Ljava/lang/String;Lio/github/linreal/cascade/editor/slash/SlashQueryTextPolicy;Lkotlin/jvm/functions/Function2;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public synthetic fun (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/util/List;Ljava/lang/String;Lio/github/linreal/cascade/editor/slash/SlashQueryTextPolicy;Lkotlin/jvm/functions/Function2;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1-6BJIqV4 ()Ljava/lang/String; + public final fun component2 ()Ljava/lang/String; + public final fun component3 ()Ljava/lang/String; + public final fun component4 ()Ljava/util/List; + public final fun component5--0eK1zE ()Ljava/lang/String; + public final fun component6 ()Lio/github/linreal/cascade/editor/slash/SlashQueryTextPolicy; + public final fun component7 ()Lkotlin/jvm/functions/Function2; + public final fun copy-vcqtq9w (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/util/List;Ljava/lang/String;Lio/github/linreal/cascade/editor/slash/SlashQueryTextPolicy;Lkotlin/jvm/functions/Function2;)Lio/github/linreal/cascade/editor/slash/SlashCommandAction; + public static synthetic fun copy-vcqtq9w$default (Lio/github/linreal/cascade/editor/slash/SlashCommandAction;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/util/List;Ljava/lang/String;Lio/github/linreal/cascade/editor/slash/SlashQueryTextPolicy;Lkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/slash/SlashCommandAction; + public fun equals (Ljava/lang/Object;)Z + public fun getDescription ()Ljava/lang/String; + public fun getIcon--0eK1zE ()Ljava/lang/String; + public fun getId-6BJIqV4 ()Ljava/lang/String; + public fun getKeywords ()Ljava/util/List; + public final fun getOnExecute ()Lkotlin/jvm/functions/Function2; + public final fun getQueryTextPolicy ()Lio/github/linreal/cascade/editor/slash/SlashQueryTextPolicy; + public fun getTitle ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/slash/SlashCommandContext { + public static final field $stable I + public synthetic fun (Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/state/SlashQueryRange;Lio/github/linreal/cascade/editor/slash/SlashCommandEditor;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1--4CzayM ()Ljava/lang/String; + public final fun component2 ()Ljava/lang/String; + public final fun component3 ()Lio/github/linreal/cascade/editor/state/SlashQueryRange; + public final fun component4 ()Lio/github/linreal/cascade/editor/slash/SlashCommandEditor; + public final fun copy-PeeSg0I (Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/state/SlashQueryRange;Lio/github/linreal/cascade/editor/slash/SlashCommandEditor;)Lio/github/linreal/cascade/editor/slash/SlashCommandContext; + public static synthetic fun copy-PeeSg0I$default (Lio/github/linreal/cascade/editor/slash/SlashCommandContext;Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/state/SlashQueryRange;Lio/github/linreal/cascade/editor/slash/SlashCommandEditor;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/slash/SlashCommandContext; + public fun equals (Ljava/lang/Object;)Z + public final fun getAnchorBlockId--4CzayM ()Ljava/lang/String; + public final fun getEditor ()Lio/github/linreal/cascade/editor/slash/SlashCommandEditor; + public final fun getQuery ()Ljava/lang/String; + public final fun getQueryRange ()Lio/github/linreal/cascade/editor/state/SlashQueryRange; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public abstract interface class io/github/linreal/cascade/editor/slash/SlashCommandEditor { + public abstract fun closeMenu ()V + public abstract fun focusBlock-7OMXkl4 (Ljava/lang/String;Ljava/lang/Integer;)V + public static synthetic fun focusBlock-7OMXkl4$default (Lio/github/linreal/cascade/editor/slash/SlashCommandEditor;Ljava/lang/String;Ljava/lang/Integer;ILjava/lang/Object;)V + public abstract fun getAnchorBlock ()Lio/github/linreal/cascade/editor/core/Block; + public abstract fun getAnchorVisibleText ()Ljava/lang/String; + public abstract fun insertBlockAfterAnchor (Lio/github/linreal/cascade/editor/core/Block;ZLjava/lang/Integer;)V + public static synthetic fun insertBlockAfterAnchor$default (Lio/github/linreal/cascade/editor/slash/SlashCommandEditor;Lio/github/linreal/cascade/editor/core/Block;ZLjava/lang/Integer;ILjava/lang/Object;)V + public abstract fun insertBlockBeforeAnchor (Lio/github/linreal/cascade/editor/core/Block;)V + public abstract fun replaceAnchorBlock (Lio/github/linreal/cascade/editor/core/Block;ZZLjava/lang/Integer;)V + public static synthetic fun replaceAnchorBlock$default (Lio/github/linreal/cascade/editor/slash/SlashCommandEditor;Lio/github/linreal/cascade/editor/core/Block;ZZLjava/lang/Integer;ILjava/lang/Object;)V + public abstract fun replaceQueryText (Ljava/lang/String;)V + public static synthetic fun replaceQueryText$default (Lio/github/linreal/cascade/editor/slash/SlashCommandEditor;Ljava/lang/String;ILjava/lang/Object;)V + public abstract fun updateAnchorText (Ljava/lang/String;Ljava/lang/Integer;)V + public static synthetic fun updateAnchorText$default (Lio/github/linreal/cascade/editor/slash/SlashCommandEditor;Ljava/lang/String;Ljava/lang/Integer;ILjava/lang/Object;)V +} + +public final class io/github/linreal/cascade/editor/slash/SlashCommandEditor$DefaultImpls { + public static synthetic fun focusBlock-7OMXkl4$default (Lio/github/linreal/cascade/editor/slash/SlashCommandEditor;Ljava/lang/String;Ljava/lang/Integer;ILjava/lang/Object;)V + public static synthetic fun insertBlockAfterAnchor$default (Lio/github/linreal/cascade/editor/slash/SlashCommandEditor;Lio/github/linreal/cascade/editor/core/Block;ZLjava/lang/Integer;ILjava/lang/Object;)V + public static synthetic fun replaceAnchorBlock$default (Lio/github/linreal/cascade/editor/slash/SlashCommandEditor;Lio/github/linreal/cascade/editor/core/Block;ZZLjava/lang/Integer;ILjava/lang/Object;)V + public static synthetic fun replaceQueryText$default (Lio/github/linreal/cascade/editor/slash/SlashCommandEditor;Ljava/lang/String;ILjava/lang/Object;)V + public static synthetic fun updateAnchorText$default (Lio/github/linreal/cascade/editor/slash/SlashCommandEditor;Ljava/lang/String;Ljava/lang/Integer;ILjava/lang/Object;)V +} + +public final class io/github/linreal/cascade/editor/slash/SlashCommandIconKey { + public static final synthetic fun box-impl (Ljava/lang/String;)Lio/github/linreal/cascade/editor/slash/SlashCommandIconKey; + public static fun constructor-impl (Ljava/lang/String;)Ljava/lang/String; + public fun equals (Ljava/lang/Object;)Z + public static fun equals-impl (Ljava/lang/String;Ljava/lang/Object;)Z + public static final fun equals-impl0 (Ljava/lang/String;Ljava/lang/String;)Z + public final fun getValue ()Ljava/lang/String; + public fun hashCode ()I + public static fun hashCode-impl (Ljava/lang/String;)I + public fun toString ()Ljava/lang/String; + public static fun toString-impl (Ljava/lang/String;)Ljava/lang/String; + public final synthetic fun unbox-impl ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/slash/SlashCommandId { + public static final synthetic fun box-impl (Ljava/lang/String;)Lio/github/linreal/cascade/editor/slash/SlashCommandId; + public static fun constructor-impl (Ljava/lang/String;)Ljava/lang/String; + public fun equals (Ljava/lang/Object;)Z + public static fun equals-impl (Ljava/lang/String;Ljava/lang/Object;)Z + public static final fun equals-impl0 (Ljava/lang/String;Ljava/lang/String;)Z + public final fun getValue ()Ljava/lang/String; + public fun hashCode ()I + public static fun hashCode-impl (Ljava/lang/String;)I + public fun toString ()Ljava/lang/String; + public static fun toString-impl (Ljava/lang/String;)Ljava/lang/String; + public final synthetic fun unbox-impl ()Ljava/lang/String; +} + +public abstract interface class io/github/linreal/cascade/editor/slash/SlashCommandItem { + public abstract fun getDescription ()Ljava/lang/String; + public abstract fun getIcon--0eK1zE ()Ljava/lang/String; + public abstract fun getId-6BJIqV4 ()Ljava/lang/String; + public abstract fun getKeywords ()Ljava/util/List; + public abstract fun getTitle ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/slash/SlashCommandMenu : io/github/linreal/cascade/editor/slash/SlashCommandItem { + public static final field $stable I + public synthetic fun (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/util/List;Ljava/lang/String;Ljava/util/List;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public synthetic fun (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/util/List;Ljava/lang/String;Ljava/util/List;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1-6BJIqV4 ()Ljava/lang/String; + public final fun component2 ()Ljava/lang/String; + public final fun component3 ()Ljava/lang/String; + public final fun component4 ()Ljava/util/List; + public final fun component5--0eK1zE ()Ljava/lang/String; + public final fun component6 ()Ljava/util/List; + public final fun copy-q6iIFMo (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/util/List;Ljava/lang/String;Ljava/util/List;)Lio/github/linreal/cascade/editor/slash/SlashCommandMenu; + public static synthetic fun copy-q6iIFMo$default (Lio/github/linreal/cascade/editor/slash/SlashCommandMenu;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/util/List;Ljava/lang/String;Ljava/util/List;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/slash/SlashCommandMenu; + public fun equals (Ljava/lang/Object;)Z + public final fun getChildren ()Ljava/util/List; + public fun getDescription ()Ljava/lang/String; + public fun getIcon--0eK1zE ()Ljava/lang/String; + public fun getId-6BJIqV4 ()Ljava/lang/String; + public fun getKeywords ()Ljava/util/List; + public fun getTitle ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/slash/SlashCommandRegistry { + public static final field $stable I + public fun ()V + public final fun getRootItems ()Ljava/util/List; + public final fun register (Lio/github/linreal/cascade/editor/slash/SlashCommandItem;)V + public final fun search (Ljava/lang/String;Ljava/util/List;)Ljava/util/List; + public static synthetic fun search$default (Lio/github/linreal/cascade/editor/slash/SlashCommandRegistry;Ljava/lang/String;Ljava/util/List;ILjava/lang/Object;)Ljava/util/List; +} + +public abstract interface class io/github/linreal/cascade/editor/slash/SlashCommandResult { +} + +public final class io/github/linreal/cascade/editor/slash/SlashCommandResult$Done : io/github/linreal/cascade/editor/slash/SlashCommandResult { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/slash/SlashCommandResult$Done; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/slash/SlashCommandResult$Failure : io/github/linreal/cascade/editor/slash/SlashCommandResult { + public static final field $stable I + public fun ()V + public fun (Ljava/lang/String;)V + public synthetic fun (Ljava/lang/String;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()Ljava/lang/String; + public final fun copy (Ljava/lang/String;)Lio/github/linreal/cascade/editor/slash/SlashCommandResult$Failure; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/slash/SlashCommandResult$Failure;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/slash/SlashCommandResult$Failure; + public fun equals (Ljava/lang/Object;)Z + public final fun getMessage ()Ljava/lang/String; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/slash/SlashCommandResult$KeepOpen : io/github/linreal/cascade/editor/slash/SlashCommandResult { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/slash/SlashCommandResult$KeepOpen; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/slash/SlashQueryTextPolicy : java/lang/Enum { + public static final field KeepText Lio/github/linreal/cascade/editor/slash/SlashQueryTextPolicy; + public static final field RemoveBeforeExecute Lio/github/linreal/cascade/editor/slash/SlashQueryTextPolicy; + public static fun getEntries ()Lkotlin/enums/EnumEntries; + public static fun valueOf (Ljava/lang/String;)Lio/github/linreal/cascade/editor/slash/SlashQueryTextPolicy; + public static fun values ()[Lio/github/linreal/cascade/editor/slash/SlashQueryTextPolicy; +} + +public final class io/github/linreal/cascade/editor/state/BlockSpanStates { + public static final field $stable I + public fun ()V + public final fun activeStylesAt-7OMXkl4 (Ljava/lang/String;I)Ljava/util/Set; + public final fun adjustForRangeReplacement-PeeSg0I (Ljava/lang/String;III)V + public final fun adjustForUserEdit-PeeSg0I (Ljava/lang/String;III)V + public final fun applyStyle-aGoj3o0 (Ljava/lang/String;IILio/github/linreal/cascade/editor/core/SpanStyle;I)V + public final fun cleanup (Ljava/util/Set;)V + public final fun clear ()V + public final fun clearPendingStyles-SDe6QqM (Ljava/lang/String;)V + public final fun get-SDe6QqM (Ljava/lang/String;)Landroidx/compose/runtime/State; + public final fun getOrCreate-p1zP0qE (Ljava/lang/String;Ljava/util/List;I)Landroidx/compose/runtime/State; + public static synthetic fun getOrCreate-p1zP0qE$default (Lio/github/linreal/cascade/editor/state/BlockSpanStates;Ljava/lang/String;Ljava/util/List;IILjava/lang/Object;)Landroidx/compose/runtime/State; + public final fun getPendingStyles-SDe6QqM (Ljava/lang/String;)Ljava/util/Set; + public final fun getSpans-SDe6QqM (Ljava/lang/String;)Ljava/util/List; + public final fun mergeInto-S_bWWxk (Ljava/lang/String;Ljava/lang/String;I)V + public final fun queryStyleStatus-PeeSg0I (Ljava/lang/String;IILio/github/linreal/cascade/editor/core/SpanStyle;)Lio/github/linreal/cascade/editor/richtext/StyleStatus; + public final fun remove-SDe6QqM (Ljava/lang/String;)V + public final fun removeLinkSpans-p1zP0qE (Ljava/lang/String;II)V + public final fun removeStyle-PeeSg0I (Ljava/lang/String;IILio/github/linreal/cascade/editor/core/SpanStyle;)V + public final fun resolveStylesForInsertion-7OMXkl4 (Ljava/lang/String;I)Ljava/util/Set; + public final fun set-p1zP0qE (Ljava/lang/String;Ljava/util/List;I)V + public final fun setPendingStyles-7OMXkl4 (Ljava/lang/String;Ljava/util/Set;)V + public final fun split-S_bWWxk (Ljava/lang/String;Ljava/lang/String;I)V + public final fun toggleStyle-aGoj3o0 (Ljava/lang/String;IILio/github/linreal/cascade/editor/core/SpanStyle;I)V +} + +public final class io/github/linreal/cascade/editor/state/BlockTextStates { + public static final field $stable I + public fun ()V + public final fun cleanup (Ljava/util/Set;)V + public final fun clear ()V + public final fun consumeProgrammaticCommit-SDe6QqM (Ljava/lang/String;)Ljava/lang/String; + public final fun extractAllText ()Ljava/util/Map; + public final fun get-SDe6QqM (Ljava/lang/String;)Landroidx/compose/foundation/text/input/TextFieldState; + public final fun getOrCreate-p1zP0qE (Ljava/lang/String;Ljava/lang/String;I)Landroidx/compose/foundation/text/input/TextFieldState; + public static synthetic fun getOrCreate-p1zP0qE$default (Lio/github/linreal/cascade/editor/state/BlockTextStates;Ljava/lang/String;Ljava/lang/String;IILjava/lang/Object;)Landroidx/compose/foundation/text/input/TextFieldState; + public final fun getSelection-UXP-uLA (Ljava/lang/String;)Landroidx/compose/ui/text/TextRange; + public final fun getVisibleText-SDe6QqM (Ljava/lang/String;)Ljava/lang/String; + public final fun mergeInto-uwJGxUo (Ljava/lang/String;Ljava/lang/String;)Ljava/lang/Integer; + public final fun remove-SDe6QqM (Ljava/lang/String;)V + public final fun replaceVisibleRange-aGoj3o0 (Ljava/lang/String;IILjava/lang/String;Ljava/lang/Integer;)Ljava/lang/String; + public static synthetic fun replaceVisibleRange-aGoj3o0$default (Lio/github/linreal/cascade/editor/state/BlockTextStates;Ljava/lang/String;IILjava/lang/String;Ljava/lang/Integer;ILjava/lang/Object;)Ljava/lang/String; + public final fun setCursorPosition-7OMXkl4 (Ljava/lang/String;I)V + public final fun setSelection-5Jeh78Y (Ljava/lang/String;J)V + public final fun setText-p1zP0qE (Ljava/lang/String;Ljava/lang/String;Ljava/lang/Integer;)V + public static synthetic fun setText-p1zP0qE$default (Lio/github/linreal/cascade/editor/state/BlockTextStates;Ljava/lang/String;Ljava/lang/String;Ljava/lang/Integer;ILjava/lang/Object;)V +} + +public final class io/github/linreal/cascade/editor/state/DragState { + public static final field $stable I + public synthetic fun (Ljava/util/Set;Ljava/lang/Integer;FILjava/util/List;Ljava/util/List;Ljava/util/Set;Ljava/util/List;Ljava/util/Set;Ljava/util/List;Ljava/lang/String;ILjava/lang/Boolean;Ljava/util/Map;Ljava/util/Map;Ljava/util/Map;IILkotlin/jvm/internal/DefaultConstructorMarker;)V + public synthetic fun (Ljava/util/Set;Ljava/lang/Integer;FILjava/util/List;Ljava/util/List;Ljava/util/Set;Ljava/util/List;Ljava/util/Set;Ljava/util/List;Ljava/lang/String;ILjava/lang/Boolean;Ljava/util/Map;Ljava/util/Map;Ljava/util/Map;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()Ljava/util/Set; + public final fun component10 ()Ljava/util/List; + public final fun component11-ticUwL4 ()Ljava/lang/String; + public final fun component12 ()I + public final fun component13 ()Ljava/lang/Boolean; + public final fun component14 ()Ljava/util/Map; + public final fun component15 ()Ljava/util/Map; + public final fun component16 ()Ljava/util/Map; + public final fun component17 ()I + public final fun component2 ()Ljava/lang/Integer; + public final fun component3 ()F + public final fun component4 ()I + public final fun component5 ()Ljava/util/List; + public final fun component6 ()Ljava/util/List; + public final fun component7 ()Ljava/util/Set; + public final fun component8 ()Ljava/util/List; + public final fun component9 ()Ljava/util/Set; + public final fun copy-tU_prow (Ljava/util/Set;Ljava/lang/Integer;FILjava/util/List;Ljava/util/List;Ljava/util/Set;Ljava/util/List;Ljava/util/Set;Ljava/util/List;Ljava/lang/String;ILjava/lang/Boolean;Ljava/util/Map;Ljava/util/Map;Ljava/util/Map;I)Lio/github/linreal/cascade/editor/state/DragState; + public static synthetic fun copy-tU_prow$default (Lio/github/linreal/cascade/editor/state/DragState;Ljava/util/Set;Ljava/lang/Integer;FILjava/util/List;Ljava/util/List;Ljava/util/Set;Ljava/util/List;Ljava/util/Set;Ljava/util/List;Ljava/lang/String;ILjava/lang/Boolean;Ljava/util/Map;Ljava/util/Map;Ljava/util/Map;IILjava/lang/Object;)Lio/github/linreal/cascade/editor/state/DragState; + public fun equals (Ljava/lang/Object;)Z + public final fun getDragRootIds ()Ljava/util/List; + public final fun getDraggingBlockIds ()Ljava/util/Set; + public final fun getFutureRootIndentationLevel ()I + public final fun getInitialTouchOffsetY ()F + public final fun getOriginalRootIndentationLevels ()Ljava/util/Map; + public final fun getPayloadBlockIdSet ()Ljava/util/Set; + public final fun getPayloadBlockIds ()Ljava/util/List; + public final fun getPayloadBlockIndexSet ()Ljava/util/Set; + public final fun getPayloadBlockIndices ()Ljava/util/List; + public final fun getPayloadIndexRanges ()Ljava/util/List; + public final fun getPayloadRelativeDepthOffsets ()Ljava/util/Map; + public final fun getPayloadRootIdsByBlockId ()Ljava/util/Map; + public final fun getPrimaryBlockOriginalIndex ()I + public final fun getPrimaryRootId-ticUwL4 ()Ljava/lang/String; + public final fun getPrimaryRootOriginalIndex ()I + public final fun getPrimaryRootSupportsIndentation ()Ljava/lang/Boolean; + public final fun getTargetIndex ()Ljava/lang/Integer; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/state/EditorState { + public static final field $stable I + public static final field Companion Lio/github/linreal/cascade/editor/state/EditorState$Companion; + public synthetic fun (Ljava/util/List;Ljava/lang/String;Ljava/util/Set;Lio/github/linreal/cascade/editor/state/DragState;Lio/github/linreal/cascade/editor/state/SlashCommandState;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()Ljava/util/List; + public final fun component2-ticUwL4 ()Ljava/lang/String; + public final fun component3 ()Ljava/util/Set; + public final fun component4 ()Lio/github/linreal/cascade/editor/state/DragState; + public final fun component5 ()Lio/github/linreal/cascade/editor/state/SlashCommandState; + public final fun copy-KjmYf4Q (Ljava/util/List;Ljava/lang/String;Ljava/util/Set;Lio/github/linreal/cascade/editor/state/DragState;Lio/github/linreal/cascade/editor/state/SlashCommandState;)Lio/github/linreal/cascade/editor/state/EditorState; + public static synthetic fun copy-KjmYf4Q$default (Lio/github/linreal/cascade/editor/state/EditorState;Ljava/util/List;Ljava/lang/String;Ljava/util/Set;Lio/github/linreal/cascade/editor/state/DragState;Lio/github/linreal/cascade/editor/state/SlashCommandState;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/state/EditorState; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlock-SDe6QqM (Ljava/lang/String;)Lio/github/linreal/cascade/editor/core/Block; + public final fun getBlocks ()Ljava/util/List; + public final fun getDragState ()Lio/github/linreal/cascade/editor/state/DragState; + public final fun getFocusedBlock ()Lio/github/linreal/cascade/editor/core/Block; + public final fun getFocusedBlockId-ticUwL4 ()Ljava/lang/String; + public final fun getHasSelection ()Z + public final fun getHasSingleSelection ()Z + public final fun getSelectedBlockIds ()Ljava/util/Set; + public final fun getSelectedBlocks ()Ljava/util/List; + public final fun getSlashCommandState ()Lio/github/linreal/cascade/editor/state/SlashCommandState; + public fun hashCode ()I + public final fun indexOfBlock-SDe6QqM (Ljava/lang/String;)I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/state/EditorState$Companion { + public final fun getEmpty ()Lio/github/linreal/cascade/editor/state/EditorState; + public final fun withBlocks (Ljava/util/List;)Lio/github/linreal/cascade/editor/state/EditorState; +} + +public final class io/github/linreal/cascade/editor/state/EditorStateHolder { + public static final field $stable I + public fun ()V + public fun (Lio/github/linreal/cascade/editor/state/EditorState;)V + public synthetic fun (Lio/github/linreal/cascade/editor/state/EditorState;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun dispatch (Lio/github/linreal/cascade/editor/action/EditorAction;)V + public final fun dispatchStructuralAction (Lio/github/linreal/cascade/editor/action/EditorAction;Lio/github/linreal/cascade/editor/state/BlockTextStates;Lio/github/linreal/cascade/editor/state/BlockSpanStates;)V + public static synthetic fun dispatchStructuralAction$default (Lio/github/linreal/cascade/editor/state/EditorStateHolder;Lio/github/linreal/cascade/editor/action/EditorAction;Lio/github/linreal/cascade/editor/state/BlockTextStates;Lio/github/linreal/cascade/editor/state/BlockSpanStates;ILjava/lang/Object;)V + public final fun getCanRedo ()Z + public final fun getCanUndo ()Z + public final fun getState ()Lio/github/linreal/cascade/editor/state/EditorState; + public final fun redo ()V + public final fun setState (Lio/github/linreal/cascade/editor/state/EditorState;)V + public final fun undo ()V +} + +public final class io/github/linreal/cascade/editor/state/EditorStateHolderKt { + public static final fun rememberEditorState (Lio/github/linreal/cascade/editor/state/EditorState;Landroidx/compose/runtime/Composer;I)Lio/github/linreal/cascade/editor/state/EditorStateHolder; + public static final fun rememberEditorState (Ljava/util/List;Landroidx/compose/runtime/Composer;II)Lio/github/linreal/cascade/editor/state/EditorStateHolder; +} + +public final class io/github/linreal/cascade/editor/state/SlashCommandState { + public static final field $stable I + public synthetic fun (Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/state/SlashQueryRange;Ljava/util/List;Ljava/lang/String;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public synthetic fun (Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/state/SlashQueryRange;Ljava/util/List;Ljava/lang/String;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1--4CzayM ()Ljava/lang/String; + public final fun component2 ()Ljava/lang/String; + public final fun component3 ()Lio/github/linreal/cascade/editor/state/SlashQueryRange; + public final fun component4 ()Ljava/util/List; + public final fun component5-YhkQzo8 ()Ljava/lang/String; + public final fun copy-vLkuX3Y (Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/state/SlashQueryRange;Ljava/util/List;Ljava/lang/String;)Lio/github/linreal/cascade/editor/state/SlashCommandState; + public static synthetic fun copy-vLkuX3Y$default (Lio/github/linreal/cascade/editor/state/SlashCommandState;Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/state/SlashQueryRange;Ljava/util/List;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/state/SlashCommandState; + public fun equals (Ljava/lang/Object;)Z + public final fun getAnchorBlockId--4CzayM ()Ljava/lang/String; + public final fun getHighlightedCommandId-YhkQzo8 ()Ljava/lang/String; + public final fun getNavigationPath ()Ljava/util/List; + public final fun getQuery ()Ljava/lang/String; + public final fun getQueryRange ()Lio/github/linreal/cascade/editor/state/SlashQueryRange; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/state/SlashQueryRange { + public static final field $stable I + public fun (II)V + public final fun component1 ()I + public final fun component2 ()I + public final fun copy (II)Lio/github/linreal/cascade/editor/state/SlashQueryRange; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/state/SlashQueryRange;IIILjava/lang/Object;)Lio/github/linreal/cascade/editor/state/SlashQueryRange; + public fun equals (Ljava/lang/Object;)Z + public final fun getEndExclusive ()I + public final fun getStart ()I + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/theme/BlockLocalizedStrings { + public static final field $stable I + public fun (Ljava/lang/String;Ljava/lang/String;Ljava/util/List;)V + public synthetic fun (Ljava/lang/String;Ljava/lang/String;Ljava/util/List;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()Ljava/lang/String; + public final fun component2 ()Ljava/lang/String; + public final fun component3 ()Ljava/util/List; + public final fun copy (Ljava/lang/String;Ljava/lang/String;Ljava/util/List;)Lio/github/linreal/cascade/editor/theme/BlockLocalizedStrings; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/theme/BlockLocalizedStrings;Ljava/lang/String;Ljava/lang/String;Ljava/util/List;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/theme/BlockLocalizedStrings; + public fun equals (Ljava/lang/Object;)Z + public final fun getDescription ()Ljava/lang/String; + public final fun getDisplayName ()Ljava/lang/String; + public final fun getKeywords ()Ljava/util/List; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/theme/CascadeEditorBlockStrings { + public static final field $stable I + public static final field Companion Lio/github/linreal/cascade/editor/theme/CascadeEditorBlockStrings$Companion; + public fun (Ljava/util/Map;)V + public final fun component1 ()Ljava/util/Map; + public final fun copy (Ljava/util/Map;)Lio/github/linreal/cascade/editor/theme/CascadeEditorBlockStrings; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/theme/CascadeEditorBlockStrings;Ljava/util/Map;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/theme/CascadeEditorBlockStrings; + public fun equals (Ljava/lang/Object;)Z + public final fun forType (Ljava/lang/String;)Lio/github/linreal/cascade/editor/theme/BlockLocalizedStrings; + public final fun getBlocks ()Ljava/util/Map; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/theme/CascadeEditorBlockStrings$Companion { + public final fun default ()Lio/github/linreal/cascade/editor/theme/CascadeEditorBlockStrings; +} + +public final class io/github/linreal/cascade/editor/theme/CascadeEditorColors { + public static final field $stable I + public static final field Companion Lio/github/linreal/cascade/editor/theme/CascadeEditorColors$Companion; + public synthetic fun (JJJJJJJJJJJJJJJJJJJJJJJJILkotlin/jvm/internal/DefaultConstructorMarker;)V + public synthetic fun (JJJJJJJJJJJJJJJJJJJJJJJJLkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1-0d7_KjU ()J + public final fun component10-0d7_KjU ()J + public final fun component11-0d7_KjU ()J + public final fun component12-0d7_KjU ()J + public final fun component13-0d7_KjU ()J + public final fun component14-0d7_KjU ()J + public final fun component15-0d7_KjU ()J + public final fun component16-0d7_KjU ()J + public final fun component17-0d7_KjU ()J + public final fun component18-0d7_KjU ()J + public final fun component19-0d7_KjU ()J + public final fun component2-0d7_KjU ()J + public final fun component20-0d7_KjU ()J + public final fun component21-0d7_KjU ()J + public final fun component22-0d7_KjU ()J + public final fun component23-0d7_KjU ()J + public final fun component24-0d7_KjU ()J + public final fun component3-0d7_KjU ()J + public final fun component4-0d7_KjU ()J + public final fun component5-0d7_KjU ()J + public final fun component6-0d7_KjU ()J + public final fun component7-0d7_KjU ()J + public final fun component8-0d7_KjU ()J + public final fun component9-0d7_KjU ()J + public final fun copy-KKJ9vVU (JJJJJJJJJJJJJJJJJJJJJJJJ)Lio/github/linreal/cascade/editor/theme/CascadeEditorColors; + public static synthetic fun copy-KKJ9vVU$default (Lio/github/linreal/cascade/editor/theme/CascadeEditorColors;JJJJJJJJJJJJJJJJJJJJJJJJILjava/lang/Object;)Lio/github/linreal/cascade/editor/theme/CascadeEditorColors; + public fun equals (Ljava/lang/Object;)Z + public final fun getCodeBlockBackground-0d7_KjU ()J + public final fun getContentDivider-0d7_KjU ()J + public final fun getCursor-0d7_KjU ()J + public final fun getError-0d7_KjU ()J + public final fun getHighlight-0d7_KjU ()J + public final fun getInlineCodeBackground-0d7_KjU ()J + public final fun getLinkText-0d7_KjU ()J + public final fun getOnPrimary-0d7_KjU ()J + public final fun getPopupBackground-0d7_KjU ()J + public final fun getPrimary-0d7_KjU ()J + public final fun getQuoteBackground-0d7_KjU ()J + public final fun getQuoteBorder-0d7_KjU ()J + public final fun getSelectionOverlay-0d7_KjU ()J + public final fun getSlashChevron-0d7_KjU ()J + public final fun getSlashItemTitle-0d7_KjU ()J + public final fun getSlashSelectedItem-0d7_KjU ()J + public final fun getText-0d7_KjU ()J + public final fun getTextSelectionBackground-0d7_KjU ()J + public final fun getToolbarBackground-0d7_KjU ()J + public final fun getToolbarIcon-0d7_KjU ()J + public final fun getToolbarIconDisabled-0d7_KjU ()J + public final fun getUiDivider-0d7_KjU ()J + public final fun getUnknownBlockBackground-0d7_KjU ()J + public final fun getUnknownBlockText-0d7_KjU ()J + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/theme/CascadeEditorColors$Companion { + public final fun dark ()Lio/github/linreal/cascade/editor/theme/CascadeEditorColors; + public final fun light ()Lio/github/linreal/cascade/editor/theme/CascadeEditorColors; +} + +public final class io/github/linreal/cascade/editor/theme/CascadeEditorDimensions { + public static final field $stable I + public static final field Companion Lio/github/linreal/cascade/editor/theme/CascadeEditorDimensions$Companion; + public synthetic fun (FFLkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1-D9Ej5fM ()F + public final fun component2-D9Ej5fM ()F + public final fun copy-YgX7TsA (FF)Lio/github/linreal/cascade/editor/theme/CascadeEditorDimensions; + public static synthetic fun copy-YgX7TsA$default (Lio/github/linreal/cascade/editor/theme/CascadeEditorDimensions;FFILjava/lang/Object;)Lio/github/linreal/cascade/editor/theme/CascadeEditorDimensions; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlockHorizontalPadding-D9Ej5fM ()F + public final fun getIndentUnit-D9Ej5fM ()F + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/theme/CascadeEditorDimensions$Companion { + public final fun default ()Lio/github/linreal/cascade/editor/theme/CascadeEditorDimensions; +} + +public final class io/github/linreal/cascade/editor/theme/CascadeEditorStrings { + public static final field $stable I + public static final field Companion Lio/github/linreal/cascade/editor/theme/CascadeEditorStrings$Companion; + public fun (Ljava/lang/String;Lkotlin/jvm/functions/Function1;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lkotlin/jvm/functions/Function1;)V + public synthetic fun (Ljava/lang/String;Lkotlin/jvm/functions/Function1;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lkotlin/jvm/functions/Function1;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()Ljava/lang/String; + public final fun component10 ()Ljava/lang/String; + public final fun component11 ()Ljava/lang/String; + public final fun component12 ()Ljava/lang/String; + public final fun component13 ()Ljava/lang/String; + public final fun component14 ()Ljava/lang/String; + public final fun component15 ()Ljava/lang/String; + public final fun component16 ()Ljava/lang/String; + public final fun component17 ()Ljava/lang/String; + public final fun component18 ()Ljava/lang/String; + public final fun component19 ()Lkotlin/jvm/functions/Function1; + public final fun component2 ()Lkotlin/jvm/functions/Function1; + public final fun component3 ()Ljava/lang/String; + public final fun component4 ()Ljava/lang/String; + public final fun component5 ()Ljava/lang/String; + public final fun component6 ()Ljava/lang/String; + public final fun component7 ()Ljava/lang/String; + public final fun component8 ()Ljava/lang/String; + public final fun component9 ()Ljava/lang/String; + public final fun copy (Ljava/lang/String;Lkotlin/jvm/functions/Function1;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lkotlin/jvm/functions/Function1;)Lio/github/linreal/cascade/editor/theme/CascadeEditorStrings; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/theme/CascadeEditorStrings;Ljava/lang/String;Lkotlin/jvm/functions/Function1;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lkotlin/jvm/functions/Function1;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/theme/CascadeEditorStrings; + public fun equals (Ljava/lang/Object;)Z + public final fun getBack ()Ljava/lang/String; + public final fun getBold ()Ljava/lang/String; + public final fun getHideKeyboard ()Ljava/lang/String; + public final fun getHighlight ()Ljava/lang/String; + public final fun getIndentBackward ()Ljava/lang/String; + public final fun getIndentForward ()Ljava/lang/String; + public final fun getInlineCode ()Ljava/lang/String; + public final fun getItalic ()Ljava/lang/String; + public final fun getLink ()Ljava/lang/String; + public final fun getLinkApply ()Ljava/lang/String; + public final fun getLinkCancel ()Ljava/lang/String; + public final fun getLinkRemove ()Ljava/lang/String; + public final fun getLinkTitle ()Ljava/lang/String; + public final fun getLinkUrl ()Ljava/lang/String; + public final fun getLinkValidationError ()Lkotlin/jvm/functions/Function1; + public final fun getSlashCommand ()Ljava/lang/String; + public final fun getStrikethrough ()Ljava/lang/String; + public final fun getUnderline ()Ljava/lang/String; + public final fun getUnsupportedBlock ()Lkotlin/jvm/functions/Function1; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/theme/CascadeEditorStrings$Companion { + public final fun default ()Lio/github/linreal/cascade/editor/theme/CascadeEditorStrings; +} + +public final class io/github/linreal/cascade/editor/theme/CascadeEditorTheme { + public static final field $stable I + public static final field Companion Lio/github/linreal/cascade/editor/theme/CascadeEditorTheme$Companion; + public fun (Lio/github/linreal/cascade/editor/theme/CascadeEditorColors;Lio/github/linreal/cascade/editor/theme/CascadeEditorTypography;Lio/github/linreal/cascade/editor/theme/CascadeEditorDimensions;)V + public synthetic fun (Lio/github/linreal/cascade/editor/theme/CascadeEditorColors;Lio/github/linreal/cascade/editor/theme/CascadeEditorTypography;Lio/github/linreal/cascade/editor/theme/CascadeEditorDimensions;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()Lio/github/linreal/cascade/editor/theme/CascadeEditorColors; + public final fun component2 ()Lio/github/linreal/cascade/editor/theme/CascadeEditorTypography; + public final fun component3 ()Lio/github/linreal/cascade/editor/theme/CascadeEditorDimensions; + public final fun copy (Lio/github/linreal/cascade/editor/theme/CascadeEditorColors;Lio/github/linreal/cascade/editor/theme/CascadeEditorTypography;Lio/github/linreal/cascade/editor/theme/CascadeEditorDimensions;)Lio/github/linreal/cascade/editor/theme/CascadeEditorTheme; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/theme/CascadeEditorTheme;Lio/github/linreal/cascade/editor/theme/CascadeEditorColors;Lio/github/linreal/cascade/editor/theme/CascadeEditorTypography;Lio/github/linreal/cascade/editor/theme/CascadeEditorDimensions;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/theme/CascadeEditorTheme; + public fun equals (Ljava/lang/Object;)Z + public final fun getColors ()Lio/github/linreal/cascade/editor/theme/CascadeEditorColors; + public final fun getDimensions ()Lio/github/linreal/cascade/editor/theme/CascadeEditorDimensions; + public final fun getTypography ()Lio/github/linreal/cascade/editor/theme/CascadeEditorTypography; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/theme/CascadeEditorTheme$Companion { + public final fun dark ()Lio/github/linreal/cascade/editor/theme/CascadeEditorTheme; + public final fun light ()Lio/github/linreal/cascade/editor/theme/CascadeEditorTheme; +} + +public final class io/github/linreal/cascade/editor/theme/CascadeEditorTypography { + public static final field $stable I + public static final field Companion Lio/github/linreal/cascade/editor/theme/CascadeEditorTypography$Companion; + public fun (Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;)V + public final fun component1 ()Landroidx/compose/ui/text/TextStyle; + public final fun component10 ()Landroidx/compose/ui/text/TextStyle; + public final fun component11 ()Landroidx/compose/ui/text/TextStyle; + public final fun component2 ()Landroidx/compose/ui/text/TextStyle; + public final fun component3 ()Landroidx/compose/ui/text/TextStyle; + public final fun component4 ()Landroidx/compose/ui/text/TextStyle; + public final fun component5 ()Landroidx/compose/ui/text/TextStyle; + public final fun component6 ()Landroidx/compose/ui/text/TextStyle; + public final fun component7 ()Landroidx/compose/ui/text/TextStyle; + public final fun component8 ()Landroidx/compose/ui/text/TextStyle; + public final fun component9 ()Landroidx/compose/ui/text/TextStyle; + public final fun copy (Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;)Lio/github/linreal/cascade/editor/theme/CascadeEditorTypography; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/theme/CascadeEditorTypography;Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/text/TextStyle;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/theme/CascadeEditorTypography; + public fun equals (Ljava/lang/Object;)Z + public final fun getBody ()Landroidx/compose/ui/text/TextStyle; + public final fun getCode ()Landroidx/compose/ui/text/TextStyle; + public final fun getHeading1 ()Landroidx/compose/ui/text/TextStyle; + public final fun getHeading2 ()Landroidx/compose/ui/text/TextStyle; + public final fun getHeading3 ()Landroidx/compose/ui/text/TextStyle; + public final fun getHeading4 ()Landroidx/compose/ui/text/TextStyle; + public final fun getHeading5 ()Landroidx/compose/ui/text/TextStyle; + public final fun getHeading6 ()Landroidx/compose/ui/text/TextStyle; + public final fun getSlashBackButton ()Landroidx/compose/ui/text/TextStyle; + public final fun getSlashItemTitle ()Landroidx/compose/ui/text/TextStyle; + public final fun getToolbarButton ()Landroidx/compose/ui/text/TextStyle; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/theme/CascadeEditorTypography$Companion { + public final fun default ()Lio/github/linreal/cascade/editor/theme/CascadeEditorTypography; +} + +public final class io/github/linreal/cascade/editor/ui/BackspaceAwareTextEditKt { + public static final fun BackspaceAwareTextField (Landroidx/compose/foundation/text/input/TextFieldState;Landroidx/compose/ui/Modifier;Landroidx/compose/ui/text/TextStyle;Landroidx/compose/ui/graphics/Brush;Landroidx/compose/foundation/text/input/OutputTransformation;Landroidx/compose/ui/focus/FocusRequester;Lkotlin/jvm/functions/Function0;Lkotlin/jvm/functions/Function1;ZLkotlin/jvm/functions/Function2;Landroidx/compose/runtime/Composer;II)V + public static final fun selectedVisibleText (Landroidx/compose/foundation/text/input/TextFieldState;)Ljava/lang/String; + public static final fun visibleCursorPosition (Landroidx/compose/foundation/text/input/TextFieldState;)I + public static final fun visibleSelection (Landroidx/compose/foundation/text/input/TextFieldState;)J + public static final fun visibleText (Landroidx/compose/foundation/text/input/TextFieldState;)Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/ui/BlockGestureModifierKt { + public static final fun draggableAfterLongPress (Landroidx/compose/ui/Modifier;Ljava/lang/Object;ZLjava/lang/Long;Lkotlin/jvm/functions/Function1;Lkotlin/jvm/functions/Function1;Lkotlin/jvm/functions/Function0;Lkotlin/jvm/functions/Function0;)Landroidx/compose/ui/Modifier; + public static synthetic fun draggableAfterLongPress$default (Landroidx/compose/ui/Modifier;Ljava/lang/Object;ZLjava/lang/Long;Lkotlin/jvm/functions/Function1;Lkotlin/jvm/functions/Function1;Lkotlin/jvm/functions/Function0;Lkotlin/jvm/functions/Function0;ILjava/lang/Object;)Landroidx/compose/ui/Modifier; +} + +public final class io/github/linreal/cascade/editor/ui/CascadeEditorConfig { + public static final field $stable I + public static final field Companion Lio/github/linreal/cascade/editor/ui/CascadeEditorConfig$Companion; + public fun ()V + public fun (ZZZLio/github/linreal/cascade/editor/CrashPolicy;Lkotlin/jvm/functions/Function1;)V + public synthetic fun (ZZZLio/github/linreal/cascade/editor/CrashPolicy;Lkotlin/jvm/functions/Function1;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()Z + public final fun component2 ()Z + public final fun component3 ()Z + public final fun component4 ()Lio/github/linreal/cascade/editor/CrashPolicy; + public final fun component5 ()Lkotlin/jvm/functions/Function1; + public final fun copy (ZZZLio/github/linreal/cascade/editor/CrashPolicy;Lkotlin/jvm/functions/Function1;)Lio/github/linreal/cascade/editor/ui/CascadeEditorConfig; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/ui/CascadeEditorConfig;ZZZLio/github/linreal/cascade/editor/CrashPolicy;Lkotlin/jvm/functions/Function1;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/ui/CascadeEditorConfig; + public fun equals (Ljava/lang/Object;)Z + public final fun getBlockDraggingEnabled ()Z + public final fun getBlockSelectionEnabled ()Z + public final fun getCrashPolicy ()Lio/github/linreal/cascade/editor/CrashPolicy; + public final fun getOnInternalError ()Lkotlin/jvm/functions/Function1; + public final fun getReadOnly ()Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/ui/CascadeEditorConfig$Companion { + public final fun getDefault ()Lio/github/linreal/cascade/editor/ui/CascadeEditorConfig; +} + +public final class io/github/linreal/cascade/editor/ui/CascadeEditorKt { + public static final fun CascadeEditor (Lio/github/linreal/cascade/editor/state/EditorStateHolder;Lio/github/linreal/cascade/editor/state/BlockTextStates;Lio/github/linreal/cascade/editor/state/BlockSpanStates;Lio/github/linreal/cascade/editor/registry/BlockRegistry;Lio/github/linreal/cascade/editor/slash/SlashCommandRegistry;Lio/github/linreal/cascade/editor/ui/SlashCommandSlot;Lio/github/linreal/cascade/editor/theme/CascadeEditorTheme;Lio/github/linreal/cascade/editor/theme/CascadeEditorStrings;Lio/github/linreal/cascade/editor/theme/CascadeEditorBlockStrings;Landroidx/compose/ui/Modifier;Lio/github/linreal/cascade/editor/ui/ToolbarSlot;Lio/github/linreal/cascade/editor/ui/LinkPopupSlot;Lkotlin/jvm/functions/Function1;Lkotlin/jvm/functions/Function1;Lio/github/linreal/cascade/editor/ui/CascadeEditorConfig;Landroidx/compose/runtime/Composer;III)V +} + +public abstract interface class io/github/linreal/cascade/editor/ui/CascadeEditorToolbarController { + public abstract fun getFormattingActions ()Lio/github/linreal/cascade/editor/richtext/FormattingActions; + public abstract fun getFormattingState ()Landroidx/compose/runtime/State; + public abstract fun getIndentationActions ()Lio/github/linreal/cascade/editor/indentation/IndentationActions; + public abstract fun getIndentationState ()Landroidx/compose/runtime/State; + public abstract fun getLinkActions ()Lio/github/linreal/cascade/editor/richtext/LinkChromeActions; + public abstract fun getLinkState ()Landroidx/compose/runtime/State; +} + +public final class io/github/linreal/cascade/editor/ui/CascadeEditorToolbarControllerKt { + public static final fun rememberCascadeEditorToolbarController (Lio/github/linreal/cascade/editor/state/EditorStateHolder;Lio/github/linreal/cascade/editor/state/BlockTextStates;Lio/github/linreal/cascade/editor/state/BlockSpanStates;Ljava/util/List;Lio/github/linreal/cascade/editor/ui/CascadeEditorConfig;Landroidx/compose/runtime/Composer;II)Lio/github/linreal/cascade/editor/ui/CascadeEditorToolbarController; +} + +public final class io/github/linreal/cascade/editor/ui/EditorRegistryKt { + public static final fun createEditorRegistry ()Lio/github/linreal/cascade/editor/registry/BlockRegistry; + public static final fun registerBuiltInRenderers (Lio/github/linreal/cascade/editor/registry/BlockRegistry;)V +} + +public final class io/github/linreal/cascade/editor/ui/HideKeyboardToolbarButtonKt { + public static final fun HideKeyboardToolbarButton (Lkotlin/jvm/functions/Function0;Landroidx/compose/ui/Modifier;Landroidx/compose/runtime/Composer;II)V +} + +public abstract interface class io/github/linreal/cascade/editor/ui/LinkPopupActions { + public abstract fun apply ()V + public abstract fun dismiss ()V + public abstract fun remove ()V + public abstract fun updateTitle (Ljava/lang/String;)V + public abstract fun updateUrl (Ljava/lang/String;)V +} + +public abstract interface class io/github/linreal/cascade/editor/ui/LinkPopupSlot { +} + +public final class io/github/linreal/cascade/editor/ui/LinkPopupSlot$Custom : io/github/linreal/cascade/editor/ui/LinkPopupSlot { + public static final field $stable I + public fun (Lkotlin/jvm/functions/Function4;)V + public final fun getContent ()Lkotlin/jvm/functions/Function4; +} + +public final class io/github/linreal/cascade/editor/ui/LinkPopupSlot$Default : io/github/linreal/cascade/editor/ui/LinkPopupSlot { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/ui/LinkPopupSlot$Default; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/ui/LinkPopupSlot$None : io/github/linreal/cascade/editor/ui/LinkPopupSlot { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/ui/LinkPopupSlot$None; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/ui/LinkPopupState { + public static final field $stable I + public fun (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/richtext/LinkValidationError;Ljava/lang/String;ZZ)V + public final fun component1 ()Ljava/lang/String; + public final fun component2 ()Ljava/lang/String; + public final fun component3 ()Ljava/lang/String; + public final fun component4 ()Lio/github/linreal/cascade/editor/richtext/LinkValidationError; + public final fun component5 ()Ljava/lang/String; + public final fun component6 ()Z + public final fun component7 ()Z + public final fun copy (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/richtext/LinkValidationError;Ljava/lang/String;ZZ)Lio/github/linreal/cascade/editor/ui/LinkPopupState; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/ui/LinkPopupState;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/richtext/LinkValidationError;Ljava/lang/String;ZZILjava/lang/Object;)Lio/github/linreal/cascade/editor/ui/LinkPopupState; + public fun equals (Ljava/lang/Object;)Z + public final fun getCanApply ()Z + public final fun getCanRemove ()Z + public final fun getExistingUrl ()Ljava/lang/String; + public final fun getNormalizedUrl ()Ljava/lang/String; + public final fun getTitle ()Ljava/lang/String; + public final fun getUrl ()Ljava/lang/String; + public final fun getValidationError ()Lio/github/linreal/cascade/editor/richtext/LinkValidationError; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/ui/LocalBlockSpanStatesKt { + public static final fun getLocalBlockSpanStates ()Landroidx/compose/runtime/ProvidableCompositionLocal; +} + +public final class io/github/linreal/cascade/editor/ui/LocalBlockTextStatesKt { + public static final fun getLocalBlockTextStates ()Landroidx/compose/runtime/ProvidableCompositionLocal; +} + +public final class io/github/linreal/cascade/editor/ui/LocalCascadeEditorConfigKt { + public static final fun getLocalCascadeEditorConfig ()Landroidx/compose/runtime/ProvidableCompositionLocal; +} + +public final class io/github/linreal/cascade/editor/ui/LocalFormattingActionsKt { + public static final fun getLocalFormattingActions ()Landroidx/compose/runtime/ProvidableCompositionLocal; +} + +public final class io/github/linreal/cascade/editor/ui/LocalIndentationActionsKt { + public static final fun getLocalIndentationActions ()Landroidx/compose/runtime/ProvidableCompositionLocal; +} + +public final class io/github/linreal/cascade/editor/ui/LocalIndentationStateKt { + public static final fun getLocalIndentationState ()Landroidx/compose/runtime/ProvidableCompositionLocal; +} + +public final class io/github/linreal/cascade/editor/ui/LocalLinkActionsKt { + public static final fun getLocalLinkActions ()Landroidx/compose/runtime/ProvidableCompositionLocal; +} + +public final class io/github/linreal/cascade/editor/ui/LocalLinkStateKt { + public static final fun getLocalLinkState ()Landroidx/compose/runtime/ProvidableCompositionLocal; +} + +public final class io/github/linreal/cascade/editor/ui/LocalSpanActionDispatcherKt { + public static final fun getLocalSpanActionDispatcher ()Landroidx/compose/runtime/ProvidableCompositionLocal; +} + +public final class io/github/linreal/cascade/editor/ui/RichTextToolbarConfig { + public static final field $stable I + public static final field Companion Lio/github/linreal/cascade/editor/ui/RichTextToolbarConfig$Companion; + public fun (Ljava/util/List;ZZ)V + public synthetic fun (Ljava/util/List;ZZILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()Ljava/util/List; + public final fun component2 ()Z + public final fun component3 ()Z + public final fun copy (Ljava/util/List;ZZ)Lio/github/linreal/cascade/editor/ui/RichTextToolbarConfig; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/ui/RichTextToolbarConfig;Ljava/util/List;ZZILjava/lang/Object;)Lio/github/linreal/cascade/editor/ui/RichTextToolbarConfig; + public fun equals (Ljava/lang/Object;)Z + public final fun getButtons ()Ljava/util/List; + public final fun getShowIndentation ()Z + public final fun getShowLink ()Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/ui/RichTextToolbarConfig$Companion { + public final fun getDefault ()Lio/github/linreal/cascade/editor/ui/RichTextToolbarConfig; +} + +public abstract interface class io/github/linreal/cascade/editor/ui/SlashCommandSlot { +} + +public final class io/github/linreal/cascade/editor/ui/SlashCommandSlot$Default : io/github/linreal/cascade/editor/ui/SlashCommandSlot { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/ui/SlashCommandSlot$Default; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/ui/SlashCommandSlot$None : io/github/linreal/cascade/editor/ui/SlashCommandSlot { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/ui/SlashCommandSlot$None; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/ui/ToolbarButtonSpec { + public static final field $stable I + public fun (Lio/github/linreal/cascade/editor/core/SpanStyle;Ljava/lang/String;)V + public final fun component1 ()Lio/github/linreal/cascade/editor/core/SpanStyle; + public final fun component2 ()Ljava/lang/String; + public final fun copy (Lio/github/linreal/cascade/editor/core/SpanStyle;Ljava/lang/String;)Lio/github/linreal/cascade/editor/ui/ToolbarButtonSpec; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/ui/ToolbarButtonSpec;Lio/github/linreal/cascade/editor/core/SpanStyle;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/ui/ToolbarButtonSpec; + public fun equals (Ljava/lang/Object;)Z + public final fun getLabel ()Ljava/lang/String; + public final fun getStyle ()Lio/github/linreal/cascade/editor/core/SpanStyle; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public abstract interface class io/github/linreal/cascade/editor/ui/ToolbarSlot { +} + +public final class io/github/linreal/cascade/editor/ui/ToolbarSlot$Custom : io/github/linreal/cascade/editor/ui/ToolbarSlot { + public static final field $stable I + public fun (Ljava/util/List;Lkotlin/jvm/functions/Function4;)V + public synthetic fun (Ljava/util/List;Lkotlin/jvm/functions/Function4;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()Ljava/util/List; + public final fun component2 ()Lkotlin/jvm/functions/Function4; + public final fun copy (Ljava/util/List;Lkotlin/jvm/functions/Function4;)Lio/github/linreal/cascade/editor/ui/ToolbarSlot$Custom; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/ui/ToolbarSlot$Custom;Ljava/util/List;Lkotlin/jvm/functions/Function4;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/ui/ToolbarSlot$Custom; + public fun equals (Ljava/lang/Object;)Z + public final fun getContent ()Lkotlin/jvm/functions/Function4; + public final fun getTrackedStyles ()Ljava/util/List; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/ui/ToolbarSlot$Default : io/github/linreal/cascade/editor/ui/ToolbarSlot { + public static final field $stable I + public fun ()V + public fun (Lio/github/linreal/cascade/editor/ui/RichTextToolbarConfig;)V + public synthetic fun (Lio/github/linreal/cascade/editor/ui/RichTextToolbarConfig;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()Lio/github/linreal/cascade/editor/ui/RichTextToolbarConfig; + public final fun copy (Lio/github/linreal/cascade/editor/ui/RichTextToolbarConfig;)Lio/github/linreal/cascade/editor/ui/ToolbarSlot$Default; + public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/ui/ToolbarSlot$Default;Lio/github/linreal/cascade/editor/ui/RichTextToolbarConfig;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/ui/ToolbarSlot$Default; + public fun equals (Ljava/lang/Object;)Z + public final fun getConfig ()Lio/github/linreal/cascade/editor/ui/RichTextToolbarConfig; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/ui/ToolbarSlot$None : io/github/linreal/cascade/editor/ui/ToolbarSlot { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/ui/ToolbarSlot$None; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class io/github/linreal/cascade/editor/ui/renderers/DividerBlockRenderer : io/github/linreal/cascade/editor/registry/BlockRenderer { + public static final field $stable I + public fun ()V + public fun Render (Lio/github/linreal/cascade/editor/core/Block;ZZLandroidx/compose/ui/Modifier;Lio/github/linreal/cascade/editor/registry/BlockCallbacks;Landroidx/compose/runtime/Composer;I)V + public fun getHandlesSelectionVisual ()Z + public fun getSupportsDragPreview ()Z +} + +public final class io/github/linreal/cascade/editor/ui/renderers/TextBlockRenderer : io/github/linreal/cascade/editor/registry/BlockRenderer { + public static final field $stable I + public fun ()V + public fun Render (Lio/github/linreal/cascade/editor/core/Block;ZZLandroidx/compose/ui/Modifier;Lio/github/linreal/cascade/editor/registry/BlockCallbacks;Landroidx/compose/runtime/Composer;I)V + public fun getHandlesSelectionVisual ()Z + public fun getSupportsDragPreview ()Z +} + +public final class io/github/linreal/cascade/editor/ui/renderers/TodoBlockRenderer : io/github/linreal/cascade/editor/registry/BlockRenderer { + public static final field $stable I + public fun ()V + public fun Render (Lio/github/linreal/cascade/editor/core/Block;ZZLandroidx/compose/ui/Modifier;Lio/github/linreal/cascade/editor/registry/BlockCallbacks;Landroidx/compose/runtime/Composer;I)V + public fun getHandlesSelectionVisual ()Z + public fun getSupportsDragPreview ()Z +} + +public final class io/github/linreal/cascade/editor/ui/utils/Dividers { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/ui/utils/Dividers; + public final fun Horizontal-DxzAY5Q (JLandroidx/compose/ui/Modifier;FLandroidx/compose/runtime/Composer;II)V + public final fun Vertical-KfjZ6_A (JLandroidx/compose/ui/Modifier;FFLandroidx/compose/runtime/Composer;II)V +} + +public final class io/github/linreal/cascade/editor/ui/utils/DragUtilsKt { + public static final fun calculateDropIndicatorY (Landroidx/compose/foundation/lazy/LazyListLayoutInfo;Ljava/lang/Integer;)Ljava/lang/Float; + public static final fun calculateDropTargetIndex (Landroidx/compose/foundation/lazy/LazyListLayoutInfo;FI)Ljava/lang/Integer; + public static final fun convertVisualGapToMoveBlocksIndex (III)Ljava/lang/Integer; +} + +public final class io/github/linreal/cascade/editor/ui/utils/Spacers { + public static final field $stable I + public static final field INSTANCE Lio/github/linreal/cascade/editor/ui/utils/Spacers; + public final fun FillHorizontalSpacer (Landroidx/compose/foundation/layout/RowScope;Landroidx/compose/runtime/Composer;I)V + public final fun FillVerticalSpacer (Landroidx/compose/foundation/layout/ColumnScope;Landroidx/compose/runtime/Composer;I)V + public final fun Horizontal-8Feqmps (FLandroidx/compose/runtime/Composer;I)V + public final fun UiSpacer-ixp7dh8 (FFLandroidx/compose/runtime/Composer;II)V + public final fun Vertical-8Feqmps (FLandroidx/compose/runtime/Composer;I)V +} + diff --git a/editor/api/editor.klib.api b/editor/api/editor.klib.api new file mode 100644 index 0000000..94c75e8 --- /dev/null +++ b/editor/api/editor.klib.api @@ -0,0 +1,3560 @@ +// Klib ABI Dump +// Targets: [iosArm64, iosSimulatorArm64, wasmJs] +// Rendering settings: +// - Signature version: 2 +// - Show manifest properties: true +// - Show declarations: true + +// Library unique name: +open annotation class io.github.linreal.cascade.editor.htmlserialization/ExperimentalCascadeHtmlApi : kotlin/Annotation { // io.github.linreal.cascade.editor.htmlserialization/ExperimentalCascadeHtmlApi|null[0] + constructor () // io.github.linreal.cascade.editor.htmlserialization/ExperimentalCascadeHtmlApi.|(){}[0] +} + +final enum class io.github.linreal.cascade.editor.richtext/LinkValidationError : kotlin/Enum { // io.github.linreal.cascade.editor.richtext/LinkValidationError|null[0] + enum entry Blank // io.github.linreal.cascade.editor.richtext/LinkValidationError.Blank|null[0] + + final val entries // io.github.linreal.cascade.editor.richtext/LinkValidationError.entries|#static{}entries[0] + final fun (): kotlin.enums/EnumEntries // io.github.linreal.cascade.editor.richtext/LinkValidationError.entries.|#static(){}[0] + + final fun valueOf(kotlin/String): io.github.linreal.cascade.editor.richtext/LinkValidationError // io.github.linreal.cascade.editor.richtext/LinkValidationError.valueOf|valueOf#static(kotlin.String){}[0] + final fun values(): kotlin/Array // io.github.linreal.cascade.editor.richtext/LinkValidationError.values|values#static(){}[0] +} + +final enum class io.github.linreal.cascade.editor.richtext/StyleStatus : kotlin/Enum { // io.github.linreal.cascade.editor.richtext/StyleStatus|null[0] + enum entry Absent // io.github.linreal.cascade.editor.richtext/StyleStatus.Absent|null[0] + enum entry FullyActive // io.github.linreal.cascade.editor.richtext/StyleStatus.FullyActive|null[0] + enum entry Partial // io.github.linreal.cascade.editor.richtext/StyleStatus.Partial|null[0] + + final val entries // io.github.linreal.cascade.editor.richtext/StyleStatus.entries|#static{}entries[0] + final fun (): kotlin.enums/EnumEntries // io.github.linreal.cascade.editor.richtext/StyleStatus.entries.|#static(){}[0] + + final fun valueOf(kotlin/String): io.github.linreal.cascade.editor.richtext/StyleStatus // io.github.linreal.cascade.editor.richtext/StyleStatus.valueOf|valueOf#static(kotlin.String){}[0] + final fun values(): kotlin/Array // io.github.linreal.cascade.editor.richtext/StyleStatus.values|values#static(){}[0] +} + +final enum class io.github.linreal.cascade.editor.serialization/BlockIdMode : kotlin/Enum { // io.github.linreal.cascade.editor.serialization/BlockIdMode|null[0] + enum entry Preserve // io.github.linreal.cascade.editor.serialization/BlockIdMode.Preserve|null[0] + enum entry Regenerate // io.github.linreal.cascade.editor.serialization/BlockIdMode.Regenerate|null[0] + + final val entries // io.github.linreal.cascade.editor.serialization/BlockIdMode.entries|#static{}entries[0] + final fun (): kotlin.enums/EnumEntries // io.github.linreal.cascade.editor.serialization/BlockIdMode.entries.|#static(){}[0] + + final fun valueOf(kotlin/String): io.github.linreal.cascade.editor.serialization/BlockIdMode // io.github.linreal.cascade.editor.serialization/BlockIdMode.valueOf|valueOf#static(kotlin.String){}[0] + final fun values(): kotlin/Array // io.github.linreal.cascade.editor.serialization/BlockIdMode.values|values#static(){}[0] +} + +final enum class io.github.linreal.cascade.editor.serialization/CustomDataMode : kotlin/Enum { // io.github.linreal.cascade.editor.serialization/CustomDataMode|null[0] + enum entry LenientSkipUnsupported // io.github.linreal.cascade.editor.serialization/CustomDataMode.LenientSkipUnsupported|null[0] + enum entry Strict // io.github.linreal.cascade.editor.serialization/CustomDataMode.Strict|null[0] + + final val entries // io.github.linreal.cascade.editor.serialization/CustomDataMode.entries|#static{}entries[0] + final fun (): kotlin.enums/EnumEntries // io.github.linreal.cascade.editor.serialization/CustomDataMode.entries.|#static(){}[0] + + final fun valueOf(kotlin/String): io.github.linreal.cascade.editor.serialization/CustomDataMode // io.github.linreal.cascade.editor.serialization/CustomDataMode.valueOf|valueOf#static(kotlin.String){}[0] + final fun values(): kotlin/Array // io.github.linreal.cascade.editor.serialization/CustomDataMode.values|values#static(){}[0] +} + +final enum class io.github.linreal.cascade.editor.serialization/DuplicateIdMode : kotlin/Enum { // io.github.linreal.cascade.editor.serialization/DuplicateIdMode|null[0] + enum entry FailFast // io.github.linreal.cascade.editor.serialization/DuplicateIdMode.FailFast|null[0] + enum entry RegenerateLaterDuplicates // io.github.linreal.cascade.editor.serialization/DuplicateIdMode.RegenerateLaterDuplicates|null[0] + + final val entries // io.github.linreal.cascade.editor.serialization/DuplicateIdMode.entries|#static{}entries[0] + final fun (): kotlin.enums/EnumEntries // io.github.linreal.cascade.editor.serialization/DuplicateIdMode.entries.|#static(){}[0] + + final fun valueOf(kotlin/String): io.github.linreal.cascade.editor.serialization/DuplicateIdMode // io.github.linreal.cascade.editor.serialization/DuplicateIdMode.valueOf|valueOf#static(kotlin.String){}[0] + final fun values(): kotlin/Array // io.github.linreal.cascade.editor.serialization/DuplicateIdMode.values|values#static(){}[0] +} + +final enum class io.github.linreal.cascade.editor.slash/SlashQueryTextPolicy : kotlin/Enum { // io.github.linreal.cascade.editor.slash/SlashQueryTextPolicy|null[0] + enum entry KeepText // io.github.linreal.cascade.editor.slash/SlashQueryTextPolicy.KeepText|null[0] + enum entry RemoveBeforeExecute // io.github.linreal.cascade.editor.slash/SlashQueryTextPolicy.RemoveBeforeExecute|null[0] + + final val entries // io.github.linreal.cascade.editor.slash/SlashQueryTextPolicy.entries|#static{}entries[0] + final fun (): kotlin.enums/EnumEntries // io.github.linreal.cascade.editor.slash/SlashQueryTextPolicy.entries.|#static(){}[0] + + final fun valueOf(kotlin/String): io.github.linreal.cascade.editor.slash/SlashQueryTextPolicy // io.github.linreal.cascade.editor.slash/SlashQueryTextPolicy.valueOf|valueOf#static(kotlin.String){}[0] + final fun values(): kotlin/Array // io.github.linreal.cascade.editor.slash/SlashQueryTextPolicy.values|values#static(){}[0] +} + +final enum class io.github.linreal.cascade.editor/CrashPolicy : kotlin/Enum { // io.github.linreal.cascade.editor/CrashPolicy|null[0] + enum entry ContainAndReport // io.github.linreal.cascade.editor/CrashPolicy.ContainAndReport|null[0] + enum entry Rethrow // io.github.linreal.cascade.editor/CrashPolicy.Rethrow|null[0] + + final val entries // io.github.linreal.cascade.editor/CrashPolicy.entries|#static{}entries[0] + final fun (): kotlin.enums/EnumEntries // io.github.linreal.cascade.editor/CrashPolicy.entries.|#static(){}[0] + + final fun valueOf(kotlin/String): io.github.linreal.cascade.editor/CrashPolicy // io.github.linreal.cascade.editor/CrashPolicy.valueOf|valueOf#static(kotlin.String){}[0] + final fun values(): kotlin/Array // io.github.linreal.cascade.editor/CrashPolicy.values|values#static(){}[0] +} + +abstract fun interface <#A: io.github.linreal.cascade.editor.core/BlockType> io.github.linreal.cascade.editor.htmlserialization/BlockEncoder { // io.github.linreal.cascade.editor.htmlserialization/BlockEncoder|null[0] + abstract fun encode(io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeContext, io.github.linreal.cascade.editor.core/Block, io.github.linreal.cascade.editor.core/BlockContent): io.github.linreal.cascade.editor.htmlserialization/HtmlEmit // io.github.linreal.cascade.editor.htmlserialization/BlockEncoder.encode|encode(io.github.linreal.cascade.editor.htmlserialization.HtmlEncodeContext;io.github.linreal.cascade.editor.core.Block;io.github.linreal.cascade.editor.core.BlockContent){}[0] +} + +abstract fun interface <#A: io.github.linreal.cascade.editor.core/SpanStyle> io.github.linreal.cascade.editor.htmlserialization/SpanEncoder { // io.github.linreal.cascade.editor.htmlserialization/SpanEncoder|null[0] + abstract fun encode(#A): io.github.linreal.cascade.editor.htmlserialization/HtmlTagPair // io.github.linreal.cascade.editor.htmlserialization/SpanEncoder.encode|encode(1:0){}[0] +} + +abstract fun interface io.github.linreal.cascade.editor.htmlserialization/TagDecoder { // io.github.linreal.cascade.editor.htmlserialization/TagDecoder|null[0] + abstract fun decode(io.github.linreal.cascade.editor.htmlserialization/TagDecodeContext, kotlin.collections/Map, kotlin.collections/List): io.github.linreal.cascade.editor.htmlserialization/TagDecodeResult // io.github.linreal.cascade.editor.htmlserialization/TagDecoder.decode|decode(io.github.linreal.cascade.editor.htmlserialization.TagDecodeContext;kotlin.collections.Map;kotlin.collections.List){}[0] +} + +abstract interface <#A: io.github.linreal.cascade.editor.core/BlockType> io.github.linreal.cascade.editor.registry/BlockRenderer { // io.github.linreal.cascade.editor.registry/BlockRenderer|null[0] + open val handlesSelectionVisual // io.github.linreal.cascade.editor.registry/BlockRenderer.handlesSelectionVisual|{}handlesSelectionVisual[0] + open fun (): kotlin/Boolean // io.github.linreal.cascade.editor.registry/BlockRenderer.handlesSelectionVisual.|(){}[0] + open val supportsDragPreview // io.github.linreal.cascade.editor.registry/BlockRenderer.supportsDragPreview|{}supportsDragPreview[0] + open fun (): kotlin/Boolean // io.github.linreal.cascade.editor.registry/BlockRenderer.supportsDragPreview.|(){}[0] + + abstract fun Render(io.github.linreal.cascade.editor.core/Block, kotlin/Boolean, kotlin/Boolean, androidx.compose.ui/Modifier, io.github.linreal.cascade.editor.registry/BlockCallbacks, androidx.compose.runtime/Composer?, kotlin/Int) // io.github.linreal.cascade.editor.registry/BlockRenderer.Render|Render(io.github.linreal.cascade.editor.core.Block;kotlin.Boolean;kotlin.Boolean;androidx.compose.ui.Modifier;io.github.linreal.cascade.editor.registry.BlockCallbacks;androidx.compose.runtime.Composer?;kotlin.Int){}[0] +} + +abstract interface <#A: io.github.linreal.cascade.editor.core/BlockType> io.github.linreal.cascade.editor.registry/ScopedBlockRenderer : io.github.linreal.cascade.editor.registry/BlockRenderer<#A> { // io.github.linreal.cascade.editor.registry/ScopedBlockRenderer|null[0] + abstract fun Render(io.github.linreal.cascade.editor.core/Block, kotlin/Boolean, kotlin/Boolean, androidx.compose.ui/Modifier, io.github.linreal.cascade.editor.registry/BlockCallbacks, io.github.linreal.cascade.editor.registry/BlockRenderScope, androidx.compose.runtime/Composer?, kotlin/Int) // io.github.linreal.cascade.editor.registry/ScopedBlockRenderer.Render|Render(io.github.linreal.cascade.editor.core.Block;kotlin.Boolean;kotlin.Boolean;androidx.compose.ui.Modifier;io.github.linreal.cascade.editor.registry.BlockCallbacks;io.github.linreal.cascade.editor.registry.BlockRenderScope;androidx.compose.runtime.Composer?;kotlin.Int){}[0] + open fun Render(io.github.linreal.cascade.editor.core/Block, kotlin/Boolean, kotlin/Boolean, androidx.compose.ui/Modifier, io.github.linreal.cascade.editor.registry/BlockCallbacks, androidx.compose.runtime/Composer?, kotlin/Int) // io.github.linreal.cascade.editor.registry/ScopedBlockRenderer.Render|Render(io.github.linreal.cascade.editor.core.Block;kotlin.Boolean;kotlin.Boolean;androidx.compose.ui.Modifier;io.github.linreal.cascade.editor.registry.BlockCallbacks;androidx.compose.runtime.Composer?;kotlin.Int){}[0] +} + +abstract interface io.github.linreal.cascade.editor.core/CustomBlockType : io.github.linreal.cascade.editor.core/BlockType // io.github.linreal.cascade.editor.core/CustomBlockType|null[0] + +abstract interface io.github.linreal.cascade.editor.htmlserialization/BlockGroupEncoder { // io.github.linreal.cascade.editor.htmlserialization/BlockGroupEncoder|null[0] + abstract fun encodeGroup(io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeContext, kotlin.collections/List): io.github.linreal.cascade.editor.htmlserialization/HtmlEmit // io.github.linreal.cascade.editor.htmlserialization/BlockGroupEncoder.encodeGroup|encodeGroup(io.github.linreal.cascade.editor.htmlserialization.HtmlEncodeContext;kotlin.collections.List){}[0] + abstract fun groupKey(io.github.linreal.cascade.editor.core/Block): kotlin/Any? // io.github.linreal.cascade.editor.htmlserialization/BlockGroupEncoder.groupKey|groupKey(io.github.linreal.cascade.editor.core.Block){}[0] +} + +abstract interface io.github.linreal.cascade.editor.indentation/IndentationActions { // io.github.linreal.cascade.editor.indentation/IndentationActions|null[0] + abstract fun indentBackward() // io.github.linreal.cascade.editor.indentation/IndentationActions.indentBackward|indentBackward(){}[0] + abstract fun indentForward() // io.github.linreal.cascade.editor.indentation/IndentationActions.indentForward|indentForward(){}[0] +} + +abstract interface io.github.linreal.cascade.editor.registry/BlockCallbacks { // io.github.linreal.cascade.editor.registry/BlockCallbacks|null[0] + abstract fun dispatch(io.github.linreal.cascade.editor.action/EditorAction) // io.github.linreal.cascade.editor.registry/BlockCallbacks.dispatch|dispatch(io.github.linreal.cascade.editor.action.EditorAction){}[0] + abstract fun onBackspaceAtStart(io.github.linreal.cascade.editor.core/BlockId) // io.github.linreal.cascade.editor.registry/BlockCallbacks.onBackspaceAtStart|onBackspaceAtStart(io.github.linreal.cascade.editor.core.BlockId){}[0] + abstract fun onClick(io.github.linreal.cascade.editor.core/BlockId) // io.github.linreal.cascade.editor.registry/BlockCallbacks.onClick|onClick(io.github.linreal.cascade.editor.core.BlockId){}[0] + abstract fun onDeleteAtEnd(io.github.linreal.cascade.editor.core/BlockId) // io.github.linreal.cascade.editor.registry/BlockCallbacks.onDeleteAtEnd|onDeleteAtEnd(io.github.linreal.cascade.editor.core.BlockId){}[0] + abstract fun onDragStart(io.github.linreal.cascade.editor.core/BlockId, kotlin/Float) // io.github.linreal.cascade.editor.registry/BlockCallbacks.onDragStart|onDragStart(io.github.linreal.cascade.editor.core.BlockId;kotlin.Float){}[0] + abstract fun onEnter(io.github.linreal.cascade.editor.core/BlockId, kotlin/Int) // io.github.linreal.cascade.editor.registry/BlockCallbacks.onEnter|onEnter(io.github.linreal.cascade.editor.core.BlockId;kotlin.Int){}[0] + abstract fun onFocus(io.github.linreal.cascade.editor.core/BlockId) // io.github.linreal.cascade.editor.registry/BlockCallbacks.onFocus|onFocus(io.github.linreal.cascade.editor.core.BlockId){}[0] + abstract fun onLongClick(io.github.linreal.cascade.editor.core/BlockId) // io.github.linreal.cascade.editor.registry/BlockCallbacks.onLongClick|onLongClick(io.github.linreal.cascade.editor.core.BlockId){}[0] + abstract fun onSlashCommand(io.github.linreal.cascade.editor.core/BlockId, io.github.linreal.cascade.editor.state/SlashQueryRange, kotlin/String = ...) // io.github.linreal.cascade.editor.registry/BlockCallbacks.onSlashCommand|onSlashCommand(io.github.linreal.cascade.editor.core.BlockId;io.github.linreal.cascade.editor.state.SlashQueryRange;kotlin.String){}[0] +} + +abstract interface io.github.linreal.cascade.editor.registry/BlockRenderScope { // io.github.linreal.cascade.editor.registry/BlockRenderScope|null[0] + abstract val canDragBlocks // io.github.linreal.cascade.editor.registry/BlockRenderScope.canDragBlocks|{}canDragBlocks[0] + abstract fun (): kotlin/Boolean // io.github.linreal.cascade.editor.registry/BlockRenderScope.canDragBlocks.|(){}[0] + abstract val canEditBlockStructure // io.github.linreal.cascade.editor.registry/BlockRenderScope.canEditBlockStructure|{}canEditBlockStructure[0] + abstract fun (): kotlin/Boolean // io.github.linreal.cascade.editor.registry/BlockRenderScope.canEditBlockStructure.|(){}[0] + abstract val canSelectBlocks // io.github.linreal.cascade.editor.registry/BlockRenderScope.canSelectBlocks|{}canSelectBlocks[0] + abstract fun (): kotlin/Boolean // io.github.linreal.cascade.editor.registry/BlockRenderScope.canSelectBlocks.|(){}[0] + abstract val canUpdateBlock // io.github.linreal.cascade.editor.registry/BlockRenderScope.canUpdateBlock|{}canUpdateBlock[0] + abstract fun (): kotlin/Boolean // io.github.linreal.cascade.editor.registry/BlockRenderScope.canUpdateBlock.|(){}[0] + abstract val config // io.github.linreal.cascade.editor.registry/BlockRenderScope.config|{}config[0] + abstract fun (): io.github.linreal.cascade.editor.ui/CascadeEditorConfig // io.github.linreal.cascade.editor.registry/BlockRenderScope.config.|(){}[0] + abstract val readOnly // io.github.linreal.cascade.editor.registry/BlockRenderScope.readOnly|{}readOnly[0] + abstract fun (): kotlin/Boolean // io.github.linreal.cascade.editor.registry/BlockRenderScope.readOnly.|(){}[0] + abstract val state // io.github.linreal.cascade.editor.registry/BlockRenderScope.state|{}state[0] + abstract fun (): io.github.linreal.cascade.editor.state/EditorState // io.github.linreal.cascade.editor.registry/BlockRenderScope.state.|(){}[0] + + abstract fun deleteBlock(io.github.linreal.cascade.editor.core/BlockId) // io.github.linreal.cascade.editor.registry/BlockRenderScope.deleteBlock|deleteBlock(io.github.linreal.cascade.editor.core.BlockId){}[0] + abstract fun focusBlock(io.github.linreal.cascade.editor.core/BlockId?) // io.github.linreal.cascade.editor.registry/BlockRenderScope.focusBlock|focusBlock(io.github.linreal.cascade.editor.core.BlockId?){}[0] + abstract fun getBlock(io.github.linreal.cascade.editor.core/BlockId): io.github.linreal.cascade.editor.core/Block? // io.github.linreal.cascade.editor.registry/BlockRenderScope.getBlock|getBlock(io.github.linreal.cascade.editor.core.BlockId){}[0] + abstract fun insertBlockAfter(io.github.linreal.cascade.editor.core/BlockId, io.github.linreal.cascade.editor.core/Block) // io.github.linreal.cascade.editor.registry/BlockRenderScope.insertBlockAfter|insertBlockAfter(io.github.linreal.cascade.editor.core.BlockId;io.github.linreal.cascade.editor.core.Block){}[0] + abstract fun insertBlockBefore(io.github.linreal.cascade.editor.core/BlockId, io.github.linreal.cascade.editor.core/Block) // io.github.linreal.cascade.editor.registry/BlockRenderScope.insertBlockBefore|insertBlockBefore(io.github.linreal.cascade.editor.core.BlockId;io.github.linreal.cascade.editor.core.Block){}[0] + abstract fun replaceBlock(io.github.linreal.cascade.editor.core/BlockId, io.github.linreal.cascade.editor.core/Block) // io.github.linreal.cascade.editor.registry/BlockRenderScope.replaceBlock|replaceBlock(io.github.linreal.cascade.editor.core.BlockId;io.github.linreal.cascade.editor.core.Block){}[0] + abstract fun updateBlock(io.github.linreal.cascade.editor.core/BlockId, kotlin/Function1) // io.github.linreal.cascade.editor.registry/BlockRenderScope.updateBlock|updateBlock(io.github.linreal.cascade.editor.core.BlockId;kotlin.Function1){}[0] +} + +abstract interface io.github.linreal.cascade.editor.richtext/FormattingActions { // io.github.linreal.cascade.editor.richtext/FormattingActions|null[0] + abstract fun applyStyle(io.github.linreal.cascade.editor.core/SpanStyle) // io.github.linreal.cascade.editor.richtext/FormattingActions.applyStyle|applyStyle(io.github.linreal.cascade.editor.core.SpanStyle){}[0] + abstract fun removeStyle(io.github.linreal.cascade.editor.core/SpanStyle) // io.github.linreal.cascade.editor.richtext/FormattingActions.removeStyle|removeStyle(io.github.linreal.cascade.editor.core.SpanStyle){}[0] + abstract fun toggleStyle(io.github.linreal.cascade.editor.core/SpanStyle) // io.github.linreal.cascade.editor.richtext/FormattingActions.toggleStyle|toggleStyle(io.github.linreal.cascade.editor.core.SpanStyle){}[0] +} + +abstract interface io.github.linreal.cascade.editor.richtext/LinkActions { // io.github.linreal.cascade.editor.richtext/LinkActions|null[0] + abstract fun applyLink(io.github.linreal.cascade.editor.richtext/LinkTarget, kotlin/String, kotlin/String? = ...): io.github.linreal.cascade.editor.richtext/LinkValidationResult // io.github.linreal.cascade.editor.richtext/LinkActions.applyLink|applyLink(io.github.linreal.cascade.editor.richtext.LinkTarget;kotlin.String;kotlin.String?){}[0] + abstract fun removeLink(io.github.linreal.cascade.editor.richtext/LinkTarget) // io.github.linreal.cascade.editor.richtext/LinkActions.removeLink|removeLink(io.github.linreal.cascade.editor.richtext.LinkTarget){}[0] +} + +abstract interface io.github.linreal.cascade.editor.richtext/LinkChromeActions : io.github.linreal.cascade.editor.richtext/LinkActions { // io.github.linreal.cascade.editor.richtext/LinkChromeActions|null[0] + abstract fun currentTarget(): io.github.linreal.cascade.editor.richtext/LinkTarget? // io.github.linreal.cascade.editor.richtext/LinkChromeActions.currentTarget|currentTarget(){}[0] + open fun applyLinkAtCurrentTarget(kotlin/String, kotlin/String? = ...): io.github.linreal.cascade.editor.richtext/LinkValidationResult? // io.github.linreal.cascade.editor.richtext/LinkChromeActions.applyLinkAtCurrentTarget|applyLinkAtCurrentTarget(kotlin.String;kotlin.String?){}[0] + open fun removeLinkAtCurrentTarget() // io.github.linreal.cascade.editor.richtext/LinkChromeActions.removeLinkAtCurrentTarget|removeLinkAtCurrentTarget(){}[0] +} + +abstract interface io.github.linreal.cascade.editor.serialization/BlockContentCodec { // io.github.linreal.cascade.editor.serialization/BlockContentCodec|null[0] + abstract fun decodeContent(kotlin/String, kotlinx.serialization.json/JsonObject): io.github.linreal.cascade.editor.core/BlockContent? // io.github.linreal.cascade.editor.serialization/BlockContentCodec.decodeContent|decodeContent(kotlin.String;kotlinx.serialization.json.JsonObject){}[0] + abstract fun encodeContent(io.github.linreal.cascade.editor.core/BlockContent): kotlinx.serialization.json/JsonObject? // io.github.linreal.cascade.editor.serialization/BlockContentCodec.encodeContent|encodeContent(io.github.linreal.cascade.editor.core.BlockContent){}[0] +} + +abstract interface io.github.linreal.cascade.editor.serialization/BlockTypeCodec { // io.github.linreal.cascade.editor.serialization/BlockTypeCodec|null[0] + abstract fun decodeType(kotlin/String, kotlinx.serialization.json/JsonObject): io.github.linreal.cascade.editor.core/BlockType? // io.github.linreal.cascade.editor.serialization/BlockTypeCodec.decodeType|decodeType(kotlin.String;kotlinx.serialization.json.JsonObject){}[0] + abstract fun encodeType(io.github.linreal.cascade.editor.core/BlockType): kotlinx.serialization.json/JsonObject? // io.github.linreal.cascade.editor.serialization/BlockTypeCodec.encodeType|encodeType(io.github.linreal.cascade.editor.core.BlockType){}[0] +} + +abstract interface io.github.linreal.cascade.editor.slash/SlashCommandEditor { // io.github.linreal.cascade.editor.slash/SlashCommandEditor|null[0] + abstract fun closeMenu() // io.github.linreal.cascade.editor.slash/SlashCommandEditor.closeMenu|closeMenu(){}[0] + abstract fun focusBlock(io.github.linreal.cascade.editor.core/BlockId, kotlin/Int? = ...) // io.github.linreal.cascade.editor.slash/SlashCommandEditor.focusBlock|focusBlock(io.github.linreal.cascade.editor.core.BlockId;kotlin.Int?){}[0] + abstract fun getAnchorBlock(): io.github.linreal.cascade.editor.core/Block? // io.github.linreal.cascade.editor.slash/SlashCommandEditor.getAnchorBlock|getAnchorBlock(){}[0] + abstract fun getAnchorVisibleText(): kotlin/String? // io.github.linreal.cascade.editor.slash/SlashCommandEditor.getAnchorVisibleText|getAnchorVisibleText(){}[0] + abstract fun insertBlockAfterAnchor(io.github.linreal.cascade.editor.core/Block, kotlin/Boolean = ..., kotlin/Int? = ...) // io.github.linreal.cascade.editor.slash/SlashCommandEditor.insertBlockAfterAnchor|insertBlockAfterAnchor(io.github.linreal.cascade.editor.core.Block;kotlin.Boolean;kotlin.Int?){}[0] + abstract fun insertBlockBeforeAnchor(io.github.linreal.cascade.editor.core/Block) // io.github.linreal.cascade.editor.slash/SlashCommandEditor.insertBlockBeforeAnchor|insertBlockBeforeAnchor(io.github.linreal.cascade.editor.core.Block){}[0] + abstract fun replaceAnchorBlock(io.github.linreal.cascade.editor.core/Block, kotlin/Boolean = ..., kotlin/Boolean = ..., kotlin/Int? = ...) // io.github.linreal.cascade.editor.slash/SlashCommandEditor.replaceAnchorBlock|replaceAnchorBlock(io.github.linreal.cascade.editor.core.Block;kotlin.Boolean;kotlin.Boolean;kotlin.Int?){}[0] + abstract fun replaceQueryText(kotlin/String = ...) // io.github.linreal.cascade.editor.slash/SlashCommandEditor.replaceQueryText|replaceQueryText(kotlin.String){}[0] + abstract fun updateAnchorText(kotlin/String, kotlin/Int? = ...) // io.github.linreal.cascade.editor.slash/SlashCommandEditor.updateAnchorText|updateAnchorText(kotlin.String;kotlin.Int?){}[0] +} + +abstract interface io.github.linreal.cascade.editor.ui/CascadeEditorToolbarController { // io.github.linreal.cascade.editor.ui/CascadeEditorToolbarController|null[0] + abstract val formattingActions // io.github.linreal.cascade.editor.ui/CascadeEditorToolbarController.formattingActions|{}formattingActions[0] + abstract fun (): io.github.linreal.cascade.editor.richtext/FormattingActions // io.github.linreal.cascade.editor.ui/CascadeEditorToolbarController.formattingActions.|(){}[0] + abstract val formattingState // io.github.linreal.cascade.editor.ui/CascadeEditorToolbarController.formattingState|{}formattingState[0] + abstract fun (): androidx.compose.runtime/State // io.github.linreal.cascade.editor.ui/CascadeEditorToolbarController.formattingState.|(){}[0] + abstract val indentationActions // io.github.linreal.cascade.editor.ui/CascadeEditorToolbarController.indentationActions|{}indentationActions[0] + abstract fun (): io.github.linreal.cascade.editor.indentation/IndentationActions // io.github.linreal.cascade.editor.ui/CascadeEditorToolbarController.indentationActions.|(){}[0] + abstract val indentationState // io.github.linreal.cascade.editor.ui/CascadeEditorToolbarController.indentationState|{}indentationState[0] + abstract fun (): androidx.compose.runtime/State // io.github.linreal.cascade.editor.ui/CascadeEditorToolbarController.indentationState.|(){}[0] + abstract val linkActions // io.github.linreal.cascade.editor.ui/CascadeEditorToolbarController.linkActions|{}linkActions[0] + abstract fun (): io.github.linreal.cascade.editor.richtext/LinkChromeActions // io.github.linreal.cascade.editor.ui/CascadeEditorToolbarController.linkActions.|(){}[0] + abstract val linkState // io.github.linreal.cascade.editor.ui/CascadeEditorToolbarController.linkState|{}linkState[0] + abstract fun (): androidx.compose.runtime/State // io.github.linreal.cascade.editor.ui/CascadeEditorToolbarController.linkState.|(){}[0] +} + +abstract interface io.github.linreal.cascade.editor.ui/LinkPopupActions { // io.github.linreal.cascade.editor.ui/LinkPopupActions|null[0] + abstract fun apply() // io.github.linreal.cascade.editor.ui/LinkPopupActions.apply|apply(){}[0] + abstract fun dismiss() // io.github.linreal.cascade.editor.ui/LinkPopupActions.dismiss|dismiss(){}[0] + abstract fun remove() // io.github.linreal.cascade.editor.ui/LinkPopupActions.remove|remove(){}[0] + abstract fun updateTitle(kotlin/String) // io.github.linreal.cascade.editor.ui/LinkPopupActions.updateTitle|updateTitle(kotlin.String){}[0] + abstract fun updateUrl(kotlin/String) // io.github.linreal.cascade.editor.ui/LinkPopupActions.updateUrl|updateUrl(kotlin.String){}[0] +} + +sealed interface io.github.linreal.cascade.editor.action/EditorAction { // io.github.linreal.cascade.editor.action/EditorAction|null[0] + abstract fun reduce(io.github.linreal.cascade.editor.state/EditorState): io.github.linreal.cascade.editor.state/EditorState // io.github.linreal.cascade.editor.action/EditorAction.reduce|reduce(io.github.linreal.cascade.editor.state.EditorState){}[0] +} + +sealed interface io.github.linreal.cascade.editor.core/BlockContent { // io.github.linreal.cascade.editor.core/BlockContent|null[0] + final class Custom : io.github.linreal.cascade.editor.core/BlockContent { // io.github.linreal.cascade.editor.core/BlockContent.Custom|null[0] + constructor (kotlin/String, kotlin.collections/Map = ...) // io.github.linreal.cascade.editor.core/BlockContent.Custom.|(kotlin.String;kotlin.collections.Map){}[0] + + final val data // io.github.linreal.cascade.editor.core/BlockContent.Custom.data|{}data[0] + final fun (): kotlin.collections/Map // io.github.linreal.cascade.editor.core/BlockContent.Custom.data.|(){}[0] + final val typeId // io.github.linreal.cascade.editor.core/BlockContent.Custom.typeId|{}typeId[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.core/BlockContent.Custom.typeId.|(){}[0] + + final fun component1(): kotlin/String // io.github.linreal.cascade.editor.core/BlockContent.Custom.component1|component1(){}[0] + final fun component2(): kotlin.collections/Map // io.github.linreal.cascade.editor.core/BlockContent.Custom.component2|component2(){}[0] + final fun copy(kotlin/String = ..., kotlin.collections/Map = ...): io.github.linreal.cascade.editor.core/BlockContent.Custom // io.github.linreal.cascade.editor.core/BlockContent.Custom.copy|copy(kotlin.String;kotlin.collections.Map){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.core/BlockContent.Custom.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.core/BlockContent.Custom.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.core/BlockContent.Custom.toString|toString(){}[0] + } + + final class Text : io.github.linreal.cascade.editor.core/BlockContent { // io.github.linreal.cascade.editor.core/BlockContent.Text|null[0] + constructor (kotlin/String, kotlin.collections/List = ...) // io.github.linreal.cascade.editor.core/BlockContent.Text.|(kotlin.String;kotlin.collections.List){}[0] + + final val spans // io.github.linreal.cascade.editor.core/BlockContent.Text.spans|{}spans[0] + final fun (): kotlin.collections/List // io.github.linreal.cascade.editor.core/BlockContent.Text.spans.|(){}[0] + final val text // io.github.linreal.cascade.editor.core/BlockContent.Text.text|{}text[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.core/BlockContent.Text.text.|(){}[0] + + final fun component1(): kotlin/String // io.github.linreal.cascade.editor.core/BlockContent.Text.component1|component1(){}[0] + final fun component2(): kotlin.collections/List // io.github.linreal.cascade.editor.core/BlockContent.Text.component2|component2(){}[0] + final fun copy(kotlin/String = ..., kotlin.collections/List = ...): io.github.linreal.cascade.editor.core/BlockContent.Text // io.github.linreal.cascade.editor.core/BlockContent.Text.copy|copy(kotlin.String;kotlin.collections.List){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.core/BlockContent.Text.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.core/BlockContent.Text.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.core/BlockContent.Text.toString|toString(){}[0] + } + + final object Empty : io.github.linreal.cascade.editor.core/BlockContent { // io.github.linreal.cascade.editor.core/BlockContent.Empty|null[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.core/BlockContent.Empty.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.core/BlockContent.Empty.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.core/BlockContent.Empty.toString|toString(){}[0] + } +} + +sealed interface io.github.linreal.cascade.editor.core/BlockType { // io.github.linreal.cascade.editor.core/BlockType|null[0] + abstract val displayName // io.github.linreal.cascade.editor.core/BlockType.displayName|{}displayName[0] + abstract fun (): kotlin/String // io.github.linreal.cascade.editor.core/BlockType.displayName.|(){}[0] + abstract val typeId // io.github.linreal.cascade.editor.core/BlockType.typeId|{}typeId[0] + abstract fun (): kotlin/String // io.github.linreal.cascade.editor.core/BlockType.typeId.|(){}[0] + open val isConvertible // io.github.linreal.cascade.editor.core/BlockType.isConvertible|{}isConvertible[0] + open fun (): kotlin/Boolean // io.github.linreal.cascade.editor.core/BlockType.isConvertible.|(){}[0] + open val supportsIndentation // io.github.linreal.cascade.editor.core/BlockType.supportsIndentation|{}supportsIndentation[0] + open fun (): kotlin/Boolean // io.github.linreal.cascade.editor.core/BlockType.supportsIndentation.|(){}[0] + open val supportsSpans // io.github.linreal.cascade.editor.core/BlockType.supportsSpans|{}supportsSpans[0] + open fun (): kotlin/Boolean // io.github.linreal.cascade.editor.core/BlockType.supportsSpans.|(){}[0] + open val supportsText // io.github.linreal.cascade.editor.core/BlockType.supportsText|{}supportsText[0] + open fun (): kotlin/Boolean // io.github.linreal.cascade.editor.core/BlockType.supportsText.|(){}[0] + + final class Heading : io.github.linreal.cascade.editor.core/BlockType { // io.github.linreal.cascade.editor.core/BlockType.Heading|null[0] + constructor (kotlin/Int) // io.github.linreal.cascade.editor.core/BlockType.Heading.|(kotlin.Int){}[0] + + final val displayName // io.github.linreal.cascade.editor.core/BlockType.Heading.displayName|{}displayName[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.core/BlockType.Heading.displayName.|(){}[0] + final val level // io.github.linreal.cascade.editor.core/BlockType.Heading.level|{}level[0] + final fun (): kotlin/Int // io.github.linreal.cascade.editor.core/BlockType.Heading.level.|(){}[0] + final val supportsText // io.github.linreal.cascade.editor.core/BlockType.Heading.supportsText|{}supportsText[0] + final fun (): kotlin/Boolean // io.github.linreal.cascade.editor.core/BlockType.Heading.supportsText.|(){}[0] + final val typeId // io.github.linreal.cascade.editor.core/BlockType.Heading.typeId|{}typeId[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.core/BlockType.Heading.typeId.|(){}[0] + + final fun component1(): kotlin/Int // io.github.linreal.cascade.editor.core/BlockType.Heading.component1|component1(){}[0] + final fun copy(kotlin/Int = ...): io.github.linreal.cascade.editor.core/BlockType.Heading // io.github.linreal.cascade.editor.core/BlockType.Heading.copy|copy(kotlin.Int){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.core/BlockType.Heading.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.core/BlockType.Heading.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.core/BlockType.Heading.toString|toString(){}[0] + } + + final class NumberedList : io.github.linreal.cascade.editor.core/BlockType { // io.github.linreal.cascade.editor.core/BlockType.NumberedList|null[0] + constructor (kotlin/Int = ...) // io.github.linreal.cascade.editor.core/BlockType.NumberedList.|(kotlin.Int){}[0] + + final val displayName // io.github.linreal.cascade.editor.core/BlockType.NumberedList.displayName|{}displayName[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.core/BlockType.NumberedList.displayName.|(){}[0] + final val number // io.github.linreal.cascade.editor.core/BlockType.NumberedList.number|{}number[0] + final fun (): kotlin/Int // io.github.linreal.cascade.editor.core/BlockType.NumberedList.number.|(){}[0] + final val supportsIndentation // io.github.linreal.cascade.editor.core/BlockType.NumberedList.supportsIndentation|{}supportsIndentation[0] + final fun (): kotlin/Boolean // io.github.linreal.cascade.editor.core/BlockType.NumberedList.supportsIndentation.|(){}[0] + final val supportsText // io.github.linreal.cascade.editor.core/BlockType.NumberedList.supportsText|{}supportsText[0] + final fun (): kotlin/Boolean // io.github.linreal.cascade.editor.core/BlockType.NumberedList.supportsText.|(){}[0] + final val typeId // io.github.linreal.cascade.editor.core/BlockType.NumberedList.typeId|{}typeId[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.core/BlockType.NumberedList.typeId.|(){}[0] + + final fun component1(): kotlin/Int // io.github.linreal.cascade.editor.core/BlockType.NumberedList.component1|component1(){}[0] + final fun copy(kotlin/Int = ...): io.github.linreal.cascade.editor.core/BlockType.NumberedList // io.github.linreal.cascade.editor.core/BlockType.NumberedList.copy|copy(kotlin.Int){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.core/BlockType.NumberedList.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.core/BlockType.NumberedList.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.core/BlockType.NumberedList.toString|toString(){}[0] + } + + final class Todo : io.github.linreal.cascade.editor.core/BlockType { // io.github.linreal.cascade.editor.core/BlockType.Todo|null[0] + constructor (kotlin/Boolean = ...) // io.github.linreal.cascade.editor.core/BlockType.Todo.|(kotlin.Boolean){}[0] + + final val checked // io.github.linreal.cascade.editor.core/BlockType.Todo.checked|{}checked[0] + final fun (): kotlin/Boolean // io.github.linreal.cascade.editor.core/BlockType.Todo.checked.|(){}[0] + final val displayName // io.github.linreal.cascade.editor.core/BlockType.Todo.displayName|{}displayName[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.core/BlockType.Todo.displayName.|(){}[0] + final val supportsIndentation // io.github.linreal.cascade.editor.core/BlockType.Todo.supportsIndentation|{}supportsIndentation[0] + final fun (): kotlin/Boolean // io.github.linreal.cascade.editor.core/BlockType.Todo.supportsIndentation.|(){}[0] + final val supportsText // io.github.linreal.cascade.editor.core/BlockType.Todo.supportsText|{}supportsText[0] + final fun (): kotlin/Boolean // io.github.linreal.cascade.editor.core/BlockType.Todo.supportsText.|(){}[0] + final val typeId // io.github.linreal.cascade.editor.core/BlockType.Todo.typeId|{}typeId[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.core/BlockType.Todo.typeId.|(){}[0] + + final fun component1(): kotlin/Boolean // io.github.linreal.cascade.editor.core/BlockType.Todo.component1|component1(){}[0] + final fun copy(kotlin/Boolean = ...): io.github.linreal.cascade.editor.core/BlockType.Todo // io.github.linreal.cascade.editor.core/BlockType.Todo.copy|copy(kotlin.Boolean){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.core/BlockType.Todo.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.core/BlockType.Todo.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.core/BlockType.Todo.toString|toString(){}[0] + } + + final object BulletList : io.github.linreal.cascade.editor.core/BlockType { // io.github.linreal.cascade.editor.core/BlockType.BulletList|null[0] + final val displayName // io.github.linreal.cascade.editor.core/BlockType.BulletList.displayName|{}displayName[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.core/BlockType.BulletList.displayName.|(){}[0] + final val supportsIndentation // io.github.linreal.cascade.editor.core/BlockType.BulletList.supportsIndentation|{}supportsIndentation[0] + final fun (): kotlin/Boolean // io.github.linreal.cascade.editor.core/BlockType.BulletList.supportsIndentation.|(){}[0] + final val supportsText // io.github.linreal.cascade.editor.core/BlockType.BulletList.supportsText|{}supportsText[0] + final fun (): kotlin/Boolean // io.github.linreal.cascade.editor.core/BlockType.BulletList.supportsText.|(){}[0] + final val typeId // io.github.linreal.cascade.editor.core/BlockType.BulletList.typeId|{}typeId[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.core/BlockType.BulletList.typeId.|(){}[0] + + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.core/BlockType.BulletList.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.core/BlockType.BulletList.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.core/BlockType.BulletList.toString|toString(){}[0] + } + + final object Code : io.github.linreal.cascade.editor.core/BlockType { // io.github.linreal.cascade.editor.core/BlockType.Code|null[0] + final val displayName // io.github.linreal.cascade.editor.core/BlockType.Code.displayName|{}displayName[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.core/BlockType.Code.displayName.|(){}[0] + final val supportsIndentation // io.github.linreal.cascade.editor.core/BlockType.Code.supportsIndentation|{}supportsIndentation[0] + final fun (): kotlin/Boolean // io.github.linreal.cascade.editor.core/BlockType.Code.supportsIndentation.|(){}[0] + final val supportsSpans // io.github.linreal.cascade.editor.core/BlockType.Code.supportsSpans|{}supportsSpans[0] + final fun (): kotlin/Boolean // io.github.linreal.cascade.editor.core/BlockType.Code.supportsSpans.|(){}[0] + final val supportsText // io.github.linreal.cascade.editor.core/BlockType.Code.supportsText|{}supportsText[0] + final fun (): kotlin/Boolean // io.github.linreal.cascade.editor.core/BlockType.Code.supportsText.|(){}[0] + final val typeId // io.github.linreal.cascade.editor.core/BlockType.Code.typeId|{}typeId[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.core/BlockType.Code.typeId.|(){}[0] + + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.core/BlockType.Code.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.core/BlockType.Code.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.core/BlockType.Code.toString|toString(){}[0] + } + + final object Divider : io.github.linreal.cascade.editor.core/BlockType { // io.github.linreal.cascade.editor.core/BlockType.Divider|null[0] + final val displayName // io.github.linreal.cascade.editor.core/BlockType.Divider.displayName|{}displayName[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.core/BlockType.Divider.displayName.|(){}[0] + final val isConvertible // io.github.linreal.cascade.editor.core/BlockType.Divider.isConvertible|{}isConvertible[0] + final fun (): kotlin/Boolean // io.github.linreal.cascade.editor.core/BlockType.Divider.isConvertible.|(){}[0] + final val supportsText // io.github.linreal.cascade.editor.core/BlockType.Divider.supportsText|{}supportsText[0] + final fun (): kotlin/Boolean // io.github.linreal.cascade.editor.core/BlockType.Divider.supportsText.|(){}[0] + final val typeId // io.github.linreal.cascade.editor.core/BlockType.Divider.typeId|{}typeId[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.core/BlockType.Divider.typeId.|(){}[0] + + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.core/BlockType.Divider.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.core/BlockType.Divider.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.core/BlockType.Divider.toString|toString(){}[0] + } + + final object Paragraph : io.github.linreal.cascade.editor.core/BlockType { // io.github.linreal.cascade.editor.core/BlockType.Paragraph|null[0] + final val displayName // io.github.linreal.cascade.editor.core/BlockType.Paragraph.displayName|{}displayName[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.core/BlockType.Paragraph.displayName.|(){}[0] + final val supportsIndentation // io.github.linreal.cascade.editor.core/BlockType.Paragraph.supportsIndentation|{}supportsIndentation[0] + final fun (): kotlin/Boolean // io.github.linreal.cascade.editor.core/BlockType.Paragraph.supportsIndentation.|(){}[0] + final val supportsText // io.github.linreal.cascade.editor.core/BlockType.Paragraph.supportsText|{}supportsText[0] + final fun (): kotlin/Boolean // io.github.linreal.cascade.editor.core/BlockType.Paragraph.supportsText.|(){}[0] + final val typeId // io.github.linreal.cascade.editor.core/BlockType.Paragraph.typeId|{}typeId[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.core/BlockType.Paragraph.typeId.|(){}[0] + + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.core/BlockType.Paragraph.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.core/BlockType.Paragraph.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.core/BlockType.Paragraph.toString|toString(){}[0] + } + + final object Quote : io.github.linreal.cascade.editor.core/BlockType { // io.github.linreal.cascade.editor.core/BlockType.Quote|null[0] + final val displayName // io.github.linreal.cascade.editor.core/BlockType.Quote.displayName|{}displayName[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.core/BlockType.Quote.displayName.|(){}[0] + final val supportsText // io.github.linreal.cascade.editor.core/BlockType.Quote.supportsText|{}supportsText[0] + final fun (): kotlin/Boolean // io.github.linreal.cascade.editor.core/BlockType.Quote.supportsText.|(){}[0] + final val typeId // io.github.linreal.cascade.editor.core/BlockType.Quote.typeId|{}typeId[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.core/BlockType.Quote.typeId.|(){}[0] + + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.core/BlockType.Quote.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.core/BlockType.Quote.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.core/BlockType.Quote.toString|toString(){}[0] + } +} + +sealed interface io.github.linreal.cascade.editor.core/SpanStyle { // io.github.linreal.cascade.editor.core/SpanStyle|null[0] + final class Custom : io.github.linreal.cascade.editor.core/SpanStyle { // io.github.linreal.cascade.editor.core/SpanStyle.Custom|null[0] + constructor (kotlin/String, kotlin/String? = ...) // io.github.linreal.cascade.editor.core/SpanStyle.Custom.|(kotlin.String;kotlin.String?){}[0] + + final val payload // io.github.linreal.cascade.editor.core/SpanStyle.Custom.payload|{}payload[0] + final fun (): kotlin/String? // io.github.linreal.cascade.editor.core/SpanStyle.Custom.payload.|(){}[0] + final val typeId // io.github.linreal.cascade.editor.core/SpanStyle.Custom.typeId|{}typeId[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.core/SpanStyle.Custom.typeId.|(){}[0] + + final fun component1(): kotlin/String // io.github.linreal.cascade.editor.core/SpanStyle.Custom.component1|component1(){}[0] + final fun component2(): kotlin/String? // io.github.linreal.cascade.editor.core/SpanStyle.Custom.component2|component2(){}[0] + final fun copy(kotlin/String = ..., kotlin/String? = ...): io.github.linreal.cascade.editor.core/SpanStyle.Custom // io.github.linreal.cascade.editor.core/SpanStyle.Custom.copy|copy(kotlin.String;kotlin.String?){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.core/SpanStyle.Custom.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.core/SpanStyle.Custom.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.core/SpanStyle.Custom.toString|toString(){}[0] + } + + final class Highlight : io.github.linreal.cascade.editor.core/SpanStyle { // io.github.linreal.cascade.editor.core/SpanStyle.Highlight|null[0] + constructor (kotlin/Long) // io.github.linreal.cascade.editor.core/SpanStyle.Highlight.|(kotlin.Long){}[0] + + final val colorArgb // io.github.linreal.cascade.editor.core/SpanStyle.Highlight.colorArgb|{}colorArgb[0] + final fun (): kotlin/Long // io.github.linreal.cascade.editor.core/SpanStyle.Highlight.colorArgb.|(){}[0] + + final fun component1(): kotlin/Long // io.github.linreal.cascade.editor.core/SpanStyle.Highlight.component1|component1(){}[0] + final fun copy(kotlin/Long = ...): io.github.linreal.cascade.editor.core/SpanStyle.Highlight // io.github.linreal.cascade.editor.core/SpanStyle.Highlight.copy|copy(kotlin.Long){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.core/SpanStyle.Highlight.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.core/SpanStyle.Highlight.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.core/SpanStyle.Highlight.toString|toString(){}[0] + } + + final class Link : io.github.linreal.cascade.editor.core/SpanStyle { // io.github.linreal.cascade.editor.core/SpanStyle.Link|null[0] + constructor (kotlin/String) // io.github.linreal.cascade.editor.core/SpanStyle.Link.|(kotlin.String){}[0] + + final val url // io.github.linreal.cascade.editor.core/SpanStyle.Link.url|{}url[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.core/SpanStyle.Link.url.|(){}[0] + + final fun component1(): kotlin/String // io.github.linreal.cascade.editor.core/SpanStyle.Link.component1|component1(){}[0] + final fun copy(kotlin/String = ...): io.github.linreal.cascade.editor.core/SpanStyle.Link // io.github.linreal.cascade.editor.core/SpanStyle.Link.copy|copy(kotlin.String){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.core/SpanStyle.Link.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.core/SpanStyle.Link.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.core/SpanStyle.Link.toString|toString(){}[0] + } + + final object Bold : io.github.linreal.cascade.editor.core/SpanStyle { // io.github.linreal.cascade.editor.core/SpanStyle.Bold|null[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.core/SpanStyle.Bold.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.core/SpanStyle.Bold.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.core/SpanStyle.Bold.toString|toString(){}[0] + } + + final object Companion { // io.github.linreal.cascade.editor.core/SpanStyle.Companion|null[0] + final fun kindKey(io.github.linreal.cascade.editor.core/SpanStyle): kotlin/Any // io.github.linreal.cascade.editor.core/SpanStyle.Companion.kindKey|kindKey(io.github.linreal.cascade.editor.core.SpanStyle){}[0] + final fun kindMatches(io.github.linreal.cascade.editor.core/SpanStyle, io.github.linreal.cascade.editor.core/SpanStyle): kotlin/Boolean // io.github.linreal.cascade.editor.core/SpanStyle.Companion.kindMatches|kindMatches(io.github.linreal.cascade.editor.core.SpanStyle;io.github.linreal.cascade.editor.core.SpanStyle){}[0] + } + + final object InlineCode : io.github.linreal.cascade.editor.core/SpanStyle { // io.github.linreal.cascade.editor.core/SpanStyle.InlineCode|null[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.core/SpanStyle.InlineCode.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.core/SpanStyle.InlineCode.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.core/SpanStyle.InlineCode.toString|toString(){}[0] + } + + final object Italic : io.github.linreal.cascade.editor.core/SpanStyle { // io.github.linreal.cascade.editor.core/SpanStyle.Italic|null[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.core/SpanStyle.Italic.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.core/SpanStyle.Italic.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.core/SpanStyle.Italic.toString|toString(){}[0] + } + + final object StrikeThrough : io.github.linreal.cascade.editor.core/SpanStyle { // io.github.linreal.cascade.editor.core/SpanStyle.StrikeThrough|null[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.core/SpanStyle.StrikeThrough.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.core/SpanStyle.StrikeThrough.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.core/SpanStyle.StrikeThrough.toString|toString(){}[0] + } + + final object Underline : io.github.linreal.cascade.editor.core/SpanStyle { // io.github.linreal.cascade.editor.core/SpanStyle.Underline|null[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.core/SpanStyle.Underline.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.core/SpanStyle.Underline.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.core/SpanStyle.Underline.toString|toString(){}[0] + } +} + +sealed interface io.github.linreal.cascade.editor.htmlserialization/BlockSeparator { // io.github.linreal.cascade.editor.htmlserialization/BlockSeparator|null[0] + final object BlockTags : io.github.linreal.cascade.editor.htmlserialization/BlockSeparator { // io.github.linreal.cascade.editor.htmlserialization/BlockSeparator.BlockTags|null[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.htmlserialization/BlockSeparator.BlockTags.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/BlockSeparator.BlockTags.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/BlockSeparator.BlockTags.toString|toString(){}[0] + } + + final object Newline : io.github.linreal.cascade.editor.htmlserialization/BlockSeparator { // io.github.linreal.cascade.editor.htmlserialization/BlockSeparator.Newline|null[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.htmlserialization/BlockSeparator.Newline.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/BlockSeparator.Newline.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/BlockSeparator.Newline.toString|toString(){}[0] + } +} + +sealed interface io.github.linreal.cascade.editor.htmlserialization/EntityDecode { // io.github.linreal.cascade.editor.htmlserialization/EntityDecode|null[0] + final object None : io.github.linreal.cascade.editor.htmlserialization/EntityDecode { // io.github.linreal.cascade.editor.htmlserialization/EntityDecode.None|null[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.htmlserialization/EntityDecode.None.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/EntityDecode.None.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/EntityDecode.None.toString|toString(){}[0] + } + + final object Standard : io.github.linreal.cascade.editor.htmlserialization/EntityDecode { // io.github.linreal.cascade.editor.htmlserialization/EntityDecode.Standard|null[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.htmlserialization/EntityDecode.Standard.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/EntityDecode.Standard.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/EntityDecode.Standard.toString|toString(){}[0] + } +} + +sealed interface io.github.linreal.cascade.editor.htmlserialization/HtmlEmit { // io.github.linreal.cascade.editor.htmlserialization/HtmlEmit|null[0] + final class Raw : io.github.linreal.cascade.editor.htmlserialization/HtmlEmit { // io.github.linreal.cascade.editor.htmlserialization/HtmlEmit.Raw|null[0] + constructor (kotlin/String) // io.github.linreal.cascade.editor.htmlserialization/HtmlEmit.Raw.|(kotlin.String){}[0] + + final val html // io.github.linreal.cascade.editor.htmlserialization/HtmlEmit.Raw.html|{}html[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlEmit.Raw.html.|(){}[0] + + final fun component1(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlEmit.Raw.component1|component1(){}[0] + final fun copy(kotlin/String = ...): io.github.linreal.cascade.editor.htmlserialization/HtmlEmit.Raw // io.github.linreal.cascade.editor.htmlserialization/HtmlEmit.Raw.copy|copy(kotlin.String){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.htmlserialization/HtmlEmit.Raw.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlEmit.Raw.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlEmit.Raw.toString|toString(){}[0] + } + + final object Skip : io.github.linreal.cascade.editor.htmlserialization/HtmlEmit { // io.github.linreal.cascade.editor.htmlserialization/HtmlEmit.Skip|null[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.htmlserialization/HtmlEmit.Skip.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlEmit.Skip.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlEmit.Skip.toString|toString(){}[0] + } +} + +sealed interface io.github.linreal.cascade.editor.htmlserialization/HtmlNodeView { // io.github.linreal.cascade.editor.htmlserialization/HtmlNodeView|null[0] + abstract val sourceEndExclusive // io.github.linreal.cascade.editor.htmlserialization/HtmlNodeView.sourceEndExclusive|{}sourceEndExclusive[0] + abstract fun (): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlNodeView.sourceEndExclusive.|(){}[0] + abstract val sourceStart // io.github.linreal.cascade.editor.htmlserialization/HtmlNodeView.sourceStart|{}sourceStart[0] + abstract fun (): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlNodeView.sourceStart.|(){}[0] + + final class Element : io.github.linreal.cascade.editor.htmlserialization/HtmlNodeView { // io.github.linreal.cascade.editor.htmlserialization/HtmlNodeView.Element|null[0] + constructor (kotlin/String, kotlin.collections/Map, kotlin.collections/List, kotlin/Int, kotlin/Int) // io.github.linreal.cascade.editor.htmlserialization/HtmlNodeView.Element.|(kotlin.String;kotlin.collections.Map;kotlin.collections.List;kotlin.Int;kotlin.Int){}[0] + + final val attrs // io.github.linreal.cascade.editor.htmlserialization/HtmlNodeView.Element.attrs|{}attrs[0] + final fun (): kotlin.collections/Map // io.github.linreal.cascade.editor.htmlserialization/HtmlNodeView.Element.attrs.|(){}[0] + final val children // io.github.linreal.cascade.editor.htmlserialization/HtmlNodeView.Element.children|{}children[0] + final fun (): kotlin.collections/List // io.github.linreal.cascade.editor.htmlserialization/HtmlNodeView.Element.children.|(){}[0] + final val sourceEndExclusive // io.github.linreal.cascade.editor.htmlserialization/HtmlNodeView.Element.sourceEndExclusive|{}sourceEndExclusive[0] + final fun (): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlNodeView.Element.sourceEndExclusive.|(){}[0] + final val sourceStart // io.github.linreal.cascade.editor.htmlserialization/HtmlNodeView.Element.sourceStart|{}sourceStart[0] + final fun (): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlNodeView.Element.sourceStart.|(){}[0] + final val tag // io.github.linreal.cascade.editor.htmlserialization/HtmlNodeView.Element.tag|{}tag[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlNodeView.Element.tag.|(){}[0] + + final fun component1(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlNodeView.Element.component1|component1(){}[0] + final fun component2(): kotlin.collections/Map // io.github.linreal.cascade.editor.htmlserialization/HtmlNodeView.Element.component2|component2(){}[0] + final fun component3(): kotlin.collections/List // io.github.linreal.cascade.editor.htmlserialization/HtmlNodeView.Element.component3|component3(){}[0] + final fun component4(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlNodeView.Element.component4|component4(){}[0] + final fun component5(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlNodeView.Element.component5|component5(){}[0] + final fun copy(kotlin/String = ..., kotlin.collections/Map = ..., kotlin.collections/List = ..., kotlin/Int = ..., kotlin/Int = ...): io.github.linreal.cascade.editor.htmlserialization/HtmlNodeView.Element // io.github.linreal.cascade.editor.htmlserialization/HtmlNodeView.Element.copy|copy(kotlin.String;kotlin.collections.Map;kotlin.collections.List;kotlin.Int;kotlin.Int){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.htmlserialization/HtmlNodeView.Element.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlNodeView.Element.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlNodeView.Element.toString|toString(){}[0] + } + + final class Text : io.github.linreal.cascade.editor.htmlserialization/HtmlNodeView { // io.github.linreal.cascade.editor.htmlserialization/HtmlNodeView.Text|null[0] + constructor (kotlin/String, kotlin/Int, kotlin/Int) // io.github.linreal.cascade.editor.htmlserialization/HtmlNodeView.Text.|(kotlin.String;kotlin.Int;kotlin.Int){}[0] + + final val sourceEndExclusive // io.github.linreal.cascade.editor.htmlserialization/HtmlNodeView.Text.sourceEndExclusive|{}sourceEndExclusive[0] + final fun (): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlNodeView.Text.sourceEndExclusive.|(){}[0] + final val sourceStart // io.github.linreal.cascade.editor.htmlserialization/HtmlNodeView.Text.sourceStart|{}sourceStart[0] + final fun (): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlNodeView.Text.sourceStart.|(){}[0] + final val text // io.github.linreal.cascade.editor.htmlserialization/HtmlNodeView.Text.text|{}text[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlNodeView.Text.text.|(){}[0] + + final fun component1(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlNodeView.Text.component1|component1(){}[0] + final fun component2(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlNodeView.Text.component2|component2(){}[0] + final fun component3(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlNodeView.Text.component3|component3(){}[0] + final fun copy(kotlin/String = ..., kotlin/Int = ..., kotlin/Int = ...): io.github.linreal.cascade.editor.htmlserialization/HtmlNodeView.Text // io.github.linreal.cascade.editor.htmlserialization/HtmlNodeView.Text.copy|copy(kotlin.String;kotlin.Int;kotlin.Int){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.htmlserialization/HtmlNodeView.Text.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlNodeView.Text.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlNodeView.Text.toString|toString(){}[0] + } +} + +sealed interface io.github.linreal.cascade.editor.htmlserialization/InlineRoot { // io.github.linreal.cascade.editor.htmlserialization/InlineRoot|null[0] + final object Drop : io.github.linreal.cascade.editor.htmlserialization/InlineRoot { // io.github.linreal.cascade.editor.htmlserialization/InlineRoot.Drop|null[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.htmlserialization/InlineRoot.Drop.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/InlineRoot.Drop.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/InlineRoot.Drop.toString|toString(){}[0] + } + + final object WrapInParagraph : io.github.linreal.cascade.editor.htmlserialization/InlineRoot { // io.github.linreal.cascade.editor.htmlserialization/InlineRoot.WrapInParagraph|null[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.htmlserialization/InlineRoot.WrapInParagraph.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/InlineRoot.WrapInParagraph.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/InlineRoot.WrapInParagraph.toString|toString(){}[0] + } +} + +sealed interface io.github.linreal.cascade.editor.htmlserialization/TagDecodeResult { // io.github.linreal.cascade.editor.htmlserialization/TagDecodeResult|null[0] + final class AsBlock : io.github.linreal.cascade.editor.htmlserialization/TagDecodeResult { // io.github.linreal.cascade.editor.htmlserialization/TagDecodeResult.AsBlock|null[0] + constructor (io.github.linreal.cascade.editor.core/Block) // io.github.linreal.cascade.editor.htmlserialization/TagDecodeResult.AsBlock.|(io.github.linreal.cascade.editor.core.Block){}[0] + + final val block // io.github.linreal.cascade.editor.htmlserialization/TagDecodeResult.AsBlock.block|{}block[0] + final fun (): io.github.linreal.cascade.editor.core/Block // io.github.linreal.cascade.editor.htmlserialization/TagDecodeResult.AsBlock.block.|(){}[0] + + final fun component1(): io.github.linreal.cascade.editor.core/Block // io.github.linreal.cascade.editor.htmlserialization/TagDecodeResult.AsBlock.component1|component1(){}[0] + final fun copy(io.github.linreal.cascade.editor.core/Block = ...): io.github.linreal.cascade.editor.htmlserialization/TagDecodeResult.AsBlock // io.github.linreal.cascade.editor.htmlserialization/TagDecodeResult.AsBlock.copy|copy(io.github.linreal.cascade.editor.core.Block){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.htmlserialization/TagDecodeResult.AsBlock.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/TagDecodeResult.AsBlock.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/TagDecodeResult.AsBlock.toString|toString(){}[0] + } + + final class AsBlocks : io.github.linreal.cascade.editor.htmlserialization/TagDecodeResult { // io.github.linreal.cascade.editor.htmlserialization/TagDecodeResult.AsBlocks|null[0] + constructor (kotlin.collections/List) // io.github.linreal.cascade.editor.htmlserialization/TagDecodeResult.AsBlocks.|(kotlin.collections.List){}[0] + + final val blocks // io.github.linreal.cascade.editor.htmlserialization/TagDecodeResult.AsBlocks.blocks|{}blocks[0] + final fun (): kotlin.collections/List // io.github.linreal.cascade.editor.htmlserialization/TagDecodeResult.AsBlocks.blocks.|(){}[0] + + final fun component1(): kotlin.collections/List // io.github.linreal.cascade.editor.htmlserialization/TagDecodeResult.AsBlocks.component1|component1(){}[0] + final fun copy(kotlin.collections/List = ...): io.github.linreal.cascade.editor.htmlserialization/TagDecodeResult.AsBlocks // io.github.linreal.cascade.editor.htmlserialization/TagDecodeResult.AsBlocks.copy|copy(kotlin.collections.List){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.htmlserialization/TagDecodeResult.AsBlocks.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/TagDecodeResult.AsBlocks.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/TagDecodeResult.AsBlocks.toString|toString(){}[0] + } + + final class AsText : io.github.linreal.cascade.editor.htmlserialization/TagDecodeResult { // io.github.linreal.cascade.editor.htmlserialization/TagDecodeResult.AsText|null[0] + constructor (kotlin/String, kotlin.collections/List) // io.github.linreal.cascade.editor.htmlserialization/TagDecodeResult.AsText.|(kotlin.String;kotlin.collections.List){}[0] + + final val spans // io.github.linreal.cascade.editor.htmlserialization/TagDecodeResult.AsText.spans|{}spans[0] + final fun (): kotlin.collections/List // io.github.linreal.cascade.editor.htmlserialization/TagDecodeResult.AsText.spans.|(){}[0] + final val text // io.github.linreal.cascade.editor.htmlserialization/TagDecodeResult.AsText.text|{}text[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/TagDecodeResult.AsText.text.|(){}[0] + + final fun component1(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/TagDecodeResult.AsText.component1|component1(){}[0] + final fun component2(): kotlin.collections/List // io.github.linreal.cascade.editor.htmlserialization/TagDecodeResult.AsText.component2|component2(){}[0] + final fun copy(kotlin/String = ..., kotlin.collections/List = ...): io.github.linreal.cascade.editor.htmlserialization/TagDecodeResult.AsText // io.github.linreal.cascade.editor.htmlserialization/TagDecodeResult.AsText.copy|copy(kotlin.String;kotlin.collections.List){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.htmlserialization/TagDecodeResult.AsText.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/TagDecodeResult.AsText.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/TagDecodeResult.AsText.toString|toString(){}[0] + } + + final object Drop : io.github.linreal.cascade.editor.htmlserialization/TagDecodeResult { // io.github.linreal.cascade.editor.htmlserialization/TagDecodeResult.Drop|null[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.htmlserialization/TagDecodeResult.Drop.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/TagDecodeResult.Drop.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/TagDecodeResult.Drop.toString|toString(){}[0] + } +} + +sealed interface io.github.linreal.cascade.editor.htmlserialization/UnknownTagPolicy { // io.github.linreal.cascade.editor.htmlserialization/UnknownTagPolicy|null[0] + final class Custom : io.github.linreal.cascade.editor.htmlserialization/UnknownTagPolicy { // io.github.linreal.cascade.editor.htmlserialization/UnknownTagPolicy.Custom|null[0] + constructor (kotlin/Function2) // io.github.linreal.cascade.editor.htmlserialization/UnknownTagPolicy.Custom.|(kotlin.Function2){}[0] + + final val handler // io.github.linreal.cascade.editor.htmlserialization/UnknownTagPolicy.Custom.handler|{}handler[0] + final fun (): kotlin/Function2 // io.github.linreal.cascade.editor.htmlserialization/UnknownTagPolicy.Custom.handler.|(){}[0] + + final fun component1(): kotlin/Function2 // io.github.linreal.cascade.editor.htmlserialization/UnknownTagPolicy.Custom.component1|component1(){}[0] + final fun copy(kotlin/Function2 = ...): io.github.linreal.cascade.editor.htmlserialization/UnknownTagPolicy.Custom // io.github.linreal.cascade.editor.htmlserialization/UnknownTagPolicy.Custom.copy|copy(kotlin.Function2){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.htmlserialization/UnknownTagPolicy.Custom.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/UnknownTagPolicy.Custom.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/UnknownTagPolicy.Custom.toString|toString(){}[0] + } + + final object Preserve : io.github.linreal.cascade.editor.htmlserialization/UnknownTagPolicy { // io.github.linreal.cascade.editor.htmlserialization/UnknownTagPolicy.Preserve|null[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.htmlserialization/UnknownTagPolicy.Preserve.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/UnknownTagPolicy.Preserve.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/UnknownTagPolicy.Preserve.toString|toString(){}[0] + } + + final object Strip : io.github.linreal.cascade.editor.htmlserialization/UnknownTagPolicy { // io.github.linreal.cascade.editor.htmlserialization/UnknownTagPolicy.Strip|null[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.htmlserialization/UnknownTagPolicy.Strip.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/UnknownTagPolicy.Strip.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/UnknownTagPolicy.Strip.toString|toString(){}[0] + } + + final object WarnAndStrip : io.github.linreal.cascade.editor.htmlserialization/UnknownTagPolicy { // io.github.linreal.cascade.editor.htmlserialization/UnknownTagPolicy.WarnAndStrip|null[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.htmlserialization/UnknownTagPolicy.WarnAndStrip.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/UnknownTagPolicy.WarnAndStrip.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/UnknownTagPolicy.WarnAndStrip.toString|toString(){}[0] + } +} + +sealed interface io.github.linreal.cascade.editor.richtext/LinkValidationResult { // io.github.linreal.cascade.editor.richtext/LinkValidationResult|null[0] + abstract val error // io.github.linreal.cascade.editor.richtext/LinkValidationResult.error|{}error[0] + abstract fun (): io.github.linreal.cascade.editor.richtext/LinkValidationError? // io.github.linreal.cascade.editor.richtext/LinkValidationResult.error.|(){}[0] + abstract val normalizedUrl // io.github.linreal.cascade.editor.richtext/LinkValidationResult.normalizedUrl|{}normalizedUrl[0] + abstract fun (): kotlin/String? // io.github.linreal.cascade.editor.richtext/LinkValidationResult.normalizedUrl.|(){}[0] + + final class Invalid : io.github.linreal.cascade.editor.richtext/LinkValidationResult { // io.github.linreal.cascade.editor.richtext/LinkValidationResult.Invalid|null[0] + constructor (io.github.linreal.cascade.editor.richtext/LinkValidationError) // io.github.linreal.cascade.editor.richtext/LinkValidationResult.Invalid.|(io.github.linreal.cascade.editor.richtext.LinkValidationError){}[0] + + final val error // io.github.linreal.cascade.editor.richtext/LinkValidationResult.Invalid.error|{}error[0] + final fun (): io.github.linreal.cascade.editor.richtext/LinkValidationError // io.github.linreal.cascade.editor.richtext/LinkValidationResult.Invalid.error.|(){}[0] + final val normalizedUrl // io.github.linreal.cascade.editor.richtext/LinkValidationResult.Invalid.normalizedUrl|{}normalizedUrl[0] + final fun (): kotlin/String? // io.github.linreal.cascade.editor.richtext/LinkValidationResult.Invalid.normalizedUrl.|(){}[0] + + final fun component1(): io.github.linreal.cascade.editor.richtext/LinkValidationError // io.github.linreal.cascade.editor.richtext/LinkValidationResult.Invalid.component1|component1(){}[0] + final fun copy(io.github.linreal.cascade.editor.richtext/LinkValidationError = ...): io.github.linreal.cascade.editor.richtext/LinkValidationResult.Invalid // io.github.linreal.cascade.editor.richtext/LinkValidationResult.Invalid.copy|copy(io.github.linreal.cascade.editor.richtext.LinkValidationError){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.richtext/LinkValidationResult.Invalid.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.richtext/LinkValidationResult.Invalid.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.richtext/LinkValidationResult.Invalid.toString|toString(){}[0] + } + + final class Valid : io.github.linreal.cascade.editor.richtext/LinkValidationResult { // io.github.linreal.cascade.editor.richtext/LinkValidationResult.Valid|null[0] + constructor (kotlin/String) // io.github.linreal.cascade.editor.richtext/LinkValidationResult.Valid.|(kotlin.String){}[0] + + final val error // io.github.linreal.cascade.editor.richtext/LinkValidationResult.Valid.error|{}error[0] + final fun (): io.github.linreal.cascade.editor.richtext/LinkValidationError? // io.github.linreal.cascade.editor.richtext/LinkValidationResult.Valid.error.|(){}[0] + final val normalizedUrl // io.github.linreal.cascade.editor.richtext/LinkValidationResult.Valid.normalizedUrl|{}normalizedUrl[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.richtext/LinkValidationResult.Valid.normalizedUrl.|(){}[0] + + final fun component1(): kotlin/String // io.github.linreal.cascade.editor.richtext/LinkValidationResult.Valid.component1|component1(){}[0] + final fun copy(kotlin/String = ...): io.github.linreal.cascade.editor.richtext/LinkValidationResult.Valid // io.github.linreal.cascade.editor.richtext/LinkValidationResult.Valid.copy|copy(kotlin.String){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.richtext/LinkValidationResult.Valid.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.richtext/LinkValidationResult.Valid.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.richtext/LinkValidationResult.Valid.toString|toString(){}[0] + } +} + +sealed interface io.github.linreal.cascade.editor.slash/BuiltInBlockSlashBehavior { // io.github.linreal.cascade.editor.slash/BuiltInBlockSlashBehavior|null[0] + final object AlwaysInsert : io.github.linreal.cascade.editor.slash/BuiltInBlockSlashBehavior { // io.github.linreal.cascade.editor.slash/BuiltInBlockSlashBehavior.AlwaysInsert|null[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.slash/BuiltInBlockSlashBehavior.AlwaysInsert.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.slash/BuiltInBlockSlashBehavior.AlwaysInsert.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.slash/BuiltInBlockSlashBehavior.AlwaysInsert.toString|toString(){}[0] + } + + final object ConvertInPlace : io.github.linreal.cascade.editor.slash/BuiltInBlockSlashBehavior { // io.github.linreal.cascade.editor.slash/BuiltInBlockSlashBehavior.ConvertInPlace|null[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.slash/BuiltInBlockSlashBehavior.ConvertInPlace.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.slash/BuiltInBlockSlashBehavior.ConvertInPlace.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.slash/BuiltInBlockSlashBehavior.ConvertInPlace.toString|toString(){}[0] + } +} + +sealed interface io.github.linreal.cascade.editor.slash/SlashCommandItem { // io.github.linreal.cascade.editor.slash/SlashCommandItem|null[0] + abstract val description // io.github.linreal.cascade.editor.slash/SlashCommandItem.description|{}description[0] + abstract fun (): kotlin/String // io.github.linreal.cascade.editor.slash/SlashCommandItem.description.|(){}[0] + abstract val icon // io.github.linreal.cascade.editor.slash/SlashCommandItem.icon|{}icon[0] + abstract fun (): io.github.linreal.cascade.editor.slash/SlashCommandIconKey? // io.github.linreal.cascade.editor.slash/SlashCommandItem.icon.|(){}[0] + abstract val id // io.github.linreal.cascade.editor.slash/SlashCommandItem.id|{}id[0] + abstract fun (): io.github.linreal.cascade.editor.slash/SlashCommandId // io.github.linreal.cascade.editor.slash/SlashCommandItem.id.|(){}[0] + abstract val keywords // io.github.linreal.cascade.editor.slash/SlashCommandItem.keywords|{}keywords[0] + abstract fun (): kotlin.collections/List // io.github.linreal.cascade.editor.slash/SlashCommandItem.keywords.|(){}[0] + abstract val title // io.github.linreal.cascade.editor.slash/SlashCommandItem.title|{}title[0] + abstract fun (): kotlin/String // io.github.linreal.cascade.editor.slash/SlashCommandItem.title.|(){}[0] +} + +sealed interface io.github.linreal.cascade.editor.slash/SlashCommandResult { // io.github.linreal.cascade.editor.slash/SlashCommandResult|null[0] + final class Failure : io.github.linreal.cascade.editor.slash/SlashCommandResult { // io.github.linreal.cascade.editor.slash/SlashCommandResult.Failure|null[0] + constructor (kotlin/String? = ...) // io.github.linreal.cascade.editor.slash/SlashCommandResult.Failure.|(kotlin.String?){}[0] + + final val message // io.github.linreal.cascade.editor.slash/SlashCommandResult.Failure.message|{}message[0] + final fun (): kotlin/String? // io.github.linreal.cascade.editor.slash/SlashCommandResult.Failure.message.|(){}[0] + + final fun component1(): kotlin/String? // io.github.linreal.cascade.editor.slash/SlashCommandResult.Failure.component1|component1(){}[0] + final fun copy(kotlin/String? = ...): io.github.linreal.cascade.editor.slash/SlashCommandResult.Failure // io.github.linreal.cascade.editor.slash/SlashCommandResult.Failure.copy|copy(kotlin.String?){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.slash/SlashCommandResult.Failure.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.slash/SlashCommandResult.Failure.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.slash/SlashCommandResult.Failure.toString|toString(){}[0] + } + + final object Done : io.github.linreal.cascade.editor.slash/SlashCommandResult { // io.github.linreal.cascade.editor.slash/SlashCommandResult.Done|null[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.slash/SlashCommandResult.Done.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.slash/SlashCommandResult.Done.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.slash/SlashCommandResult.Done.toString|toString(){}[0] + } + + final object KeepOpen : io.github.linreal.cascade.editor.slash/SlashCommandResult { // io.github.linreal.cascade.editor.slash/SlashCommandResult.KeepOpen|null[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.slash/SlashCommandResult.KeepOpen.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.slash/SlashCommandResult.KeepOpen.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.slash/SlashCommandResult.KeepOpen.toString|toString(){}[0] + } +} + +sealed interface io.github.linreal.cascade.editor.ui/LinkPopupSlot { // io.github.linreal.cascade.editor.ui/LinkPopupSlot|null[0] + final class Custom : io.github.linreal.cascade.editor.ui/LinkPopupSlot { // io.github.linreal.cascade.editor.ui/LinkPopupSlot.Custom|null[0] + constructor (kotlin/Function4) // io.github.linreal.cascade.editor.ui/LinkPopupSlot.Custom.|(kotlin.Function4){}[0] + + final val content // io.github.linreal.cascade.editor.ui/LinkPopupSlot.Custom.content|{}content[0] + final fun (): kotlin/Function4 // io.github.linreal.cascade.editor.ui/LinkPopupSlot.Custom.content.|(){}[0] + } + + final object Default : io.github.linreal.cascade.editor.ui/LinkPopupSlot { // io.github.linreal.cascade.editor.ui/LinkPopupSlot.Default|null[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.ui/LinkPopupSlot.Default.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.ui/LinkPopupSlot.Default.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.ui/LinkPopupSlot.Default.toString|toString(){}[0] + } + + final object None : io.github.linreal.cascade.editor.ui/LinkPopupSlot { // io.github.linreal.cascade.editor.ui/LinkPopupSlot.None|null[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.ui/LinkPopupSlot.None.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.ui/LinkPopupSlot.None.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.ui/LinkPopupSlot.None.toString|toString(){}[0] + } +} + +sealed interface io.github.linreal.cascade.editor.ui/SlashCommandSlot { // io.github.linreal.cascade.editor.ui/SlashCommandSlot|null[0] + final object Default : io.github.linreal.cascade.editor.ui/SlashCommandSlot { // io.github.linreal.cascade.editor.ui/SlashCommandSlot.Default|null[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.ui/SlashCommandSlot.Default.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.ui/SlashCommandSlot.Default.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.ui/SlashCommandSlot.Default.toString|toString(){}[0] + } + + final object None : io.github.linreal.cascade.editor.ui/SlashCommandSlot { // io.github.linreal.cascade.editor.ui/SlashCommandSlot.None|null[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.ui/SlashCommandSlot.None.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.ui/SlashCommandSlot.None.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.ui/SlashCommandSlot.None.toString|toString(){}[0] + } +} + +sealed interface io.github.linreal.cascade.editor.ui/ToolbarSlot { // io.github.linreal.cascade.editor.ui/ToolbarSlot|null[0] + final class Custom : io.github.linreal.cascade.editor.ui/ToolbarSlot { // io.github.linreal.cascade.editor.ui/ToolbarSlot.Custom|null[0] + constructor (kotlin.collections/List = ..., kotlin/Function4, io.github.linreal.cascade.editor.richtext/FormattingActions, androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>) // io.github.linreal.cascade.editor.ui/ToolbarSlot.Custom.|(kotlin.collections.List;kotlin.Function4,io.github.linreal.cascade.editor.richtext.FormattingActions,androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>){}[0] + + final val content // io.github.linreal.cascade.editor.ui/ToolbarSlot.Custom.content|{}content[0] + final fun (): kotlin/Function4, io.github.linreal.cascade.editor.richtext/FormattingActions, androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit> // io.github.linreal.cascade.editor.ui/ToolbarSlot.Custom.content.|(){}[0] + final val trackedStyles // io.github.linreal.cascade.editor.ui/ToolbarSlot.Custom.trackedStyles|{}trackedStyles[0] + final fun (): kotlin.collections/List // io.github.linreal.cascade.editor.ui/ToolbarSlot.Custom.trackedStyles.|(){}[0] + + final fun component1(): kotlin.collections/List // io.github.linreal.cascade.editor.ui/ToolbarSlot.Custom.component1|component1(){}[0] + final fun component2(): kotlin/Function4, io.github.linreal.cascade.editor.richtext/FormattingActions, androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit> // io.github.linreal.cascade.editor.ui/ToolbarSlot.Custom.component2|component2(){}[0] + final fun copy(kotlin.collections/List = ..., kotlin/Function4, io.github.linreal.cascade.editor.richtext/FormattingActions, androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit> = ...): io.github.linreal.cascade.editor.ui/ToolbarSlot.Custom // io.github.linreal.cascade.editor.ui/ToolbarSlot.Custom.copy|copy(kotlin.collections.List;kotlin.Function4,io.github.linreal.cascade.editor.richtext.FormattingActions,androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.ui/ToolbarSlot.Custom.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.ui/ToolbarSlot.Custom.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.ui/ToolbarSlot.Custom.toString|toString(){}[0] + } + + final class Default : io.github.linreal.cascade.editor.ui/ToolbarSlot { // io.github.linreal.cascade.editor.ui/ToolbarSlot.Default|null[0] + constructor (io.github.linreal.cascade.editor.ui/RichTextToolbarConfig = ...) // io.github.linreal.cascade.editor.ui/ToolbarSlot.Default.|(io.github.linreal.cascade.editor.ui.RichTextToolbarConfig){}[0] + + final val config // io.github.linreal.cascade.editor.ui/ToolbarSlot.Default.config|{}config[0] + final fun (): io.github.linreal.cascade.editor.ui/RichTextToolbarConfig // io.github.linreal.cascade.editor.ui/ToolbarSlot.Default.config.|(){}[0] + + final fun component1(): io.github.linreal.cascade.editor.ui/RichTextToolbarConfig // io.github.linreal.cascade.editor.ui/ToolbarSlot.Default.component1|component1(){}[0] + final fun copy(io.github.linreal.cascade.editor.ui/RichTextToolbarConfig = ...): io.github.linreal.cascade.editor.ui/ToolbarSlot.Default // io.github.linreal.cascade.editor.ui/ToolbarSlot.Default.copy|copy(io.github.linreal.cascade.editor.ui.RichTextToolbarConfig){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.ui/ToolbarSlot.Default.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.ui/ToolbarSlot.Default.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.ui/ToolbarSlot.Default.toString|toString(){}[0] + } + + final object None : io.github.linreal.cascade.editor.ui/ToolbarSlot { // io.github.linreal.cascade.editor.ui/ToolbarSlot.None|null[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.ui/ToolbarSlot.None.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.ui/ToolbarSlot.None.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.ui/ToolbarSlot.None.toString|toString(){}[0] + } +} + +abstract class io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeContext { // io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeContext|null[0] + abstract fun encodeInline(io.github.linreal.cascade.editor.core/Block): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeContext.encodeInline|encodeInline(io.github.linreal.cascade.editor.core.Block){}[0] + abstract fun encodeInlineFragment(kotlin/String, kotlin.collections/List, kotlin/Boolean = ...): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeContext.encodeInlineFragment|encodeInlineFragment(kotlin.String;kotlin.collections.List;kotlin.Boolean){}[0] + abstract fun encodeTextOnly(io.github.linreal.cascade.editor.core/Block): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeContext.encodeTextOnly|encodeTextOnly(io.github.linreal.cascade.editor.core.Block){}[0] + abstract fun escapeAttr(kotlin/String): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeContext.escapeAttr|escapeAttr(kotlin.String){}[0] + abstract fun escapeText(kotlin/String): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeContext.escapeText|escapeText(kotlin.String){}[0] + abstract fun warn(io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeWarning) // io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeContext.warn|warn(io.github.linreal.cascade.editor.htmlserialization.HtmlEncodeWarning){}[0] +} + +abstract class io.github.linreal.cascade.editor.htmlserialization/TagDecodeContext { // io.github.linreal.cascade.editor.htmlserialization/TagDecodeContext|null[0] + abstract val charOffset // io.github.linreal.cascade.editor.htmlserialization/TagDecodeContext.charOffset|{}charOffset[0] + abstract fun (): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/TagDecodeContext.charOffset.|(){}[0] + abstract val isBlockContext // io.github.linreal.cascade.editor.htmlserialization/TagDecodeContext.isBlockContext|{}isBlockContext[0] + abstract fun (): kotlin/Boolean // io.github.linreal.cascade.editor.htmlserialization/TagDecodeContext.isBlockContext.|(){}[0] + abstract val parentTag // io.github.linreal.cascade.editor.htmlserialization/TagDecodeContext.parentTag|{}parentTag[0] + abstract fun (): kotlin/String? // io.github.linreal.cascade.editor.htmlserialization/TagDecodeContext.parentTag.|(){}[0] + abstract val rawSource // io.github.linreal.cascade.editor.htmlserialization/TagDecodeContext.rawSource|{}rawSource[0] + abstract fun (): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/TagDecodeContext.rawSource.|(){}[0] + + abstract fun collectInlineText(kotlin.collections/List, kotlin/Boolean = ..., kotlin/Boolean = ..., kotlin/Boolean = ...): io.github.linreal.cascade.editor.htmlserialization/InlineFragment // io.github.linreal.cascade.editor.htmlserialization/TagDecodeContext.collectInlineText|collectInlineText(kotlin.collections.List;kotlin.Boolean;kotlin.Boolean;kotlin.Boolean){}[0] + abstract fun decodeBlocks(kotlin.collections/List): kotlin.collections/List // io.github.linreal.cascade.editor.htmlserialization/TagDecodeContext.decodeBlocks|decodeBlocks(kotlin.collections.List){}[0] + abstract fun decodeInline(kotlin.collections/List): io.github.linreal.cascade.editor.htmlserialization/InlineFragment // io.github.linreal.cascade.editor.htmlserialization/TagDecodeContext.decodeInline|decodeInline(kotlin.collections.List){}[0] + abstract fun rawSliceOf(io.github.linreal.cascade.editor.htmlserialization/HtmlNodeView): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/TagDecodeContext.rawSliceOf|rawSliceOf(io.github.linreal.cascade.editor.htmlserialization.HtmlNodeView){}[0] + abstract fun tagDecoderFor(kotlin/String): io.github.linreal.cascade.editor.htmlserialization/TagDecoder? // io.github.linreal.cascade.editor.htmlserialization/TagDecodeContext.tagDecoderFor|tagDecoderFor(kotlin.String){}[0] + abstract fun warn(io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning) // io.github.linreal.cascade.editor.htmlserialization/TagDecodeContext.warn|warn(io.github.linreal.cascade.editor.htmlserialization.HtmlDecodeWarning){}[0] +} + +final class <#A: io.github.linreal.cascade.editor.core/BlockType> io.github.linreal.cascade.editor.registry/LambdaBlockRenderer : io.github.linreal.cascade.editor.registry/BlockRenderer<#A> { // io.github.linreal.cascade.editor.registry/LambdaBlockRenderer|null[0] + constructor (kotlin/Function7) // io.github.linreal.cascade.editor.registry/LambdaBlockRenderer.|(kotlin.Function7){}[0] + + final fun Render(io.github.linreal.cascade.editor.core/Block, kotlin/Boolean, kotlin/Boolean, androidx.compose.ui/Modifier, io.github.linreal.cascade.editor.registry/BlockCallbacks, androidx.compose.runtime/Composer?, kotlin/Int) // io.github.linreal.cascade.editor.registry/LambdaBlockRenderer.Render|Render(io.github.linreal.cascade.editor.core.Block;kotlin.Boolean;kotlin.Boolean;androidx.compose.ui.Modifier;io.github.linreal.cascade.editor.registry.BlockCallbacks;androidx.compose.runtime.Composer?;kotlin.Int){}[0] +} + +final class io.github.linreal.cascade.editor.action/AddBlockRangeToSelection : io.github.linreal.cascade.editor.action/EditorAction { // io.github.linreal.cascade.editor.action/AddBlockRangeToSelection|null[0] + constructor (io.github.linreal.cascade.editor.core/BlockId, io.github.linreal.cascade.editor.core/BlockId) // io.github.linreal.cascade.editor.action/AddBlockRangeToSelection.|(io.github.linreal.cascade.editor.core.BlockId;io.github.linreal.cascade.editor.core.BlockId){}[0] + + final val fromId // io.github.linreal.cascade.editor.action/AddBlockRangeToSelection.fromId|{}fromId[0] + final fun (): io.github.linreal.cascade.editor.core/BlockId // io.github.linreal.cascade.editor.action/AddBlockRangeToSelection.fromId.|(){}[0] + final val toId // io.github.linreal.cascade.editor.action/AddBlockRangeToSelection.toId|{}toId[0] + final fun (): io.github.linreal.cascade.editor.core/BlockId // io.github.linreal.cascade.editor.action/AddBlockRangeToSelection.toId.|(){}[0] + + final fun component1(): io.github.linreal.cascade.editor.core/BlockId // io.github.linreal.cascade.editor.action/AddBlockRangeToSelection.component1|component1(){}[0] + final fun component2(): io.github.linreal.cascade.editor.core/BlockId // io.github.linreal.cascade.editor.action/AddBlockRangeToSelection.component2|component2(){}[0] + final fun copy(io.github.linreal.cascade.editor.core/BlockId = ..., io.github.linreal.cascade.editor.core/BlockId = ...): io.github.linreal.cascade.editor.action/AddBlockRangeToSelection // io.github.linreal.cascade.editor.action/AddBlockRangeToSelection.copy|copy(io.github.linreal.cascade.editor.core.BlockId;io.github.linreal.cascade.editor.core.BlockId){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.action/AddBlockRangeToSelection.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.action/AddBlockRangeToSelection.hashCode|hashCode(){}[0] + final fun reduce(io.github.linreal.cascade.editor.state/EditorState): io.github.linreal.cascade.editor.state/EditorState // io.github.linreal.cascade.editor.action/AddBlockRangeToSelection.reduce|reduce(io.github.linreal.cascade.editor.state.EditorState){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.action/AddBlockRangeToSelection.toString|toString(){}[0] +} + +final class io.github.linreal.cascade.editor.action/ApplySpanStyle : io.github.linreal.cascade.editor.action/EditorAction { // io.github.linreal.cascade.editor.action/ApplySpanStyle|null[0] + constructor (io.github.linreal.cascade.editor.core/BlockId, kotlin/Int, kotlin/Int, io.github.linreal.cascade.editor.core/SpanStyle) // io.github.linreal.cascade.editor.action/ApplySpanStyle.|(io.github.linreal.cascade.editor.core.BlockId;kotlin.Int;kotlin.Int;io.github.linreal.cascade.editor.core.SpanStyle){}[0] + + final val blockId // io.github.linreal.cascade.editor.action/ApplySpanStyle.blockId|{}blockId[0] + final fun (): io.github.linreal.cascade.editor.core/BlockId // io.github.linreal.cascade.editor.action/ApplySpanStyle.blockId.|(){}[0] + final val rangeEnd // io.github.linreal.cascade.editor.action/ApplySpanStyle.rangeEnd|{}rangeEnd[0] + final fun (): kotlin/Int // io.github.linreal.cascade.editor.action/ApplySpanStyle.rangeEnd.|(){}[0] + final val rangeStart // io.github.linreal.cascade.editor.action/ApplySpanStyle.rangeStart|{}rangeStart[0] + final fun (): kotlin/Int // io.github.linreal.cascade.editor.action/ApplySpanStyle.rangeStart.|(){}[0] + final val style // io.github.linreal.cascade.editor.action/ApplySpanStyle.style|{}style[0] + final fun (): io.github.linreal.cascade.editor.core/SpanStyle // io.github.linreal.cascade.editor.action/ApplySpanStyle.style.|(){}[0] + + final fun component1(): io.github.linreal.cascade.editor.core/BlockId // io.github.linreal.cascade.editor.action/ApplySpanStyle.component1|component1(){}[0] + final fun component2(): kotlin/Int // io.github.linreal.cascade.editor.action/ApplySpanStyle.component2|component2(){}[0] + final fun component3(): kotlin/Int // io.github.linreal.cascade.editor.action/ApplySpanStyle.component3|component3(){}[0] + final fun component4(): io.github.linreal.cascade.editor.core/SpanStyle // io.github.linreal.cascade.editor.action/ApplySpanStyle.component4|component4(){}[0] + final fun copy(io.github.linreal.cascade.editor.core/BlockId = ..., kotlin/Int = ..., kotlin/Int = ..., io.github.linreal.cascade.editor.core/SpanStyle = ...): io.github.linreal.cascade.editor.action/ApplySpanStyle // io.github.linreal.cascade.editor.action/ApplySpanStyle.copy|copy(io.github.linreal.cascade.editor.core.BlockId;kotlin.Int;kotlin.Int;io.github.linreal.cascade.editor.core.SpanStyle){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.action/ApplySpanStyle.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.action/ApplySpanStyle.hashCode|hashCode(){}[0] + final fun reduce(io.github.linreal.cascade.editor.state/EditorState): io.github.linreal.cascade.editor.state/EditorState // io.github.linreal.cascade.editor.action/ApplySpanStyle.reduce|reduce(io.github.linreal.cascade.editor.state.EditorState){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.action/ApplySpanStyle.toString|toString(){}[0] +} + +final class io.github.linreal.cascade.editor.action/ConvertBlockType : io.github.linreal.cascade.editor.action/EditorAction { // io.github.linreal.cascade.editor.action/ConvertBlockType|null[0] + constructor (io.github.linreal.cascade.editor.core/BlockId, io.github.linreal.cascade.editor.core/BlockType) // io.github.linreal.cascade.editor.action/ConvertBlockType.|(io.github.linreal.cascade.editor.core.BlockId;io.github.linreal.cascade.editor.core.BlockType){}[0] + + final val blockId // io.github.linreal.cascade.editor.action/ConvertBlockType.blockId|{}blockId[0] + final fun (): io.github.linreal.cascade.editor.core/BlockId // io.github.linreal.cascade.editor.action/ConvertBlockType.blockId.|(){}[0] + final val newType // io.github.linreal.cascade.editor.action/ConvertBlockType.newType|{}newType[0] + final fun (): io.github.linreal.cascade.editor.core/BlockType // io.github.linreal.cascade.editor.action/ConvertBlockType.newType.|(){}[0] + + final fun component1(): io.github.linreal.cascade.editor.core/BlockId // io.github.linreal.cascade.editor.action/ConvertBlockType.component1|component1(){}[0] + final fun component2(): io.github.linreal.cascade.editor.core/BlockType // io.github.linreal.cascade.editor.action/ConvertBlockType.component2|component2(){}[0] + final fun copy(io.github.linreal.cascade.editor.core/BlockId = ..., io.github.linreal.cascade.editor.core/BlockType = ...): io.github.linreal.cascade.editor.action/ConvertBlockType // io.github.linreal.cascade.editor.action/ConvertBlockType.copy|copy(io.github.linreal.cascade.editor.core.BlockId;io.github.linreal.cascade.editor.core.BlockType){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.action/ConvertBlockType.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.action/ConvertBlockType.hashCode|hashCode(){}[0] + final fun reduce(io.github.linreal.cascade.editor.state/EditorState): io.github.linreal.cascade.editor.state/EditorState // io.github.linreal.cascade.editor.action/ConvertBlockType.reduce|reduce(io.github.linreal.cascade.editor.state.EditorState){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.action/ConvertBlockType.toString|toString(){}[0] +} + +final class io.github.linreal.cascade.editor.action/DeleteBlock : io.github.linreal.cascade.editor.action/EditorAction { // io.github.linreal.cascade.editor.action/DeleteBlock|null[0] + constructor (io.github.linreal.cascade.editor.core/BlockId) // io.github.linreal.cascade.editor.action/DeleteBlock.|(io.github.linreal.cascade.editor.core.BlockId){}[0] + + final val blockId // io.github.linreal.cascade.editor.action/DeleteBlock.blockId|{}blockId[0] + final fun (): io.github.linreal.cascade.editor.core/BlockId // io.github.linreal.cascade.editor.action/DeleteBlock.blockId.|(){}[0] + + final fun component1(): io.github.linreal.cascade.editor.core/BlockId // io.github.linreal.cascade.editor.action/DeleteBlock.component1|component1(){}[0] + final fun copy(io.github.linreal.cascade.editor.core/BlockId = ...): io.github.linreal.cascade.editor.action/DeleteBlock // io.github.linreal.cascade.editor.action/DeleteBlock.copy|copy(io.github.linreal.cascade.editor.core.BlockId){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.action/DeleteBlock.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.action/DeleteBlock.hashCode|hashCode(){}[0] + final fun reduce(io.github.linreal.cascade.editor.state/EditorState): io.github.linreal.cascade.editor.state/EditorState // io.github.linreal.cascade.editor.action/DeleteBlock.reduce|reduce(io.github.linreal.cascade.editor.state.EditorState){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.action/DeleteBlock.toString|toString(){}[0] +} + +final class io.github.linreal.cascade.editor.action/DeleteBlocks : io.github.linreal.cascade.editor.action/EditorAction { // io.github.linreal.cascade.editor.action/DeleteBlocks|null[0] + constructor (kotlin.collections/Set) // io.github.linreal.cascade.editor.action/DeleteBlocks.|(kotlin.collections.Set){}[0] + + final val blockIds // io.github.linreal.cascade.editor.action/DeleteBlocks.blockIds|{}blockIds[0] + final fun (): kotlin.collections/Set // io.github.linreal.cascade.editor.action/DeleteBlocks.blockIds.|(){}[0] + + final fun component1(): kotlin.collections/Set // io.github.linreal.cascade.editor.action/DeleteBlocks.component1|component1(){}[0] + final fun copy(kotlin.collections/Set = ...): io.github.linreal.cascade.editor.action/DeleteBlocks // io.github.linreal.cascade.editor.action/DeleteBlocks.copy|copy(kotlin.collections.Set){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.action/DeleteBlocks.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.action/DeleteBlocks.hashCode|hashCode(){}[0] + final fun reduce(io.github.linreal.cascade.editor.state/EditorState): io.github.linreal.cascade.editor.state/EditorState // io.github.linreal.cascade.editor.action/DeleteBlocks.reduce|reduce(io.github.linreal.cascade.editor.state.EditorState){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.action/DeleteBlocks.toString|toString(){}[0] +} + +final class io.github.linreal.cascade.editor.action/FocusBlock : io.github.linreal.cascade.editor.action/EditorAction { // io.github.linreal.cascade.editor.action/FocusBlock|null[0] + constructor (io.github.linreal.cascade.editor.core/BlockId?) // io.github.linreal.cascade.editor.action/FocusBlock.|(io.github.linreal.cascade.editor.core.BlockId?){}[0] + + final val blockId // io.github.linreal.cascade.editor.action/FocusBlock.blockId|{}blockId[0] + final fun (): io.github.linreal.cascade.editor.core/BlockId? // io.github.linreal.cascade.editor.action/FocusBlock.blockId.|(){}[0] + + final fun component1(): io.github.linreal.cascade.editor.core/BlockId? // io.github.linreal.cascade.editor.action/FocusBlock.component1|component1(){}[0] + final fun copy(io.github.linreal.cascade.editor.core/BlockId? = ...): io.github.linreal.cascade.editor.action/FocusBlock // io.github.linreal.cascade.editor.action/FocusBlock.copy|copy(io.github.linreal.cascade.editor.core.BlockId?){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.action/FocusBlock.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.action/FocusBlock.hashCode|hashCode(){}[0] + final fun reduce(io.github.linreal.cascade.editor.state/EditorState): io.github.linreal.cascade.editor.state/EditorState // io.github.linreal.cascade.editor.action/FocusBlock.reduce|reduce(io.github.linreal.cascade.editor.state.EditorState){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.action/FocusBlock.toString|toString(){}[0] +} + +final class io.github.linreal.cascade.editor.action/HighlightSlashCommand : io.github.linreal.cascade.editor.action/EditorAction { // io.github.linreal.cascade.editor.action/HighlightSlashCommand|null[0] + constructor (io.github.linreal.cascade.editor.slash/SlashCommandId?) // io.github.linreal.cascade.editor.action/HighlightSlashCommand.|(io.github.linreal.cascade.editor.slash.SlashCommandId?){}[0] + + final val commandId // io.github.linreal.cascade.editor.action/HighlightSlashCommand.commandId|{}commandId[0] + final fun (): io.github.linreal.cascade.editor.slash/SlashCommandId? // io.github.linreal.cascade.editor.action/HighlightSlashCommand.commandId.|(){}[0] + + final fun component1(): io.github.linreal.cascade.editor.slash/SlashCommandId? // io.github.linreal.cascade.editor.action/HighlightSlashCommand.component1|component1(){}[0] + final fun copy(io.github.linreal.cascade.editor.slash/SlashCommandId? = ...): io.github.linreal.cascade.editor.action/HighlightSlashCommand // io.github.linreal.cascade.editor.action/HighlightSlashCommand.copy|copy(io.github.linreal.cascade.editor.slash.SlashCommandId?){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.action/HighlightSlashCommand.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.action/HighlightSlashCommand.hashCode|hashCode(){}[0] + final fun reduce(io.github.linreal.cascade.editor.state/EditorState): io.github.linreal.cascade.editor.state/EditorState // io.github.linreal.cascade.editor.action/HighlightSlashCommand.reduce|reduce(io.github.linreal.cascade.editor.state.EditorState){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.action/HighlightSlashCommand.toString|toString(){}[0] +} + +final class io.github.linreal.cascade.editor.action/InsertBlock : io.github.linreal.cascade.editor.action/EditorAction { // io.github.linreal.cascade.editor.action/InsertBlock|null[0] + constructor (io.github.linreal.cascade.editor.core/Block, kotlin/Int? = ...) // io.github.linreal.cascade.editor.action/InsertBlock.|(io.github.linreal.cascade.editor.core.Block;kotlin.Int?){}[0] + + final val atIndex // io.github.linreal.cascade.editor.action/InsertBlock.atIndex|{}atIndex[0] + final fun (): kotlin/Int? // io.github.linreal.cascade.editor.action/InsertBlock.atIndex.|(){}[0] + final val block // io.github.linreal.cascade.editor.action/InsertBlock.block|{}block[0] + final fun (): io.github.linreal.cascade.editor.core/Block // io.github.linreal.cascade.editor.action/InsertBlock.block.|(){}[0] + + final fun component1(): io.github.linreal.cascade.editor.core/Block // io.github.linreal.cascade.editor.action/InsertBlock.component1|component1(){}[0] + final fun component2(): kotlin/Int? // io.github.linreal.cascade.editor.action/InsertBlock.component2|component2(){}[0] + final fun copy(io.github.linreal.cascade.editor.core/Block = ..., kotlin/Int? = ...): io.github.linreal.cascade.editor.action/InsertBlock // io.github.linreal.cascade.editor.action/InsertBlock.copy|copy(io.github.linreal.cascade.editor.core.Block;kotlin.Int?){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.action/InsertBlock.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.action/InsertBlock.hashCode|hashCode(){}[0] + final fun reduce(io.github.linreal.cascade.editor.state/EditorState): io.github.linreal.cascade.editor.state/EditorState // io.github.linreal.cascade.editor.action/InsertBlock.reduce|reduce(io.github.linreal.cascade.editor.state.EditorState){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.action/InsertBlock.toString|toString(){}[0] +} + +final class io.github.linreal.cascade.editor.action/InsertBlockAfter : io.github.linreal.cascade.editor.action/EditorAction { // io.github.linreal.cascade.editor.action/InsertBlockAfter|null[0] + constructor (io.github.linreal.cascade.editor.core/Block, io.github.linreal.cascade.editor.core/BlockId?) // io.github.linreal.cascade.editor.action/InsertBlockAfter.|(io.github.linreal.cascade.editor.core.Block;io.github.linreal.cascade.editor.core.BlockId?){}[0] + + final val afterBlockId // io.github.linreal.cascade.editor.action/InsertBlockAfter.afterBlockId|{}afterBlockId[0] + final fun (): io.github.linreal.cascade.editor.core/BlockId? // io.github.linreal.cascade.editor.action/InsertBlockAfter.afterBlockId.|(){}[0] + final val block // io.github.linreal.cascade.editor.action/InsertBlockAfter.block|{}block[0] + final fun (): io.github.linreal.cascade.editor.core/Block // io.github.linreal.cascade.editor.action/InsertBlockAfter.block.|(){}[0] + + final fun component1(): io.github.linreal.cascade.editor.core/Block // io.github.linreal.cascade.editor.action/InsertBlockAfter.component1|component1(){}[0] + final fun component2(): io.github.linreal.cascade.editor.core/BlockId? // io.github.linreal.cascade.editor.action/InsertBlockAfter.component2|component2(){}[0] + final fun copy(io.github.linreal.cascade.editor.core/Block = ..., io.github.linreal.cascade.editor.core/BlockId? = ...): io.github.linreal.cascade.editor.action/InsertBlockAfter // io.github.linreal.cascade.editor.action/InsertBlockAfter.copy|copy(io.github.linreal.cascade.editor.core.Block;io.github.linreal.cascade.editor.core.BlockId?){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.action/InsertBlockAfter.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.action/InsertBlockAfter.hashCode|hashCode(){}[0] + final fun reduce(io.github.linreal.cascade.editor.state/EditorState): io.github.linreal.cascade.editor.state/EditorState // io.github.linreal.cascade.editor.action/InsertBlockAfter.reduce|reduce(io.github.linreal.cascade.editor.state.EditorState){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.action/InsertBlockAfter.toString|toString(){}[0] +} + +final class io.github.linreal.cascade.editor.action/InsertBlockBefore : io.github.linreal.cascade.editor.action/EditorAction { // io.github.linreal.cascade.editor.action/InsertBlockBefore|null[0] + constructor (io.github.linreal.cascade.editor.core/Block, io.github.linreal.cascade.editor.core/BlockId?) // io.github.linreal.cascade.editor.action/InsertBlockBefore.|(io.github.linreal.cascade.editor.core.Block;io.github.linreal.cascade.editor.core.BlockId?){}[0] + + final val beforeBlockId // io.github.linreal.cascade.editor.action/InsertBlockBefore.beforeBlockId|{}beforeBlockId[0] + final fun (): io.github.linreal.cascade.editor.core/BlockId? // io.github.linreal.cascade.editor.action/InsertBlockBefore.beforeBlockId.|(){}[0] + final val block // io.github.linreal.cascade.editor.action/InsertBlockBefore.block|{}block[0] + final fun (): io.github.linreal.cascade.editor.core/Block // io.github.linreal.cascade.editor.action/InsertBlockBefore.block.|(){}[0] + + final fun component1(): io.github.linreal.cascade.editor.core/Block // io.github.linreal.cascade.editor.action/InsertBlockBefore.component1|component1(){}[0] + final fun component2(): io.github.linreal.cascade.editor.core/BlockId? // io.github.linreal.cascade.editor.action/InsertBlockBefore.component2|component2(){}[0] + final fun copy(io.github.linreal.cascade.editor.core/Block = ..., io.github.linreal.cascade.editor.core/BlockId? = ...): io.github.linreal.cascade.editor.action/InsertBlockBefore // io.github.linreal.cascade.editor.action/InsertBlockBefore.copy|copy(io.github.linreal.cascade.editor.core.Block;io.github.linreal.cascade.editor.core.BlockId?){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.action/InsertBlockBefore.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.action/InsertBlockBefore.hashCode|hashCode(){}[0] + final fun reduce(io.github.linreal.cascade.editor.state/EditorState): io.github.linreal.cascade.editor.state/EditorState // io.github.linreal.cascade.editor.action/InsertBlockBefore.reduce|reduce(io.github.linreal.cascade.editor.state.EditorState){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.action/InsertBlockBefore.toString|toString(){}[0] +} + +final class io.github.linreal.cascade.editor.action/MergeBlocks : io.github.linreal.cascade.editor.action/EditorAction { // io.github.linreal.cascade.editor.action/MergeBlocks|null[0] + constructor (io.github.linreal.cascade.editor.core/BlockId, io.github.linreal.cascade.editor.core/BlockId) // io.github.linreal.cascade.editor.action/MergeBlocks.|(io.github.linreal.cascade.editor.core.BlockId;io.github.linreal.cascade.editor.core.BlockId){}[0] + + final val sourceId // io.github.linreal.cascade.editor.action/MergeBlocks.sourceId|{}sourceId[0] + final fun (): io.github.linreal.cascade.editor.core/BlockId // io.github.linreal.cascade.editor.action/MergeBlocks.sourceId.|(){}[0] + final val targetId // io.github.linreal.cascade.editor.action/MergeBlocks.targetId|{}targetId[0] + final fun (): io.github.linreal.cascade.editor.core/BlockId // io.github.linreal.cascade.editor.action/MergeBlocks.targetId.|(){}[0] + + final fun component1(): io.github.linreal.cascade.editor.core/BlockId // io.github.linreal.cascade.editor.action/MergeBlocks.component1|component1(){}[0] + final fun component2(): io.github.linreal.cascade.editor.core/BlockId // io.github.linreal.cascade.editor.action/MergeBlocks.component2|component2(){}[0] + final fun copy(io.github.linreal.cascade.editor.core/BlockId = ..., io.github.linreal.cascade.editor.core/BlockId = ...): io.github.linreal.cascade.editor.action/MergeBlocks // io.github.linreal.cascade.editor.action/MergeBlocks.copy|copy(io.github.linreal.cascade.editor.core.BlockId;io.github.linreal.cascade.editor.core.BlockId){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.action/MergeBlocks.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.action/MergeBlocks.hashCode|hashCode(){}[0] + final fun reduce(io.github.linreal.cascade.editor.state/EditorState): io.github.linreal.cascade.editor.state/EditorState // io.github.linreal.cascade.editor.action/MergeBlocks.reduce|reduce(io.github.linreal.cascade.editor.state.EditorState){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.action/MergeBlocks.toString|toString(){}[0] +} + +final class io.github.linreal.cascade.editor.action/MoveBlocks : io.github.linreal.cascade.editor.action/EditorAction { // io.github.linreal.cascade.editor.action/MoveBlocks|null[0] + constructor (kotlin.collections/Set, kotlin/Int) // io.github.linreal.cascade.editor.action/MoveBlocks.|(kotlin.collections.Set;kotlin.Int){}[0] + + final val blockIds // io.github.linreal.cascade.editor.action/MoveBlocks.blockIds|{}blockIds[0] + final fun (): kotlin.collections/Set // io.github.linreal.cascade.editor.action/MoveBlocks.blockIds.|(){}[0] + final val toIndex // io.github.linreal.cascade.editor.action/MoveBlocks.toIndex|{}toIndex[0] + final fun (): kotlin/Int // io.github.linreal.cascade.editor.action/MoveBlocks.toIndex.|(){}[0] + + final fun component1(): kotlin.collections/Set // io.github.linreal.cascade.editor.action/MoveBlocks.component1|component1(){}[0] + final fun component2(): kotlin/Int // io.github.linreal.cascade.editor.action/MoveBlocks.component2|component2(){}[0] + final fun copy(kotlin.collections/Set = ..., kotlin/Int = ...): io.github.linreal.cascade.editor.action/MoveBlocks // io.github.linreal.cascade.editor.action/MoveBlocks.copy|copy(kotlin.collections.Set;kotlin.Int){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.action/MoveBlocks.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.action/MoveBlocks.hashCode|hashCode(){}[0] + final fun reduce(io.github.linreal.cascade.editor.state/EditorState): io.github.linreal.cascade.editor.state/EditorState // io.github.linreal.cascade.editor.action/MoveBlocks.reduce|reduce(io.github.linreal.cascade.editor.state.EditorState){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.action/MoveBlocks.toString|toString(){}[0] +} + +final class io.github.linreal.cascade.editor.action/NavigateSlashSubmenu : io.github.linreal.cascade.editor.action/EditorAction { // io.github.linreal.cascade.editor.action/NavigateSlashSubmenu|null[0] + constructor (io.github.linreal.cascade.editor.slash/SlashCommandId) // io.github.linreal.cascade.editor.action/NavigateSlashSubmenu.|(io.github.linreal.cascade.editor.slash.SlashCommandId){}[0] + + final val submenuId // io.github.linreal.cascade.editor.action/NavigateSlashSubmenu.submenuId|{}submenuId[0] + final fun (): io.github.linreal.cascade.editor.slash/SlashCommandId // io.github.linreal.cascade.editor.action/NavigateSlashSubmenu.submenuId.|(){}[0] + + final fun component1(): io.github.linreal.cascade.editor.slash/SlashCommandId // io.github.linreal.cascade.editor.action/NavigateSlashSubmenu.component1|component1(){}[0] + final fun copy(io.github.linreal.cascade.editor.slash/SlashCommandId = ...): io.github.linreal.cascade.editor.action/NavigateSlashSubmenu // io.github.linreal.cascade.editor.action/NavigateSlashSubmenu.copy|copy(io.github.linreal.cascade.editor.slash.SlashCommandId){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.action/NavigateSlashSubmenu.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.action/NavigateSlashSubmenu.hashCode|hashCode(){}[0] + final fun reduce(io.github.linreal.cascade.editor.state/EditorState): io.github.linreal.cascade.editor.state/EditorState // io.github.linreal.cascade.editor.action/NavigateSlashSubmenu.reduce|reduce(io.github.linreal.cascade.editor.state.EditorState){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.action/NavigateSlashSubmenu.toString|toString(){}[0] +} + +final class io.github.linreal.cascade.editor.action/OpenSlashCommand : io.github.linreal.cascade.editor.action/EditorAction { // io.github.linreal.cascade.editor.action/OpenSlashCommand|null[0] + constructor (io.github.linreal.cascade.editor.core/BlockId, io.github.linreal.cascade.editor.state/SlashQueryRange, kotlin/String = ...) // io.github.linreal.cascade.editor.action/OpenSlashCommand.|(io.github.linreal.cascade.editor.core.BlockId;io.github.linreal.cascade.editor.state.SlashQueryRange;kotlin.String){}[0] + + final val anchorBlockId // io.github.linreal.cascade.editor.action/OpenSlashCommand.anchorBlockId|{}anchorBlockId[0] + final fun (): io.github.linreal.cascade.editor.core/BlockId // io.github.linreal.cascade.editor.action/OpenSlashCommand.anchorBlockId.|(){}[0] + final val initialQuery // io.github.linreal.cascade.editor.action/OpenSlashCommand.initialQuery|{}initialQuery[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.action/OpenSlashCommand.initialQuery.|(){}[0] + final val queryRange // io.github.linreal.cascade.editor.action/OpenSlashCommand.queryRange|{}queryRange[0] + final fun (): io.github.linreal.cascade.editor.state/SlashQueryRange // io.github.linreal.cascade.editor.action/OpenSlashCommand.queryRange.|(){}[0] + + final fun component1(): io.github.linreal.cascade.editor.core/BlockId // io.github.linreal.cascade.editor.action/OpenSlashCommand.component1|component1(){}[0] + final fun component2(): io.github.linreal.cascade.editor.state/SlashQueryRange // io.github.linreal.cascade.editor.action/OpenSlashCommand.component2|component2(){}[0] + final fun component3(): kotlin/String // io.github.linreal.cascade.editor.action/OpenSlashCommand.component3|component3(){}[0] + final fun copy(io.github.linreal.cascade.editor.core/BlockId = ..., io.github.linreal.cascade.editor.state/SlashQueryRange = ..., kotlin/String = ...): io.github.linreal.cascade.editor.action/OpenSlashCommand // io.github.linreal.cascade.editor.action/OpenSlashCommand.copy|copy(io.github.linreal.cascade.editor.core.BlockId;io.github.linreal.cascade.editor.state.SlashQueryRange;kotlin.String){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.action/OpenSlashCommand.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.action/OpenSlashCommand.hashCode|hashCode(){}[0] + final fun reduce(io.github.linreal.cascade.editor.state/EditorState): io.github.linreal.cascade.editor.state/EditorState // io.github.linreal.cascade.editor.action/OpenSlashCommand.reduce|reduce(io.github.linreal.cascade.editor.state.EditorState){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.action/OpenSlashCommand.toString|toString(){}[0] +} + +final class io.github.linreal.cascade.editor.action/RemoveSpanStyle : io.github.linreal.cascade.editor.action/EditorAction { // io.github.linreal.cascade.editor.action/RemoveSpanStyle|null[0] + constructor (io.github.linreal.cascade.editor.core/BlockId, kotlin/Int, kotlin/Int, io.github.linreal.cascade.editor.core/SpanStyle) // io.github.linreal.cascade.editor.action/RemoveSpanStyle.|(io.github.linreal.cascade.editor.core.BlockId;kotlin.Int;kotlin.Int;io.github.linreal.cascade.editor.core.SpanStyle){}[0] + + final val blockId // io.github.linreal.cascade.editor.action/RemoveSpanStyle.blockId|{}blockId[0] + final fun (): io.github.linreal.cascade.editor.core/BlockId // io.github.linreal.cascade.editor.action/RemoveSpanStyle.blockId.|(){}[0] + final val rangeEnd // io.github.linreal.cascade.editor.action/RemoveSpanStyle.rangeEnd|{}rangeEnd[0] + final fun (): kotlin/Int // io.github.linreal.cascade.editor.action/RemoveSpanStyle.rangeEnd.|(){}[0] + final val rangeStart // io.github.linreal.cascade.editor.action/RemoveSpanStyle.rangeStart|{}rangeStart[0] + final fun (): kotlin/Int // io.github.linreal.cascade.editor.action/RemoveSpanStyle.rangeStart.|(){}[0] + final val style // io.github.linreal.cascade.editor.action/RemoveSpanStyle.style|{}style[0] + final fun (): io.github.linreal.cascade.editor.core/SpanStyle // io.github.linreal.cascade.editor.action/RemoveSpanStyle.style.|(){}[0] + + final fun component1(): io.github.linreal.cascade.editor.core/BlockId // io.github.linreal.cascade.editor.action/RemoveSpanStyle.component1|component1(){}[0] + final fun component2(): kotlin/Int // io.github.linreal.cascade.editor.action/RemoveSpanStyle.component2|component2(){}[0] + final fun component3(): kotlin/Int // io.github.linreal.cascade.editor.action/RemoveSpanStyle.component3|component3(){}[0] + final fun component4(): io.github.linreal.cascade.editor.core/SpanStyle // io.github.linreal.cascade.editor.action/RemoveSpanStyle.component4|component4(){}[0] + final fun copy(io.github.linreal.cascade.editor.core/BlockId = ..., kotlin/Int = ..., kotlin/Int = ..., io.github.linreal.cascade.editor.core/SpanStyle = ...): io.github.linreal.cascade.editor.action/RemoveSpanStyle // io.github.linreal.cascade.editor.action/RemoveSpanStyle.copy|copy(io.github.linreal.cascade.editor.core.BlockId;kotlin.Int;kotlin.Int;io.github.linreal.cascade.editor.core.SpanStyle){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.action/RemoveSpanStyle.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.action/RemoveSpanStyle.hashCode|hashCode(){}[0] + final fun reduce(io.github.linreal.cascade.editor.state/EditorState): io.github.linreal.cascade.editor.state/EditorState // io.github.linreal.cascade.editor.action/RemoveSpanStyle.reduce|reduce(io.github.linreal.cascade.editor.state.EditorState){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.action/RemoveSpanStyle.toString|toString(){}[0] +} + +final class io.github.linreal.cascade.editor.action/ReplaceBlock : io.github.linreal.cascade.editor.action/EditorAction { // io.github.linreal.cascade.editor.action/ReplaceBlock|null[0] + constructor (io.github.linreal.cascade.editor.core/BlockId, io.github.linreal.cascade.editor.core/Block) // io.github.linreal.cascade.editor.action/ReplaceBlock.|(io.github.linreal.cascade.editor.core.BlockId;io.github.linreal.cascade.editor.core.Block){}[0] + + final val blockId // io.github.linreal.cascade.editor.action/ReplaceBlock.blockId|{}blockId[0] + final fun (): io.github.linreal.cascade.editor.core/BlockId // io.github.linreal.cascade.editor.action/ReplaceBlock.blockId.|(){}[0] + final val newBlock // io.github.linreal.cascade.editor.action/ReplaceBlock.newBlock|{}newBlock[0] + final fun (): io.github.linreal.cascade.editor.core/Block // io.github.linreal.cascade.editor.action/ReplaceBlock.newBlock.|(){}[0] + + final fun component1(): io.github.linreal.cascade.editor.core/BlockId // io.github.linreal.cascade.editor.action/ReplaceBlock.component1|component1(){}[0] + final fun component2(): io.github.linreal.cascade.editor.core/Block // io.github.linreal.cascade.editor.action/ReplaceBlock.component2|component2(){}[0] + final fun copy(io.github.linreal.cascade.editor.core/BlockId = ..., io.github.linreal.cascade.editor.core/Block = ...): io.github.linreal.cascade.editor.action/ReplaceBlock // io.github.linreal.cascade.editor.action/ReplaceBlock.copy|copy(io.github.linreal.cascade.editor.core.BlockId;io.github.linreal.cascade.editor.core.Block){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.action/ReplaceBlock.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.action/ReplaceBlock.hashCode|hashCode(){}[0] + final fun reduce(io.github.linreal.cascade.editor.state/EditorState): io.github.linreal.cascade.editor.state/EditorState // io.github.linreal.cascade.editor.action/ReplaceBlock.reduce|reduce(io.github.linreal.cascade.editor.state.EditorState){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.action/ReplaceBlock.toString|toString(){}[0] +} + +final class io.github.linreal.cascade.editor.action/SelectBlock : io.github.linreal.cascade.editor.action/EditorAction { // io.github.linreal.cascade.editor.action/SelectBlock|null[0] + constructor (io.github.linreal.cascade.editor.core/BlockId) // io.github.linreal.cascade.editor.action/SelectBlock.|(io.github.linreal.cascade.editor.core.BlockId){}[0] + + final val blockId // io.github.linreal.cascade.editor.action/SelectBlock.blockId|{}blockId[0] + final fun (): io.github.linreal.cascade.editor.core/BlockId // io.github.linreal.cascade.editor.action/SelectBlock.blockId.|(){}[0] + + final fun component1(): io.github.linreal.cascade.editor.core/BlockId // io.github.linreal.cascade.editor.action/SelectBlock.component1|component1(){}[0] + final fun copy(io.github.linreal.cascade.editor.core/BlockId = ...): io.github.linreal.cascade.editor.action/SelectBlock // io.github.linreal.cascade.editor.action/SelectBlock.copy|copy(io.github.linreal.cascade.editor.core.BlockId){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.action/SelectBlock.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.action/SelectBlock.hashCode|hashCode(){}[0] + final fun reduce(io.github.linreal.cascade.editor.state/EditorState): io.github.linreal.cascade.editor.state/EditorState // io.github.linreal.cascade.editor.action/SelectBlock.reduce|reduce(io.github.linreal.cascade.editor.state.EditorState){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.action/SelectBlock.toString|toString(){}[0] +} + +final class io.github.linreal.cascade.editor.action/SelectBlockRange : io.github.linreal.cascade.editor.action/EditorAction { // io.github.linreal.cascade.editor.action/SelectBlockRange|null[0] + constructor (io.github.linreal.cascade.editor.core/BlockId, io.github.linreal.cascade.editor.core/BlockId) // io.github.linreal.cascade.editor.action/SelectBlockRange.|(io.github.linreal.cascade.editor.core.BlockId;io.github.linreal.cascade.editor.core.BlockId){}[0] + + final val fromId // io.github.linreal.cascade.editor.action/SelectBlockRange.fromId|{}fromId[0] + final fun (): io.github.linreal.cascade.editor.core/BlockId // io.github.linreal.cascade.editor.action/SelectBlockRange.fromId.|(){}[0] + final val toId // io.github.linreal.cascade.editor.action/SelectBlockRange.toId|{}toId[0] + final fun (): io.github.linreal.cascade.editor.core/BlockId // io.github.linreal.cascade.editor.action/SelectBlockRange.toId.|(){}[0] + + final fun component1(): io.github.linreal.cascade.editor.core/BlockId // io.github.linreal.cascade.editor.action/SelectBlockRange.component1|component1(){}[0] + final fun component2(): io.github.linreal.cascade.editor.core/BlockId // io.github.linreal.cascade.editor.action/SelectBlockRange.component2|component2(){}[0] + final fun copy(io.github.linreal.cascade.editor.core/BlockId = ..., io.github.linreal.cascade.editor.core/BlockId = ...): io.github.linreal.cascade.editor.action/SelectBlockRange // io.github.linreal.cascade.editor.action/SelectBlockRange.copy|copy(io.github.linreal.cascade.editor.core.BlockId;io.github.linreal.cascade.editor.core.BlockId){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.action/SelectBlockRange.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.action/SelectBlockRange.hashCode|hashCode(){}[0] + final fun reduce(io.github.linreal.cascade.editor.state/EditorState): io.github.linreal.cascade.editor.state/EditorState // io.github.linreal.cascade.editor.action/SelectBlockRange.reduce|reduce(io.github.linreal.cascade.editor.state.EditorState){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.action/SelectBlockRange.toString|toString(){}[0] +} + +final class io.github.linreal.cascade.editor.action/SplitBlock : io.github.linreal.cascade.editor.action/EditorAction { // io.github.linreal.cascade.editor.action/SplitBlock|null[0] + constructor (io.github.linreal.cascade.editor.core/BlockId, kotlin/Int, kotlin/String? = ..., io.github.linreal.cascade.editor.core/BlockId? = ..., kotlin.collections/List? = ..., kotlin/String? = ..., kotlin.collections/List? = ...) // io.github.linreal.cascade.editor.action/SplitBlock.|(io.github.linreal.cascade.editor.core.BlockId;kotlin.Int;kotlin.String?;io.github.linreal.cascade.editor.core.BlockId?;kotlin.collections.List?;kotlin.String?;kotlin.collections.List?){}[0] + + final val atPosition // io.github.linreal.cascade.editor.action/SplitBlock.atPosition|{}atPosition[0] + final fun (): kotlin/Int // io.github.linreal.cascade.editor.action/SplitBlock.atPosition.|(){}[0] + final val blockId // io.github.linreal.cascade.editor.action/SplitBlock.blockId|{}blockId[0] + final fun (): io.github.linreal.cascade.editor.core/BlockId // io.github.linreal.cascade.editor.action/SplitBlock.blockId.|(){}[0] + final val newBlockId // io.github.linreal.cascade.editor.action/SplitBlock.newBlockId|{}newBlockId[0] + final fun (): io.github.linreal.cascade.editor.core/BlockId? // io.github.linreal.cascade.editor.action/SplitBlock.newBlockId.|(){}[0] + final val newBlockSpans // io.github.linreal.cascade.editor.action/SplitBlock.newBlockSpans|{}newBlockSpans[0] + final fun (): kotlin.collections/List? // io.github.linreal.cascade.editor.action/SplitBlock.newBlockSpans.|(){}[0] + final val newBlockText // io.github.linreal.cascade.editor.action/SplitBlock.newBlockText|{}newBlockText[0] + final fun (): kotlin/String? // io.github.linreal.cascade.editor.action/SplitBlock.newBlockText.|(){}[0] + final val sourceBlockSpans // io.github.linreal.cascade.editor.action/SplitBlock.sourceBlockSpans|{}sourceBlockSpans[0] + final fun (): kotlin.collections/List? // io.github.linreal.cascade.editor.action/SplitBlock.sourceBlockSpans.|(){}[0] + final val sourceBlockText // io.github.linreal.cascade.editor.action/SplitBlock.sourceBlockText|{}sourceBlockText[0] + final fun (): kotlin/String? // io.github.linreal.cascade.editor.action/SplitBlock.sourceBlockText.|(){}[0] + + final fun component1(): io.github.linreal.cascade.editor.core/BlockId // io.github.linreal.cascade.editor.action/SplitBlock.component1|component1(){}[0] + final fun component2(): kotlin/Int // io.github.linreal.cascade.editor.action/SplitBlock.component2|component2(){}[0] + final fun component3(): kotlin/String? // io.github.linreal.cascade.editor.action/SplitBlock.component3|component3(){}[0] + final fun component4(): io.github.linreal.cascade.editor.core/BlockId? // io.github.linreal.cascade.editor.action/SplitBlock.component4|component4(){}[0] + final fun component5(): kotlin.collections/List? // io.github.linreal.cascade.editor.action/SplitBlock.component5|component5(){}[0] + final fun component6(): kotlin/String? // io.github.linreal.cascade.editor.action/SplitBlock.component6|component6(){}[0] + final fun component7(): kotlin.collections/List? // io.github.linreal.cascade.editor.action/SplitBlock.component7|component7(){}[0] + final fun copy(io.github.linreal.cascade.editor.core/BlockId = ..., kotlin/Int = ..., kotlin/String? = ..., io.github.linreal.cascade.editor.core/BlockId? = ..., kotlin.collections/List? = ..., kotlin/String? = ..., kotlin.collections/List? = ...): io.github.linreal.cascade.editor.action/SplitBlock // io.github.linreal.cascade.editor.action/SplitBlock.copy|copy(io.github.linreal.cascade.editor.core.BlockId;kotlin.Int;kotlin.String?;io.github.linreal.cascade.editor.core.BlockId?;kotlin.collections.List?;kotlin.String?;kotlin.collections.List?){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.action/SplitBlock.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.action/SplitBlock.hashCode|hashCode(){}[0] + final fun reduce(io.github.linreal.cascade.editor.state/EditorState): io.github.linreal.cascade.editor.state/EditorState // io.github.linreal.cascade.editor.action/SplitBlock.reduce|reduce(io.github.linreal.cascade.editor.state.EditorState){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.action/SplitBlock.toString|toString(){}[0] +} + +final class io.github.linreal.cascade.editor.action/StartDrag : io.github.linreal.cascade.editor.action/EditorAction { // io.github.linreal.cascade.editor.action/StartDrag|null[0] + constructor (io.github.linreal.cascade.editor.core/BlockId, kotlin/Float) // io.github.linreal.cascade.editor.action/StartDrag.|(io.github.linreal.cascade.editor.core.BlockId;kotlin.Float){}[0] + + final val blockId // io.github.linreal.cascade.editor.action/StartDrag.blockId|{}blockId[0] + final fun (): io.github.linreal.cascade.editor.core/BlockId // io.github.linreal.cascade.editor.action/StartDrag.blockId.|(){}[0] + final val touchOffsetY // io.github.linreal.cascade.editor.action/StartDrag.touchOffsetY|{}touchOffsetY[0] + final fun (): kotlin/Float // io.github.linreal.cascade.editor.action/StartDrag.touchOffsetY.|(){}[0] + + final fun component1(): io.github.linreal.cascade.editor.core/BlockId // io.github.linreal.cascade.editor.action/StartDrag.component1|component1(){}[0] + final fun component2(): kotlin/Float // io.github.linreal.cascade.editor.action/StartDrag.component2|component2(){}[0] + final fun copy(io.github.linreal.cascade.editor.core/BlockId = ..., kotlin/Float = ...): io.github.linreal.cascade.editor.action/StartDrag // io.github.linreal.cascade.editor.action/StartDrag.copy|copy(io.github.linreal.cascade.editor.core.BlockId;kotlin.Float){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.action/StartDrag.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.action/StartDrag.hashCode|hashCode(){}[0] + final fun reduce(io.github.linreal.cascade.editor.state/EditorState): io.github.linreal.cascade.editor.state/EditorState // io.github.linreal.cascade.editor.action/StartDrag.reduce|reduce(io.github.linreal.cascade.editor.state.EditorState){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.action/StartDrag.toString|toString(){}[0] +} + +final class io.github.linreal.cascade.editor.action/ToggleBlockSelection : io.github.linreal.cascade.editor.action/EditorAction { // io.github.linreal.cascade.editor.action/ToggleBlockSelection|null[0] + constructor (io.github.linreal.cascade.editor.core/BlockId) // io.github.linreal.cascade.editor.action/ToggleBlockSelection.|(io.github.linreal.cascade.editor.core.BlockId){}[0] + + final val blockId // io.github.linreal.cascade.editor.action/ToggleBlockSelection.blockId|{}blockId[0] + final fun (): io.github.linreal.cascade.editor.core/BlockId // io.github.linreal.cascade.editor.action/ToggleBlockSelection.blockId.|(){}[0] + + final fun component1(): io.github.linreal.cascade.editor.core/BlockId // io.github.linreal.cascade.editor.action/ToggleBlockSelection.component1|component1(){}[0] + final fun copy(io.github.linreal.cascade.editor.core/BlockId = ...): io.github.linreal.cascade.editor.action/ToggleBlockSelection // io.github.linreal.cascade.editor.action/ToggleBlockSelection.copy|copy(io.github.linreal.cascade.editor.core.BlockId){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.action/ToggleBlockSelection.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.action/ToggleBlockSelection.hashCode|hashCode(){}[0] + final fun reduce(io.github.linreal.cascade.editor.state/EditorState): io.github.linreal.cascade.editor.state/EditorState // io.github.linreal.cascade.editor.action/ToggleBlockSelection.reduce|reduce(io.github.linreal.cascade.editor.state.EditorState){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.action/ToggleBlockSelection.toString|toString(){}[0] +} + +final class io.github.linreal.cascade.editor.action/ToggleTodo : io.github.linreal.cascade.editor.action/EditorAction { // io.github.linreal.cascade.editor.action/ToggleTodo|null[0] + constructor (io.github.linreal.cascade.editor.core/BlockId) // io.github.linreal.cascade.editor.action/ToggleTodo.|(io.github.linreal.cascade.editor.core.BlockId){}[0] + + final val blockId // io.github.linreal.cascade.editor.action/ToggleTodo.blockId|{}blockId[0] + final fun (): io.github.linreal.cascade.editor.core/BlockId // io.github.linreal.cascade.editor.action/ToggleTodo.blockId.|(){}[0] + + final fun component1(): io.github.linreal.cascade.editor.core/BlockId // io.github.linreal.cascade.editor.action/ToggleTodo.component1|component1(){}[0] + final fun copy(io.github.linreal.cascade.editor.core/BlockId = ...): io.github.linreal.cascade.editor.action/ToggleTodo // io.github.linreal.cascade.editor.action/ToggleTodo.copy|copy(io.github.linreal.cascade.editor.core.BlockId){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.action/ToggleTodo.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.action/ToggleTodo.hashCode|hashCode(){}[0] + final fun reduce(io.github.linreal.cascade.editor.state/EditorState): io.github.linreal.cascade.editor.state/EditorState // io.github.linreal.cascade.editor.action/ToggleTodo.reduce|reduce(io.github.linreal.cascade.editor.state.EditorState){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.action/ToggleTodo.toString|toString(){}[0] +} + +final class io.github.linreal.cascade.editor.action/UpdateBlockContent : io.github.linreal.cascade.editor.action/EditorAction { // io.github.linreal.cascade.editor.action/UpdateBlockContent|null[0] + constructor (io.github.linreal.cascade.editor.core/BlockId, io.github.linreal.cascade.editor.core/BlockContent) // io.github.linreal.cascade.editor.action/UpdateBlockContent.|(io.github.linreal.cascade.editor.core.BlockId;io.github.linreal.cascade.editor.core.BlockContent){}[0] + + final val blockId // io.github.linreal.cascade.editor.action/UpdateBlockContent.blockId|{}blockId[0] + final fun (): io.github.linreal.cascade.editor.core/BlockId // io.github.linreal.cascade.editor.action/UpdateBlockContent.blockId.|(){}[0] + final val content // io.github.linreal.cascade.editor.action/UpdateBlockContent.content|{}content[0] + final fun (): io.github.linreal.cascade.editor.core/BlockContent // io.github.linreal.cascade.editor.action/UpdateBlockContent.content.|(){}[0] + + final fun component1(): io.github.linreal.cascade.editor.core/BlockId // io.github.linreal.cascade.editor.action/UpdateBlockContent.component1|component1(){}[0] + final fun component2(): io.github.linreal.cascade.editor.core/BlockContent // io.github.linreal.cascade.editor.action/UpdateBlockContent.component2|component2(){}[0] + final fun copy(io.github.linreal.cascade.editor.core/BlockId = ..., io.github.linreal.cascade.editor.core/BlockContent = ...): io.github.linreal.cascade.editor.action/UpdateBlockContent // io.github.linreal.cascade.editor.action/UpdateBlockContent.copy|copy(io.github.linreal.cascade.editor.core.BlockId;io.github.linreal.cascade.editor.core.BlockContent){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.action/UpdateBlockContent.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.action/UpdateBlockContent.hashCode|hashCode(){}[0] + final fun reduce(io.github.linreal.cascade.editor.state/EditorState): io.github.linreal.cascade.editor.state/EditorState // io.github.linreal.cascade.editor.action/UpdateBlockContent.reduce|reduce(io.github.linreal.cascade.editor.state.EditorState){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.action/UpdateBlockContent.toString|toString(){}[0] +} + +final class io.github.linreal.cascade.editor.action/UpdateBlockText : io.github.linreal.cascade.editor.action/EditorAction { // io.github.linreal.cascade.editor.action/UpdateBlockText|null[0] + constructor (io.github.linreal.cascade.editor.core/BlockId, kotlin/String) // io.github.linreal.cascade.editor.action/UpdateBlockText.|(io.github.linreal.cascade.editor.core.BlockId;kotlin.String){}[0] + + final val blockId // io.github.linreal.cascade.editor.action/UpdateBlockText.blockId|{}blockId[0] + final fun (): io.github.linreal.cascade.editor.core/BlockId // io.github.linreal.cascade.editor.action/UpdateBlockText.blockId.|(){}[0] + final val text // io.github.linreal.cascade.editor.action/UpdateBlockText.text|{}text[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.action/UpdateBlockText.text.|(){}[0] + + final fun component1(): io.github.linreal.cascade.editor.core/BlockId // io.github.linreal.cascade.editor.action/UpdateBlockText.component1|component1(){}[0] + final fun component2(): kotlin/String // io.github.linreal.cascade.editor.action/UpdateBlockText.component2|component2(){}[0] + final fun copy(io.github.linreal.cascade.editor.core/BlockId = ..., kotlin/String = ...): io.github.linreal.cascade.editor.action/UpdateBlockText // io.github.linreal.cascade.editor.action/UpdateBlockText.copy|copy(io.github.linreal.cascade.editor.core.BlockId;kotlin.String){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.action/UpdateBlockText.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.action/UpdateBlockText.hashCode|hashCode(){}[0] + final fun reduce(io.github.linreal.cascade.editor.state/EditorState): io.github.linreal.cascade.editor.state/EditorState // io.github.linreal.cascade.editor.action/UpdateBlockText.reduce|reduce(io.github.linreal.cascade.editor.state.EditorState){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.action/UpdateBlockText.toString|toString(){}[0] +} + +final class io.github.linreal.cascade.editor.action/UpdateDragTarget : io.github.linreal.cascade.editor.action/EditorAction { // io.github.linreal.cascade.editor.action/UpdateDragTarget|null[0] + constructor (kotlin/Int?, kotlin/Int? = ...) // io.github.linreal.cascade.editor.action/UpdateDragTarget.|(kotlin.Int?;kotlin.Int?){}[0] + + final val futureRootIndentationLevel // io.github.linreal.cascade.editor.action/UpdateDragTarget.futureRootIndentationLevel|{}futureRootIndentationLevel[0] + final fun (): kotlin/Int? // io.github.linreal.cascade.editor.action/UpdateDragTarget.futureRootIndentationLevel.|(){}[0] + final val targetIndex // io.github.linreal.cascade.editor.action/UpdateDragTarget.targetIndex|{}targetIndex[0] + final fun (): kotlin/Int? // io.github.linreal.cascade.editor.action/UpdateDragTarget.targetIndex.|(){}[0] + + final fun component1(): kotlin/Int? // io.github.linreal.cascade.editor.action/UpdateDragTarget.component1|component1(){}[0] + final fun component2(): kotlin/Int? // io.github.linreal.cascade.editor.action/UpdateDragTarget.component2|component2(){}[0] + final fun copy(kotlin/Int? = ..., kotlin/Int? = ...): io.github.linreal.cascade.editor.action/UpdateDragTarget // io.github.linreal.cascade.editor.action/UpdateDragTarget.copy|copy(kotlin.Int?;kotlin.Int?){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.action/UpdateDragTarget.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.action/UpdateDragTarget.hashCode|hashCode(){}[0] + final fun reduce(io.github.linreal.cascade.editor.state/EditorState): io.github.linreal.cascade.editor.state/EditorState // io.github.linreal.cascade.editor.action/UpdateDragTarget.reduce|reduce(io.github.linreal.cascade.editor.state.EditorState){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.action/UpdateDragTarget.toString|toString(){}[0] +} + +final class io.github.linreal.cascade.editor.action/UpdateSlashCommandSession : io.github.linreal.cascade.editor.action/EditorAction { // io.github.linreal.cascade.editor.action/UpdateSlashCommandSession|null[0] + constructor (kotlin/String, io.github.linreal.cascade.editor.state/SlashQueryRange) // io.github.linreal.cascade.editor.action/UpdateSlashCommandSession.|(kotlin.String;io.github.linreal.cascade.editor.state.SlashQueryRange){}[0] + + final val query // io.github.linreal.cascade.editor.action/UpdateSlashCommandSession.query|{}query[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.action/UpdateSlashCommandSession.query.|(){}[0] + final val queryRange // io.github.linreal.cascade.editor.action/UpdateSlashCommandSession.queryRange|{}queryRange[0] + final fun (): io.github.linreal.cascade.editor.state/SlashQueryRange // io.github.linreal.cascade.editor.action/UpdateSlashCommandSession.queryRange.|(){}[0] + + final fun component1(): kotlin/String // io.github.linreal.cascade.editor.action/UpdateSlashCommandSession.component1|component1(){}[0] + final fun component2(): io.github.linreal.cascade.editor.state/SlashQueryRange // io.github.linreal.cascade.editor.action/UpdateSlashCommandSession.component2|component2(){}[0] + final fun copy(kotlin/String = ..., io.github.linreal.cascade.editor.state/SlashQueryRange = ...): io.github.linreal.cascade.editor.action/UpdateSlashCommandSession // io.github.linreal.cascade.editor.action/UpdateSlashCommandSession.copy|copy(kotlin.String;io.github.linreal.cascade.editor.state.SlashQueryRange){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.action/UpdateSlashCommandSession.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.action/UpdateSlashCommandSession.hashCode|hashCode(){}[0] + final fun reduce(io.github.linreal.cascade.editor.state/EditorState): io.github.linreal.cascade.editor.state/EditorState // io.github.linreal.cascade.editor.action/UpdateSlashCommandSession.reduce|reduce(io.github.linreal.cascade.editor.state.EditorState){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.action/UpdateSlashCommandSession.toString|toString(){}[0] +} + +final class io.github.linreal.cascade.editor.core/Block { // io.github.linreal.cascade.editor.core/Block|null[0] + constructor (io.github.linreal.cascade.editor.core/BlockId, io.github.linreal.cascade.editor.core/BlockType, io.github.linreal.cascade.editor.core/BlockContent, io.github.linreal.cascade.editor.core/BlockAttributes = ...) // io.github.linreal.cascade.editor.core/Block.|(io.github.linreal.cascade.editor.core.BlockId;io.github.linreal.cascade.editor.core.BlockType;io.github.linreal.cascade.editor.core.BlockContent;io.github.linreal.cascade.editor.core.BlockAttributes){}[0] + + final val attributes // io.github.linreal.cascade.editor.core/Block.attributes|{}attributes[0] + final fun (): io.github.linreal.cascade.editor.core/BlockAttributes // io.github.linreal.cascade.editor.core/Block.attributes.|(){}[0] + final val content // io.github.linreal.cascade.editor.core/Block.content|{}content[0] + final fun (): io.github.linreal.cascade.editor.core/BlockContent // io.github.linreal.cascade.editor.core/Block.content.|(){}[0] + final val id // io.github.linreal.cascade.editor.core/Block.id|{}id[0] + final fun (): io.github.linreal.cascade.editor.core/BlockId // io.github.linreal.cascade.editor.core/Block.id.|(){}[0] + final val type // io.github.linreal.cascade.editor.core/Block.type|{}type[0] + final fun (): io.github.linreal.cascade.editor.core/BlockType // io.github.linreal.cascade.editor.core/Block.type.|(){}[0] + + final fun component1(): io.github.linreal.cascade.editor.core/BlockId // io.github.linreal.cascade.editor.core/Block.component1|component1(){}[0] + final fun component2(): io.github.linreal.cascade.editor.core/BlockType // io.github.linreal.cascade.editor.core/Block.component2|component2(){}[0] + final fun component3(): io.github.linreal.cascade.editor.core/BlockContent // io.github.linreal.cascade.editor.core/Block.component3|component3(){}[0] + final fun component4(): io.github.linreal.cascade.editor.core/BlockAttributes // io.github.linreal.cascade.editor.core/Block.component4|component4(){}[0] + final fun copy(io.github.linreal.cascade.editor.core/BlockId = ..., io.github.linreal.cascade.editor.core/BlockType = ..., io.github.linreal.cascade.editor.core/BlockContent = ..., io.github.linreal.cascade.editor.core/BlockAttributes = ...): io.github.linreal.cascade.editor.core/Block // io.github.linreal.cascade.editor.core/Block.copy|copy(io.github.linreal.cascade.editor.core.BlockId;io.github.linreal.cascade.editor.core.BlockType;io.github.linreal.cascade.editor.core.BlockContent;io.github.linreal.cascade.editor.core.BlockAttributes){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.core/Block.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.core/Block.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.core/Block.toString|toString(){}[0] + final fun withAttributes(io.github.linreal.cascade.editor.core/BlockAttributes): io.github.linreal.cascade.editor.core/Block // io.github.linreal.cascade.editor.core/Block.withAttributes|withAttributes(io.github.linreal.cascade.editor.core.BlockAttributes){}[0] + final fun withContent(io.github.linreal.cascade.editor.core/BlockContent): io.github.linreal.cascade.editor.core/Block // io.github.linreal.cascade.editor.core/Block.withContent|withContent(io.github.linreal.cascade.editor.core.BlockContent){}[0] + final fun withType(io.github.linreal.cascade.editor.core/BlockType): io.github.linreal.cascade.editor.core/Block // io.github.linreal.cascade.editor.core/Block.withType|withType(io.github.linreal.cascade.editor.core.BlockType){}[0] + + final object Companion { // io.github.linreal.cascade.editor.core/Block.Companion|null[0] + final fun bulletList(kotlin/String = ...): io.github.linreal.cascade.editor.core/Block // io.github.linreal.cascade.editor.core/Block.Companion.bulletList|bulletList(kotlin.String){}[0] + final fun divider(): io.github.linreal.cascade.editor.core/Block // io.github.linreal.cascade.editor.core/Block.Companion.divider|divider(){}[0] + final fun heading(kotlin/Int, kotlin/String = ...): io.github.linreal.cascade.editor.core/Block // io.github.linreal.cascade.editor.core/Block.Companion.heading|heading(kotlin.Int;kotlin.String){}[0] + final fun numberedList(kotlin/String = ..., kotlin/Int = ...): io.github.linreal.cascade.editor.core/Block // io.github.linreal.cascade.editor.core/Block.Companion.numberedList|numberedList(kotlin.String;kotlin.Int){}[0] + final fun paragraph(kotlin/String = ..., kotlin.collections/List = ...): io.github.linreal.cascade.editor.core/Block // io.github.linreal.cascade.editor.core/Block.Companion.paragraph|paragraph(kotlin.String;kotlin.collections.List){}[0] + final fun todo(kotlin/String = ..., kotlin/Boolean = ...): io.github.linreal.cascade.editor.core/Block // io.github.linreal.cascade.editor.core/Block.Companion.todo|todo(kotlin.String;kotlin.Boolean){}[0] + } +} + +final class io.github.linreal.cascade.editor.core/BlockAttributes { // io.github.linreal.cascade.editor.core/BlockAttributes|null[0] + constructor (kotlin/Int = ...) // io.github.linreal.cascade.editor.core/BlockAttributes.|(kotlin.Int){}[0] + + final val indentationLevel // io.github.linreal.cascade.editor.core/BlockAttributes.indentationLevel|{}indentationLevel[0] + final fun (): kotlin/Int // io.github.linreal.cascade.editor.core/BlockAttributes.indentationLevel.|(){}[0] + + final fun component1(): kotlin/Int // io.github.linreal.cascade.editor.core/BlockAttributes.component1|component1(){}[0] + final fun copy(kotlin/Int = ...): io.github.linreal.cascade.editor.core/BlockAttributes // io.github.linreal.cascade.editor.core/BlockAttributes.copy|copy(kotlin.Int){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.core/BlockAttributes.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.core/BlockAttributes.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.core/BlockAttributes.toString|toString(){}[0] + + final object Companion { // io.github.linreal.cascade.editor.core/BlockAttributes.Companion|null[0] + final const val MAX_INDENTATION_LEVEL // io.github.linreal.cascade.editor.core/BlockAttributes.Companion.MAX_INDENTATION_LEVEL|{}MAX_INDENTATION_LEVEL[0] + final fun (): kotlin/Int // io.github.linreal.cascade.editor.core/BlockAttributes.Companion.MAX_INDENTATION_LEVEL.|(){}[0] + final const val MIN_INDENTATION_LEVEL // io.github.linreal.cascade.editor.core/BlockAttributes.Companion.MIN_INDENTATION_LEVEL|{}MIN_INDENTATION_LEVEL[0] + final fun (): kotlin/Int // io.github.linreal.cascade.editor.core/BlockAttributes.Companion.MIN_INDENTATION_LEVEL.|(){}[0] + + final val Default // io.github.linreal.cascade.editor.core/BlockAttributes.Companion.Default|{}Default[0] + final fun (): io.github.linreal.cascade.editor.core/BlockAttributes // io.github.linreal.cascade.editor.core/BlockAttributes.Companion.Default.|(){}[0] + } +} + +final class io.github.linreal.cascade.editor.core/TextSpan { // io.github.linreal.cascade.editor.core/TextSpan|null[0] + constructor (kotlin/Int, kotlin/Int, io.github.linreal.cascade.editor.core/SpanStyle) // io.github.linreal.cascade.editor.core/TextSpan.|(kotlin.Int;kotlin.Int;io.github.linreal.cascade.editor.core.SpanStyle){}[0] + + final val end // io.github.linreal.cascade.editor.core/TextSpan.end|{}end[0] + final fun (): kotlin/Int // io.github.linreal.cascade.editor.core/TextSpan.end.|(){}[0] + final val start // io.github.linreal.cascade.editor.core/TextSpan.start|{}start[0] + final fun (): kotlin/Int // io.github.linreal.cascade.editor.core/TextSpan.start.|(){}[0] + final val style // io.github.linreal.cascade.editor.core/TextSpan.style|{}style[0] + final fun (): io.github.linreal.cascade.editor.core/SpanStyle // io.github.linreal.cascade.editor.core/TextSpan.style.|(){}[0] + + final fun component1(): kotlin/Int // io.github.linreal.cascade.editor.core/TextSpan.component1|component1(){}[0] + final fun component2(): kotlin/Int // io.github.linreal.cascade.editor.core/TextSpan.component2|component2(){}[0] + final fun component3(): io.github.linreal.cascade.editor.core/SpanStyle // io.github.linreal.cascade.editor.core/TextSpan.component3|component3(){}[0] + final fun copy(kotlin/Int = ..., kotlin/Int = ..., io.github.linreal.cascade.editor.core/SpanStyle = ...): io.github.linreal.cascade.editor.core/TextSpan // io.github.linreal.cascade.editor.core/TextSpan.copy|copy(kotlin.Int;kotlin.Int;io.github.linreal.cascade.editor.core.SpanStyle){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.core/TextSpan.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.core/TextSpan.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.core/TextSpan.toString|toString(){}[0] +} + +final class io.github.linreal.cascade.editor.core/UnknownBlockType : io.github.linreal.cascade.editor.core/CustomBlockType { // io.github.linreal.cascade.editor.core/UnknownBlockType|null[0] + constructor (kotlin/String, kotlin/String) // io.github.linreal.cascade.editor.core/UnknownBlockType.|(kotlin.String;kotlin.String){}[0] + + final val displayName // io.github.linreal.cascade.editor.core/UnknownBlockType.displayName|{}displayName[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.core/UnknownBlockType.displayName.|(){}[0] + final val isConvertible // io.github.linreal.cascade.editor.core/UnknownBlockType.isConvertible|{}isConvertible[0] + final fun (): kotlin/Boolean // io.github.linreal.cascade.editor.core/UnknownBlockType.isConvertible.|(){}[0] + final val rawTypeJson // io.github.linreal.cascade.editor.core/UnknownBlockType.rawTypeJson|{}rawTypeJson[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.core/UnknownBlockType.rawTypeJson.|(){}[0] + final val supportsText // io.github.linreal.cascade.editor.core/UnknownBlockType.supportsText|{}supportsText[0] + final fun (): kotlin/Boolean // io.github.linreal.cascade.editor.core/UnknownBlockType.supportsText.|(){}[0] + final val typeId // io.github.linreal.cascade.editor.core/UnknownBlockType.typeId|{}typeId[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.core/UnknownBlockType.typeId.|(){}[0] + + final fun component1(): kotlin/String // io.github.linreal.cascade.editor.core/UnknownBlockType.component1|component1(){}[0] + final fun component2(): kotlin/String // io.github.linreal.cascade.editor.core/UnknownBlockType.component2|component2(){}[0] + final fun copy(kotlin/String = ..., kotlin/String = ...): io.github.linreal.cascade.editor.core/UnknownBlockType // io.github.linreal.cascade.editor.core/UnknownBlockType.copy|copy(kotlin.String;kotlin.String){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.core/UnknownBlockType.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.core/UnknownBlockType.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.core/UnknownBlockType.toString|toString(){}[0] +} + +final class io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeLimits { // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeLimits|null[0] + constructor (kotlin/Int = ...) // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeLimits.|(kotlin.Int){}[0] + + final val maxInputChars // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeLimits.maxInputChars|{}maxInputChars[0] + final fun (): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeLimits.maxInputChars.|(){}[0] + + final fun component1(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeLimits.component1|component1(){}[0] + final fun copy(kotlin/Int = ...): io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeLimits // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeLimits.copy|copy(kotlin.Int){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeLimits.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeLimits.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeLimits.toString|toString(){}[0] + + final object Companion { // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeLimits.Companion|null[0] + final const val DEFAULT_MAX_INPUT_CHARS // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeLimits.Companion.DEFAULT_MAX_INPUT_CHARS|{}DEFAULT_MAX_INPUT_CHARS[0] + final fun (): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeLimits.Companion.DEFAULT_MAX_INPUT_CHARS.|(){}[0] + + final val Default // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeLimits.Companion.Default|{}Default[0] + final fun (): io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeLimits // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeLimits.Companion.Default.|(){}[0] + } +} + +final class io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeResult { // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeResult|null[0] + constructor (kotlin.collections/List, kotlin.collections/List) // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeResult.|(kotlin.collections.List;kotlin.collections.List){}[0] + + final val blocks // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeResult.blocks|{}blocks[0] + final fun (): kotlin.collections/List // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeResult.blocks.|(){}[0] + final val warnings // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeResult.warnings|{}warnings[0] + final fun (): kotlin.collections/List // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeResult.warnings.|(){}[0] + + final fun component1(): kotlin.collections/List // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeResult.component1|component1(){}[0] + final fun component2(): kotlin.collections/List // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeResult.component2|component2(){}[0] + final fun copy(kotlin.collections/List = ..., kotlin.collections/List = ...): io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeResult // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeResult.copy|copy(kotlin.collections.List;kotlin.collections.List){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeResult.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeResult.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeResult.toString|toString(){}[0] +} + +final class io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeResult { // io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeResult|null[0] + constructor (kotlin/String, kotlin.collections/List) // io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeResult.|(kotlin.String;kotlin.collections.List){}[0] + + final val html // io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeResult.html|{}html[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeResult.html.|(){}[0] + final val warnings // io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeResult.warnings|{}warnings[0] + final fun (): kotlin.collections/List // io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeResult.warnings.|(){}[0] + + final fun component1(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeResult.component1|component1(){}[0] + final fun component2(): kotlin.collections/List // io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeResult.component2|component2(){}[0] + final fun copy(kotlin/String = ..., kotlin.collections/List = ...): io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeResult // io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeResult.copy|copy(kotlin.String;kotlin.collections.List){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeResult.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeResult.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeResult.toString|toString(){}[0] +} + +final class io.github.linreal.cascade.editor.htmlserialization/HtmlProfile { // io.github.linreal.cascade.editor.htmlserialization/HtmlProfile|null[0] + final val supportSet // io.github.linreal.cascade.editor.htmlserialization/HtmlProfile.supportSet|{}supportSet[0] + final fun (): io.github.linreal.cascade.editor.htmlserialization/HtmlProfileSupportSet // io.github.linreal.cascade.editor.htmlserialization/HtmlProfile.supportSet.|(){}[0] + + final fun tagDecoderFor(kotlin/String): io.github.linreal.cascade.editor.htmlserialization/TagDecoder? // io.github.linreal.cascade.editor.htmlserialization/HtmlProfile.tagDecoderFor|tagDecoderFor(kotlin.String){}[0] + final fun withBlockEncoderInternal(kotlin.reflect/KClass, io.github.linreal.cascade.editor.htmlserialization/BlockEncoder<*>): io.github.linreal.cascade.editor.htmlserialization/HtmlProfile // io.github.linreal.cascade.editor.htmlserialization/HtmlProfile.withBlockEncoderInternal|withBlockEncoderInternal(kotlin.reflect.KClass;io.github.linreal.cascade.editor.htmlserialization.BlockEncoder<*>){}[0] + final fun withBlockGroupEncoder(kotlin/String, io.github.linreal.cascade.editor.htmlserialization/BlockGroupEncoder): io.github.linreal.cascade.editor.htmlserialization/HtmlProfile // io.github.linreal.cascade.editor.htmlserialization/HtmlProfile.withBlockGroupEncoder|withBlockGroupEncoder(kotlin.String;io.github.linreal.cascade.editor.htmlserialization.BlockGroupEncoder){}[0] + final fun withCustomBlockEncoder(kotlin/String, io.github.linreal.cascade.editor.htmlserialization/BlockEncoder<*>): io.github.linreal.cascade.editor.htmlserialization/HtmlProfile // io.github.linreal.cascade.editor.htmlserialization/HtmlProfile.withCustomBlockEncoder|withCustomBlockEncoder(kotlin.String;io.github.linreal.cascade.editor.htmlserialization.BlockEncoder<*>){}[0] + final fun withCustomSpanEncoder(kotlin/String, io.github.linreal.cascade.editor.htmlserialization/SpanEncoder): io.github.linreal.cascade.editor.htmlserialization/HtmlProfile // io.github.linreal.cascade.editor.htmlserialization/HtmlProfile.withCustomSpanEncoder|withCustomSpanEncoder(kotlin.String;io.github.linreal.cascade.editor.htmlserialization.SpanEncoder){}[0] + final fun withEncoderBlockFallback(io.github.linreal.cascade.editor.htmlserialization/BlockEncoder): io.github.linreal.cascade.editor.htmlserialization/HtmlProfile // io.github.linreal.cascade.editor.htmlserialization/HtmlProfile.withEncoderBlockFallback|withEncoderBlockFallback(io.github.linreal.cascade.editor.htmlserialization.BlockEncoder){}[0] + final fun withEncoderSpanFallback(io.github.linreal.cascade.editor.htmlserialization/SpanEncoder): io.github.linreal.cascade.editor.htmlserialization/HtmlProfile // io.github.linreal.cascade.editor.htmlserialization/HtmlProfile.withEncoderSpanFallback|withEncoderSpanFallback(io.github.linreal.cascade.editor.htmlserialization.SpanEncoder){}[0] + final fun withParserPolicy(io.github.linreal.cascade.editor.htmlserialization/BlockSeparator): io.github.linreal.cascade.editor.htmlserialization/HtmlProfile // io.github.linreal.cascade.editor.htmlserialization/HtmlProfile.withParserPolicy|withParserPolicy(io.github.linreal.cascade.editor.htmlserialization.BlockSeparator){}[0] + final fun withParserPolicy(io.github.linreal.cascade.editor.htmlserialization/EntityDecode): io.github.linreal.cascade.editor.htmlserialization/HtmlProfile // io.github.linreal.cascade.editor.htmlserialization/HtmlProfile.withParserPolicy|withParserPolicy(io.github.linreal.cascade.editor.htmlserialization.EntityDecode){}[0] + final fun withParserPolicy(io.github.linreal.cascade.editor.htmlserialization/InlineRoot): io.github.linreal.cascade.editor.htmlserialization/HtmlProfile // io.github.linreal.cascade.editor.htmlserialization/HtmlProfile.withParserPolicy|withParserPolicy(io.github.linreal.cascade.editor.htmlserialization.InlineRoot){}[0] + final fun withSpanEncoderInternal(kotlin.reflect/KClass, io.github.linreal.cascade.editor.htmlserialization/SpanEncoder<*>): io.github.linreal.cascade.editor.htmlserialization/HtmlProfile // io.github.linreal.cascade.editor.htmlserialization/HtmlProfile.withSpanEncoderInternal|withSpanEncoderInternal(kotlin.reflect.KClass;io.github.linreal.cascade.editor.htmlserialization.SpanEncoder<*>){}[0] + final fun withSupportSet(io.github.linreal.cascade.editor.htmlserialization/HtmlProfileSupportSet): io.github.linreal.cascade.editor.htmlserialization/HtmlProfile // io.github.linreal.cascade.editor.htmlserialization/HtmlProfile.withSupportSet|withSupportSet(io.github.linreal.cascade.editor.htmlserialization.HtmlProfileSupportSet){}[0] + final fun withTagDecoder(kotlin/String, io.github.linreal.cascade.editor.htmlserialization/TagDecoder): io.github.linreal.cascade.editor.htmlserialization/HtmlProfile // io.github.linreal.cascade.editor.htmlserialization/HtmlProfile.withTagDecoder|withTagDecoder(kotlin.String;io.github.linreal.cascade.editor.htmlserialization.TagDecoder){}[0] + final fun withUnknownTagPolicy(io.github.linreal.cascade.editor.htmlserialization/UnknownTagPolicy): io.github.linreal.cascade.editor.htmlserialization/HtmlProfile // io.github.linreal.cascade.editor.htmlserialization/HtmlProfile.withUnknownTagPolicy|withUnknownTagPolicy(io.github.linreal.cascade.editor.htmlserialization.UnknownTagPolicy){}[0] + final fun withoutBlockGroupEncoder(kotlin/String): io.github.linreal.cascade.editor.htmlserialization/HtmlProfile // io.github.linreal.cascade.editor.htmlserialization/HtmlProfile.withoutBlockGroupEncoder|withoutBlockGroupEncoder(kotlin.String){}[0] + final fun withoutTagDecoder(kotlin/String): io.github.linreal.cascade.editor.htmlserialization/HtmlProfile // io.github.linreal.cascade.editor.htmlserialization/HtmlProfile.withoutTagDecoder|withoutTagDecoder(kotlin.String){}[0] + final inline fun <#A1: reified io.github.linreal.cascade.editor.core/BlockType> withBlockEncoder(io.github.linreal.cascade.editor.htmlserialization/BlockEncoder<#A1>): io.github.linreal.cascade.editor.htmlserialization/HtmlProfile // io.github.linreal.cascade.editor.htmlserialization/HtmlProfile.withBlockEncoder|withBlockEncoder(io.github.linreal.cascade.editor.htmlserialization.BlockEncoder<0:0>){0§}[0] + final inline fun <#A1: reified io.github.linreal.cascade.editor.core/SpanStyle> withSpanEncoder(io.github.linreal.cascade.editor.htmlserialization/SpanEncoder<#A1>): io.github.linreal.cascade.editor.htmlserialization/HtmlProfile // io.github.linreal.cascade.editor.htmlserialization/HtmlProfile.withSpanEncoder|withSpanEncoder(io.github.linreal.cascade.editor.htmlserialization.SpanEncoder<0:0>){0§}[0] + + final object Companion { // io.github.linreal.cascade.editor.htmlserialization/HtmlProfile.Companion|null[0] + final const val DEFAULT_HIGHLIGHT_COLOR_ARGB // io.github.linreal.cascade.editor.htmlserialization/HtmlProfile.Companion.DEFAULT_HIGHLIGHT_COLOR_ARGB|{}DEFAULT_HIGHLIGHT_COLOR_ARGB[0] + final fun (): kotlin/Long // io.github.linreal.cascade.editor.htmlserialization/HtmlProfile.Companion.DEFAULT_HIGHLIGHT_COLOR_ARGB.|(){}[0] + + final val Default // io.github.linreal.cascade.editor.htmlserialization/HtmlProfile.Companion.Default|{}Default[0] + final fun (): io.github.linreal.cascade.editor.htmlserialization/HtmlProfile // io.github.linreal.cascade.editor.htmlserialization/HtmlProfile.Companion.Default.|(){}[0] + } +} + +final class io.github.linreal.cascade.editor.htmlserialization/HtmlProfileSupportSet { // io.github.linreal.cascade.editor.htmlserialization/HtmlProfileSupportSet|null[0] + constructor (kotlin/Function1, kotlin/Function1) // io.github.linreal.cascade.editor.htmlserialization/HtmlProfileSupportSet.|(kotlin.Function1;kotlin.Function1){}[0] + + final val supportsBlockPredicate // io.github.linreal.cascade.editor.htmlserialization/HtmlProfileSupportSet.supportsBlockPredicate|{}supportsBlockPredicate[0] + final fun (): kotlin/Function1 // io.github.linreal.cascade.editor.htmlserialization/HtmlProfileSupportSet.supportsBlockPredicate.|(){}[0] + final val supportsSpanPredicate // io.github.linreal.cascade.editor.htmlserialization/HtmlProfileSupportSet.supportsSpanPredicate|{}supportsSpanPredicate[0] + final fun (): kotlin/Function1 // io.github.linreal.cascade.editor.htmlserialization/HtmlProfileSupportSet.supportsSpanPredicate.|(){}[0] + + final fun supportsBlock(io.github.linreal.cascade.editor.core/Block): kotlin/Boolean // io.github.linreal.cascade.editor.htmlserialization/HtmlProfileSupportSet.supportsBlock|supportsBlock(io.github.linreal.cascade.editor.core.Block){}[0] + final fun supportsDocument(kotlin.collections/List): kotlin/Boolean // io.github.linreal.cascade.editor.htmlserialization/HtmlProfileSupportSet.supportsDocument|supportsDocument(kotlin.collections.List){}[0] + final fun supportsSpan(io.github.linreal.cascade.editor.core/SpanStyle): kotlin/Boolean // io.github.linreal.cascade.editor.htmlserialization/HtmlProfileSupportSet.supportsSpan|supportsSpan(io.github.linreal.cascade.editor.core.SpanStyle){}[0] + + final object Companion { // io.github.linreal.cascade.editor.htmlserialization/HtmlProfileSupportSet.Companion|null[0] + final val Default // io.github.linreal.cascade.editor.htmlserialization/HtmlProfileSupportSet.Companion.Default|{}Default[0] + final fun (): io.github.linreal.cascade.editor.htmlserialization/HtmlProfileSupportSet // io.github.linreal.cascade.editor.htmlserialization/HtmlProfileSupportSet.Companion.Default.|(){}[0] + } +} + +final class io.github.linreal.cascade.editor.htmlserialization/HtmlTagPair { // io.github.linreal.cascade.editor.htmlserialization/HtmlTagPair|null[0] + constructor (kotlin/String, kotlin/String) // io.github.linreal.cascade.editor.htmlserialization/HtmlTagPair.|(kotlin.String;kotlin.String){}[0] + + final val close // io.github.linreal.cascade.editor.htmlserialization/HtmlTagPair.close|{}close[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlTagPair.close.|(){}[0] + final val open // io.github.linreal.cascade.editor.htmlserialization/HtmlTagPair.open|{}open[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlTagPair.open.|(){}[0] + + final fun component1(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlTagPair.component1|component1(){}[0] + final fun component2(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlTagPair.component2|component2(){}[0] + final fun copy(kotlin/String = ..., kotlin/String = ...): io.github.linreal.cascade.editor.htmlserialization/HtmlTagPair // io.github.linreal.cascade.editor.htmlserialization/HtmlTagPair.copy|copy(kotlin.String;kotlin.String){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.htmlserialization/HtmlTagPair.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlTagPair.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlTagPair.toString|toString(){}[0] +} + +final class io.github.linreal.cascade.editor.htmlserialization/InlineFragment { // io.github.linreal.cascade.editor.htmlserialization/InlineFragment|null[0] + constructor (kotlin/String, kotlin.collections/List) // io.github.linreal.cascade.editor.htmlserialization/InlineFragment.|(kotlin.String;kotlin.collections.List){}[0] + + final val spans // io.github.linreal.cascade.editor.htmlserialization/InlineFragment.spans|{}spans[0] + final fun (): kotlin.collections/List // io.github.linreal.cascade.editor.htmlserialization/InlineFragment.spans.|(){}[0] + final val text // io.github.linreal.cascade.editor.htmlserialization/InlineFragment.text|{}text[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/InlineFragment.text.|(){}[0] + + final fun component1(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/InlineFragment.component1|component1(){}[0] + final fun component2(): kotlin.collections/List // io.github.linreal.cascade.editor.htmlserialization/InlineFragment.component2|component2(){}[0] + final fun copy(kotlin/String = ..., kotlin.collections/List = ...): io.github.linreal.cascade.editor.htmlserialization/InlineFragment // io.github.linreal.cascade.editor.htmlserialization/InlineFragment.copy|copy(kotlin.String;kotlin.collections.List){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.htmlserialization/InlineFragment.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/InlineFragment.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/InlineFragment.toString|toString(){}[0] +} + +final class io.github.linreal.cascade.editor.indentation/IndentationState { // io.github.linreal.cascade.editor.indentation/IndentationState|null[0] + constructor (kotlin/Boolean, kotlin/Boolean, kotlin.collections/List) // io.github.linreal.cascade.editor.indentation/IndentationState.|(kotlin.Boolean;kotlin.Boolean;kotlin.collections.List){}[0] + + final val canIndentBackward // io.github.linreal.cascade.editor.indentation/IndentationState.canIndentBackward|{}canIndentBackward[0] + final fun (): kotlin/Boolean // io.github.linreal.cascade.editor.indentation/IndentationState.canIndentBackward.|(){}[0] + final val canIndentForward // io.github.linreal.cascade.editor.indentation/IndentationState.canIndentForward|{}canIndentForward[0] + final fun (): kotlin/Boolean // io.github.linreal.cascade.editor.indentation/IndentationState.canIndentForward.|(){}[0] + final val targetBlockIds // io.github.linreal.cascade.editor.indentation/IndentationState.targetBlockIds|{}targetBlockIds[0] + final fun (): kotlin.collections/List // io.github.linreal.cascade.editor.indentation/IndentationState.targetBlockIds.|(){}[0] + + final fun component1(): kotlin/Boolean // io.github.linreal.cascade.editor.indentation/IndentationState.component1|component1(){}[0] + final fun component2(): kotlin/Boolean // io.github.linreal.cascade.editor.indentation/IndentationState.component2|component2(){}[0] + final fun component3(): kotlin.collections/List // io.github.linreal.cascade.editor.indentation/IndentationState.component3|component3(){}[0] + final fun copy(kotlin/Boolean = ..., kotlin/Boolean = ..., kotlin.collections/List = ...): io.github.linreal.cascade.editor.indentation/IndentationState // io.github.linreal.cascade.editor.indentation/IndentationState.copy|copy(kotlin.Boolean;kotlin.Boolean;kotlin.collections.List){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.indentation/IndentationState.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.indentation/IndentationState.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.indentation/IndentationState.toString|toString(){}[0] + + final object Companion { // io.github.linreal.cascade.editor.indentation/IndentationState.Companion|null[0] + final val Empty // io.github.linreal.cascade.editor.indentation/IndentationState.Companion.Empty|{}Empty[0] + final fun (): io.github.linreal.cascade.editor.indentation/IndentationState // io.github.linreal.cascade.editor.indentation/IndentationState.Companion.Empty.|(){}[0] + } +} + +final class io.github.linreal.cascade.editor.registry/BlockDescriptor { // io.github.linreal.cascade.editor.registry/BlockDescriptor|null[0] + constructor (kotlin/String, kotlin/String, kotlin/String, kotlin.collections/List = ..., kotlin/String? = ..., io.github.linreal.cascade.editor.slash/BuiltInSlashCommandSpec? = ..., kotlin/Function1) // io.github.linreal.cascade.editor.registry/BlockDescriptor.|(kotlin.String;kotlin.String;kotlin.String;kotlin.collections.List;kotlin.String?;io.github.linreal.cascade.editor.slash.BuiltInSlashCommandSpec?;kotlin.Function1){}[0] + + final val description // io.github.linreal.cascade.editor.registry/BlockDescriptor.description|{}description[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.registry/BlockDescriptor.description.|(){}[0] + final val displayName // io.github.linreal.cascade.editor.registry/BlockDescriptor.displayName|{}displayName[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.registry/BlockDescriptor.displayName.|(){}[0] + final val factory // io.github.linreal.cascade.editor.registry/BlockDescriptor.factory|{}factory[0] + final fun (): kotlin/Function1 // io.github.linreal.cascade.editor.registry/BlockDescriptor.factory.|(){}[0] + final val icon // io.github.linreal.cascade.editor.registry/BlockDescriptor.icon|{}icon[0] + final fun (): kotlin/String? // io.github.linreal.cascade.editor.registry/BlockDescriptor.icon.|(){}[0] + final val keywords // io.github.linreal.cascade.editor.registry/BlockDescriptor.keywords|{}keywords[0] + final fun (): kotlin.collections/List // io.github.linreal.cascade.editor.registry/BlockDescriptor.keywords.|(){}[0] + final val slash // io.github.linreal.cascade.editor.registry/BlockDescriptor.slash|{}slash[0] + final fun (): io.github.linreal.cascade.editor.slash/BuiltInSlashCommandSpec? // io.github.linreal.cascade.editor.registry/BlockDescriptor.slash.|(){}[0] + final val typeId // io.github.linreal.cascade.editor.registry/BlockDescriptor.typeId|{}typeId[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.registry/BlockDescriptor.typeId.|(){}[0] + + final fun component1(): kotlin/String // io.github.linreal.cascade.editor.registry/BlockDescriptor.component1|component1(){}[0] + final fun component2(): kotlin/String // io.github.linreal.cascade.editor.registry/BlockDescriptor.component2|component2(){}[0] + final fun component3(): kotlin/String // io.github.linreal.cascade.editor.registry/BlockDescriptor.component3|component3(){}[0] + final fun component4(): kotlin.collections/List // io.github.linreal.cascade.editor.registry/BlockDescriptor.component4|component4(){}[0] + final fun component5(): kotlin/String? // io.github.linreal.cascade.editor.registry/BlockDescriptor.component5|component5(){}[0] + final fun component6(): io.github.linreal.cascade.editor.slash/BuiltInSlashCommandSpec? // io.github.linreal.cascade.editor.registry/BlockDescriptor.component6|component6(){}[0] + final fun component7(): kotlin/Function1 // io.github.linreal.cascade.editor.registry/BlockDescriptor.component7|component7(){}[0] + final fun copy(kotlin/String = ..., kotlin/String = ..., kotlin/String = ..., kotlin.collections/List = ..., kotlin/String? = ..., io.github.linreal.cascade.editor.slash/BuiltInSlashCommandSpec? = ..., kotlin/Function1 = ...): io.github.linreal.cascade.editor.registry/BlockDescriptor // io.github.linreal.cascade.editor.registry/BlockDescriptor.copy|copy(kotlin.String;kotlin.String;kotlin.String;kotlin.collections.List;kotlin.String?;io.github.linreal.cascade.editor.slash.BuiltInSlashCommandSpec?;kotlin.Function1){}[0] + final fun createBlock(): io.github.linreal.cascade.editor.core/Block // io.github.linreal.cascade.editor.registry/BlockDescriptor.createBlock|createBlock(){}[0] + final fun createBlock(io.github.linreal.cascade.editor.core/BlockId): io.github.linreal.cascade.editor.core/Block // io.github.linreal.cascade.editor.registry/BlockDescriptor.createBlock|createBlock(io.github.linreal.cascade.editor.core.BlockId){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.registry/BlockDescriptor.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.registry/BlockDescriptor.hashCode|hashCode(){}[0] + final fun matches(kotlin/String): kotlin/Boolean // io.github.linreal.cascade.editor.registry/BlockDescriptor.matches|matches(kotlin.String){}[0] + final fun relevanceScore(kotlin/String): kotlin/Int // io.github.linreal.cascade.editor.registry/BlockDescriptor.relevanceScore|relevanceScore(kotlin.String){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.registry/BlockDescriptor.toString|toString(){}[0] +} + +final class io.github.linreal.cascade.editor.registry/BlockRegistry { // io.github.linreal.cascade.editor.registry/BlockRegistry|null[0] + constructor () // io.github.linreal.cascade.editor.registry/BlockRegistry.|(){}[0] + + final fun <#A1: io.github.linreal.cascade.editor.core/BlockType> register(io.github.linreal.cascade.editor.registry/BlockDescriptor, io.github.linreal.cascade.editor.registry/BlockRenderer<#A1>) // io.github.linreal.cascade.editor.registry/BlockRegistry.register|register(io.github.linreal.cascade.editor.registry.BlockDescriptor;io.github.linreal.cascade.editor.registry.BlockRenderer<0:0>){0§}[0] + final fun <#A1: io.github.linreal.cascade.editor.core/BlockType> registerRenderer(kotlin/String, io.github.linreal.cascade.editor.registry/BlockRenderer<#A1>) // io.github.linreal.cascade.editor.registry/BlockRegistry.registerRenderer|registerRenderer(kotlin.String;io.github.linreal.cascade.editor.registry.BlockRenderer<0:0>){0§}[0] + final fun createBlock(kotlin/String): io.github.linreal.cascade.editor.core/Block? // io.github.linreal.cascade.editor.registry/BlockRegistry.createBlock|createBlock(kotlin.String){}[0] + final fun getAllDescriptors(): kotlin.collections/List // io.github.linreal.cascade.editor.registry/BlockRegistry.getAllDescriptors|getAllDescriptors(){}[0] + final fun getDescriptor(kotlin/String): io.github.linreal.cascade.editor.registry/BlockDescriptor? // io.github.linreal.cascade.editor.registry/BlockRegistry.getDescriptor|getDescriptor(kotlin.String){}[0] + final fun getRenderer(io.github.linreal.cascade.editor.core/BlockType): io.github.linreal.cascade.editor.registry/BlockRenderer<*>? // io.github.linreal.cascade.editor.registry/BlockRegistry.getRenderer|getRenderer(io.github.linreal.cascade.editor.core.BlockType){}[0] + final fun getRenderer(kotlin/String): io.github.linreal.cascade.editor.registry/BlockRenderer<*>? // io.github.linreal.cascade.editor.registry/BlockRegistry.getRenderer|getRenderer(kotlin.String){}[0] + final fun isRegistered(kotlin/String): kotlin/Boolean // io.github.linreal.cascade.editor.registry/BlockRegistry.isRegistered|isRegistered(kotlin.String){}[0] + final fun registerDescriptor(io.github.linreal.cascade.editor.registry/BlockDescriptor) // io.github.linreal.cascade.editor.registry/BlockRegistry.registerDescriptor|registerDescriptor(io.github.linreal.cascade.editor.registry.BlockDescriptor){}[0] + final fun search(kotlin/String): kotlin.collections/List // io.github.linreal.cascade.editor.registry/BlockRegistry.search|search(kotlin.String){}[0] + final fun setUnknownBlockRenderer(io.github.linreal.cascade.editor.registry/BlockRenderer<*>) // io.github.linreal.cascade.editor.registry/BlockRegistry.setUnknownBlockRenderer|setUnknownBlockRenderer(io.github.linreal.cascade.editor.registry.BlockRenderer<*>){}[0] + + final object Companion { // io.github.linreal.cascade.editor.registry/BlockRegistry.Companion|null[0] + final fun create(): io.github.linreal.cascade.editor.registry/BlockRegistry // io.github.linreal.cascade.editor.registry/BlockRegistry.Companion.create|create(){}[0] + final fun createDefault(): io.github.linreal.cascade.editor.registry/BlockRegistry // io.github.linreal.cascade.editor.registry/BlockRegistry.Companion.createDefault|createDefault(){}[0] + } +} + +final class io.github.linreal.cascade.editor.richtext/FormattingState { // io.github.linreal.cascade.editor.richtext/FormattingState|null[0] + constructor (kotlin.collections/Map, kotlin/Boolean, io.github.linreal.cascade.editor.core/BlockId?, kotlin/Boolean) // io.github.linreal.cascade.editor.richtext/FormattingState.|(kotlin.collections.Map;kotlin.Boolean;io.github.linreal.cascade.editor.core.BlockId?;kotlin.Boolean){}[0] + + final val canFormat // io.github.linreal.cascade.editor.richtext/FormattingState.canFormat|{}canFormat[0] + final fun (): kotlin/Boolean // io.github.linreal.cascade.editor.richtext/FormattingState.canFormat.|(){}[0] + final val focusedBlockId // io.github.linreal.cascade.editor.richtext/FormattingState.focusedBlockId|{}focusedBlockId[0] + final fun (): io.github.linreal.cascade.editor.core/BlockId? // io.github.linreal.cascade.editor.richtext/FormattingState.focusedBlockId.|(){}[0] + final val selectionCollapsed // io.github.linreal.cascade.editor.richtext/FormattingState.selectionCollapsed|{}selectionCollapsed[0] + final fun (): kotlin/Boolean // io.github.linreal.cascade.editor.richtext/FormattingState.selectionCollapsed.|(){}[0] + final val styles // io.github.linreal.cascade.editor.richtext/FormattingState.styles|{}styles[0] + final fun (): kotlin.collections/Map // io.github.linreal.cascade.editor.richtext/FormattingState.styles.|(){}[0] + + final fun component1(): kotlin.collections/Map // io.github.linreal.cascade.editor.richtext/FormattingState.component1|component1(){}[0] + final fun component2(): kotlin/Boolean // io.github.linreal.cascade.editor.richtext/FormattingState.component2|component2(){}[0] + final fun component3(): io.github.linreal.cascade.editor.core/BlockId? // io.github.linreal.cascade.editor.richtext/FormattingState.component3|component3(){}[0] + final fun component4(): kotlin/Boolean // io.github.linreal.cascade.editor.richtext/FormattingState.component4|component4(){}[0] + final fun copy(kotlin.collections/Map = ..., kotlin/Boolean = ..., io.github.linreal.cascade.editor.core/BlockId? = ..., kotlin/Boolean = ...): io.github.linreal.cascade.editor.richtext/FormattingState // io.github.linreal.cascade.editor.richtext/FormattingState.copy|copy(kotlin.collections.Map;kotlin.Boolean;io.github.linreal.cascade.editor.core.BlockId?;kotlin.Boolean){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.richtext/FormattingState.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.richtext/FormattingState.hashCode|hashCode(){}[0] + final fun styleStatusOf(io.github.linreal.cascade.editor.core/SpanStyle): io.github.linreal.cascade.editor.richtext/StyleStatus // io.github.linreal.cascade.editor.richtext/FormattingState.styleStatusOf|styleStatusOf(io.github.linreal.cascade.editor.core.SpanStyle){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.richtext/FormattingState.toString|toString(){}[0] + + final object Companion { // io.github.linreal.cascade.editor.richtext/FormattingState.Companion|null[0] + final val Empty // io.github.linreal.cascade.editor.richtext/FormattingState.Companion.Empty|{}Empty[0] + final fun (): io.github.linreal.cascade.editor.richtext/FormattingState // io.github.linreal.cascade.editor.richtext/FormattingState.Companion.Empty.|(){}[0] + } +} + +final class io.github.linreal.cascade.editor.richtext/LinkActionDispatcher : io.github.linreal.cascade.editor.richtext/LinkActions { // io.github.linreal.cascade.editor.richtext/LinkActionDispatcher|null[0] + constructor (kotlin/Function1, io.github.linreal.cascade.editor.state/BlockTextStates, io.github.linreal.cascade.editor.state/BlockSpanStates, io.github.linreal.cascade.editor.state/EditorStateHolder? = ...) // io.github.linreal.cascade.editor.richtext/LinkActionDispatcher.|(kotlin.Function1;io.github.linreal.cascade.editor.state.BlockTextStates;io.github.linreal.cascade.editor.state.BlockSpanStates;io.github.linreal.cascade.editor.state.EditorStateHolder?){}[0] + + final fun applyLink(io.github.linreal.cascade.editor.richtext/LinkTarget, kotlin/String, kotlin/String?): io.github.linreal.cascade.editor.richtext/LinkValidationResult // io.github.linreal.cascade.editor.richtext/LinkActionDispatcher.applyLink|applyLink(io.github.linreal.cascade.editor.richtext.LinkTarget;kotlin.String;kotlin.String?){}[0] + final fun removeLink(io.github.linreal.cascade.editor.richtext/LinkTarget) // io.github.linreal.cascade.editor.richtext/LinkActionDispatcher.removeLink|removeLink(io.github.linreal.cascade.editor.richtext.LinkTarget){}[0] +} + +final class io.github.linreal.cascade.editor.richtext/LinkState { // io.github.linreal.cascade.editor.richtext/LinkState|null[0] + constructor (kotlin/Boolean, io.github.linreal.cascade.editor.core/BlockId?, io.github.linreal.cascade.editor.richtext/LinkTarget?, kotlin/String, kotlin/Boolean, kotlin/String?, io.github.linreal.cascade.editor.richtext/LinkTarget?, kotlin/String?, kotlin/Boolean, kotlin/Boolean) // io.github.linreal.cascade.editor.richtext/LinkState.|(kotlin.Boolean;io.github.linreal.cascade.editor.core.BlockId?;io.github.linreal.cascade.editor.richtext.LinkTarget?;kotlin.String;kotlin.Boolean;kotlin.String?;io.github.linreal.cascade.editor.richtext.LinkTarget?;kotlin.String?;kotlin.Boolean;kotlin.Boolean){}[0] + + final val canLink // io.github.linreal.cascade.editor.richtext/LinkState.canLink|{}canLink[0] + final fun (): kotlin/Boolean // io.github.linreal.cascade.editor.richtext/LinkState.canLink.|(){}[0] + final val existingLinkRange // io.github.linreal.cascade.editor.richtext/LinkState.existingLinkRange|{}existingLinkRange[0] + final fun (): io.github.linreal.cascade.editor.richtext/LinkTarget? // io.github.linreal.cascade.editor.richtext/LinkState.existingLinkRange.|(){}[0] + final val existingLinkText // io.github.linreal.cascade.editor.richtext/LinkState.existingLinkText|{}existingLinkText[0] + final fun (): kotlin/String? // io.github.linreal.cascade.editor.richtext/LinkState.existingLinkText.|(){}[0] + final val existingUrl // io.github.linreal.cascade.editor.richtext/LinkState.existingUrl|{}existingUrl[0] + final fun (): kotlin/String? // io.github.linreal.cascade.editor.richtext/LinkState.existingUrl.|(){}[0] + final val focusedBlockId // io.github.linreal.cascade.editor.richtext/LinkState.focusedBlockId|{}focusedBlockId[0] + final fun (): io.github.linreal.cascade.editor.core/BlockId? // io.github.linreal.cascade.editor.richtext/LinkState.focusedBlockId.|(){}[0] + final val intersectsLink // io.github.linreal.cascade.editor.richtext/LinkState.intersectsLink|{}intersectsLink[0] + final fun (): kotlin/Boolean // io.github.linreal.cascade.editor.richtext/LinkState.intersectsLink.|(){}[0] + final val isInsideLink // io.github.linreal.cascade.editor.richtext/LinkState.isInsideLink|{}isInsideLink[0] + final fun (): kotlin/Boolean // io.github.linreal.cascade.editor.richtext/LinkState.isInsideLink.|(){}[0] + final val selectionCollapsed // io.github.linreal.cascade.editor.richtext/LinkState.selectionCollapsed|{}selectionCollapsed[0] + final fun (): kotlin/Boolean // io.github.linreal.cascade.editor.richtext/LinkState.selectionCollapsed.|(){}[0] + final val target // io.github.linreal.cascade.editor.richtext/LinkState.target|{}target[0] + final fun (): io.github.linreal.cascade.editor.richtext/LinkTarget? // io.github.linreal.cascade.editor.richtext/LinkState.target.|(){}[0] + final val targetText // io.github.linreal.cascade.editor.richtext/LinkState.targetText|{}targetText[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.richtext/LinkState.targetText.|(){}[0] + + final fun component1(): kotlin/Boolean // io.github.linreal.cascade.editor.richtext/LinkState.component1|component1(){}[0] + final fun component10(): kotlin/Boolean // io.github.linreal.cascade.editor.richtext/LinkState.component10|component10(){}[0] + final fun component2(): io.github.linreal.cascade.editor.core/BlockId? // io.github.linreal.cascade.editor.richtext/LinkState.component2|component2(){}[0] + final fun component3(): io.github.linreal.cascade.editor.richtext/LinkTarget? // io.github.linreal.cascade.editor.richtext/LinkState.component3|component3(){}[0] + final fun component4(): kotlin/String // io.github.linreal.cascade.editor.richtext/LinkState.component4|component4(){}[0] + final fun component5(): kotlin/Boolean // io.github.linreal.cascade.editor.richtext/LinkState.component5|component5(){}[0] + final fun component6(): kotlin/String? // io.github.linreal.cascade.editor.richtext/LinkState.component6|component6(){}[0] + final fun component7(): io.github.linreal.cascade.editor.richtext/LinkTarget? // io.github.linreal.cascade.editor.richtext/LinkState.component7|component7(){}[0] + final fun component8(): kotlin/String? // io.github.linreal.cascade.editor.richtext/LinkState.component8|component8(){}[0] + final fun component9(): kotlin/Boolean // io.github.linreal.cascade.editor.richtext/LinkState.component9|component9(){}[0] + final fun copy(kotlin/Boolean = ..., io.github.linreal.cascade.editor.core/BlockId? = ..., io.github.linreal.cascade.editor.richtext/LinkTarget? = ..., kotlin/String = ..., kotlin/Boolean = ..., kotlin/String? = ..., io.github.linreal.cascade.editor.richtext/LinkTarget? = ..., kotlin/String? = ..., kotlin/Boolean = ..., kotlin/Boolean = ...): io.github.linreal.cascade.editor.richtext/LinkState // io.github.linreal.cascade.editor.richtext/LinkState.copy|copy(kotlin.Boolean;io.github.linreal.cascade.editor.core.BlockId?;io.github.linreal.cascade.editor.richtext.LinkTarget?;kotlin.String;kotlin.Boolean;kotlin.String?;io.github.linreal.cascade.editor.richtext.LinkTarget?;kotlin.String?;kotlin.Boolean;kotlin.Boolean){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.richtext/LinkState.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.richtext/LinkState.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.richtext/LinkState.toString|toString(){}[0] + + final object Companion { // io.github.linreal.cascade.editor.richtext/LinkState.Companion|null[0] + final val Empty // io.github.linreal.cascade.editor.richtext/LinkState.Companion.Empty|{}Empty[0] + final fun (): io.github.linreal.cascade.editor.richtext/LinkState // io.github.linreal.cascade.editor.richtext/LinkState.Companion.Empty.|(){}[0] + } +} + +final class io.github.linreal.cascade.editor.richtext/LinkTarget { // io.github.linreal.cascade.editor.richtext/LinkTarget|null[0] + constructor (io.github.linreal.cascade.editor.core/BlockId, kotlin/Int, kotlin/Int) // io.github.linreal.cascade.editor.richtext/LinkTarget.|(io.github.linreal.cascade.editor.core.BlockId;kotlin.Int;kotlin.Int){}[0] + + final val blockId // io.github.linreal.cascade.editor.richtext/LinkTarget.blockId|{}blockId[0] + final fun (): io.github.linreal.cascade.editor.core/BlockId // io.github.linreal.cascade.editor.richtext/LinkTarget.blockId.|(){}[0] + final val isCollapsed // io.github.linreal.cascade.editor.richtext/LinkTarget.isCollapsed|{}isCollapsed[0] + final fun (): kotlin/Boolean // io.github.linreal.cascade.editor.richtext/LinkTarget.isCollapsed.|(){}[0] + final val normalizedEnd // io.github.linreal.cascade.editor.richtext/LinkTarget.normalizedEnd|{}normalizedEnd[0] + final fun (): kotlin/Int // io.github.linreal.cascade.editor.richtext/LinkTarget.normalizedEnd.|(){}[0] + final val normalizedStart // io.github.linreal.cascade.editor.richtext/LinkTarget.normalizedStart|{}normalizedStart[0] + final fun (): kotlin/Int // io.github.linreal.cascade.editor.richtext/LinkTarget.normalizedStart.|(){}[0] + final val rangeEnd // io.github.linreal.cascade.editor.richtext/LinkTarget.rangeEnd|{}rangeEnd[0] + final fun (): kotlin/Int // io.github.linreal.cascade.editor.richtext/LinkTarget.rangeEnd.|(){}[0] + final val rangeStart // io.github.linreal.cascade.editor.richtext/LinkTarget.rangeStart|{}rangeStart[0] + final fun (): kotlin/Int // io.github.linreal.cascade.editor.richtext/LinkTarget.rangeStart.|(){}[0] + + final fun component1(): io.github.linreal.cascade.editor.core/BlockId // io.github.linreal.cascade.editor.richtext/LinkTarget.component1|component1(){}[0] + final fun component2(): kotlin/Int // io.github.linreal.cascade.editor.richtext/LinkTarget.component2|component2(){}[0] + final fun component3(): kotlin/Int // io.github.linreal.cascade.editor.richtext/LinkTarget.component3|component3(){}[0] + final fun copy(io.github.linreal.cascade.editor.core/BlockId = ..., kotlin/Int = ..., kotlin/Int = ...): io.github.linreal.cascade.editor.richtext/LinkTarget // io.github.linreal.cascade.editor.richtext/LinkTarget.copy|copy(io.github.linreal.cascade.editor.core.BlockId;kotlin.Int;kotlin.Int){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.richtext/LinkTarget.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.richtext/LinkTarget.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.richtext/LinkTarget.toString|toString(){}[0] +} + +final class io.github.linreal.cascade.editor.richtext/SpanActionDispatcher { // io.github.linreal.cascade.editor.richtext/SpanActionDispatcher|null[0] + constructor (kotlin/Function1, io.github.linreal.cascade.editor.state/BlockTextStates, io.github.linreal.cascade.editor.state/BlockSpanStates, io.github.linreal.cascade.editor.state/EditorStateHolder? = ...) // io.github.linreal.cascade.editor.richtext/SpanActionDispatcher.|(kotlin.Function1;io.github.linreal.cascade.editor.state.BlockTextStates;io.github.linreal.cascade.editor.state.BlockSpanStates;io.github.linreal.cascade.editor.state.EditorStateHolder?){}[0] + + final fun applyStyle(io.github.linreal.cascade.editor.core/BlockId, kotlin/Int, kotlin/Int, io.github.linreal.cascade.editor.core/SpanStyle) // io.github.linreal.cascade.editor.richtext/SpanActionDispatcher.applyStyle|applyStyle(io.github.linreal.cascade.editor.core.BlockId;kotlin.Int;kotlin.Int;io.github.linreal.cascade.editor.core.SpanStyle){}[0] + final fun removeStyle(io.github.linreal.cascade.editor.core/BlockId, kotlin/Int, kotlin/Int, io.github.linreal.cascade.editor.core/SpanStyle) // io.github.linreal.cascade.editor.richtext/SpanActionDispatcher.removeStyle|removeStyle(io.github.linreal.cascade.editor.core.BlockId;kotlin.Int;kotlin.Int;io.github.linreal.cascade.editor.core.SpanStyle){}[0] + final fun toggleStyle(io.github.linreal.cascade.editor.core/BlockId, kotlin/Int, kotlin/Int, io.github.linreal.cascade.editor.core/SpanStyle) // io.github.linreal.cascade.editor.richtext/SpanActionDispatcher.toggleStyle|toggleStyle(io.github.linreal.cascade.editor.core.BlockId;kotlin.Int;kotlin.Int;io.github.linreal.cascade.editor.core.SpanStyle){}[0] +} + +final class io.github.linreal.cascade.editor.serialization/DocumentDecodeOptions { // io.github.linreal.cascade.editor.serialization/DocumentDecodeOptions|null[0] + constructor (io.github.linreal.cascade.editor.serialization/BlockIdMode = ..., io.github.linreal.cascade.editor.serialization/DuplicateIdMode = ...) // io.github.linreal.cascade.editor.serialization/DocumentDecodeOptions.|(io.github.linreal.cascade.editor.serialization.BlockIdMode;io.github.linreal.cascade.editor.serialization.DuplicateIdMode){}[0] + + final val duplicateIdMode // io.github.linreal.cascade.editor.serialization/DocumentDecodeOptions.duplicateIdMode|{}duplicateIdMode[0] + final fun (): io.github.linreal.cascade.editor.serialization/DuplicateIdMode // io.github.linreal.cascade.editor.serialization/DocumentDecodeOptions.duplicateIdMode.|(){}[0] + final val idMode // io.github.linreal.cascade.editor.serialization/DocumentDecodeOptions.idMode|{}idMode[0] + final fun (): io.github.linreal.cascade.editor.serialization/BlockIdMode // io.github.linreal.cascade.editor.serialization/DocumentDecodeOptions.idMode.|(){}[0] + + final fun component1(): io.github.linreal.cascade.editor.serialization/BlockIdMode // io.github.linreal.cascade.editor.serialization/DocumentDecodeOptions.component1|component1(){}[0] + final fun component2(): io.github.linreal.cascade.editor.serialization/DuplicateIdMode // io.github.linreal.cascade.editor.serialization/DocumentDecodeOptions.component2|component2(){}[0] + final fun copy(io.github.linreal.cascade.editor.serialization/BlockIdMode = ..., io.github.linreal.cascade.editor.serialization/DuplicateIdMode = ...): io.github.linreal.cascade.editor.serialization/DocumentDecodeOptions // io.github.linreal.cascade.editor.serialization/DocumentDecodeOptions.copy|copy(io.github.linreal.cascade.editor.serialization.BlockIdMode;io.github.linreal.cascade.editor.serialization.DuplicateIdMode){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.serialization/DocumentDecodeOptions.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.serialization/DocumentDecodeOptions.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.serialization/DocumentDecodeOptions.toString|toString(){}[0] +} + +final class io.github.linreal.cascade.editor.serialization/DocumentDecodeResult { // io.github.linreal.cascade.editor.serialization/DocumentDecodeResult|null[0] + constructor (kotlin.collections/List, kotlin.collections/List) // io.github.linreal.cascade.editor.serialization/DocumentDecodeResult.|(kotlin.collections.List;kotlin.collections.List){}[0] + + final val blocks // io.github.linreal.cascade.editor.serialization/DocumentDecodeResult.blocks|{}blocks[0] + final fun (): kotlin.collections/List // io.github.linreal.cascade.editor.serialization/DocumentDecodeResult.blocks.|(){}[0] + final val warnings // io.github.linreal.cascade.editor.serialization/DocumentDecodeResult.warnings|{}warnings[0] + final fun (): kotlin.collections/List // io.github.linreal.cascade.editor.serialization/DocumentDecodeResult.warnings.|(){}[0] + + final fun component1(): kotlin.collections/List // io.github.linreal.cascade.editor.serialization/DocumentDecodeResult.component1|component1(){}[0] + final fun component2(): kotlin.collections/List // io.github.linreal.cascade.editor.serialization/DocumentDecodeResult.component2|component2(){}[0] + final fun copy(kotlin.collections/List = ..., kotlin.collections/List = ...): io.github.linreal.cascade.editor.serialization/DocumentDecodeResult // io.github.linreal.cascade.editor.serialization/DocumentDecodeResult.copy|copy(kotlin.collections.List;kotlin.collections.List){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.serialization/DocumentDecodeResult.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.serialization/DocumentDecodeResult.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.serialization/DocumentDecodeResult.toString|toString(){}[0] +} + +final class io.github.linreal.cascade.editor.serialization/DocumentEncodeOptions { // io.github.linreal.cascade.editor.serialization/DocumentEncodeOptions|null[0] + constructor (io.github.linreal.cascade.editor.serialization/CustomDataMode = ...) // io.github.linreal.cascade.editor.serialization/DocumentEncodeOptions.|(io.github.linreal.cascade.editor.serialization.CustomDataMode){}[0] + + final val customDataMode // io.github.linreal.cascade.editor.serialization/DocumentEncodeOptions.customDataMode|{}customDataMode[0] + final fun (): io.github.linreal.cascade.editor.serialization/CustomDataMode // io.github.linreal.cascade.editor.serialization/DocumentEncodeOptions.customDataMode.|(){}[0] + + final fun component1(): io.github.linreal.cascade.editor.serialization/CustomDataMode // io.github.linreal.cascade.editor.serialization/DocumentEncodeOptions.component1|component1(){}[0] + final fun copy(io.github.linreal.cascade.editor.serialization/CustomDataMode = ...): io.github.linreal.cascade.editor.serialization/DocumentEncodeOptions // io.github.linreal.cascade.editor.serialization/DocumentEncodeOptions.copy|copy(io.github.linreal.cascade.editor.serialization.CustomDataMode){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.serialization/DocumentEncodeOptions.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.serialization/DocumentEncodeOptions.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.serialization/DocumentEncodeOptions.toString|toString(){}[0] +} + +final class io.github.linreal.cascade.editor.slash/BuiltInSlashCommandSpec { // io.github.linreal.cascade.editor.slash/BuiltInSlashCommandSpec|null[0] + constructor (io.github.linreal.cascade.editor.slash/BuiltInBlockSlashBehavior, io.github.linreal.cascade.editor.slash/SlashCommandIconKey? = ...) // io.github.linreal.cascade.editor.slash/BuiltInSlashCommandSpec.|(io.github.linreal.cascade.editor.slash.BuiltInBlockSlashBehavior;io.github.linreal.cascade.editor.slash.SlashCommandIconKey?){}[0] + + final val behavior // io.github.linreal.cascade.editor.slash/BuiltInSlashCommandSpec.behavior|{}behavior[0] + final fun (): io.github.linreal.cascade.editor.slash/BuiltInBlockSlashBehavior // io.github.linreal.cascade.editor.slash/BuiltInSlashCommandSpec.behavior.|(){}[0] + final val icon // io.github.linreal.cascade.editor.slash/BuiltInSlashCommandSpec.icon|{}icon[0] + final fun (): io.github.linreal.cascade.editor.slash/SlashCommandIconKey? // io.github.linreal.cascade.editor.slash/BuiltInSlashCommandSpec.icon.|(){}[0] + + final fun component1(): io.github.linreal.cascade.editor.slash/BuiltInBlockSlashBehavior // io.github.linreal.cascade.editor.slash/BuiltInSlashCommandSpec.component1|component1(){}[0] + final fun component2(): io.github.linreal.cascade.editor.slash/SlashCommandIconKey? // io.github.linreal.cascade.editor.slash/BuiltInSlashCommandSpec.component2|component2(){}[0] + final fun copy(io.github.linreal.cascade.editor.slash/BuiltInBlockSlashBehavior = ..., io.github.linreal.cascade.editor.slash/SlashCommandIconKey? = ...): io.github.linreal.cascade.editor.slash/BuiltInSlashCommandSpec // io.github.linreal.cascade.editor.slash/BuiltInSlashCommandSpec.copy|copy(io.github.linreal.cascade.editor.slash.BuiltInBlockSlashBehavior;io.github.linreal.cascade.editor.slash.SlashCommandIconKey?){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.slash/BuiltInSlashCommandSpec.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.slash/BuiltInSlashCommandSpec.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.slash/BuiltInSlashCommandSpec.toString|toString(){}[0] +} + +final class io.github.linreal.cascade.editor.slash/SlashCommandAction : io.github.linreal.cascade.editor.slash/SlashCommandItem { // io.github.linreal.cascade.editor.slash/SlashCommandAction|null[0] + constructor (io.github.linreal.cascade.editor.slash/SlashCommandId, kotlin/String, kotlin/String, kotlin.collections/List = ..., io.github.linreal.cascade.editor.slash/SlashCommandIconKey? = ..., io.github.linreal.cascade.editor.slash/SlashQueryTextPolicy = ..., kotlin.coroutines/SuspendFunction1) // io.github.linreal.cascade.editor.slash/SlashCommandAction.|(io.github.linreal.cascade.editor.slash.SlashCommandId;kotlin.String;kotlin.String;kotlin.collections.List;io.github.linreal.cascade.editor.slash.SlashCommandIconKey?;io.github.linreal.cascade.editor.slash.SlashQueryTextPolicy;kotlin.coroutines.SuspendFunction1){}[0] + + final val description // io.github.linreal.cascade.editor.slash/SlashCommandAction.description|{}description[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.slash/SlashCommandAction.description.|(){}[0] + final val icon // io.github.linreal.cascade.editor.slash/SlashCommandAction.icon|{}icon[0] + final fun (): io.github.linreal.cascade.editor.slash/SlashCommandIconKey? // io.github.linreal.cascade.editor.slash/SlashCommandAction.icon.|(){}[0] + final val id // io.github.linreal.cascade.editor.slash/SlashCommandAction.id|{}id[0] + final fun (): io.github.linreal.cascade.editor.slash/SlashCommandId // io.github.linreal.cascade.editor.slash/SlashCommandAction.id.|(){}[0] + final val keywords // io.github.linreal.cascade.editor.slash/SlashCommandAction.keywords|{}keywords[0] + final fun (): kotlin.collections/List // io.github.linreal.cascade.editor.slash/SlashCommandAction.keywords.|(){}[0] + final val onExecute // io.github.linreal.cascade.editor.slash/SlashCommandAction.onExecute|{}onExecute[0] + final fun (): kotlin.coroutines/SuspendFunction1 // io.github.linreal.cascade.editor.slash/SlashCommandAction.onExecute.|(){}[0] + final val queryTextPolicy // io.github.linreal.cascade.editor.slash/SlashCommandAction.queryTextPolicy|{}queryTextPolicy[0] + final fun (): io.github.linreal.cascade.editor.slash/SlashQueryTextPolicy // io.github.linreal.cascade.editor.slash/SlashCommandAction.queryTextPolicy.|(){}[0] + final val title // io.github.linreal.cascade.editor.slash/SlashCommandAction.title|{}title[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.slash/SlashCommandAction.title.|(){}[0] + + final fun component1(): io.github.linreal.cascade.editor.slash/SlashCommandId // io.github.linreal.cascade.editor.slash/SlashCommandAction.component1|component1(){}[0] + final fun component2(): kotlin/String // io.github.linreal.cascade.editor.slash/SlashCommandAction.component2|component2(){}[0] + final fun component3(): kotlin/String // io.github.linreal.cascade.editor.slash/SlashCommandAction.component3|component3(){}[0] + final fun component4(): kotlin.collections/List // io.github.linreal.cascade.editor.slash/SlashCommandAction.component4|component4(){}[0] + final fun component5(): io.github.linreal.cascade.editor.slash/SlashCommandIconKey? // io.github.linreal.cascade.editor.slash/SlashCommandAction.component5|component5(){}[0] + final fun component6(): io.github.linreal.cascade.editor.slash/SlashQueryTextPolicy // io.github.linreal.cascade.editor.slash/SlashCommandAction.component6|component6(){}[0] + final fun component7(): kotlin.coroutines/SuspendFunction1 // io.github.linreal.cascade.editor.slash/SlashCommandAction.component7|component7(){}[0] + final fun copy(io.github.linreal.cascade.editor.slash/SlashCommandId = ..., kotlin/String = ..., kotlin/String = ..., kotlin.collections/List = ..., io.github.linreal.cascade.editor.slash/SlashCommandIconKey? = ..., io.github.linreal.cascade.editor.slash/SlashQueryTextPolicy = ..., kotlin.coroutines/SuspendFunction1 = ...): io.github.linreal.cascade.editor.slash/SlashCommandAction // io.github.linreal.cascade.editor.slash/SlashCommandAction.copy|copy(io.github.linreal.cascade.editor.slash.SlashCommandId;kotlin.String;kotlin.String;kotlin.collections.List;io.github.linreal.cascade.editor.slash.SlashCommandIconKey?;io.github.linreal.cascade.editor.slash.SlashQueryTextPolicy;kotlin.coroutines.SuspendFunction1){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.slash/SlashCommandAction.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.slash/SlashCommandAction.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.slash/SlashCommandAction.toString|toString(){}[0] +} + +final class io.github.linreal.cascade.editor.slash/SlashCommandContext { // io.github.linreal.cascade.editor.slash/SlashCommandContext|null[0] + constructor (io.github.linreal.cascade.editor.core/BlockId, kotlin/String, io.github.linreal.cascade.editor.state/SlashQueryRange, io.github.linreal.cascade.editor.slash/SlashCommandEditor) // io.github.linreal.cascade.editor.slash/SlashCommandContext.|(io.github.linreal.cascade.editor.core.BlockId;kotlin.String;io.github.linreal.cascade.editor.state.SlashQueryRange;io.github.linreal.cascade.editor.slash.SlashCommandEditor){}[0] + + final val anchorBlockId // io.github.linreal.cascade.editor.slash/SlashCommandContext.anchorBlockId|{}anchorBlockId[0] + final fun (): io.github.linreal.cascade.editor.core/BlockId // io.github.linreal.cascade.editor.slash/SlashCommandContext.anchorBlockId.|(){}[0] + final val editor // io.github.linreal.cascade.editor.slash/SlashCommandContext.editor|{}editor[0] + final fun (): io.github.linreal.cascade.editor.slash/SlashCommandEditor // io.github.linreal.cascade.editor.slash/SlashCommandContext.editor.|(){}[0] + final val query // io.github.linreal.cascade.editor.slash/SlashCommandContext.query|{}query[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.slash/SlashCommandContext.query.|(){}[0] + final val queryRange // io.github.linreal.cascade.editor.slash/SlashCommandContext.queryRange|{}queryRange[0] + final fun (): io.github.linreal.cascade.editor.state/SlashQueryRange // io.github.linreal.cascade.editor.slash/SlashCommandContext.queryRange.|(){}[0] + + final fun component1(): io.github.linreal.cascade.editor.core/BlockId // io.github.linreal.cascade.editor.slash/SlashCommandContext.component1|component1(){}[0] + final fun component2(): kotlin/String // io.github.linreal.cascade.editor.slash/SlashCommandContext.component2|component2(){}[0] + final fun component3(): io.github.linreal.cascade.editor.state/SlashQueryRange // io.github.linreal.cascade.editor.slash/SlashCommandContext.component3|component3(){}[0] + final fun component4(): io.github.linreal.cascade.editor.slash/SlashCommandEditor // io.github.linreal.cascade.editor.slash/SlashCommandContext.component4|component4(){}[0] + final fun copy(io.github.linreal.cascade.editor.core/BlockId = ..., kotlin/String = ..., io.github.linreal.cascade.editor.state/SlashQueryRange = ..., io.github.linreal.cascade.editor.slash/SlashCommandEditor = ...): io.github.linreal.cascade.editor.slash/SlashCommandContext // io.github.linreal.cascade.editor.slash/SlashCommandContext.copy|copy(io.github.linreal.cascade.editor.core.BlockId;kotlin.String;io.github.linreal.cascade.editor.state.SlashQueryRange;io.github.linreal.cascade.editor.slash.SlashCommandEditor){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.slash/SlashCommandContext.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.slash/SlashCommandContext.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.slash/SlashCommandContext.toString|toString(){}[0] +} + +final class io.github.linreal.cascade.editor.slash/SlashCommandMenu : io.github.linreal.cascade.editor.slash/SlashCommandItem { // io.github.linreal.cascade.editor.slash/SlashCommandMenu|null[0] + constructor (io.github.linreal.cascade.editor.slash/SlashCommandId, kotlin/String, kotlin/String, kotlin.collections/List = ..., io.github.linreal.cascade.editor.slash/SlashCommandIconKey? = ..., kotlin.collections/List = ...) // io.github.linreal.cascade.editor.slash/SlashCommandMenu.|(io.github.linreal.cascade.editor.slash.SlashCommandId;kotlin.String;kotlin.String;kotlin.collections.List;io.github.linreal.cascade.editor.slash.SlashCommandIconKey?;kotlin.collections.List){}[0] + + final val children // io.github.linreal.cascade.editor.slash/SlashCommandMenu.children|{}children[0] + final fun (): kotlin.collections/List // io.github.linreal.cascade.editor.slash/SlashCommandMenu.children.|(){}[0] + final val description // io.github.linreal.cascade.editor.slash/SlashCommandMenu.description|{}description[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.slash/SlashCommandMenu.description.|(){}[0] + final val icon // io.github.linreal.cascade.editor.slash/SlashCommandMenu.icon|{}icon[0] + final fun (): io.github.linreal.cascade.editor.slash/SlashCommandIconKey? // io.github.linreal.cascade.editor.slash/SlashCommandMenu.icon.|(){}[0] + final val id // io.github.linreal.cascade.editor.slash/SlashCommandMenu.id|{}id[0] + final fun (): io.github.linreal.cascade.editor.slash/SlashCommandId // io.github.linreal.cascade.editor.slash/SlashCommandMenu.id.|(){}[0] + final val keywords // io.github.linreal.cascade.editor.slash/SlashCommandMenu.keywords|{}keywords[0] + final fun (): kotlin.collections/List // io.github.linreal.cascade.editor.slash/SlashCommandMenu.keywords.|(){}[0] + final val title // io.github.linreal.cascade.editor.slash/SlashCommandMenu.title|{}title[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.slash/SlashCommandMenu.title.|(){}[0] + + final fun component1(): io.github.linreal.cascade.editor.slash/SlashCommandId // io.github.linreal.cascade.editor.slash/SlashCommandMenu.component1|component1(){}[0] + final fun component2(): kotlin/String // io.github.linreal.cascade.editor.slash/SlashCommandMenu.component2|component2(){}[0] + final fun component3(): kotlin/String // io.github.linreal.cascade.editor.slash/SlashCommandMenu.component3|component3(){}[0] + final fun component4(): kotlin.collections/List // io.github.linreal.cascade.editor.slash/SlashCommandMenu.component4|component4(){}[0] + final fun component5(): io.github.linreal.cascade.editor.slash/SlashCommandIconKey? // io.github.linreal.cascade.editor.slash/SlashCommandMenu.component5|component5(){}[0] + final fun component6(): kotlin.collections/List // io.github.linreal.cascade.editor.slash/SlashCommandMenu.component6|component6(){}[0] + final fun copy(io.github.linreal.cascade.editor.slash/SlashCommandId = ..., kotlin/String = ..., kotlin/String = ..., kotlin.collections/List = ..., io.github.linreal.cascade.editor.slash/SlashCommandIconKey? = ..., kotlin.collections/List = ...): io.github.linreal.cascade.editor.slash/SlashCommandMenu // io.github.linreal.cascade.editor.slash/SlashCommandMenu.copy|copy(io.github.linreal.cascade.editor.slash.SlashCommandId;kotlin.String;kotlin.String;kotlin.collections.List;io.github.linreal.cascade.editor.slash.SlashCommandIconKey?;kotlin.collections.List){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.slash/SlashCommandMenu.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.slash/SlashCommandMenu.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.slash/SlashCommandMenu.toString|toString(){}[0] +} + +final class io.github.linreal.cascade.editor.slash/SlashCommandRegistry { // io.github.linreal.cascade.editor.slash/SlashCommandRegistry|null[0] + constructor () // io.github.linreal.cascade.editor.slash/SlashCommandRegistry.|(){}[0] + + final fun getRootItems(): kotlin.collections/List // io.github.linreal.cascade.editor.slash/SlashCommandRegistry.getRootItems|getRootItems(){}[0] + final fun register(io.github.linreal.cascade.editor.slash/SlashCommandItem) // io.github.linreal.cascade.editor.slash/SlashCommandRegistry.register|register(io.github.linreal.cascade.editor.slash.SlashCommandItem){}[0] + final fun search(kotlin/String, kotlin.collections/List = ...): kotlin.collections/List // io.github.linreal.cascade.editor.slash/SlashCommandRegistry.search|search(kotlin.String;kotlin.collections.List){}[0] +} + +final class io.github.linreal.cascade.editor.state/BlockSpanStates { // io.github.linreal.cascade.editor.state/BlockSpanStates|null[0] + constructor () // io.github.linreal.cascade.editor.state/BlockSpanStates.|(){}[0] + + final fun activeStylesAt(io.github.linreal.cascade.editor.core/BlockId, kotlin/Int): kotlin.collections/Set // io.github.linreal.cascade.editor.state/BlockSpanStates.activeStylesAt|activeStylesAt(io.github.linreal.cascade.editor.core.BlockId;kotlin.Int){}[0] + final fun adjustForRangeReplacement(io.github.linreal.cascade.editor.core/BlockId, kotlin/Int, kotlin/Int, kotlin/Int) // io.github.linreal.cascade.editor.state/BlockSpanStates.adjustForRangeReplacement|adjustForRangeReplacement(io.github.linreal.cascade.editor.core.BlockId;kotlin.Int;kotlin.Int;kotlin.Int){}[0] + final fun adjustForUserEdit(io.github.linreal.cascade.editor.core/BlockId, kotlin/Int, kotlin/Int, kotlin/Int) // io.github.linreal.cascade.editor.state/BlockSpanStates.adjustForUserEdit|adjustForUserEdit(io.github.linreal.cascade.editor.core.BlockId;kotlin.Int;kotlin.Int;kotlin.Int){}[0] + final fun applyStyle(io.github.linreal.cascade.editor.core/BlockId, kotlin/Int, kotlin/Int, io.github.linreal.cascade.editor.core/SpanStyle, kotlin/Int) // io.github.linreal.cascade.editor.state/BlockSpanStates.applyStyle|applyStyle(io.github.linreal.cascade.editor.core.BlockId;kotlin.Int;kotlin.Int;io.github.linreal.cascade.editor.core.SpanStyle;kotlin.Int){}[0] + final fun cleanup(kotlin.collections/Set) // io.github.linreal.cascade.editor.state/BlockSpanStates.cleanup|cleanup(kotlin.collections.Set){}[0] + final fun clear() // io.github.linreal.cascade.editor.state/BlockSpanStates.clear|clear(){}[0] + final fun clearPendingStyles(io.github.linreal.cascade.editor.core/BlockId) // io.github.linreal.cascade.editor.state/BlockSpanStates.clearPendingStyles|clearPendingStyles(io.github.linreal.cascade.editor.core.BlockId){}[0] + final fun get(io.github.linreal.cascade.editor.core/BlockId): androidx.compose.runtime/State>? // io.github.linreal.cascade.editor.state/BlockSpanStates.get|get(io.github.linreal.cascade.editor.core.BlockId){}[0] + final fun getOrCreate(io.github.linreal.cascade.editor.core/BlockId, kotlin.collections/List = ..., kotlin/Int): androidx.compose.runtime/State> // io.github.linreal.cascade.editor.state/BlockSpanStates.getOrCreate|getOrCreate(io.github.linreal.cascade.editor.core.BlockId;kotlin.collections.List;kotlin.Int){}[0] + final fun getPendingStyles(io.github.linreal.cascade.editor.core/BlockId): kotlin.collections/Set? // io.github.linreal.cascade.editor.state/BlockSpanStates.getPendingStyles|getPendingStyles(io.github.linreal.cascade.editor.core.BlockId){}[0] + final fun getSpans(io.github.linreal.cascade.editor.core/BlockId): kotlin.collections/List // io.github.linreal.cascade.editor.state/BlockSpanStates.getSpans|getSpans(io.github.linreal.cascade.editor.core.BlockId){}[0] + final fun mergeInto(io.github.linreal.cascade.editor.core/BlockId, io.github.linreal.cascade.editor.core/BlockId, kotlin/Int) // io.github.linreal.cascade.editor.state/BlockSpanStates.mergeInto|mergeInto(io.github.linreal.cascade.editor.core.BlockId;io.github.linreal.cascade.editor.core.BlockId;kotlin.Int){}[0] + final fun queryStyleStatus(io.github.linreal.cascade.editor.core/BlockId, kotlin/Int, kotlin/Int, io.github.linreal.cascade.editor.core/SpanStyle): io.github.linreal.cascade.editor.richtext/StyleStatus // io.github.linreal.cascade.editor.state/BlockSpanStates.queryStyleStatus|queryStyleStatus(io.github.linreal.cascade.editor.core.BlockId;kotlin.Int;kotlin.Int;io.github.linreal.cascade.editor.core.SpanStyle){}[0] + final fun remove(io.github.linreal.cascade.editor.core/BlockId) // io.github.linreal.cascade.editor.state/BlockSpanStates.remove|remove(io.github.linreal.cascade.editor.core.BlockId){}[0] + final fun removeLinkSpans(io.github.linreal.cascade.editor.core/BlockId, kotlin/Int, kotlin/Int) // io.github.linreal.cascade.editor.state/BlockSpanStates.removeLinkSpans|removeLinkSpans(io.github.linreal.cascade.editor.core.BlockId;kotlin.Int;kotlin.Int){}[0] + final fun removeStyle(io.github.linreal.cascade.editor.core/BlockId, kotlin/Int, kotlin/Int, io.github.linreal.cascade.editor.core/SpanStyle) // io.github.linreal.cascade.editor.state/BlockSpanStates.removeStyle|removeStyle(io.github.linreal.cascade.editor.core.BlockId;kotlin.Int;kotlin.Int;io.github.linreal.cascade.editor.core.SpanStyle){}[0] + final fun resolveStylesForInsertion(io.github.linreal.cascade.editor.core/BlockId, kotlin/Int): kotlin.collections/Set // io.github.linreal.cascade.editor.state/BlockSpanStates.resolveStylesForInsertion|resolveStylesForInsertion(io.github.linreal.cascade.editor.core.BlockId;kotlin.Int){}[0] + final fun set(io.github.linreal.cascade.editor.core/BlockId, kotlin.collections/List, kotlin/Int) // io.github.linreal.cascade.editor.state/BlockSpanStates.set|set(io.github.linreal.cascade.editor.core.BlockId;kotlin.collections.List;kotlin.Int){}[0] + final fun setPendingStyles(io.github.linreal.cascade.editor.core/BlockId, kotlin.collections/Set) // io.github.linreal.cascade.editor.state/BlockSpanStates.setPendingStyles|setPendingStyles(io.github.linreal.cascade.editor.core.BlockId;kotlin.collections.Set){}[0] + final fun split(io.github.linreal.cascade.editor.core/BlockId, io.github.linreal.cascade.editor.core/BlockId, kotlin/Int) // io.github.linreal.cascade.editor.state/BlockSpanStates.split|split(io.github.linreal.cascade.editor.core.BlockId;io.github.linreal.cascade.editor.core.BlockId;kotlin.Int){}[0] + final fun toggleStyle(io.github.linreal.cascade.editor.core/BlockId, kotlin/Int, kotlin/Int, io.github.linreal.cascade.editor.core/SpanStyle, kotlin/Int) // io.github.linreal.cascade.editor.state/BlockSpanStates.toggleStyle|toggleStyle(io.github.linreal.cascade.editor.core.BlockId;kotlin.Int;kotlin.Int;io.github.linreal.cascade.editor.core.SpanStyle;kotlin.Int){}[0] +} + +final class io.github.linreal.cascade.editor.state/BlockTextStates { // io.github.linreal.cascade.editor.state/BlockTextStates|null[0] + constructor () // io.github.linreal.cascade.editor.state/BlockTextStates.|(){}[0] + + final fun cleanup(kotlin.collections/Set) // io.github.linreal.cascade.editor.state/BlockTextStates.cleanup|cleanup(kotlin.collections.Set){}[0] + final fun clear() // io.github.linreal.cascade.editor.state/BlockTextStates.clear|clear(){}[0] + final fun consumeProgrammaticCommit(io.github.linreal.cascade.editor.core/BlockId): kotlin/String? // io.github.linreal.cascade.editor.state/BlockTextStates.consumeProgrammaticCommit|consumeProgrammaticCommit(io.github.linreal.cascade.editor.core.BlockId){}[0] + final fun extractAllText(): kotlin.collections/Map // io.github.linreal.cascade.editor.state/BlockTextStates.extractAllText|extractAllText(){}[0] + final fun get(io.github.linreal.cascade.editor.core/BlockId): androidx.compose.foundation.text.input/TextFieldState? // io.github.linreal.cascade.editor.state/BlockTextStates.get|get(io.github.linreal.cascade.editor.core.BlockId){}[0] + final fun getOrCreate(io.github.linreal.cascade.editor.core/BlockId, kotlin/String, kotlin/Int = ...): androidx.compose.foundation.text.input/TextFieldState // io.github.linreal.cascade.editor.state/BlockTextStates.getOrCreate|getOrCreate(io.github.linreal.cascade.editor.core.BlockId;kotlin.String;kotlin.Int){}[0] + final fun getSelection(io.github.linreal.cascade.editor.core/BlockId): androidx.compose.ui.text/TextRange? // io.github.linreal.cascade.editor.state/BlockTextStates.getSelection|getSelection(io.github.linreal.cascade.editor.core.BlockId){}[0] + final fun getVisibleText(io.github.linreal.cascade.editor.core/BlockId): kotlin/String? // io.github.linreal.cascade.editor.state/BlockTextStates.getVisibleText|getVisibleText(io.github.linreal.cascade.editor.core.BlockId){}[0] + final fun mergeInto(io.github.linreal.cascade.editor.core/BlockId, io.github.linreal.cascade.editor.core/BlockId): kotlin/Int? // io.github.linreal.cascade.editor.state/BlockTextStates.mergeInto|mergeInto(io.github.linreal.cascade.editor.core.BlockId;io.github.linreal.cascade.editor.core.BlockId){}[0] + final fun remove(io.github.linreal.cascade.editor.core/BlockId) // io.github.linreal.cascade.editor.state/BlockTextStates.remove|remove(io.github.linreal.cascade.editor.core.BlockId){}[0] + final fun replaceVisibleRange(io.github.linreal.cascade.editor.core/BlockId, kotlin/Int, kotlin/Int, kotlin/String, kotlin/Int? = ...): kotlin/String? // io.github.linreal.cascade.editor.state/BlockTextStates.replaceVisibleRange|replaceVisibleRange(io.github.linreal.cascade.editor.core.BlockId;kotlin.Int;kotlin.Int;kotlin.String;kotlin.Int?){}[0] + final fun setCursorPosition(io.github.linreal.cascade.editor.core/BlockId, kotlin/Int) // io.github.linreal.cascade.editor.state/BlockTextStates.setCursorPosition|setCursorPosition(io.github.linreal.cascade.editor.core.BlockId;kotlin.Int){}[0] + final fun setSelection(io.github.linreal.cascade.editor.core/BlockId, androidx.compose.ui.text/TextRange) // io.github.linreal.cascade.editor.state/BlockTextStates.setSelection|setSelection(io.github.linreal.cascade.editor.core.BlockId;androidx.compose.ui.text.TextRange){}[0] + final fun setText(io.github.linreal.cascade.editor.core/BlockId, kotlin/String, kotlin/Int? = ...) // io.github.linreal.cascade.editor.state/BlockTextStates.setText|setText(io.github.linreal.cascade.editor.core.BlockId;kotlin.String;kotlin.Int?){}[0] +} + +final class io.github.linreal.cascade.editor.state/DragState { // io.github.linreal.cascade.editor.state/DragState|null[0] + constructor (kotlin.collections/Set, kotlin/Int?, kotlin/Float = ..., kotlin/Int = ..., kotlin.collections/List = ..., kotlin.collections/List = ..., kotlin.collections/Set = ..., kotlin.collections/List = ..., kotlin.collections/Set = ..., kotlin.collections/List = ..., io.github.linreal.cascade.editor.core/BlockId? = ..., kotlin/Int = ..., kotlin/Boolean? = ..., kotlin.collections/Map = ..., kotlin.collections/Map = ..., kotlin.collections/Map = ..., kotlin/Int = ...) // io.github.linreal.cascade.editor.state/DragState.|(kotlin.collections.Set;kotlin.Int?;kotlin.Float;kotlin.Int;kotlin.collections.List;kotlin.collections.List;kotlin.collections.Set;kotlin.collections.List;kotlin.collections.Set;kotlin.collections.List;io.github.linreal.cascade.editor.core.BlockId?;kotlin.Int;kotlin.Boolean?;kotlin.collections.Map;kotlin.collections.Map;kotlin.collections.Map;kotlin.Int){}[0] + + final val dragRootIds // io.github.linreal.cascade.editor.state/DragState.dragRootIds|{}dragRootIds[0] + final fun (): kotlin.collections/List // io.github.linreal.cascade.editor.state/DragState.dragRootIds.|(){}[0] + final val draggingBlockIds // io.github.linreal.cascade.editor.state/DragState.draggingBlockIds|{}draggingBlockIds[0] + final fun (): kotlin.collections/Set // io.github.linreal.cascade.editor.state/DragState.draggingBlockIds.|(){}[0] + final val futureRootIndentationLevel // io.github.linreal.cascade.editor.state/DragState.futureRootIndentationLevel|{}futureRootIndentationLevel[0] + final fun (): kotlin/Int // io.github.linreal.cascade.editor.state/DragState.futureRootIndentationLevel.|(){}[0] + final val initialTouchOffsetY // io.github.linreal.cascade.editor.state/DragState.initialTouchOffsetY|{}initialTouchOffsetY[0] + final fun (): kotlin/Float // io.github.linreal.cascade.editor.state/DragState.initialTouchOffsetY.|(){}[0] + final val originalRootIndentationLevels // io.github.linreal.cascade.editor.state/DragState.originalRootIndentationLevels|{}originalRootIndentationLevels[0] + final fun (): kotlin.collections/Map // io.github.linreal.cascade.editor.state/DragState.originalRootIndentationLevels.|(){}[0] + final val payloadBlockIdSet // io.github.linreal.cascade.editor.state/DragState.payloadBlockIdSet|{}payloadBlockIdSet[0] + final fun (): kotlin.collections/Set // io.github.linreal.cascade.editor.state/DragState.payloadBlockIdSet.|(){}[0] + final val payloadBlockIds // io.github.linreal.cascade.editor.state/DragState.payloadBlockIds|{}payloadBlockIds[0] + final fun (): kotlin.collections/List // io.github.linreal.cascade.editor.state/DragState.payloadBlockIds.|(){}[0] + final val payloadBlockIndexSet // io.github.linreal.cascade.editor.state/DragState.payloadBlockIndexSet|{}payloadBlockIndexSet[0] + final fun (): kotlin.collections/Set // io.github.linreal.cascade.editor.state/DragState.payloadBlockIndexSet.|(){}[0] + final val payloadBlockIndices // io.github.linreal.cascade.editor.state/DragState.payloadBlockIndices|{}payloadBlockIndices[0] + final fun (): kotlin.collections/List // io.github.linreal.cascade.editor.state/DragState.payloadBlockIndices.|(){}[0] + final val payloadIndexRanges // io.github.linreal.cascade.editor.state/DragState.payloadIndexRanges|{}payloadIndexRanges[0] + final fun (): kotlin.collections/List // io.github.linreal.cascade.editor.state/DragState.payloadIndexRanges.|(){}[0] + final val payloadRelativeDepthOffsets // io.github.linreal.cascade.editor.state/DragState.payloadRelativeDepthOffsets|{}payloadRelativeDepthOffsets[0] + final fun (): kotlin.collections/Map // io.github.linreal.cascade.editor.state/DragState.payloadRelativeDepthOffsets.|(){}[0] + final val payloadRootIdsByBlockId // io.github.linreal.cascade.editor.state/DragState.payloadRootIdsByBlockId|{}payloadRootIdsByBlockId[0] + final fun (): kotlin.collections/Map // io.github.linreal.cascade.editor.state/DragState.payloadRootIdsByBlockId.|(){}[0] + final val primaryBlockOriginalIndex // io.github.linreal.cascade.editor.state/DragState.primaryBlockOriginalIndex|{}primaryBlockOriginalIndex[0] + final fun (): kotlin/Int // io.github.linreal.cascade.editor.state/DragState.primaryBlockOriginalIndex.|(){}[0] + final val primaryRootId // io.github.linreal.cascade.editor.state/DragState.primaryRootId|{}primaryRootId[0] + final fun (): io.github.linreal.cascade.editor.core/BlockId? // io.github.linreal.cascade.editor.state/DragState.primaryRootId.|(){}[0] + final val primaryRootOriginalIndex // io.github.linreal.cascade.editor.state/DragState.primaryRootOriginalIndex|{}primaryRootOriginalIndex[0] + final fun (): kotlin/Int // io.github.linreal.cascade.editor.state/DragState.primaryRootOriginalIndex.|(){}[0] + final val primaryRootSupportsIndentation // io.github.linreal.cascade.editor.state/DragState.primaryRootSupportsIndentation|{}primaryRootSupportsIndentation[0] + final fun (): kotlin/Boolean? // io.github.linreal.cascade.editor.state/DragState.primaryRootSupportsIndentation.|(){}[0] + final val targetIndex // io.github.linreal.cascade.editor.state/DragState.targetIndex|{}targetIndex[0] + final fun (): kotlin/Int? // io.github.linreal.cascade.editor.state/DragState.targetIndex.|(){}[0] + + final fun component1(): kotlin.collections/Set // io.github.linreal.cascade.editor.state/DragState.component1|component1(){}[0] + final fun component10(): kotlin.collections/List // io.github.linreal.cascade.editor.state/DragState.component10|component10(){}[0] + final fun component11(): io.github.linreal.cascade.editor.core/BlockId? // io.github.linreal.cascade.editor.state/DragState.component11|component11(){}[0] + final fun component12(): kotlin/Int // io.github.linreal.cascade.editor.state/DragState.component12|component12(){}[0] + final fun component13(): kotlin/Boolean? // io.github.linreal.cascade.editor.state/DragState.component13|component13(){}[0] + final fun component14(): kotlin.collections/Map // io.github.linreal.cascade.editor.state/DragState.component14|component14(){}[0] + final fun component15(): kotlin.collections/Map // io.github.linreal.cascade.editor.state/DragState.component15|component15(){}[0] + final fun component16(): kotlin.collections/Map // io.github.linreal.cascade.editor.state/DragState.component16|component16(){}[0] + final fun component17(): kotlin/Int // io.github.linreal.cascade.editor.state/DragState.component17|component17(){}[0] + final fun component2(): kotlin/Int? // io.github.linreal.cascade.editor.state/DragState.component2|component2(){}[0] + final fun component3(): kotlin/Float // io.github.linreal.cascade.editor.state/DragState.component3|component3(){}[0] + final fun component4(): kotlin/Int // io.github.linreal.cascade.editor.state/DragState.component4|component4(){}[0] + final fun component5(): kotlin.collections/List // io.github.linreal.cascade.editor.state/DragState.component5|component5(){}[0] + final fun component6(): kotlin.collections/List // io.github.linreal.cascade.editor.state/DragState.component6|component6(){}[0] + final fun component7(): kotlin.collections/Set // io.github.linreal.cascade.editor.state/DragState.component7|component7(){}[0] + final fun component8(): kotlin.collections/List // io.github.linreal.cascade.editor.state/DragState.component8|component8(){}[0] + final fun component9(): kotlin.collections/Set // io.github.linreal.cascade.editor.state/DragState.component9|component9(){}[0] + final fun copy(kotlin.collections/Set = ..., kotlin/Int? = ..., kotlin/Float = ..., kotlin/Int = ..., kotlin.collections/List = ..., kotlin.collections/List = ..., kotlin.collections/Set = ..., kotlin.collections/List = ..., kotlin.collections/Set = ..., kotlin.collections/List = ..., io.github.linreal.cascade.editor.core/BlockId? = ..., kotlin/Int = ..., kotlin/Boolean? = ..., kotlin.collections/Map = ..., kotlin.collections/Map = ..., kotlin.collections/Map = ..., kotlin/Int = ...): io.github.linreal.cascade.editor.state/DragState // io.github.linreal.cascade.editor.state/DragState.copy|copy(kotlin.collections.Set;kotlin.Int?;kotlin.Float;kotlin.Int;kotlin.collections.List;kotlin.collections.List;kotlin.collections.Set;kotlin.collections.List;kotlin.collections.Set;kotlin.collections.List;io.github.linreal.cascade.editor.core.BlockId?;kotlin.Int;kotlin.Boolean?;kotlin.collections.Map;kotlin.collections.Map;kotlin.collections.Map;kotlin.Int){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.state/DragState.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.state/DragState.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.state/DragState.toString|toString(){}[0] +} + +final class io.github.linreal.cascade.editor.state/EditorState { // io.github.linreal.cascade.editor.state/EditorState|null[0] + constructor (kotlin.collections/List, io.github.linreal.cascade.editor.core/BlockId?, kotlin.collections/Set, io.github.linreal.cascade.editor.state/DragState?, io.github.linreal.cascade.editor.state/SlashCommandState?) // io.github.linreal.cascade.editor.state/EditorState.|(kotlin.collections.List;io.github.linreal.cascade.editor.core.BlockId?;kotlin.collections.Set;io.github.linreal.cascade.editor.state.DragState?;io.github.linreal.cascade.editor.state.SlashCommandState?){}[0] + + final val blocks // io.github.linreal.cascade.editor.state/EditorState.blocks|{}blocks[0] + final fun (): kotlin.collections/List // io.github.linreal.cascade.editor.state/EditorState.blocks.|(){}[0] + final val dragState // io.github.linreal.cascade.editor.state/EditorState.dragState|{}dragState[0] + final fun (): io.github.linreal.cascade.editor.state/DragState? // io.github.linreal.cascade.editor.state/EditorState.dragState.|(){}[0] + final val focusedBlock // io.github.linreal.cascade.editor.state/EditorState.focusedBlock|{}focusedBlock[0] + final fun (): io.github.linreal.cascade.editor.core/Block? // io.github.linreal.cascade.editor.state/EditorState.focusedBlock.|(){}[0] + final val focusedBlockId // io.github.linreal.cascade.editor.state/EditorState.focusedBlockId|{}focusedBlockId[0] + final fun (): io.github.linreal.cascade.editor.core/BlockId? // io.github.linreal.cascade.editor.state/EditorState.focusedBlockId.|(){}[0] + final val hasSelection // io.github.linreal.cascade.editor.state/EditorState.hasSelection|{}hasSelection[0] + final fun (): kotlin/Boolean // io.github.linreal.cascade.editor.state/EditorState.hasSelection.|(){}[0] + final val hasSingleSelection // io.github.linreal.cascade.editor.state/EditorState.hasSingleSelection|{}hasSingleSelection[0] + final fun (): kotlin/Boolean // io.github.linreal.cascade.editor.state/EditorState.hasSingleSelection.|(){}[0] + final val selectedBlockIds // io.github.linreal.cascade.editor.state/EditorState.selectedBlockIds|{}selectedBlockIds[0] + final fun (): kotlin.collections/Set // io.github.linreal.cascade.editor.state/EditorState.selectedBlockIds.|(){}[0] + final val selectedBlocks // io.github.linreal.cascade.editor.state/EditorState.selectedBlocks|{}selectedBlocks[0] + final fun (): kotlin.collections/List // io.github.linreal.cascade.editor.state/EditorState.selectedBlocks.|(){}[0] + final val slashCommandState // io.github.linreal.cascade.editor.state/EditorState.slashCommandState|{}slashCommandState[0] + final fun (): io.github.linreal.cascade.editor.state/SlashCommandState? // io.github.linreal.cascade.editor.state/EditorState.slashCommandState.|(){}[0] + + final fun component1(): kotlin.collections/List // io.github.linreal.cascade.editor.state/EditorState.component1|component1(){}[0] + final fun component2(): io.github.linreal.cascade.editor.core/BlockId? // io.github.linreal.cascade.editor.state/EditorState.component2|component2(){}[0] + final fun component3(): kotlin.collections/Set // io.github.linreal.cascade.editor.state/EditorState.component3|component3(){}[0] + final fun component4(): io.github.linreal.cascade.editor.state/DragState? // io.github.linreal.cascade.editor.state/EditorState.component4|component4(){}[0] + final fun component5(): io.github.linreal.cascade.editor.state/SlashCommandState? // io.github.linreal.cascade.editor.state/EditorState.component5|component5(){}[0] + final fun copy(kotlin.collections/List = ..., io.github.linreal.cascade.editor.core/BlockId? = ..., kotlin.collections/Set = ..., io.github.linreal.cascade.editor.state/DragState? = ..., io.github.linreal.cascade.editor.state/SlashCommandState? = ...): io.github.linreal.cascade.editor.state/EditorState // io.github.linreal.cascade.editor.state/EditorState.copy|copy(kotlin.collections.List;io.github.linreal.cascade.editor.core.BlockId?;kotlin.collections.Set;io.github.linreal.cascade.editor.state.DragState?;io.github.linreal.cascade.editor.state.SlashCommandState?){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.state/EditorState.equals|equals(kotlin.Any?){}[0] + final fun getBlock(io.github.linreal.cascade.editor.core/BlockId): io.github.linreal.cascade.editor.core/Block? // io.github.linreal.cascade.editor.state/EditorState.getBlock|getBlock(io.github.linreal.cascade.editor.core.BlockId){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.state/EditorState.hashCode|hashCode(){}[0] + final fun indexOfBlock(io.github.linreal.cascade.editor.core/BlockId): kotlin/Int // io.github.linreal.cascade.editor.state/EditorState.indexOfBlock|indexOfBlock(io.github.linreal.cascade.editor.core.BlockId){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.state/EditorState.toString|toString(){}[0] + + final object Companion { // io.github.linreal.cascade.editor.state/EditorState.Companion|null[0] + final val Empty // io.github.linreal.cascade.editor.state/EditorState.Companion.Empty|{}Empty[0] + final fun (): io.github.linreal.cascade.editor.state/EditorState // io.github.linreal.cascade.editor.state/EditorState.Companion.Empty.|(){}[0] + + final fun withBlocks(kotlin.collections/List): io.github.linreal.cascade.editor.state/EditorState // io.github.linreal.cascade.editor.state/EditorState.Companion.withBlocks|withBlocks(kotlin.collections.List){}[0] + } +} + +final class io.github.linreal.cascade.editor.state/EditorStateHolder { // io.github.linreal.cascade.editor.state/EditorStateHolder|null[0] + constructor (io.github.linreal.cascade.editor.state/EditorState = ...) // io.github.linreal.cascade.editor.state/EditorStateHolder.|(io.github.linreal.cascade.editor.state.EditorState){}[0] + + final val canRedo // io.github.linreal.cascade.editor.state/EditorStateHolder.canRedo|{}canRedo[0] + final fun (): kotlin/Boolean // io.github.linreal.cascade.editor.state/EditorStateHolder.canRedo.|(){}[0] + final val canUndo // io.github.linreal.cascade.editor.state/EditorStateHolder.canUndo|{}canUndo[0] + final fun (): kotlin/Boolean // io.github.linreal.cascade.editor.state/EditorStateHolder.canUndo.|(){}[0] + final val state // io.github.linreal.cascade.editor.state/EditorStateHolder.state|{}state[0] + final fun (): io.github.linreal.cascade.editor.state/EditorState // io.github.linreal.cascade.editor.state/EditorStateHolder.state.|(){}[0] + + final fun dispatch(io.github.linreal.cascade.editor.action/EditorAction) // io.github.linreal.cascade.editor.state/EditorStateHolder.dispatch|dispatch(io.github.linreal.cascade.editor.action.EditorAction){}[0] + final fun dispatchStructuralAction(io.github.linreal.cascade.editor.action/EditorAction, io.github.linreal.cascade.editor.state/BlockTextStates? = ..., io.github.linreal.cascade.editor.state/BlockSpanStates? = ...) // io.github.linreal.cascade.editor.state/EditorStateHolder.dispatchStructuralAction|dispatchStructuralAction(io.github.linreal.cascade.editor.action.EditorAction;io.github.linreal.cascade.editor.state.BlockTextStates?;io.github.linreal.cascade.editor.state.BlockSpanStates?){}[0] + final fun redo() // io.github.linreal.cascade.editor.state/EditorStateHolder.redo|redo(){}[0] + final fun setState(io.github.linreal.cascade.editor.state/EditorState) // io.github.linreal.cascade.editor.state/EditorStateHolder.setState|setState(io.github.linreal.cascade.editor.state.EditorState){}[0] + final fun undo() // io.github.linreal.cascade.editor.state/EditorStateHolder.undo|undo(){}[0] +} + +final class io.github.linreal.cascade.editor.state/SlashCommandState { // io.github.linreal.cascade.editor.state/SlashCommandState|null[0] + constructor (io.github.linreal.cascade.editor.core/BlockId, kotlin/String, io.github.linreal.cascade.editor.state/SlashQueryRange, kotlin.collections/List = ..., io.github.linreal.cascade.editor.slash/SlashCommandId? = ...) // io.github.linreal.cascade.editor.state/SlashCommandState.|(io.github.linreal.cascade.editor.core.BlockId;kotlin.String;io.github.linreal.cascade.editor.state.SlashQueryRange;kotlin.collections.List;io.github.linreal.cascade.editor.slash.SlashCommandId?){}[0] + + final val anchorBlockId // io.github.linreal.cascade.editor.state/SlashCommandState.anchorBlockId|{}anchorBlockId[0] + final fun (): io.github.linreal.cascade.editor.core/BlockId // io.github.linreal.cascade.editor.state/SlashCommandState.anchorBlockId.|(){}[0] + final val highlightedCommandId // io.github.linreal.cascade.editor.state/SlashCommandState.highlightedCommandId|{}highlightedCommandId[0] + final fun (): io.github.linreal.cascade.editor.slash/SlashCommandId? // io.github.linreal.cascade.editor.state/SlashCommandState.highlightedCommandId.|(){}[0] + final val navigationPath // io.github.linreal.cascade.editor.state/SlashCommandState.navigationPath|{}navigationPath[0] + final fun (): kotlin.collections/List // io.github.linreal.cascade.editor.state/SlashCommandState.navigationPath.|(){}[0] + final val query // io.github.linreal.cascade.editor.state/SlashCommandState.query|{}query[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.state/SlashCommandState.query.|(){}[0] + final val queryRange // io.github.linreal.cascade.editor.state/SlashCommandState.queryRange|{}queryRange[0] + final fun (): io.github.linreal.cascade.editor.state/SlashQueryRange // io.github.linreal.cascade.editor.state/SlashCommandState.queryRange.|(){}[0] + + final fun component1(): io.github.linreal.cascade.editor.core/BlockId // io.github.linreal.cascade.editor.state/SlashCommandState.component1|component1(){}[0] + final fun component2(): kotlin/String // io.github.linreal.cascade.editor.state/SlashCommandState.component2|component2(){}[0] + final fun component3(): io.github.linreal.cascade.editor.state/SlashQueryRange // io.github.linreal.cascade.editor.state/SlashCommandState.component3|component3(){}[0] + final fun component4(): kotlin.collections/List // io.github.linreal.cascade.editor.state/SlashCommandState.component4|component4(){}[0] + final fun component5(): io.github.linreal.cascade.editor.slash/SlashCommandId? // io.github.linreal.cascade.editor.state/SlashCommandState.component5|component5(){}[0] + final fun copy(io.github.linreal.cascade.editor.core/BlockId = ..., kotlin/String = ..., io.github.linreal.cascade.editor.state/SlashQueryRange = ..., kotlin.collections/List = ..., io.github.linreal.cascade.editor.slash/SlashCommandId? = ...): io.github.linreal.cascade.editor.state/SlashCommandState // io.github.linreal.cascade.editor.state/SlashCommandState.copy|copy(io.github.linreal.cascade.editor.core.BlockId;kotlin.String;io.github.linreal.cascade.editor.state.SlashQueryRange;kotlin.collections.List;io.github.linreal.cascade.editor.slash.SlashCommandId?){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.state/SlashCommandState.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.state/SlashCommandState.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.state/SlashCommandState.toString|toString(){}[0] +} + +final class io.github.linreal.cascade.editor.state/SlashQueryRange { // io.github.linreal.cascade.editor.state/SlashQueryRange|null[0] + constructor (kotlin/Int, kotlin/Int) // io.github.linreal.cascade.editor.state/SlashQueryRange.|(kotlin.Int;kotlin.Int){}[0] + + final val endExclusive // io.github.linreal.cascade.editor.state/SlashQueryRange.endExclusive|{}endExclusive[0] + final fun (): kotlin/Int // io.github.linreal.cascade.editor.state/SlashQueryRange.endExclusive.|(){}[0] + final val start // io.github.linreal.cascade.editor.state/SlashQueryRange.start|{}start[0] + final fun (): kotlin/Int // io.github.linreal.cascade.editor.state/SlashQueryRange.start.|(){}[0] + + final fun component1(): kotlin/Int // io.github.linreal.cascade.editor.state/SlashQueryRange.component1|component1(){}[0] + final fun component2(): kotlin/Int // io.github.linreal.cascade.editor.state/SlashQueryRange.component2|component2(){}[0] + final fun copy(kotlin/Int = ..., kotlin/Int = ...): io.github.linreal.cascade.editor.state/SlashQueryRange // io.github.linreal.cascade.editor.state/SlashQueryRange.copy|copy(kotlin.Int;kotlin.Int){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.state/SlashQueryRange.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.state/SlashQueryRange.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.state/SlashQueryRange.toString|toString(){}[0] +} + +final class io.github.linreal.cascade.editor.theme/BlockLocalizedStrings { // io.github.linreal.cascade.editor.theme/BlockLocalizedStrings|null[0] + constructor (kotlin/String, kotlin/String, kotlin.collections/List = ...) // io.github.linreal.cascade.editor.theme/BlockLocalizedStrings.|(kotlin.String;kotlin.String;kotlin.collections.List){}[0] + + final val description // io.github.linreal.cascade.editor.theme/BlockLocalizedStrings.description|{}description[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.theme/BlockLocalizedStrings.description.|(){}[0] + final val displayName // io.github.linreal.cascade.editor.theme/BlockLocalizedStrings.displayName|{}displayName[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.theme/BlockLocalizedStrings.displayName.|(){}[0] + final val keywords // io.github.linreal.cascade.editor.theme/BlockLocalizedStrings.keywords|{}keywords[0] + final fun (): kotlin.collections/List // io.github.linreal.cascade.editor.theme/BlockLocalizedStrings.keywords.|(){}[0] + + final fun component1(): kotlin/String // io.github.linreal.cascade.editor.theme/BlockLocalizedStrings.component1|component1(){}[0] + final fun component2(): kotlin/String // io.github.linreal.cascade.editor.theme/BlockLocalizedStrings.component2|component2(){}[0] + final fun component3(): kotlin.collections/List // io.github.linreal.cascade.editor.theme/BlockLocalizedStrings.component3|component3(){}[0] + final fun copy(kotlin/String = ..., kotlin/String = ..., kotlin.collections/List = ...): io.github.linreal.cascade.editor.theme/BlockLocalizedStrings // io.github.linreal.cascade.editor.theme/BlockLocalizedStrings.copy|copy(kotlin.String;kotlin.String;kotlin.collections.List){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.theme/BlockLocalizedStrings.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.theme/BlockLocalizedStrings.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.theme/BlockLocalizedStrings.toString|toString(){}[0] +} + +final class io.github.linreal.cascade.editor.theme/CascadeEditorBlockStrings { // io.github.linreal.cascade.editor.theme/CascadeEditorBlockStrings|null[0] + constructor (kotlin.collections/Map) // io.github.linreal.cascade.editor.theme/CascadeEditorBlockStrings.|(kotlin.collections.Map){}[0] + + final val blocks // io.github.linreal.cascade.editor.theme/CascadeEditorBlockStrings.blocks|{}blocks[0] + final fun (): kotlin.collections/Map // io.github.linreal.cascade.editor.theme/CascadeEditorBlockStrings.blocks.|(){}[0] + + final fun component1(): kotlin.collections/Map // io.github.linreal.cascade.editor.theme/CascadeEditorBlockStrings.component1|component1(){}[0] + final fun copy(kotlin.collections/Map = ...): io.github.linreal.cascade.editor.theme/CascadeEditorBlockStrings // io.github.linreal.cascade.editor.theme/CascadeEditorBlockStrings.copy|copy(kotlin.collections.Map){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.theme/CascadeEditorBlockStrings.equals|equals(kotlin.Any?){}[0] + final fun forType(kotlin/String): io.github.linreal.cascade.editor.theme/BlockLocalizedStrings? // io.github.linreal.cascade.editor.theme/CascadeEditorBlockStrings.forType|forType(kotlin.String){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.theme/CascadeEditorBlockStrings.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.theme/CascadeEditorBlockStrings.toString|toString(){}[0] + + final object Companion { // io.github.linreal.cascade.editor.theme/CascadeEditorBlockStrings.Companion|null[0] + final fun default(): io.github.linreal.cascade.editor.theme/CascadeEditorBlockStrings // io.github.linreal.cascade.editor.theme/CascadeEditorBlockStrings.Companion.default|default(){}[0] + } +} + +final class io.github.linreal.cascade.editor.theme/CascadeEditorColors { // io.github.linreal.cascade.editor.theme/CascadeEditorColors|null[0] + constructor (androidx.compose.ui.graphics/Color, androidx.compose.ui.graphics/Color, androidx.compose.ui.graphics/Color, androidx.compose.ui.graphics/Color, androidx.compose.ui.graphics/Color, androidx.compose.ui.graphics/Color, androidx.compose.ui.graphics/Color, androidx.compose.ui.graphics/Color, androidx.compose.ui.graphics/Color, androidx.compose.ui.graphics/Color, androidx.compose.ui.graphics/Color, androidx.compose.ui.graphics/Color, androidx.compose.ui.graphics/Color, androidx.compose.ui.graphics/Color, androidx.compose.ui.graphics/Color, androidx.compose.ui.graphics/Color, androidx.compose.ui.graphics/Color, androidx.compose.ui.graphics/Color, androidx.compose.ui.graphics/Color, androidx.compose.ui.graphics/Color, androidx.compose.ui.graphics/Color = ..., androidx.compose.ui.graphics/Color = ..., androidx.compose.ui.graphics/Color = ..., androidx.compose.ui.graphics/Color = ...) // io.github.linreal.cascade.editor.theme/CascadeEditorColors.|(androidx.compose.ui.graphics.Color;androidx.compose.ui.graphics.Color;androidx.compose.ui.graphics.Color;androidx.compose.ui.graphics.Color;androidx.compose.ui.graphics.Color;androidx.compose.ui.graphics.Color;androidx.compose.ui.graphics.Color;androidx.compose.ui.graphics.Color;androidx.compose.ui.graphics.Color;androidx.compose.ui.graphics.Color;androidx.compose.ui.graphics.Color;androidx.compose.ui.graphics.Color;androidx.compose.ui.graphics.Color;androidx.compose.ui.graphics.Color;androidx.compose.ui.graphics.Color;androidx.compose.ui.graphics.Color;androidx.compose.ui.graphics.Color;androidx.compose.ui.graphics.Color;androidx.compose.ui.graphics.Color;androidx.compose.ui.graphics.Color;androidx.compose.ui.graphics.Color;androidx.compose.ui.graphics.Color;androidx.compose.ui.graphics.Color;androidx.compose.ui.graphics.Color){}[0] + + final val codeBlockBackground // io.github.linreal.cascade.editor.theme/CascadeEditorColors.codeBlockBackground|{}codeBlockBackground[0] + final fun (): androidx.compose.ui.graphics/Color // io.github.linreal.cascade.editor.theme/CascadeEditorColors.codeBlockBackground.|(){}[0] + final val contentDivider // io.github.linreal.cascade.editor.theme/CascadeEditorColors.contentDivider|{}contentDivider[0] + final fun (): androidx.compose.ui.graphics/Color // io.github.linreal.cascade.editor.theme/CascadeEditorColors.contentDivider.|(){}[0] + final val cursor // io.github.linreal.cascade.editor.theme/CascadeEditorColors.cursor|{}cursor[0] + final fun (): androidx.compose.ui.graphics/Color // io.github.linreal.cascade.editor.theme/CascadeEditorColors.cursor.|(){}[0] + final val error // io.github.linreal.cascade.editor.theme/CascadeEditorColors.error|{}error[0] + final fun (): androidx.compose.ui.graphics/Color // io.github.linreal.cascade.editor.theme/CascadeEditorColors.error.|(){}[0] + final val highlight // io.github.linreal.cascade.editor.theme/CascadeEditorColors.highlight|{}highlight[0] + final fun (): androidx.compose.ui.graphics/Color // io.github.linreal.cascade.editor.theme/CascadeEditorColors.highlight.|(){}[0] + final val inlineCodeBackground // io.github.linreal.cascade.editor.theme/CascadeEditorColors.inlineCodeBackground|{}inlineCodeBackground[0] + final fun (): androidx.compose.ui.graphics/Color // io.github.linreal.cascade.editor.theme/CascadeEditorColors.inlineCodeBackground.|(){}[0] + final val linkText // io.github.linreal.cascade.editor.theme/CascadeEditorColors.linkText|{}linkText[0] + final fun (): androidx.compose.ui.graphics/Color // io.github.linreal.cascade.editor.theme/CascadeEditorColors.linkText.|(){}[0] + final val onPrimary // io.github.linreal.cascade.editor.theme/CascadeEditorColors.onPrimary|{}onPrimary[0] + final fun (): androidx.compose.ui.graphics/Color // io.github.linreal.cascade.editor.theme/CascadeEditorColors.onPrimary.|(){}[0] + final val popupBackground // io.github.linreal.cascade.editor.theme/CascadeEditorColors.popupBackground|{}popupBackground[0] + final fun (): androidx.compose.ui.graphics/Color // io.github.linreal.cascade.editor.theme/CascadeEditorColors.popupBackground.|(){}[0] + final val primary // io.github.linreal.cascade.editor.theme/CascadeEditorColors.primary|{}primary[0] + final fun (): androidx.compose.ui.graphics/Color // io.github.linreal.cascade.editor.theme/CascadeEditorColors.primary.|(){}[0] + final val quoteBackground // io.github.linreal.cascade.editor.theme/CascadeEditorColors.quoteBackground|{}quoteBackground[0] + final fun (): androidx.compose.ui.graphics/Color // io.github.linreal.cascade.editor.theme/CascadeEditorColors.quoteBackground.|(){}[0] + final val quoteBorder // io.github.linreal.cascade.editor.theme/CascadeEditorColors.quoteBorder|{}quoteBorder[0] + final fun (): androidx.compose.ui.graphics/Color // io.github.linreal.cascade.editor.theme/CascadeEditorColors.quoteBorder.|(){}[0] + final val selectionOverlay // io.github.linreal.cascade.editor.theme/CascadeEditorColors.selectionOverlay|{}selectionOverlay[0] + final fun (): androidx.compose.ui.graphics/Color // io.github.linreal.cascade.editor.theme/CascadeEditorColors.selectionOverlay.|(){}[0] + final val slashChevron // io.github.linreal.cascade.editor.theme/CascadeEditorColors.slashChevron|{}slashChevron[0] + final fun (): androidx.compose.ui.graphics/Color // io.github.linreal.cascade.editor.theme/CascadeEditorColors.slashChevron.|(){}[0] + final val slashItemTitle // io.github.linreal.cascade.editor.theme/CascadeEditorColors.slashItemTitle|{}slashItemTitle[0] + final fun (): androidx.compose.ui.graphics/Color // io.github.linreal.cascade.editor.theme/CascadeEditorColors.slashItemTitle.|(){}[0] + final val slashSelectedItem // io.github.linreal.cascade.editor.theme/CascadeEditorColors.slashSelectedItem|{}slashSelectedItem[0] + final fun (): androidx.compose.ui.graphics/Color // io.github.linreal.cascade.editor.theme/CascadeEditorColors.slashSelectedItem.|(){}[0] + final val text // io.github.linreal.cascade.editor.theme/CascadeEditorColors.text|{}text[0] + final fun (): androidx.compose.ui.graphics/Color // io.github.linreal.cascade.editor.theme/CascadeEditorColors.text.|(){}[0] + final val textSelectionBackground // io.github.linreal.cascade.editor.theme/CascadeEditorColors.textSelectionBackground|{}textSelectionBackground[0] + final fun (): androidx.compose.ui.graphics/Color // io.github.linreal.cascade.editor.theme/CascadeEditorColors.textSelectionBackground.|(){}[0] + final val toolbarBackground // io.github.linreal.cascade.editor.theme/CascadeEditorColors.toolbarBackground|{}toolbarBackground[0] + final fun (): androidx.compose.ui.graphics/Color // io.github.linreal.cascade.editor.theme/CascadeEditorColors.toolbarBackground.|(){}[0] + final val toolbarIcon // io.github.linreal.cascade.editor.theme/CascadeEditorColors.toolbarIcon|{}toolbarIcon[0] + final fun (): androidx.compose.ui.graphics/Color // io.github.linreal.cascade.editor.theme/CascadeEditorColors.toolbarIcon.|(){}[0] + final val toolbarIconDisabled // io.github.linreal.cascade.editor.theme/CascadeEditorColors.toolbarIconDisabled|{}toolbarIconDisabled[0] + final fun (): androidx.compose.ui.graphics/Color // io.github.linreal.cascade.editor.theme/CascadeEditorColors.toolbarIconDisabled.|(){}[0] + final val uiDivider // io.github.linreal.cascade.editor.theme/CascadeEditorColors.uiDivider|{}uiDivider[0] + final fun (): androidx.compose.ui.graphics/Color // io.github.linreal.cascade.editor.theme/CascadeEditorColors.uiDivider.|(){}[0] + final val unknownBlockBackground // io.github.linreal.cascade.editor.theme/CascadeEditorColors.unknownBlockBackground|{}unknownBlockBackground[0] + final fun (): androidx.compose.ui.graphics/Color // io.github.linreal.cascade.editor.theme/CascadeEditorColors.unknownBlockBackground.|(){}[0] + final val unknownBlockText // io.github.linreal.cascade.editor.theme/CascadeEditorColors.unknownBlockText|{}unknownBlockText[0] + final fun (): androidx.compose.ui.graphics/Color // io.github.linreal.cascade.editor.theme/CascadeEditorColors.unknownBlockText.|(){}[0] + + final fun component1(): androidx.compose.ui.graphics/Color // io.github.linreal.cascade.editor.theme/CascadeEditorColors.component1|component1(){}[0] + final fun component10(): androidx.compose.ui.graphics/Color // io.github.linreal.cascade.editor.theme/CascadeEditorColors.component10|component10(){}[0] + final fun component11(): androidx.compose.ui.graphics/Color // io.github.linreal.cascade.editor.theme/CascadeEditorColors.component11|component11(){}[0] + final fun component12(): androidx.compose.ui.graphics/Color // io.github.linreal.cascade.editor.theme/CascadeEditorColors.component12|component12(){}[0] + final fun component13(): androidx.compose.ui.graphics/Color // io.github.linreal.cascade.editor.theme/CascadeEditorColors.component13|component13(){}[0] + final fun component14(): androidx.compose.ui.graphics/Color // io.github.linreal.cascade.editor.theme/CascadeEditorColors.component14|component14(){}[0] + final fun component15(): androidx.compose.ui.graphics/Color // io.github.linreal.cascade.editor.theme/CascadeEditorColors.component15|component15(){}[0] + final fun component16(): androidx.compose.ui.graphics/Color // io.github.linreal.cascade.editor.theme/CascadeEditorColors.component16|component16(){}[0] + final fun component17(): androidx.compose.ui.graphics/Color // io.github.linreal.cascade.editor.theme/CascadeEditorColors.component17|component17(){}[0] + final fun component18(): androidx.compose.ui.graphics/Color // io.github.linreal.cascade.editor.theme/CascadeEditorColors.component18|component18(){}[0] + final fun component19(): androidx.compose.ui.graphics/Color // io.github.linreal.cascade.editor.theme/CascadeEditorColors.component19|component19(){}[0] + final fun component2(): androidx.compose.ui.graphics/Color // io.github.linreal.cascade.editor.theme/CascadeEditorColors.component2|component2(){}[0] + final fun component20(): androidx.compose.ui.graphics/Color // io.github.linreal.cascade.editor.theme/CascadeEditorColors.component20|component20(){}[0] + final fun component21(): androidx.compose.ui.graphics/Color // io.github.linreal.cascade.editor.theme/CascadeEditorColors.component21|component21(){}[0] + final fun component22(): androidx.compose.ui.graphics/Color // io.github.linreal.cascade.editor.theme/CascadeEditorColors.component22|component22(){}[0] + final fun component23(): androidx.compose.ui.graphics/Color // io.github.linreal.cascade.editor.theme/CascadeEditorColors.component23|component23(){}[0] + final fun component24(): androidx.compose.ui.graphics/Color // io.github.linreal.cascade.editor.theme/CascadeEditorColors.component24|component24(){}[0] + final fun component3(): androidx.compose.ui.graphics/Color // io.github.linreal.cascade.editor.theme/CascadeEditorColors.component3|component3(){}[0] + final fun component4(): androidx.compose.ui.graphics/Color // io.github.linreal.cascade.editor.theme/CascadeEditorColors.component4|component4(){}[0] + final fun component5(): androidx.compose.ui.graphics/Color // io.github.linreal.cascade.editor.theme/CascadeEditorColors.component5|component5(){}[0] + final fun component6(): androidx.compose.ui.graphics/Color // io.github.linreal.cascade.editor.theme/CascadeEditorColors.component6|component6(){}[0] + final fun component7(): androidx.compose.ui.graphics/Color // io.github.linreal.cascade.editor.theme/CascadeEditorColors.component7|component7(){}[0] + final fun component8(): androidx.compose.ui.graphics/Color // io.github.linreal.cascade.editor.theme/CascadeEditorColors.component8|component8(){}[0] + final fun component9(): androidx.compose.ui.graphics/Color // io.github.linreal.cascade.editor.theme/CascadeEditorColors.component9|component9(){}[0] + final fun copy(androidx.compose.ui.graphics/Color = ..., androidx.compose.ui.graphics/Color = ..., androidx.compose.ui.graphics/Color = ..., androidx.compose.ui.graphics/Color = ..., androidx.compose.ui.graphics/Color = ..., androidx.compose.ui.graphics/Color = ..., androidx.compose.ui.graphics/Color = ..., androidx.compose.ui.graphics/Color = ..., androidx.compose.ui.graphics/Color = ..., androidx.compose.ui.graphics/Color = ..., androidx.compose.ui.graphics/Color = ..., androidx.compose.ui.graphics/Color = ..., androidx.compose.ui.graphics/Color = ..., androidx.compose.ui.graphics/Color = ..., androidx.compose.ui.graphics/Color = ..., androidx.compose.ui.graphics/Color = ..., androidx.compose.ui.graphics/Color = ..., androidx.compose.ui.graphics/Color = ..., androidx.compose.ui.graphics/Color = ..., androidx.compose.ui.graphics/Color = ..., androidx.compose.ui.graphics/Color = ..., androidx.compose.ui.graphics/Color = ..., androidx.compose.ui.graphics/Color = ..., androidx.compose.ui.graphics/Color = ...): io.github.linreal.cascade.editor.theme/CascadeEditorColors // io.github.linreal.cascade.editor.theme/CascadeEditorColors.copy|copy(androidx.compose.ui.graphics.Color;androidx.compose.ui.graphics.Color;androidx.compose.ui.graphics.Color;androidx.compose.ui.graphics.Color;androidx.compose.ui.graphics.Color;androidx.compose.ui.graphics.Color;androidx.compose.ui.graphics.Color;androidx.compose.ui.graphics.Color;androidx.compose.ui.graphics.Color;androidx.compose.ui.graphics.Color;androidx.compose.ui.graphics.Color;androidx.compose.ui.graphics.Color;androidx.compose.ui.graphics.Color;androidx.compose.ui.graphics.Color;androidx.compose.ui.graphics.Color;androidx.compose.ui.graphics.Color;androidx.compose.ui.graphics.Color;androidx.compose.ui.graphics.Color;androidx.compose.ui.graphics.Color;androidx.compose.ui.graphics.Color;androidx.compose.ui.graphics.Color;androidx.compose.ui.graphics.Color;androidx.compose.ui.graphics.Color;androidx.compose.ui.graphics.Color){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.theme/CascadeEditorColors.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.theme/CascadeEditorColors.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.theme/CascadeEditorColors.toString|toString(){}[0] + + final object Companion { // io.github.linreal.cascade.editor.theme/CascadeEditorColors.Companion|null[0] + final fun dark(): io.github.linreal.cascade.editor.theme/CascadeEditorColors // io.github.linreal.cascade.editor.theme/CascadeEditorColors.Companion.dark|dark(){}[0] + final fun light(): io.github.linreal.cascade.editor.theme/CascadeEditorColors // io.github.linreal.cascade.editor.theme/CascadeEditorColors.Companion.light|light(){}[0] + } +} + +final class io.github.linreal.cascade.editor.theme/CascadeEditorDimensions { // io.github.linreal.cascade.editor.theme/CascadeEditorDimensions|null[0] + constructor (androidx.compose.ui.unit/Dp, androidx.compose.ui.unit/Dp) // io.github.linreal.cascade.editor.theme/CascadeEditorDimensions.|(androidx.compose.ui.unit.Dp;androidx.compose.ui.unit.Dp){}[0] + + final val blockHorizontalPadding // io.github.linreal.cascade.editor.theme/CascadeEditorDimensions.blockHorizontalPadding|{}blockHorizontalPadding[0] + final fun (): androidx.compose.ui.unit/Dp // io.github.linreal.cascade.editor.theme/CascadeEditorDimensions.blockHorizontalPadding.|(){}[0] + final val indentUnit // io.github.linreal.cascade.editor.theme/CascadeEditorDimensions.indentUnit|{}indentUnit[0] + final fun (): androidx.compose.ui.unit/Dp // io.github.linreal.cascade.editor.theme/CascadeEditorDimensions.indentUnit.|(){}[0] + + final fun component1(): androidx.compose.ui.unit/Dp // io.github.linreal.cascade.editor.theme/CascadeEditorDimensions.component1|component1(){}[0] + final fun component2(): androidx.compose.ui.unit/Dp // io.github.linreal.cascade.editor.theme/CascadeEditorDimensions.component2|component2(){}[0] + final fun copy(androidx.compose.ui.unit/Dp = ..., androidx.compose.ui.unit/Dp = ...): io.github.linreal.cascade.editor.theme/CascadeEditorDimensions // io.github.linreal.cascade.editor.theme/CascadeEditorDimensions.copy|copy(androidx.compose.ui.unit.Dp;androidx.compose.ui.unit.Dp){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.theme/CascadeEditorDimensions.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.theme/CascadeEditorDimensions.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.theme/CascadeEditorDimensions.toString|toString(){}[0] + + final object Companion { // io.github.linreal.cascade.editor.theme/CascadeEditorDimensions.Companion|null[0] + final fun default(): io.github.linreal.cascade.editor.theme/CascadeEditorDimensions // io.github.linreal.cascade.editor.theme/CascadeEditorDimensions.Companion.default|default(){}[0] + } +} + +final class io.github.linreal.cascade.editor.theme/CascadeEditorStrings { // io.github.linreal.cascade.editor.theme/CascadeEditorStrings|null[0] + constructor (kotlin/String, kotlin/Function1, kotlin/String, kotlin/String, kotlin/String, kotlin/String, kotlin/String, kotlin/String, kotlin/String, kotlin/String, kotlin/String = ..., kotlin/String = ..., kotlin/String = ..., kotlin/String = ..., kotlin/String = ..., kotlin/String = ..., kotlin/String = ..., kotlin/String = ..., kotlin/Function1 = ...) // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.|(kotlin.String;kotlin.Function1;kotlin.String;kotlin.String;kotlin.String;kotlin.String;kotlin.String;kotlin.String;kotlin.String;kotlin.String;kotlin.String;kotlin.String;kotlin.String;kotlin.String;kotlin.String;kotlin.String;kotlin.String;kotlin.String;kotlin.Function1){}[0] + + final val back // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.back|{}back[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.back.|(){}[0] + final val bold // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.bold|{}bold[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.bold.|(){}[0] + final val hideKeyboard // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.hideKeyboard|{}hideKeyboard[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.hideKeyboard.|(){}[0] + final val highlight // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.highlight|{}highlight[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.highlight.|(){}[0] + final val indentBackward // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.indentBackward|{}indentBackward[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.indentBackward.|(){}[0] + final val indentForward // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.indentForward|{}indentForward[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.indentForward.|(){}[0] + final val inlineCode // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.inlineCode|{}inlineCode[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.inlineCode.|(){}[0] + final val italic // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.italic|{}italic[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.italic.|(){}[0] + final val link // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.link|{}link[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.link.|(){}[0] + final val linkApply // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.linkApply|{}linkApply[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.linkApply.|(){}[0] + final val linkCancel // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.linkCancel|{}linkCancel[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.linkCancel.|(){}[0] + final val linkRemove // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.linkRemove|{}linkRemove[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.linkRemove.|(){}[0] + final val linkTitle // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.linkTitle|{}linkTitle[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.linkTitle.|(){}[0] + final val linkUrl // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.linkUrl|{}linkUrl[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.linkUrl.|(){}[0] + final val linkValidationError // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.linkValidationError|{}linkValidationError[0] + final fun (): kotlin/Function1 // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.linkValidationError.|(){}[0] + final val slashCommand // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.slashCommand|{}slashCommand[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.slashCommand.|(){}[0] + final val strikethrough // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.strikethrough|{}strikethrough[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.strikethrough.|(){}[0] + final val underline // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.underline|{}underline[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.underline.|(){}[0] + final val unsupportedBlock // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.unsupportedBlock|{}unsupportedBlock[0] + final fun (): kotlin/Function1 // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.unsupportedBlock.|(){}[0] + + final fun component1(): kotlin/String // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.component1|component1(){}[0] + final fun component10(): kotlin/String // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.component10|component10(){}[0] + final fun component11(): kotlin/String // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.component11|component11(){}[0] + final fun component12(): kotlin/String // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.component12|component12(){}[0] + final fun component13(): kotlin/String // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.component13|component13(){}[0] + final fun component14(): kotlin/String // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.component14|component14(){}[0] + final fun component15(): kotlin/String // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.component15|component15(){}[0] + final fun component16(): kotlin/String // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.component16|component16(){}[0] + final fun component17(): kotlin/String // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.component17|component17(){}[0] + final fun component18(): kotlin/String // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.component18|component18(){}[0] + final fun component19(): kotlin/Function1 // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.component19|component19(){}[0] + final fun component2(): kotlin/Function1 // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.component2|component2(){}[0] + final fun component3(): kotlin/String // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.component3|component3(){}[0] + final fun component4(): kotlin/String // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.component4|component4(){}[0] + final fun component5(): kotlin/String // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.component5|component5(){}[0] + final fun component6(): kotlin/String // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.component6|component6(){}[0] + final fun component7(): kotlin/String // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.component7|component7(){}[0] + final fun component8(): kotlin/String // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.component8|component8(){}[0] + final fun component9(): kotlin/String // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.component9|component9(){}[0] + final fun copy(kotlin/String = ..., kotlin/Function1 = ..., kotlin/String = ..., kotlin/String = ..., kotlin/String = ..., kotlin/String = ..., kotlin/String = ..., kotlin/String = ..., kotlin/String = ..., kotlin/String = ..., kotlin/String = ..., kotlin/String = ..., kotlin/String = ..., kotlin/String = ..., kotlin/String = ..., kotlin/String = ..., kotlin/String = ..., kotlin/String = ..., kotlin/Function1 = ...): io.github.linreal.cascade.editor.theme/CascadeEditorStrings // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.copy|copy(kotlin.String;kotlin.Function1;kotlin.String;kotlin.String;kotlin.String;kotlin.String;kotlin.String;kotlin.String;kotlin.String;kotlin.String;kotlin.String;kotlin.String;kotlin.String;kotlin.String;kotlin.String;kotlin.String;kotlin.String;kotlin.String;kotlin.Function1){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.toString|toString(){}[0] + + final object Companion { // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.Companion|null[0] + final fun default(): io.github.linreal.cascade.editor.theme/CascadeEditorStrings // io.github.linreal.cascade.editor.theme/CascadeEditorStrings.Companion.default|default(){}[0] + } +} + +final class io.github.linreal.cascade.editor.theme/CascadeEditorTheme { // io.github.linreal.cascade.editor.theme/CascadeEditorTheme|null[0] + constructor (io.github.linreal.cascade.editor.theme/CascadeEditorColors, io.github.linreal.cascade.editor.theme/CascadeEditorTypography, io.github.linreal.cascade.editor.theme/CascadeEditorDimensions = ...) // io.github.linreal.cascade.editor.theme/CascadeEditorTheme.|(io.github.linreal.cascade.editor.theme.CascadeEditorColors;io.github.linreal.cascade.editor.theme.CascadeEditorTypography;io.github.linreal.cascade.editor.theme.CascadeEditorDimensions){}[0] + + final val colors // io.github.linreal.cascade.editor.theme/CascadeEditorTheme.colors|{}colors[0] + final fun (): io.github.linreal.cascade.editor.theme/CascadeEditorColors // io.github.linreal.cascade.editor.theme/CascadeEditorTheme.colors.|(){}[0] + final val dimensions // io.github.linreal.cascade.editor.theme/CascadeEditorTheme.dimensions|{}dimensions[0] + final fun (): io.github.linreal.cascade.editor.theme/CascadeEditorDimensions // io.github.linreal.cascade.editor.theme/CascadeEditorTheme.dimensions.|(){}[0] + final val typography // io.github.linreal.cascade.editor.theme/CascadeEditorTheme.typography|{}typography[0] + final fun (): io.github.linreal.cascade.editor.theme/CascadeEditorTypography // io.github.linreal.cascade.editor.theme/CascadeEditorTheme.typography.|(){}[0] + + final fun component1(): io.github.linreal.cascade.editor.theme/CascadeEditorColors // io.github.linreal.cascade.editor.theme/CascadeEditorTheme.component1|component1(){}[0] + final fun component2(): io.github.linreal.cascade.editor.theme/CascadeEditorTypography // io.github.linreal.cascade.editor.theme/CascadeEditorTheme.component2|component2(){}[0] + final fun component3(): io.github.linreal.cascade.editor.theme/CascadeEditorDimensions // io.github.linreal.cascade.editor.theme/CascadeEditorTheme.component3|component3(){}[0] + final fun copy(io.github.linreal.cascade.editor.theme/CascadeEditorColors = ..., io.github.linreal.cascade.editor.theme/CascadeEditorTypography = ..., io.github.linreal.cascade.editor.theme/CascadeEditorDimensions = ...): io.github.linreal.cascade.editor.theme/CascadeEditorTheme // io.github.linreal.cascade.editor.theme/CascadeEditorTheme.copy|copy(io.github.linreal.cascade.editor.theme.CascadeEditorColors;io.github.linreal.cascade.editor.theme.CascadeEditorTypography;io.github.linreal.cascade.editor.theme.CascadeEditorDimensions){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.theme/CascadeEditorTheme.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.theme/CascadeEditorTheme.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.theme/CascadeEditorTheme.toString|toString(){}[0] + + final object Companion { // io.github.linreal.cascade.editor.theme/CascadeEditorTheme.Companion|null[0] + final fun dark(): io.github.linreal.cascade.editor.theme/CascadeEditorTheme // io.github.linreal.cascade.editor.theme/CascadeEditorTheme.Companion.dark|dark(){}[0] + final fun light(): io.github.linreal.cascade.editor.theme/CascadeEditorTheme // io.github.linreal.cascade.editor.theme/CascadeEditorTheme.Companion.light|light(){}[0] + } +} + +final class io.github.linreal.cascade.editor.theme/CascadeEditorTypography { // io.github.linreal.cascade.editor.theme/CascadeEditorTypography|null[0] + constructor (androidx.compose.ui.text/TextStyle, androidx.compose.ui.text/TextStyle, androidx.compose.ui.text/TextStyle, androidx.compose.ui.text/TextStyle, androidx.compose.ui.text/TextStyle, androidx.compose.ui.text/TextStyle, androidx.compose.ui.text/TextStyle, androidx.compose.ui.text/TextStyle, androidx.compose.ui.text/TextStyle, androidx.compose.ui.text/TextStyle, androidx.compose.ui.text/TextStyle) // io.github.linreal.cascade.editor.theme/CascadeEditorTypography.|(androidx.compose.ui.text.TextStyle;androidx.compose.ui.text.TextStyle;androidx.compose.ui.text.TextStyle;androidx.compose.ui.text.TextStyle;androidx.compose.ui.text.TextStyle;androidx.compose.ui.text.TextStyle;androidx.compose.ui.text.TextStyle;androidx.compose.ui.text.TextStyle;androidx.compose.ui.text.TextStyle;androidx.compose.ui.text.TextStyle;androidx.compose.ui.text.TextStyle){}[0] + + final val body // io.github.linreal.cascade.editor.theme/CascadeEditorTypography.body|{}body[0] + final fun (): androidx.compose.ui.text/TextStyle // io.github.linreal.cascade.editor.theme/CascadeEditorTypography.body.|(){}[0] + final val code // io.github.linreal.cascade.editor.theme/CascadeEditorTypography.code|{}code[0] + final fun (): androidx.compose.ui.text/TextStyle // io.github.linreal.cascade.editor.theme/CascadeEditorTypography.code.|(){}[0] + final val heading1 // io.github.linreal.cascade.editor.theme/CascadeEditorTypography.heading1|{}heading1[0] + final fun (): androidx.compose.ui.text/TextStyle // io.github.linreal.cascade.editor.theme/CascadeEditorTypography.heading1.|(){}[0] + final val heading2 // io.github.linreal.cascade.editor.theme/CascadeEditorTypography.heading2|{}heading2[0] + final fun (): androidx.compose.ui.text/TextStyle // io.github.linreal.cascade.editor.theme/CascadeEditorTypography.heading2.|(){}[0] + final val heading3 // io.github.linreal.cascade.editor.theme/CascadeEditorTypography.heading3|{}heading3[0] + final fun (): androidx.compose.ui.text/TextStyle // io.github.linreal.cascade.editor.theme/CascadeEditorTypography.heading3.|(){}[0] + final val heading4 // io.github.linreal.cascade.editor.theme/CascadeEditorTypography.heading4|{}heading4[0] + final fun (): androidx.compose.ui.text/TextStyle // io.github.linreal.cascade.editor.theme/CascadeEditorTypography.heading4.|(){}[0] + final val heading5 // io.github.linreal.cascade.editor.theme/CascadeEditorTypography.heading5|{}heading5[0] + final fun (): androidx.compose.ui.text/TextStyle // io.github.linreal.cascade.editor.theme/CascadeEditorTypography.heading5.|(){}[0] + final val heading6 // io.github.linreal.cascade.editor.theme/CascadeEditorTypography.heading6|{}heading6[0] + final fun (): androidx.compose.ui.text/TextStyle // io.github.linreal.cascade.editor.theme/CascadeEditorTypography.heading6.|(){}[0] + final val slashBackButton // io.github.linreal.cascade.editor.theme/CascadeEditorTypography.slashBackButton|{}slashBackButton[0] + final fun (): androidx.compose.ui.text/TextStyle // io.github.linreal.cascade.editor.theme/CascadeEditorTypography.slashBackButton.|(){}[0] + final val slashItemTitle // io.github.linreal.cascade.editor.theme/CascadeEditorTypography.slashItemTitle|{}slashItemTitle[0] + final fun (): androidx.compose.ui.text/TextStyle // io.github.linreal.cascade.editor.theme/CascadeEditorTypography.slashItemTitle.|(){}[0] + final val toolbarButton // io.github.linreal.cascade.editor.theme/CascadeEditorTypography.toolbarButton|{}toolbarButton[0] + final fun (): androidx.compose.ui.text/TextStyle // io.github.linreal.cascade.editor.theme/CascadeEditorTypography.toolbarButton.|(){}[0] + + final fun component1(): androidx.compose.ui.text/TextStyle // io.github.linreal.cascade.editor.theme/CascadeEditorTypography.component1|component1(){}[0] + final fun component10(): androidx.compose.ui.text/TextStyle // io.github.linreal.cascade.editor.theme/CascadeEditorTypography.component10|component10(){}[0] + final fun component11(): androidx.compose.ui.text/TextStyle // io.github.linreal.cascade.editor.theme/CascadeEditorTypography.component11|component11(){}[0] + final fun component2(): androidx.compose.ui.text/TextStyle // io.github.linreal.cascade.editor.theme/CascadeEditorTypography.component2|component2(){}[0] + final fun component3(): androidx.compose.ui.text/TextStyle // io.github.linreal.cascade.editor.theme/CascadeEditorTypography.component3|component3(){}[0] + final fun component4(): androidx.compose.ui.text/TextStyle // io.github.linreal.cascade.editor.theme/CascadeEditorTypography.component4|component4(){}[0] + final fun component5(): androidx.compose.ui.text/TextStyle // io.github.linreal.cascade.editor.theme/CascadeEditorTypography.component5|component5(){}[0] + final fun component6(): androidx.compose.ui.text/TextStyle // io.github.linreal.cascade.editor.theme/CascadeEditorTypography.component6|component6(){}[0] + final fun component7(): androidx.compose.ui.text/TextStyle // io.github.linreal.cascade.editor.theme/CascadeEditorTypography.component7|component7(){}[0] + final fun component8(): androidx.compose.ui.text/TextStyle // io.github.linreal.cascade.editor.theme/CascadeEditorTypography.component8|component8(){}[0] + final fun component9(): androidx.compose.ui.text/TextStyle // io.github.linreal.cascade.editor.theme/CascadeEditorTypography.component9|component9(){}[0] + final fun copy(androidx.compose.ui.text/TextStyle = ..., androidx.compose.ui.text/TextStyle = ..., androidx.compose.ui.text/TextStyle = ..., androidx.compose.ui.text/TextStyle = ..., androidx.compose.ui.text/TextStyle = ..., androidx.compose.ui.text/TextStyle = ..., androidx.compose.ui.text/TextStyle = ..., androidx.compose.ui.text/TextStyle = ..., androidx.compose.ui.text/TextStyle = ..., androidx.compose.ui.text/TextStyle = ..., androidx.compose.ui.text/TextStyle = ...): io.github.linreal.cascade.editor.theme/CascadeEditorTypography // io.github.linreal.cascade.editor.theme/CascadeEditorTypography.copy|copy(androidx.compose.ui.text.TextStyle;androidx.compose.ui.text.TextStyle;androidx.compose.ui.text.TextStyle;androidx.compose.ui.text.TextStyle;androidx.compose.ui.text.TextStyle;androidx.compose.ui.text.TextStyle;androidx.compose.ui.text.TextStyle;androidx.compose.ui.text.TextStyle;androidx.compose.ui.text.TextStyle;androidx.compose.ui.text.TextStyle;androidx.compose.ui.text.TextStyle){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.theme/CascadeEditorTypography.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.theme/CascadeEditorTypography.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.theme/CascadeEditorTypography.toString|toString(){}[0] + + final object Companion { // io.github.linreal.cascade.editor.theme/CascadeEditorTypography.Companion|null[0] + final fun default(): io.github.linreal.cascade.editor.theme/CascadeEditorTypography // io.github.linreal.cascade.editor.theme/CascadeEditorTypography.Companion.default|default(){}[0] + } +} + +final class io.github.linreal.cascade.editor.ui.renderers/DividerBlockRenderer : io.github.linreal.cascade.editor.registry/BlockRenderer { // io.github.linreal.cascade.editor.ui.renderers/DividerBlockRenderer|null[0] + constructor () // io.github.linreal.cascade.editor.ui.renderers/DividerBlockRenderer.|(){}[0] + + final fun Render(io.github.linreal.cascade.editor.core/Block, kotlin/Boolean, kotlin/Boolean, androidx.compose.ui/Modifier, io.github.linreal.cascade.editor.registry/BlockCallbacks, androidx.compose.runtime/Composer?, kotlin/Int) // io.github.linreal.cascade.editor.ui.renderers/DividerBlockRenderer.Render|Render(io.github.linreal.cascade.editor.core.Block;kotlin.Boolean;kotlin.Boolean;androidx.compose.ui.Modifier;io.github.linreal.cascade.editor.registry.BlockCallbacks;androidx.compose.runtime.Composer?;kotlin.Int){}[0] +} + +final class io.github.linreal.cascade.editor.ui.renderers/TextBlockRenderer : io.github.linreal.cascade.editor.registry/BlockRenderer { // io.github.linreal.cascade.editor.ui.renderers/TextBlockRenderer|null[0] + constructor () // io.github.linreal.cascade.editor.ui.renderers/TextBlockRenderer.|(){}[0] + + final fun Render(io.github.linreal.cascade.editor.core/Block, kotlin/Boolean, kotlin/Boolean, androidx.compose.ui/Modifier, io.github.linreal.cascade.editor.registry/BlockCallbacks, androidx.compose.runtime/Composer?, kotlin/Int) // io.github.linreal.cascade.editor.ui.renderers/TextBlockRenderer.Render|Render(io.github.linreal.cascade.editor.core.Block;kotlin.Boolean;kotlin.Boolean;androidx.compose.ui.Modifier;io.github.linreal.cascade.editor.registry.BlockCallbacks;androidx.compose.runtime.Composer?;kotlin.Int){}[0] +} + +final class io.github.linreal.cascade.editor.ui.renderers/TodoBlockRenderer : io.github.linreal.cascade.editor.registry/BlockRenderer { // io.github.linreal.cascade.editor.ui.renderers/TodoBlockRenderer|null[0] + constructor () // io.github.linreal.cascade.editor.ui.renderers/TodoBlockRenderer.|(){}[0] + + final fun Render(io.github.linreal.cascade.editor.core/Block, kotlin/Boolean, kotlin/Boolean, androidx.compose.ui/Modifier, io.github.linreal.cascade.editor.registry/BlockCallbacks, androidx.compose.runtime/Composer?, kotlin/Int) // io.github.linreal.cascade.editor.ui.renderers/TodoBlockRenderer.Render|Render(io.github.linreal.cascade.editor.core.Block;kotlin.Boolean;kotlin.Boolean;androidx.compose.ui.Modifier;io.github.linreal.cascade.editor.registry.BlockCallbacks;androidx.compose.runtime.Composer?;kotlin.Int){}[0] +} + +final class io.github.linreal.cascade.editor.ui/CascadeEditorConfig { // io.github.linreal.cascade.editor.ui/CascadeEditorConfig|null[0] + constructor (kotlin/Boolean = ..., kotlin/Boolean = ..., kotlin/Boolean = ..., io.github.linreal.cascade.editor/CrashPolicy = ..., kotlin/Function1? = ...) // io.github.linreal.cascade.editor.ui/CascadeEditorConfig.|(kotlin.Boolean;kotlin.Boolean;kotlin.Boolean;io.github.linreal.cascade.editor.CrashPolicy;kotlin.Function1?){}[0] + + final val blockDraggingEnabled // io.github.linreal.cascade.editor.ui/CascadeEditorConfig.blockDraggingEnabled|{}blockDraggingEnabled[0] + final fun (): kotlin/Boolean // io.github.linreal.cascade.editor.ui/CascadeEditorConfig.blockDraggingEnabled.|(){}[0] + final val blockSelectionEnabled // io.github.linreal.cascade.editor.ui/CascadeEditorConfig.blockSelectionEnabled|{}blockSelectionEnabled[0] + final fun (): kotlin/Boolean // io.github.linreal.cascade.editor.ui/CascadeEditorConfig.blockSelectionEnabled.|(){}[0] + final val crashPolicy // io.github.linreal.cascade.editor.ui/CascadeEditorConfig.crashPolicy|{}crashPolicy[0] + final fun (): io.github.linreal.cascade.editor/CrashPolicy // io.github.linreal.cascade.editor.ui/CascadeEditorConfig.crashPolicy.|(){}[0] + final val onInternalError // io.github.linreal.cascade.editor.ui/CascadeEditorConfig.onInternalError|{}onInternalError[0] + final fun (): kotlin/Function1? // io.github.linreal.cascade.editor.ui/CascadeEditorConfig.onInternalError.|(){}[0] + final val readOnly // io.github.linreal.cascade.editor.ui/CascadeEditorConfig.readOnly|{}readOnly[0] + final fun (): kotlin/Boolean // io.github.linreal.cascade.editor.ui/CascadeEditorConfig.readOnly.|(){}[0] + + final fun component1(): kotlin/Boolean // io.github.linreal.cascade.editor.ui/CascadeEditorConfig.component1|component1(){}[0] + final fun component2(): kotlin/Boolean // io.github.linreal.cascade.editor.ui/CascadeEditorConfig.component2|component2(){}[0] + final fun component3(): kotlin/Boolean // io.github.linreal.cascade.editor.ui/CascadeEditorConfig.component3|component3(){}[0] + final fun component4(): io.github.linreal.cascade.editor/CrashPolicy // io.github.linreal.cascade.editor.ui/CascadeEditorConfig.component4|component4(){}[0] + final fun component5(): kotlin/Function1? // io.github.linreal.cascade.editor.ui/CascadeEditorConfig.component5|component5(){}[0] + final fun copy(kotlin/Boolean = ..., kotlin/Boolean = ..., kotlin/Boolean = ..., io.github.linreal.cascade.editor/CrashPolicy = ..., kotlin/Function1? = ...): io.github.linreal.cascade.editor.ui/CascadeEditorConfig // io.github.linreal.cascade.editor.ui/CascadeEditorConfig.copy|copy(kotlin.Boolean;kotlin.Boolean;kotlin.Boolean;io.github.linreal.cascade.editor.CrashPolicy;kotlin.Function1?){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.ui/CascadeEditorConfig.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.ui/CascadeEditorConfig.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.ui/CascadeEditorConfig.toString|toString(){}[0] + + final object Companion { // io.github.linreal.cascade.editor.ui/CascadeEditorConfig.Companion|null[0] + final val Default // io.github.linreal.cascade.editor.ui/CascadeEditorConfig.Companion.Default|{}Default[0] + final fun (): io.github.linreal.cascade.editor.ui/CascadeEditorConfig // io.github.linreal.cascade.editor.ui/CascadeEditorConfig.Companion.Default.|(){}[0] + } +} + +final class io.github.linreal.cascade.editor.ui/LinkPopupState { // io.github.linreal.cascade.editor.ui/LinkPopupState|null[0] + constructor (kotlin/String, kotlin/String, kotlin/String?, io.github.linreal.cascade.editor.richtext/LinkValidationError?, kotlin/String?, kotlin/Boolean, kotlin/Boolean) // io.github.linreal.cascade.editor.ui/LinkPopupState.|(kotlin.String;kotlin.String;kotlin.String?;io.github.linreal.cascade.editor.richtext.LinkValidationError?;kotlin.String?;kotlin.Boolean;kotlin.Boolean){}[0] + + final val canApply // io.github.linreal.cascade.editor.ui/LinkPopupState.canApply|{}canApply[0] + final fun (): kotlin/Boolean // io.github.linreal.cascade.editor.ui/LinkPopupState.canApply.|(){}[0] + final val canRemove // io.github.linreal.cascade.editor.ui/LinkPopupState.canRemove|{}canRemove[0] + final fun (): kotlin/Boolean // io.github.linreal.cascade.editor.ui/LinkPopupState.canRemove.|(){}[0] + final val existingUrl // io.github.linreal.cascade.editor.ui/LinkPopupState.existingUrl|{}existingUrl[0] + final fun (): kotlin/String? // io.github.linreal.cascade.editor.ui/LinkPopupState.existingUrl.|(){}[0] + final val normalizedUrl // io.github.linreal.cascade.editor.ui/LinkPopupState.normalizedUrl|{}normalizedUrl[0] + final fun (): kotlin/String? // io.github.linreal.cascade.editor.ui/LinkPopupState.normalizedUrl.|(){}[0] + final val title // io.github.linreal.cascade.editor.ui/LinkPopupState.title|{}title[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.ui/LinkPopupState.title.|(){}[0] + final val url // io.github.linreal.cascade.editor.ui/LinkPopupState.url|{}url[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.ui/LinkPopupState.url.|(){}[0] + final val validationError // io.github.linreal.cascade.editor.ui/LinkPopupState.validationError|{}validationError[0] + final fun (): io.github.linreal.cascade.editor.richtext/LinkValidationError? // io.github.linreal.cascade.editor.ui/LinkPopupState.validationError.|(){}[0] + + final fun component1(): kotlin/String // io.github.linreal.cascade.editor.ui/LinkPopupState.component1|component1(){}[0] + final fun component2(): kotlin/String // io.github.linreal.cascade.editor.ui/LinkPopupState.component2|component2(){}[0] + final fun component3(): kotlin/String? // io.github.linreal.cascade.editor.ui/LinkPopupState.component3|component3(){}[0] + final fun component4(): io.github.linreal.cascade.editor.richtext/LinkValidationError? // io.github.linreal.cascade.editor.ui/LinkPopupState.component4|component4(){}[0] + final fun component5(): kotlin/String? // io.github.linreal.cascade.editor.ui/LinkPopupState.component5|component5(){}[0] + final fun component6(): kotlin/Boolean // io.github.linreal.cascade.editor.ui/LinkPopupState.component6|component6(){}[0] + final fun component7(): kotlin/Boolean // io.github.linreal.cascade.editor.ui/LinkPopupState.component7|component7(){}[0] + final fun copy(kotlin/String = ..., kotlin/String = ..., kotlin/String? = ..., io.github.linreal.cascade.editor.richtext/LinkValidationError? = ..., kotlin/String? = ..., kotlin/Boolean = ..., kotlin/Boolean = ...): io.github.linreal.cascade.editor.ui/LinkPopupState // io.github.linreal.cascade.editor.ui/LinkPopupState.copy|copy(kotlin.String;kotlin.String;kotlin.String?;io.github.linreal.cascade.editor.richtext.LinkValidationError?;kotlin.String?;kotlin.Boolean;kotlin.Boolean){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.ui/LinkPopupState.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.ui/LinkPopupState.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.ui/LinkPopupState.toString|toString(){}[0] +} + +final class io.github.linreal.cascade.editor.ui/RichTextToolbarConfig { // io.github.linreal.cascade.editor.ui/RichTextToolbarConfig|null[0] + constructor (kotlin.collections/List, kotlin/Boolean = ..., kotlin/Boolean = ...) // io.github.linreal.cascade.editor.ui/RichTextToolbarConfig.|(kotlin.collections.List;kotlin.Boolean;kotlin.Boolean){}[0] + + final val buttons // io.github.linreal.cascade.editor.ui/RichTextToolbarConfig.buttons|{}buttons[0] + final fun (): kotlin.collections/List // io.github.linreal.cascade.editor.ui/RichTextToolbarConfig.buttons.|(){}[0] + final val showIndentation // io.github.linreal.cascade.editor.ui/RichTextToolbarConfig.showIndentation|{}showIndentation[0] + final fun (): kotlin/Boolean // io.github.linreal.cascade.editor.ui/RichTextToolbarConfig.showIndentation.|(){}[0] + final val showLink // io.github.linreal.cascade.editor.ui/RichTextToolbarConfig.showLink|{}showLink[0] + final fun (): kotlin/Boolean // io.github.linreal.cascade.editor.ui/RichTextToolbarConfig.showLink.|(){}[0] + + final fun component1(): kotlin.collections/List // io.github.linreal.cascade.editor.ui/RichTextToolbarConfig.component1|component1(){}[0] + final fun component2(): kotlin/Boolean // io.github.linreal.cascade.editor.ui/RichTextToolbarConfig.component2|component2(){}[0] + final fun component3(): kotlin/Boolean // io.github.linreal.cascade.editor.ui/RichTextToolbarConfig.component3|component3(){}[0] + final fun copy(kotlin.collections/List = ..., kotlin/Boolean = ..., kotlin/Boolean = ...): io.github.linreal.cascade.editor.ui/RichTextToolbarConfig // io.github.linreal.cascade.editor.ui/RichTextToolbarConfig.copy|copy(kotlin.collections.List;kotlin.Boolean;kotlin.Boolean){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.ui/RichTextToolbarConfig.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.ui/RichTextToolbarConfig.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.ui/RichTextToolbarConfig.toString|toString(){}[0] + + final object Companion { // io.github.linreal.cascade.editor.ui/RichTextToolbarConfig.Companion|null[0] + final val Default // io.github.linreal.cascade.editor.ui/RichTextToolbarConfig.Companion.Default|{}Default[0] + final fun (): io.github.linreal.cascade.editor.ui/RichTextToolbarConfig // io.github.linreal.cascade.editor.ui/RichTextToolbarConfig.Companion.Default.|(){}[0] + } +} + +final class io.github.linreal.cascade.editor.ui/ToolbarButtonSpec { // io.github.linreal.cascade.editor.ui/ToolbarButtonSpec|null[0] + constructor (io.github.linreal.cascade.editor.core/SpanStyle, kotlin/String) // io.github.linreal.cascade.editor.ui/ToolbarButtonSpec.|(io.github.linreal.cascade.editor.core.SpanStyle;kotlin.String){}[0] + + final val label // io.github.linreal.cascade.editor.ui/ToolbarButtonSpec.label|{}label[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.ui/ToolbarButtonSpec.label.|(){}[0] + final val style // io.github.linreal.cascade.editor.ui/ToolbarButtonSpec.style|{}style[0] + final fun (): io.github.linreal.cascade.editor.core/SpanStyle // io.github.linreal.cascade.editor.ui/ToolbarButtonSpec.style.|(){}[0] + + final fun component1(): io.github.linreal.cascade.editor.core/SpanStyle // io.github.linreal.cascade.editor.ui/ToolbarButtonSpec.component1|component1(){}[0] + final fun component2(): kotlin/String // io.github.linreal.cascade.editor.ui/ToolbarButtonSpec.component2|component2(){}[0] + final fun copy(io.github.linreal.cascade.editor.core/SpanStyle = ..., kotlin/String = ...): io.github.linreal.cascade.editor.ui/ToolbarButtonSpec // io.github.linreal.cascade.editor.ui/ToolbarButtonSpec.copy|copy(io.github.linreal.cascade.editor.core.SpanStyle;kotlin.String){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.ui/ToolbarButtonSpec.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.ui/ToolbarButtonSpec.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.ui/ToolbarButtonSpec.toString|toString(){}[0] +} + +final class io.github.linreal.cascade.editor/CascadeError { // io.github.linreal.cascade.editor/CascadeError|null[0] + constructor (kotlin/String, kotlin/Throwable) // io.github.linreal.cascade.editor/CascadeError.|(kotlin.String;kotlin.Throwable){}[0] + + final val cause // io.github.linreal.cascade.editor/CascadeError.cause|{}cause[0] + final fun (): kotlin/Throwable // io.github.linreal.cascade.editor/CascadeError.cause.|(){}[0] + final val context // io.github.linreal.cascade.editor/CascadeError.context|{}context[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor/CascadeError.context.|(){}[0] + + final fun component1(): kotlin/String // io.github.linreal.cascade.editor/CascadeError.component1|component1(){}[0] + final fun component2(): kotlin/Throwable // io.github.linreal.cascade.editor/CascadeError.component2|component2(){}[0] + final fun copy(kotlin/String = ..., kotlin/Throwable = ...): io.github.linreal.cascade.editor/CascadeError // io.github.linreal.cascade.editor/CascadeError.copy|copy(kotlin.String;kotlin.Throwable){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor/CascadeError.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor/CascadeError.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor/CascadeError.toString|toString(){}[0] +} + +final value class io.github.linreal.cascade.editor.core/BlockId { // io.github.linreal.cascade.editor.core/BlockId|null[0] + constructor (kotlin/String) // io.github.linreal.cascade.editor.core/BlockId.|(kotlin.String){}[0] + + final val value // io.github.linreal.cascade.editor.core/BlockId.value|{}value[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.core/BlockId.value.|(){}[0] + + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.core/BlockId.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.core/BlockId.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.core/BlockId.toString|toString(){}[0] + + final object Companion { // io.github.linreal.cascade.editor.core/BlockId.Companion|null[0] + final fun generate(): io.github.linreal.cascade.editor.core/BlockId // io.github.linreal.cascade.editor.core/BlockId.Companion.generate|generate(){}[0] + } +} + +final value class io.github.linreal.cascade.editor.slash/SlashCommandIconKey { // io.github.linreal.cascade.editor.slash/SlashCommandIconKey|null[0] + constructor (kotlin/String) // io.github.linreal.cascade.editor.slash/SlashCommandIconKey.|(kotlin.String){}[0] + + final val value // io.github.linreal.cascade.editor.slash/SlashCommandIconKey.value|{}value[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.slash/SlashCommandIconKey.value.|(){}[0] + + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.slash/SlashCommandIconKey.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.slash/SlashCommandIconKey.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.slash/SlashCommandIconKey.toString|toString(){}[0] +} + +final value class io.github.linreal.cascade.editor.slash/SlashCommandId { // io.github.linreal.cascade.editor.slash/SlashCommandId|null[0] + constructor (kotlin/String) // io.github.linreal.cascade.editor.slash/SlashCommandId.|(kotlin.String){}[0] + + final val value // io.github.linreal.cascade.editor.slash/SlashCommandId.value|{}value[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.slash/SlashCommandId.value.|(){}[0] + + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.slash/SlashCommandId.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.slash/SlashCommandId.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.slash/SlashCommandId.toString|toString(){}[0] +} + +open class io.github.linreal.cascade.editor.registry/DefaultBlockCallbacks : io.github.linreal.cascade.editor.registry/BlockCallbacks { // io.github.linreal.cascade.editor.registry/DefaultBlockCallbacks|null[0] + constructor (kotlin/Function1, kotlin/Function0? = ..., io.github.linreal.cascade.editor.state/BlockTextStates? = ..., io.github.linreal.cascade.editor.state/BlockSpanStates? = ..., io.github.linreal.cascade.editor.state/EditorStateHolder? = ...) // io.github.linreal.cascade.editor.registry/DefaultBlockCallbacks.|(kotlin.Function1;kotlin.Function0?;io.github.linreal.cascade.editor.state.BlockTextStates?;io.github.linreal.cascade.editor.state.BlockSpanStates?;io.github.linreal.cascade.editor.state.EditorStateHolder?){}[0] + + open fun dispatch(io.github.linreal.cascade.editor.action/EditorAction) // io.github.linreal.cascade.editor.registry/DefaultBlockCallbacks.dispatch|dispatch(io.github.linreal.cascade.editor.action.EditorAction){}[0] + open fun onBackspaceAtStart(io.github.linreal.cascade.editor.core/BlockId) // io.github.linreal.cascade.editor.registry/DefaultBlockCallbacks.onBackspaceAtStart|onBackspaceAtStart(io.github.linreal.cascade.editor.core.BlockId){}[0] + open fun onClick(io.github.linreal.cascade.editor.core/BlockId) // io.github.linreal.cascade.editor.registry/DefaultBlockCallbacks.onClick|onClick(io.github.linreal.cascade.editor.core.BlockId){}[0] + open fun onDeleteAtEnd(io.github.linreal.cascade.editor.core/BlockId) // io.github.linreal.cascade.editor.registry/DefaultBlockCallbacks.onDeleteAtEnd|onDeleteAtEnd(io.github.linreal.cascade.editor.core.BlockId){}[0] + open fun onDragStart(io.github.linreal.cascade.editor.core/BlockId, kotlin/Float) // io.github.linreal.cascade.editor.registry/DefaultBlockCallbacks.onDragStart|onDragStart(io.github.linreal.cascade.editor.core.BlockId;kotlin.Float){}[0] + open fun onEnter(io.github.linreal.cascade.editor.core/BlockId, kotlin/Int) // io.github.linreal.cascade.editor.registry/DefaultBlockCallbacks.onEnter|onEnter(io.github.linreal.cascade.editor.core.BlockId;kotlin.Int){}[0] + open fun onFocus(io.github.linreal.cascade.editor.core/BlockId) // io.github.linreal.cascade.editor.registry/DefaultBlockCallbacks.onFocus|onFocus(io.github.linreal.cascade.editor.core.BlockId){}[0] + open fun onLongClick(io.github.linreal.cascade.editor.core/BlockId) // io.github.linreal.cascade.editor.registry/DefaultBlockCallbacks.onLongClick|onLongClick(io.github.linreal.cascade.editor.core.BlockId){}[0] + open fun onSlashCommand(io.github.linreal.cascade.editor.core/BlockId, io.github.linreal.cascade.editor.state/SlashQueryRange, kotlin/String) // io.github.linreal.cascade.editor.registry/DefaultBlockCallbacks.onSlashCommand|onSlashCommand(io.github.linreal.cascade.editor.core.BlockId;io.github.linreal.cascade.editor.state.SlashQueryRange;kotlin.String){}[0] +} + +sealed class io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning { // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning|null[0] + abstract val charOffset // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.charOffset|{}charOffset[0] + abstract fun (): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.charOffset.|(){}[0] + + final class BlockInInlineContext : io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning { // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.BlockInInlineContext|null[0] + constructor (kotlin/String, kotlin/Int) // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.BlockInInlineContext.|(kotlin.String;kotlin.Int){}[0] + + final val charOffset // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.BlockInInlineContext.charOffset|{}charOffset[0] + final fun (): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.BlockInInlineContext.charOffset.|(){}[0] + final val tag // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.BlockInInlineContext.tag|{}tag[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.BlockInInlineContext.tag.|(){}[0] + + final fun component1(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.BlockInInlineContext.component1|component1(){}[0] + final fun component2(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.BlockInInlineContext.component2|component2(){}[0] + final fun copy(kotlin/String = ..., kotlin/Int = ...): io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.BlockInInlineContext // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.BlockInInlineContext.copy|copy(kotlin.String;kotlin.Int){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.BlockInInlineContext.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.BlockInInlineContext.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.BlockInInlineContext.toString|toString(){}[0] + } + + final class DecoderException : io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning { // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.DecoderException|null[0] + constructor (kotlin/String?, kotlin/String, kotlin/Int) // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.DecoderException.|(kotlin.String?;kotlin.String;kotlin.Int){}[0] + + final val charOffset // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.DecoderException.charOffset|{}charOffset[0] + final fun (): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.DecoderException.charOffset.|(){}[0] + final val message // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.DecoderException.message|{}message[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.DecoderException.message.|(){}[0] + final val tag // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.DecoderException.tag|{}tag[0] + final fun (): kotlin/String? // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.DecoderException.tag.|(){}[0] + + final fun component1(): kotlin/String? // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.DecoderException.component1|component1(){}[0] + final fun component2(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.DecoderException.component2|component2(){}[0] + final fun component3(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.DecoderException.component3|component3(){}[0] + final fun copy(kotlin/String? = ..., kotlin/String = ..., kotlin/Int = ...): io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.DecoderException // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.DecoderException.copy|copy(kotlin.String?;kotlin.String;kotlin.Int){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.DecoderException.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.DecoderException.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.DecoderException.toString|toString(){}[0] + } + + final class DroppedAttribute : io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning { // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.DroppedAttribute|null[0] + constructor (kotlin/String, kotlin/String, kotlin/String, kotlin/Int) // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.DroppedAttribute.|(kotlin.String;kotlin.String;kotlin.String;kotlin.Int){}[0] + + final val attr // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.DroppedAttribute.attr|{}attr[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.DroppedAttribute.attr.|(){}[0] + final val charOffset // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.DroppedAttribute.charOffset|{}charOffset[0] + final fun (): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.DroppedAttribute.charOffset.|(){}[0] + final val reason // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.DroppedAttribute.reason|{}reason[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.DroppedAttribute.reason.|(){}[0] + final val tag // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.DroppedAttribute.tag|{}tag[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.DroppedAttribute.tag.|(){}[0] + + final fun component1(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.DroppedAttribute.component1|component1(){}[0] + final fun component2(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.DroppedAttribute.component2|component2(){}[0] + final fun component3(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.DroppedAttribute.component3|component3(){}[0] + final fun component4(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.DroppedAttribute.component4|component4(){}[0] + final fun copy(kotlin/String = ..., kotlin/String = ..., kotlin/String = ..., kotlin/Int = ...): io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.DroppedAttribute // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.DroppedAttribute.copy|copy(kotlin.String;kotlin.String;kotlin.String;kotlin.Int){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.DroppedAttribute.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.DroppedAttribute.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.DroppedAttribute.toString|toString(){}[0] + } + + final class DroppedContent : io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning { // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.DroppedContent|null[0] + constructor (kotlin/String, kotlin/Int) // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.DroppedContent.|(kotlin.String;kotlin.Int){}[0] + + final val charOffset // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.DroppedContent.charOffset|{}charOffset[0] + final fun (): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.DroppedContent.charOffset.|(){}[0] + final val reason // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.DroppedContent.reason|{}reason[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.DroppedContent.reason.|(){}[0] + + final fun component1(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.DroppedContent.component1|component1(){}[0] + final fun component2(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.DroppedContent.component2|component2(){}[0] + final fun copy(kotlin/String = ..., kotlin/Int = ...): io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.DroppedContent // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.DroppedContent.copy|copy(kotlin.String;kotlin.Int){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.DroppedContent.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.DroppedContent.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.DroppedContent.toString|toString(){}[0] + } + + final class InputLimitExceeded : io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning { // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.InputLimitExceeded|null[0] + constructor (kotlin/Int, kotlin/Int, kotlin/Int = ...) // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.InputLimitExceeded.|(kotlin.Int;kotlin.Int;kotlin.Int){}[0] + + final val actual // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.InputLimitExceeded.actual|{}actual[0] + final fun (): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.InputLimitExceeded.actual.|(){}[0] + final val charOffset // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.InputLimitExceeded.charOffset|{}charOffset[0] + final fun (): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.InputLimitExceeded.charOffset.|(){}[0] + final val limit // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.InputLimitExceeded.limit|{}limit[0] + final fun (): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.InputLimitExceeded.limit.|(){}[0] + + final fun component1(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.InputLimitExceeded.component1|component1(){}[0] + final fun component2(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.InputLimitExceeded.component2|component2(){}[0] + final fun component3(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.InputLimitExceeded.component3|component3(){}[0] + final fun copy(kotlin/Int = ..., kotlin/Int = ..., kotlin/Int = ...): io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.InputLimitExceeded // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.InputLimitExceeded.copy|copy(kotlin.Int;kotlin.Int;kotlin.Int){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.InputLimitExceeded.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.InputLimitExceeded.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.InputLimitExceeded.toString|toString(){}[0] + } + + final class InvalidAttribute : io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning { // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.InvalidAttribute|null[0] + constructor (kotlin/String, kotlin/String, kotlin/String, kotlin/String, kotlin/Int) // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.InvalidAttribute.|(kotlin.String;kotlin.String;kotlin.String;kotlin.String;kotlin.Int){}[0] + + final val attr // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.InvalidAttribute.attr|{}attr[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.InvalidAttribute.attr.|(){}[0] + final val charOffset // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.InvalidAttribute.charOffset|{}charOffset[0] + final fun (): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.InvalidAttribute.charOffset.|(){}[0] + final val reason // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.InvalidAttribute.reason|{}reason[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.InvalidAttribute.reason.|(){}[0] + final val tag // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.InvalidAttribute.tag|{}tag[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.InvalidAttribute.tag.|(){}[0] + final val value // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.InvalidAttribute.value|{}value[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.InvalidAttribute.value.|(){}[0] + + final fun component1(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.InvalidAttribute.component1|component1(){}[0] + final fun component2(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.InvalidAttribute.component2|component2(){}[0] + final fun component3(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.InvalidAttribute.component3|component3(){}[0] + final fun component4(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.InvalidAttribute.component4|component4(){}[0] + final fun component5(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.InvalidAttribute.component5|component5(){}[0] + final fun copy(kotlin/String = ..., kotlin/String = ..., kotlin/String = ..., kotlin/String = ..., kotlin/Int = ...): io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.InvalidAttribute // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.InvalidAttribute.copy|copy(kotlin.String;kotlin.String;kotlin.String;kotlin.String;kotlin.Int){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.InvalidAttribute.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.InvalidAttribute.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.InvalidAttribute.toString|toString(){}[0] + } + + final class MismatchedNesting : io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning { // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.MismatchedNesting|null[0] + constructor (kotlin/String, kotlin/String, kotlin/Int) // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.MismatchedNesting.|(kotlin.String;kotlin.String;kotlin.Int){}[0] + + final val charOffset // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.MismatchedNesting.charOffset|{}charOffset[0] + final fun (): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.MismatchedNesting.charOffset.|(){}[0] + final val expected // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.MismatchedNesting.expected|{}expected[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.MismatchedNesting.expected.|(){}[0] + final val found // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.MismatchedNesting.found|{}found[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.MismatchedNesting.found.|(){}[0] + + final fun component1(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.MismatchedNesting.component1|component1(){}[0] + final fun component2(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.MismatchedNesting.component2|component2(){}[0] + final fun component3(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.MismatchedNesting.component3|component3(){}[0] + final fun copy(kotlin/String = ..., kotlin/String = ..., kotlin/Int = ...): io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.MismatchedNesting // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.MismatchedNesting.copy|copy(kotlin.String;kotlin.String;kotlin.Int){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.MismatchedNesting.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.MismatchedNesting.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.MismatchedNesting.toString|toString(){}[0] + } + + final class StrayClosingTag : io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning { // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.StrayClosingTag|null[0] + constructor (kotlin/String, kotlin/Int) // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.StrayClosingTag.|(kotlin.String;kotlin.Int){}[0] + + final val charOffset // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.StrayClosingTag.charOffset|{}charOffset[0] + final fun (): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.StrayClosingTag.charOffset.|(){}[0] + final val tag // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.StrayClosingTag.tag|{}tag[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.StrayClosingTag.tag.|(){}[0] + + final fun component1(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.StrayClosingTag.component1|component1(){}[0] + final fun component2(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.StrayClosingTag.component2|component2(){}[0] + final fun copy(kotlin/String = ..., kotlin/Int = ...): io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.StrayClosingTag // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.StrayClosingTag.copy|copy(kotlin.String;kotlin.Int){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.StrayClosingTag.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.StrayClosingTag.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.StrayClosingTag.toString|toString(){}[0] + } + + final class UnclosedTag : io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning { // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.UnclosedTag|null[0] + constructor (kotlin/String, kotlin/Int) // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.UnclosedTag.|(kotlin.String;kotlin.Int){}[0] + + final val charOffset // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.UnclosedTag.charOffset|{}charOffset[0] + final fun (): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.UnclosedTag.charOffset.|(){}[0] + final val tag // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.UnclosedTag.tag|{}tag[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.UnclosedTag.tag.|(){}[0] + + final fun component1(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.UnclosedTag.component1|component1(){}[0] + final fun component2(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.UnclosedTag.component2|component2(){}[0] + final fun copy(kotlin/String = ..., kotlin/Int = ...): io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.UnclosedTag // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.UnclosedTag.copy|copy(kotlin.String;kotlin.Int){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.UnclosedTag.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.UnclosedTag.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.UnclosedTag.toString|toString(){}[0] + } + + final class UnknownAttribute : io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning { // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.UnknownAttribute|null[0] + constructor (kotlin/String, kotlin/String, kotlin/Int) // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.UnknownAttribute.|(kotlin.String;kotlin.String;kotlin.Int){}[0] + + final val attr // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.UnknownAttribute.attr|{}attr[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.UnknownAttribute.attr.|(){}[0] + final val charOffset // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.UnknownAttribute.charOffset|{}charOffset[0] + final fun (): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.UnknownAttribute.charOffset.|(){}[0] + final val tag // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.UnknownAttribute.tag|{}tag[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.UnknownAttribute.tag.|(){}[0] + + final fun component1(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.UnknownAttribute.component1|component1(){}[0] + final fun component2(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.UnknownAttribute.component2|component2(){}[0] + final fun component3(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.UnknownAttribute.component3|component3(){}[0] + final fun copy(kotlin/String = ..., kotlin/String = ..., kotlin/Int = ...): io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.UnknownAttribute // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.UnknownAttribute.copy|copy(kotlin.String;kotlin.String;kotlin.Int){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.UnknownAttribute.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.UnknownAttribute.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.UnknownAttribute.toString|toString(){}[0] + } + + final class UnknownTag : io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning { // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.UnknownTag|null[0] + constructor (kotlin/String, kotlin/Int) // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.UnknownTag.|(kotlin.String;kotlin.Int){}[0] + + final val charOffset // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.UnknownTag.charOffset|{}charOffset[0] + final fun (): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.UnknownTag.charOffset.|(){}[0] + final val tag // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.UnknownTag.tag|{}tag[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.UnknownTag.tag.|(){}[0] + + final fun component1(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.UnknownTag.component1|component1(){}[0] + final fun component2(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.UnknownTag.component2|component2(){}[0] + final fun copy(kotlin/String = ..., kotlin/Int = ...): io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.UnknownTag // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.UnknownTag.copy|copy(kotlin.String;kotlin.Int){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.UnknownTag.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.UnknownTag.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning.UnknownTag.toString|toString(){}[0] + } +} + +sealed class io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeWarning { // io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeWarning|null[0] + final class DroppedAttribute : io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeWarning { // io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeWarning.DroppedAttribute|null[0] + constructor (kotlin/String, kotlin/String, kotlin/String) // io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeWarning.DroppedAttribute.|(kotlin.String;kotlin.String;kotlin.String){}[0] + + final val attr // io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeWarning.DroppedAttribute.attr|{}attr[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeWarning.DroppedAttribute.attr.|(){}[0] + final val reason // io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeWarning.DroppedAttribute.reason|{}reason[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeWarning.DroppedAttribute.reason.|(){}[0] + final val typeId // io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeWarning.DroppedAttribute.typeId|{}typeId[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeWarning.DroppedAttribute.typeId.|(){}[0] + + final fun component1(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeWarning.DroppedAttribute.component1|component1(){}[0] + final fun component2(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeWarning.DroppedAttribute.component2|component2(){}[0] + final fun component3(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeWarning.DroppedAttribute.component3|component3(){}[0] + final fun copy(kotlin/String = ..., kotlin/String = ..., kotlin/String = ...): io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeWarning.DroppedAttribute // io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeWarning.DroppedAttribute.copy|copy(kotlin.String;kotlin.String;kotlin.String){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeWarning.DroppedAttribute.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeWarning.DroppedAttribute.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeWarning.DroppedAttribute.toString|toString(){}[0] + } + + final class EncoderException : io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeWarning { // io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeWarning.EncoderException|null[0] + constructor (kotlin/String?, kotlin/String) // io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeWarning.EncoderException.|(kotlin.String?;kotlin.String){}[0] + + final val message // io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeWarning.EncoderException.message|{}message[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeWarning.EncoderException.message.|(){}[0] + final val typeId // io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeWarning.EncoderException.typeId|{}typeId[0] + final fun (): kotlin/String? // io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeWarning.EncoderException.typeId.|(){}[0] + + final fun component1(): kotlin/String? // io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeWarning.EncoderException.component1|component1(){}[0] + final fun component2(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeWarning.EncoderException.component2|component2(){}[0] + final fun copy(kotlin/String? = ..., kotlin/String = ...): io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeWarning.EncoderException // io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeWarning.EncoderException.copy|copy(kotlin.String?;kotlin.String){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeWarning.EncoderException.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeWarning.EncoderException.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeWarning.EncoderException.toString|toString(){}[0] + } +} + +sealed class io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning { // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning|null[0] + final class DocumentParseFailed : io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning { // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.DocumentParseFailed|null[0] + constructor (kotlin/String) // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.DocumentParseFailed.|(kotlin.String){}[0] + + final val reason // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.DocumentParseFailed.reason|{}reason[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.DocumentParseFailed.reason.|(){}[0] + + final fun component1(): kotlin/String // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.DocumentParseFailed.component1|component1(){}[0] + final fun copy(kotlin/String = ...): io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.DocumentParseFailed // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.DocumentParseFailed.copy|copy(kotlin.String){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.DocumentParseFailed.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.DocumentParseFailed.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.DocumentParseFailed.toString|toString(){}[0] + } + + final class DuplicateIdRegenerated : io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning { // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.DuplicateIdRegenerated|null[0] + constructor (kotlin/Int, kotlin/String, kotlin/String) // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.DuplicateIdRegenerated.|(kotlin.Int;kotlin.String;kotlin.String){}[0] + + final val blockIndex // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.DuplicateIdRegenerated.blockIndex|{}blockIndex[0] + final fun (): kotlin/Int // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.DuplicateIdRegenerated.blockIndex.|(){}[0] + final val newId // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.DuplicateIdRegenerated.newId|{}newId[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.DuplicateIdRegenerated.newId.|(){}[0] + final val originalId // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.DuplicateIdRegenerated.originalId|{}originalId[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.DuplicateIdRegenerated.originalId.|(){}[0] + + final fun component1(): kotlin/Int // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.DuplicateIdRegenerated.component1|component1(){}[0] + final fun component2(): kotlin/String // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.DuplicateIdRegenerated.component2|component2(){}[0] + final fun component3(): kotlin/String // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.DuplicateIdRegenerated.component3|component3(){}[0] + final fun copy(kotlin/Int = ..., kotlin/String = ..., kotlin/String = ...): io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.DuplicateIdRegenerated // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.DuplicateIdRegenerated.copy|copy(kotlin.Int;kotlin.String;kotlin.String){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.DuplicateIdRegenerated.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.DuplicateIdRegenerated.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.DuplicateIdRegenerated.toString|toString(){}[0] + } + + final class InvalidBlockAttributeParam : io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning { // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.InvalidBlockAttributeParam|null[0] + constructor (kotlin/Int, kotlin/String, kotlin/String) // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.InvalidBlockAttributeParam.|(kotlin.Int;kotlin.String;kotlin.String){}[0] + + final val blockIndex // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.InvalidBlockAttributeParam.blockIndex|{}blockIndex[0] + final fun (): kotlin/Int // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.InvalidBlockAttributeParam.blockIndex.|(){}[0] + final val fallback // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.InvalidBlockAttributeParam.fallback|{}fallback[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.InvalidBlockAttributeParam.fallback.|(){}[0] + final val param // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.InvalidBlockAttributeParam.param|{}param[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.InvalidBlockAttributeParam.param.|(){}[0] + + final fun component1(): kotlin/Int // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.InvalidBlockAttributeParam.component1|component1(){}[0] + final fun component2(): kotlin/String // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.InvalidBlockAttributeParam.component2|component2(){}[0] + final fun component3(): kotlin/String // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.InvalidBlockAttributeParam.component3|component3(){}[0] + final fun copy(kotlin/Int = ..., kotlin/String = ..., kotlin/String = ...): io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.InvalidBlockAttributeParam // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.InvalidBlockAttributeParam.copy|copy(kotlin.Int;kotlin.String;kotlin.String){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.InvalidBlockAttributeParam.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.InvalidBlockAttributeParam.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.InvalidBlockAttributeParam.toString|toString(){}[0] + } + + final class InvalidBlockTypeParam : io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning { // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.InvalidBlockTypeParam|null[0] + constructor (kotlin/Int, kotlin/String, kotlin/String, kotlin/String) // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.InvalidBlockTypeParam.|(kotlin.Int;kotlin.String;kotlin.String;kotlin.String){}[0] + + final val blockIndex // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.InvalidBlockTypeParam.blockIndex|{}blockIndex[0] + final fun (): kotlin/Int // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.InvalidBlockTypeParam.blockIndex.|(){}[0] + final val fallback // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.InvalidBlockTypeParam.fallback|{}fallback[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.InvalidBlockTypeParam.fallback.|(){}[0] + final val param // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.InvalidBlockTypeParam.param|{}param[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.InvalidBlockTypeParam.param.|(){}[0] + final val typeId // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.InvalidBlockTypeParam.typeId|{}typeId[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.InvalidBlockTypeParam.typeId.|(){}[0] + + final fun component1(): kotlin/Int // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.InvalidBlockTypeParam.component1|component1(){}[0] + final fun component2(): kotlin/String // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.InvalidBlockTypeParam.component2|component2(){}[0] + final fun component3(): kotlin/String // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.InvalidBlockTypeParam.component3|component3(){}[0] + final fun component4(): kotlin/String // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.InvalidBlockTypeParam.component4|component4(){}[0] + final fun copy(kotlin/Int = ..., kotlin/String = ..., kotlin/String = ..., kotlin/String = ...): io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.InvalidBlockTypeParam // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.InvalidBlockTypeParam.copy|copy(kotlin.Int;kotlin.String;kotlin.String;kotlin.String){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.InvalidBlockTypeParam.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.InvalidBlockTypeParam.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.InvalidBlockTypeParam.toString|toString(){}[0] + } + + final class MalformedBlockSkipped : io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning { // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.MalformedBlockSkipped|null[0] + constructor (kotlin/Int, kotlin/String) // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.MalformedBlockSkipped.|(kotlin.Int;kotlin.String){}[0] + + final val blockIndex // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.MalformedBlockSkipped.blockIndex|{}blockIndex[0] + final fun (): kotlin/Int // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.MalformedBlockSkipped.blockIndex.|(){}[0] + final val reason // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.MalformedBlockSkipped.reason|{}reason[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.MalformedBlockSkipped.reason.|(){}[0] + + final fun component1(): kotlin/Int // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.MalformedBlockSkipped.component1|component1(){}[0] + final fun component2(): kotlin/String // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.MalformedBlockSkipped.component2|component2(){}[0] + final fun copy(kotlin/Int = ..., kotlin/String = ...): io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.MalformedBlockSkipped // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.MalformedBlockSkipped.copy|copy(kotlin.Int;kotlin.String){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.MalformedBlockSkipped.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.MalformedBlockSkipped.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.MalformedBlockSkipped.toString|toString(){}[0] + } + + final class MissingIdRegenerated : io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning { // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.MissingIdRegenerated|null[0] + constructor (kotlin/Int) // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.MissingIdRegenerated.|(kotlin.Int){}[0] + + final val blockIndex // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.MissingIdRegenerated.blockIndex|{}blockIndex[0] + final fun (): kotlin/Int // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.MissingIdRegenerated.blockIndex.|(){}[0] + + final fun component1(): kotlin/Int // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.MissingIdRegenerated.component1|component1(){}[0] + final fun copy(kotlin/Int = ...): io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.MissingIdRegenerated // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.MissingIdRegenerated.copy|copy(kotlin.Int){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.MissingIdRegenerated.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.MissingIdRegenerated.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.MissingIdRegenerated.toString|toString(){}[0] + } + + final class UnknownBlockTypePreserved : io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning { // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.UnknownBlockTypePreserved|null[0] + constructor (kotlin/Int, kotlin/String) // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.UnknownBlockTypePreserved.|(kotlin.Int;kotlin.String){}[0] + + final val blockIndex // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.UnknownBlockTypePreserved.blockIndex|{}blockIndex[0] + final fun (): kotlin/Int // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.UnknownBlockTypePreserved.blockIndex.|(){}[0] + final val typeId // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.UnknownBlockTypePreserved.typeId|{}typeId[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.UnknownBlockTypePreserved.typeId.|(){}[0] + + final fun component1(): kotlin/Int // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.UnknownBlockTypePreserved.component1|component1(){}[0] + final fun component2(): kotlin/String // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.UnknownBlockTypePreserved.component2|component2(){}[0] + final fun copy(kotlin/Int = ..., kotlin/String = ...): io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.UnknownBlockTypePreserved // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.UnknownBlockTypePreserved.copy|copy(kotlin.Int;kotlin.String){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.UnknownBlockTypePreserved.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.UnknownBlockTypePreserved.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.UnknownBlockTypePreserved.toString|toString(){}[0] + } + + final class UnknownContentKind : io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning { // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.UnknownContentKind|null[0] + constructor (kotlin/Int, kotlin/String) // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.UnknownContentKind.|(kotlin.Int;kotlin.String){}[0] + + final val blockIndex // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.UnknownContentKind.blockIndex|{}blockIndex[0] + final fun (): kotlin/Int // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.UnknownContentKind.blockIndex.|(){}[0] + final val kind // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.UnknownContentKind.kind|{}kind[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.UnknownContentKind.kind.|(){}[0] + + final fun component1(): kotlin/Int // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.UnknownContentKind.component1|component1(){}[0] + final fun component2(): kotlin/String // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.UnknownContentKind.component2|component2(){}[0] + final fun copy(kotlin/Int = ..., kotlin/String = ...): io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.UnknownContentKind // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.UnknownContentKind.copy|copy(kotlin.Int;kotlin.String){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.UnknownContentKind.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.UnknownContentKind.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.UnknownContentKind.toString|toString(){}[0] + } + + final class UnsupportedCustomDataDropped : io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning { // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.UnsupportedCustomDataDropped|null[0] + constructor (kotlin/Int, kotlin/String, kotlin/String) // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.UnsupportedCustomDataDropped.|(kotlin.Int;kotlin.String;kotlin.String){}[0] + + final val blockIndex // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.UnsupportedCustomDataDropped.blockIndex|{}blockIndex[0] + final fun (): kotlin/Int // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.UnsupportedCustomDataDropped.blockIndex.|(){}[0] + final val key // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.UnsupportedCustomDataDropped.key|{}key[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.UnsupportedCustomDataDropped.key.|(){}[0] + final val valueType // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.UnsupportedCustomDataDropped.valueType|{}valueType[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.UnsupportedCustomDataDropped.valueType.|(){}[0] + + final fun component1(): kotlin/Int // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.UnsupportedCustomDataDropped.component1|component1(){}[0] + final fun component2(): kotlin/String // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.UnsupportedCustomDataDropped.component2|component2(){}[0] + final fun component3(): kotlin/String // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.UnsupportedCustomDataDropped.component3|component3(){}[0] + final fun copy(kotlin/Int = ..., kotlin/String = ..., kotlin/String = ...): io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.UnsupportedCustomDataDropped // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.UnsupportedCustomDataDropped.copy|copy(kotlin.Int;kotlin.String;kotlin.String){}[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.UnsupportedCustomDataDropped.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.UnsupportedCustomDataDropped.hashCode|hashCode(){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.UnsupportedCustomDataDropped.toString|toString(){}[0] + } +} + +final object io.github.linreal.cascade.editor.action/CancelDrag : io.github.linreal.cascade.editor.action/EditorAction { // io.github.linreal.cascade.editor.action/CancelDrag|null[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.action/CancelDrag.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.action/CancelDrag.hashCode|hashCode(){}[0] + final fun reduce(io.github.linreal.cascade.editor.state/EditorState): io.github.linreal.cascade.editor.state/EditorState // io.github.linreal.cascade.editor.action/CancelDrag.reduce|reduce(io.github.linreal.cascade.editor.state.EditorState){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.action/CancelDrag.toString|toString(){}[0] +} + +final object io.github.linreal.cascade.editor.action/ClearFocus : io.github.linreal.cascade.editor.action/EditorAction { // io.github.linreal.cascade.editor.action/ClearFocus|null[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.action/ClearFocus.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.action/ClearFocus.hashCode|hashCode(){}[0] + final fun reduce(io.github.linreal.cascade.editor.state/EditorState): io.github.linreal.cascade.editor.state/EditorState // io.github.linreal.cascade.editor.action/ClearFocus.reduce|reduce(io.github.linreal.cascade.editor.state.EditorState){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.action/ClearFocus.toString|toString(){}[0] +} + +final object io.github.linreal.cascade.editor.action/ClearSelection : io.github.linreal.cascade.editor.action/EditorAction { // io.github.linreal.cascade.editor.action/ClearSelection|null[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.action/ClearSelection.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.action/ClearSelection.hashCode|hashCode(){}[0] + final fun reduce(io.github.linreal.cascade.editor.state/EditorState): io.github.linreal.cascade.editor.state/EditorState // io.github.linreal.cascade.editor.action/ClearSelection.reduce|reduce(io.github.linreal.cascade.editor.state.EditorState){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.action/ClearSelection.toString|toString(){}[0] +} + +final object io.github.linreal.cascade.editor.action/CloseSlashCommand : io.github.linreal.cascade.editor.action/EditorAction { // io.github.linreal.cascade.editor.action/CloseSlashCommand|null[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.action/CloseSlashCommand.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.action/CloseSlashCommand.hashCode|hashCode(){}[0] + final fun reduce(io.github.linreal.cascade.editor.state/EditorState): io.github.linreal.cascade.editor.state/EditorState // io.github.linreal.cascade.editor.action/CloseSlashCommand.reduce|reduce(io.github.linreal.cascade.editor.state.EditorState){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.action/CloseSlashCommand.toString|toString(){}[0] +} + +final object io.github.linreal.cascade.editor.action/CompleteDrag : io.github.linreal.cascade.editor.action/EditorAction { // io.github.linreal.cascade.editor.action/CompleteDrag|null[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.action/CompleteDrag.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.action/CompleteDrag.hashCode|hashCode(){}[0] + final fun reduce(io.github.linreal.cascade.editor.state/EditorState): io.github.linreal.cascade.editor.state/EditorState // io.github.linreal.cascade.editor.action/CompleteDrag.reduce|reduce(io.github.linreal.cascade.editor.state.EditorState){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.action/CompleteDrag.toString|toString(){}[0] +} + +final object io.github.linreal.cascade.editor.action/DeleteSelectedOrFocused : io.github.linreal.cascade.editor.action/EditorAction { // io.github.linreal.cascade.editor.action/DeleteSelectedOrFocused|null[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.action/DeleteSelectedOrFocused.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.action/DeleteSelectedOrFocused.hashCode|hashCode(){}[0] + final fun reduce(io.github.linreal.cascade.editor.state/EditorState): io.github.linreal.cascade.editor.state/EditorState // io.github.linreal.cascade.editor.action/DeleteSelectedOrFocused.reduce|reduce(io.github.linreal.cascade.editor.state.EditorState){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.action/DeleteSelectedOrFocused.toString|toString(){}[0] +} + +final object io.github.linreal.cascade.editor.action/FocusNextBlock : io.github.linreal.cascade.editor.action/EditorAction { // io.github.linreal.cascade.editor.action/FocusNextBlock|null[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.action/FocusNextBlock.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.action/FocusNextBlock.hashCode|hashCode(){}[0] + final fun reduce(io.github.linreal.cascade.editor.state/EditorState): io.github.linreal.cascade.editor.state/EditorState // io.github.linreal.cascade.editor.action/FocusNextBlock.reduce|reduce(io.github.linreal.cascade.editor.state.EditorState){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.action/FocusNextBlock.toString|toString(){}[0] +} + +final object io.github.linreal.cascade.editor.action/FocusPreviousBlock : io.github.linreal.cascade.editor.action/EditorAction { // io.github.linreal.cascade.editor.action/FocusPreviousBlock|null[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.action/FocusPreviousBlock.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.action/FocusPreviousBlock.hashCode|hashCode(){}[0] + final fun reduce(io.github.linreal.cascade.editor.state/EditorState): io.github.linreal.cascade.editor.state/EditorState // io.github.linreal.cascade.editor.action/FocusPreviousBlock.reduce|reduce(io.github.linreal.cascade.editor.state.EditorState){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.action/FocusPreviousBlock.toString|toString(){}[0] +} + +final object io.github.linreal.cascade.editor.action/IndentBackward : io.github.linreal.cascade.editor.action/EditorAction { // io.github.linreal.cascade.editor.action/IndentBackward|null[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.action/IndentBackward.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.action/IndentBackward.hashCode|hashCode(){}[0] + final fun reduce(io.github.linreal.cascade.editor.state/EditorState): io.github.linreal.cascade.editor.state/EditorState // io.github.linreal.cascade.editor.action/IndentBackward.reduce|reduce(io.github.linreal.cascade.editor.state.EditorState){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.action/IndentBackward.toString|toString(){}[0] +} + +final object io.github.linreal.cascade.editor.action/IndentForward : io.github.linreal.cascade.editor.action/EditorAction { // io.github.linreal.cascade.editor.action/IndentForward|null[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.action/IndentForward.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.action/IndentForward.hashCode|hashCode(){}[0] + final fun reduce(io.github.linreal.cascade.editor.state/EditorState): io.github.linreal.cascade.editor.state/EditorState // io.github.linreal.cascade.editor.action/IndentForward.reduce|reduce(io.github.linreal.cascade.editor.state.EditorState){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.action/IndentForward.toString|toString(){}[0] +} + +final object io.github.linreal.cascade.editor.action/NavigateSlashBack : io.github.linreal.cascade.editor.action/EditorAction { // io.github.linreal.cascade.editor.action/NavigateSlashBack|null[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.action/NavigateSlashBack.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.action/NavigateSlashBack.hashCode|hashCode(){}[0] + final fun reduce(io.github.linreal.cascade.editor.state/EditorState): io.github.linreal.cascade.editor.state/EditorState // io.github.linreal.cascade.editor.action/NavigateSlashBack.reduce|reduce(io.github.linreal.cascade.editor.state.EditorState){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.action/NavigateSlashBack.toString|toString(){}[0] +} + +final object io.github.linreal.cascade.editor.action/SelectAll : io.github.linreal.cascade.editor.action/EditorAction { // io.github.linreal.cascade.editor.action/SelectAll|null[0] + final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.action/SelectAll.equals|equals(kotlin.Any?){}[0] + final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.action/SelectAll.hashCode|hashCode(){}[0] + final fun reduce(io.github.linreal.cascade.editor.state/EditorState): io.github.linreal.cascade.editor.state/EditorState // io.github.linreal.cascade.editor.action/SelectAll.reduce|reduce(io.github.linreal.cascade.editor.state.EditorState){}[0] + final fun toString(): kotlin/String // io.github.linreal.cascade.editor.action/SelectAll.toString|toString(){}[0] +} + +final object io.github.linreal.cascade.editor.htmlserialization/Html { // io.github.linreal.cascade.editor.htmlserialization/Html|null[0] + final fun escapeAttr(kotlin/String): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/Html.escapeAttr|escapeAttr(kotlin.String){}[0] + final fun escapeText(kotlin/String): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/Html.escapeText|escapeText(kotlin.String){}[0] +} + +final object io.github.linreal.cascade.editor.htmlserialization/HtmlSchema { // io.github.linreal.cascade.editor.htmlserialization/HtmlSchema|null[0] + final fun decode(kotlin/String, io.github.linreal.cascade.editor.htmlserialization/HtmlProfile): kotlin.collections/List // io.github.linreal.cascade.editor.htmlserialization/HtmlSchema.decode|decode(kotlin.String;io.github.linreal.cascade.editor.htmlserialization.HtmlProfile){}[0] + final fun decodeWithReport(kotlin/String, io.github.linreal.cascade.editor.htmlserialization/HtmlProfile, io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeLimits = ...): io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeResult // io.github.linreal.cascade.editor.htmlserialization/HtmlSchema.decodeWithReport|decodeWithReport(kotlin.String;io.github.linreal.cascade.editor.htmlserialization.HtmlProfile;io.github.linreal.cascade.editor.htmlserialization.HtmlDecodeLimits){}[0] + final fun encode(kotlin.collections/List, io.github.linreal.cascade.editor.htmlserialization/HtmlProfile): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/HtmlSchema.encode|encode(kotlin.collections.List;io.github.linreal.cascade.editor.htmlserialization.HtmlProfile){}[0] + final fun encodeWithReport(kotlin.collections/List, io.github.linreal.cascade.editor.htmlserialization/HtmlProfile): io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeResult // io.github.linreal.cascade.editor.htmlserialization/HtmlSchema.encodeWithReport|encodeWithReport(kotlin.collections.List;io.github.linreal.cascade.editor.htmlserialization.HtmlProfile){}[0] +} + +final object io.github.linreal.cascade.editor.richtext/LinkUrlPolicy { // io.github.linreal.cascade.editor.richtext/LinkUrlPolicy|null[0] + final fun validate(kotlin/String): io.github.linreal.cascade.editor.richtext/LinkValidationResult // io.github.linreal.cascade.editor.richtext/LinkUrlPolicy.validate|validate(kotlin.String){}[0] +} + +final object io.github.linreal.cascade.editor.serialization/DocumentSchema { // io.github.linreal.cascade.editor.serialization/DocumentSchema|null[0] + final const val CURRENT_VERSION // io.github.linreal.cascade.editor.serialization/DocumentSchema.CURRENT_VERSION|{}CURRENT_VERSION[0] + final fun (): kotlin/Int // io.github.linreal.cascade.editor.serialization/DocumentSchema.CURRENT_VERSION.|(){}[0] + + final fun decode(kotlinx.serialization.json/JsonObject, io.github.linreal.cascade.editor.serialization/DocumentDecodeOptions = ..., io.github.linreal.cascade.editor.serialization/BlockTypeCodec? = ..., io.github.linreal.cascade.editor.serialization/BlockContentCodec? = ...): kotlin.collections/List // io.github.linreal.cascade.editor.serialization/DocumentSchema.decode|decode(kotlinx.serialization.json.JsonObject;io.github.linreal.cascade.editor.serialization.DocumentDecodeOptions;io.github.linreal.cascade.editor.serialization.BlockTypeCodec?;io.github.linreal.cascade.editor.serialization.BlockContentCodec?){}[0] + final fun decodeFromString(kotlin/String, io.github.linreal.cascade.editor.serialization/DocumentDecodeOptions = ..., io.github.linreal.cascade.editor.serialization/BlockTypeCodec? = ..., io.github.linreal.cascade.editor.serialization/BlockContentCodec? = ...): kotlin.collections/List // io.github.linreal.cascade.editor.serialization/DocumentSchema.decodeFromString|decodeFromString(kotlin.String;io.github.linreal.cascade.editor.serialization.DocumentDecodeOptions;io.github.linreal.cascade.editor.serialization.BlockTypeCodec?;io.github.linreal.cascade.editor.serialization.BlockContentCodec?){}[0] + final fun decodeFromStringWithReport(kotlin/String, io.github.linreal.cascade.editor.serialization/DocumentDecodeOptions = ..., io.github.linreal.cascade.editor.serialization/BlockTypeCodec? = ..., io.github.linreal.cascade.editor.serialization/BlockContentCodec? = ...): io.github.linreal.cascade.editor.serialization/DocumentDecodeResult // io.github.linreal.cascade.editor.serialization/DocumentSchema.decodeFromStringWithReport|decodeFromStringWithReport(kotlin.String;io.github.linreal.cascade.editor.serialization.DocumentDecodeOptions;io.github.linreal.cascade.editor.serialization.BlockTypeCodec?;io.github.linreal.cascade.editor.serialization.BlockContentCodec?){}[0] + final fun decodeWithReport(kotlinx.serialization.json/JsonObject, io.github.linreal.cascade.editor.serialization/DocumentDecodeOptions = ..., io.github.linreal.cascade.editor.serialization/BlockTypeCodec? = ..., io.github.linreal.cascade.editor.serialization/BlockContentCodec? = ...): io.github.linreal.cascade.editor.serialization/DocumentDecodeResult // io.github.linreal.cascade.editor.serialization/DocumentSchema.decodeWithReport|decodeWithReport(kotlinx.serialization.json.JsonObject;io.github.linreal.cascade.editor.serialization.DocumentDecodeOptions;io.github.linreal.cascade.editor.serialization.BlockTypeCodec?;io.github.linreal.cascade.editor.serialization.BlockContentCodec?){}[0] + final fun encode(kotlin.collections/List, io.github.linreal.cascade.editor.serialization/DocumentEncodeOptions = ..., io.github.linreal.cascade.editor.serialization/BlockTypeCodec? = ..., io.github.linreal.cascade.editor.serialization/BlockContentCodec? = ...): kotlinx.serialization.json/JsonObject // io.github.linreal.cascade.editor.serialization/DocumentSchema.encode|encode(kotlin.collections.List;io.github.linreal.cascade.editor.serialization.DocumentEncodeOptions;io.github.linreal.cascade.editor.serialization.BlockTypeCodec?;io.github.linreal.cascade.editor.serialization.BlockContentCodec?){}[0] + final fun encodeToString(kotlin.collections/List, io.github.linreal.cascade.editor.serialization/DocumentEncodeOptions = ..., io.github.linreal.cascade.editor.serialization/BlockTypeCodec? = ..., io.github.linreal.cascade.editor.serialization/BlockContentCodec? = ...): kotlin/String // io.github.linreal.cascade.editor.serialization/DocumentSchema.encodeToString|encodeToString(kotlin.collections.List;io.github.linreal.cascade.editor.serialization.DocumentEncodeOptions;io.github.linreal.cascade.editor.serialization.BlockTypeCodec?;io.github.linreal.cascade.editor.serialization.BlockContentCodec?){}[0] +} + +final object io.github.linreal.cascade.editor.serialization/RichTextSchema { // io.github.linreal.cascade.editor.serialization/RichTextSchema|null[0] + final const val CURRENT_VERSION // io.github.linreal.cascade.editor.serialization/RichTextSchema.CURRENT_VERSION|{}CURRENT_VERSION[0] + final fun (): kotlin/Int // io.github.linreal.cascade.editor.serialization/RichTextSchema.CURRENT_VERSION.|(){}[0] + + final fun decode(kotlinx.serialization.json/JsonObject): io.github.linreal.cascade.editor.core/BlockContent.Text // io.github.linreal.cascade.editor.serialization/RichTextSchema.decode|decode(kotlinx.serialization.json.JsonObject){}[0] + final fun decodeFromString(kotlin/String): io.github.linreal.cascade.editor.core/BlockContent.Text // io.github.linreal.cascade.editor.serialization/RichTextSchema.decodeFromString|decodeFromString(kotlin.String){}[0] + final fun encode(io.github.linreal.cascade.editor.core/BlockContent.Text): kotlinx.serialization.json/JsonObject // io.github.linreal.cascade.editor.serialization/RichTextSchema.encode|encode(io.github.linreal.cascade.editor.core.BlockContent.Text){}[0] + final fun encodeToString(io.github.linreal.cascade.editor.core/BlockContent.Text): kotlin/String // io.github.linreal.cascade.editor.serialization/RichTextSchema.encodeToString|encodeToString(io.github.linreal.cascade.editor.core.BlockContent.Text){}[0] +} + +final object io.github.linreal.cascade.editor.ui.utils/Dividers { // io.github.linreal.cascade.editor.ui.utils/Dividers|null[0] + final fun Horizontal(androidx.compose.ui.graphics/Color, androidx.compose.ui/Modifier?, androidx.compose.ui.unit/Dp, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int) // io.github.linreal.cascade.editor.ui.utils/Dividers.Horizontal|Horizontal(androidx.compose.ui.graphics.Color;androidx.compose.ui.Modifier?;androidx.compose.ui.unit.Dp;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){}[0] + final fun Vertical(androidx.compose.ui.graphics/Color, androidx.compose.ui/Modifier?, androidx.compose.ui.unit/Dp, androidx.compose.ui.unit/Dp, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int) // io.github.linreal.cascade.editor.ui.utils/Dividers.Vertical|Vertical(androidx.compose.ui.graphics.Color;androidx.compose.ui.Modifier?;androidx.compose.ui.unit.Dp;androidx.compose.ui.unit.Dp;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){}[0] +} + +final object io.github.linreal.cascade.editor.ui.utils/Spacers { // io.github.linreal.cascade.editor.ui.utils/Spacers|null[0] + final fun (androidx.compose.foundation.layout/ColumnScope).FillVerticalSpacer(androidx.compose.runtime/Composer?, kotlin/Int) // io.github.linreal.cascade.editor.ui.utils/Spacers.FillVerticalSpacer|FillVerticalSpacer@androidx.compose.foundation.layout.ColumnScope(androidx.compose.runtime.Composer?;kotlin.Int){}[0] + final fun (androidx.compose.foundation.layout/RowScope).FillHorizontalSpacer(androidx.compose.runtime/Composer?, kotlin/Int) // io.github.linreal.cascade.editor.ui.utils/Spacers.FillHorizontalSpacer|FillHorizontalSpacer@androidx.compose.foundation.layout.RowScope(androidx.compose.runtime.Composer?;kotlin.Int){}[0] + final fun Horizontal(androidx.compose.ui.unit/Dp, androidx.compose.runtime/Composer?, kotlin/Int) // io.github.linreal.cascade.editor.ui.utils/Spacers.Horizontal|Horizontal(androidx.compose.ui.unit.Dp;androidx.compose.runtime.Composer?;kotlin.Int){}[0] + final fun UiSpacer(androidx.compose.ui.unit/Dp, androidx.compose.ui.unit/Dp, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int) // io.github.linreal.cascade.editor.ui.utils/Spacers.UiSpacer|UiSpacer(androidx.compose.ui.unit.Dp;androidx.compose.ui.unit.Dp;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){}[0] + final fun Vertical(androidx.compose.ui.unit/Dp, androidx.compose.runtime/Composer?, kotlin/Int) // io.github.linreal.cascade.editor.ui.utils/Spacers.Vertical|Vertical(androidx.compose.ui.unit.Dp;androidx.compose.runtime.Composer?;kotlin.Int){}[0] +} + +final const val io.github.linreal.cascade.editor.htmlserialization/CASCADE_INDENT_CLASS_PREFIX // io.github.linreal.cascade.editor.htmlserialization/CASCADE_INDENT_CLASS_PREFIX|{}CASCADE_INDENT_CLASS_PREFIX[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/CASCADE_INDENT_CLASS_PREFIX.|(){}[0] +final const val io.github.linreal.cascade.editor.slash/BUILTIN_BLOCK_SLASH_COMMAND_ID_PREFIX // io.github.linreal.cascade.editor.slash/BUILTIN_BLOCK_SLASH_COMMAND_ID_PREFIX|{}BUILTIN_BLOCK_SLASH_COMMAND_ID_PREFIX[0] + final fun (): kotlin/String // io.github.linreal.cascade.editor.slash/BUILTIN_BLOCK_SLASH_COMMAND_ID_PREFIX.|(){}[0] + +final val cascadeeditor.editor.generated.resources/cascadeeditor_editor_generated_resources_Res_array$stableprop // cascadeeditor.editor.generated.resources/cascadeeditor_editor_generated_resources_Res_array$stableprop|#static{}cascadeeditor_editor_generated_resources_Res_array$stableprop[0] +final val cascadeeditor.editor.generated.resources/cascadeeditor_editor_generated_resources_Res_drawable$stableprop // cascadeeditor.editor.generated.resources/cascadeeditor_editor_generated_resources_Res_drawable$stableprop|#static{}cascadeeditor_editor_generated_resources_Res_drawable$stableprop[0] +final val cascadeeditor.editor.generated.resources/cascadeeditor_editor_generated_resources_Res_font$stableprop // cascadeeditor.editor.generated.resources/cascadeeditor_editor_generated_resources_Res_font$stableprop|#static{}cascadeeditor_editor_generated_resources_Res_font$stableprop[0] +final val cascadeeditor.editor.generated.resources/cascadeeditor_editor_generated_resources_Res_plurals$stableprop // cascadeeditor.editor.generated.resources/cascadeeditor_editor_generated_resources_Res_plurals$stableprop|#static{}cascadeeditor_editor_generated_resources_Res_plurals$stableprop[0] +final val cascadeeditor.editor.generated.resources/cascadeeditor_editor_generated_resources_Res_string$stableprop // cascadeeditor.editor.generated.resources/cascadeeditor_editor_generated_resources_Res_string$stableprop|#static{}cascadeeditor_editor_generated_resources_Res_string$stableprop[0] +final val io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_AddBlockRangeToSelection$stableprop // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_AddBlockRangeToSelection$stableprop|#static{}io_github_linreal_cascade_editor_action_AddBlockRangeToSelection$stableprop[0] +final val io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_ApplySpanStyle$stableprop // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_ApplySpanStyle$stableprop|#static{}io_github_linreal_cascade_editor_action_ApplySpanStyle$stableprop[0] +final val io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_CancelDrag$stableprop // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_CancelDrag$stableprop|#static{}io_github_linreal_cascade_editor_action_CancelDrag$stableprop[0] +final val io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_ClearFocus$stableprop // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_ClearFocus$stableprop|#static{}io_github_linreal_cascade_editor_action_ClearFocus$stableprop[0] +final val io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_ClearSelection$stableprop // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_ClearSelection$stableprop|#static{}io_github_linreal_cascade_editor_action_ClearSelection$stableprop[0] +final val io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_CloseSlashCommand$stableprop // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_CloseSlashCommand$stableprop|#static{}io_github_linreal_cascade_editor_action_CloseSlashCommand$stableprop[0] +final val io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_CompleteDrag$stableprop // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_CompleteDrag$stableprop|#static{}io_github_linreal_cascade_editor_action_CompleteDrag$stableprop[0] +final val io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_ConvertBlockType$stableprop // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_ConvertBlockType$stableprop|#static{}io_github_linreal_cascade_editor_action_ConvertBlockType$stableprop[0] +final val io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_DeleteBlock$stableprop // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_DeleteBlock$stableprop|#static{}io_github_linreal_cascade_editor_action_DeleteBlock$stableprop[0] +final val io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_DeleteBlocks$stableprop // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_DeleteBlocks$stableprop|#static{}io_github_linreal_cascade_editor_action_DeleteBlocks$stableprop[0] +final val io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_DeleteSelectedOrFocused$stableprop // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_DeleteSelectedOrFocused$stableprop|#static{}io_github_linreal_cascade_editor_action_DeleteSelectedOrFocused$stableprop[0] +final val io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_FocusBlock$stableprop // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_FocusBlock$stableprop|#static{}io_github_linreal_cascade_editor_action_FocusBlock$stableprop[0] +final val io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_FocusNextBlock$stableprop // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_FocusNextBlock$stableprop|#static{}io_github_linreal_cascade_editor_action_FocusNextBlock$stableprop[0] +final val io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_FocusPreviousBlock$stableprop // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_FocusPreviousBlock$stableprop|#static{}io_github_linreal_cascade_editor_action_FocusPreviousBlock$stableprop[0] +final val io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_HighlightSlashCommand$stableprop // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_HighlightSlashCommand$stableprop|#static{}io_github_linreal_cascade_editor_action_HighlightSlashCommand$stableprop[0] +final val io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_IndentBackward$stableprop // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_IndentBackward$stableprop|#static{}io_github_linreal_cascade_editor_action_IndentBackward$stableprop[0] +final val io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_IndentForward$stableprop // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_IndentForward$stableprop|#static{}io_github_linreal_cascade_editor_action_IndentForward$stableprop[0] +final val io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_InsertBlock$stableprop // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_InsertBlock$stableprop|#static{}io_github_linreal_cascade_editor_action_InsertBlock$stableprop[0] +final val io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_InsertBlockAfter$stableprop // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_InsertBlockAfter$stableprop|#static{}io_github_linreal_cascade_editor_action_InsertBlockAfter$stableprop[0] +final val io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_InsertBlockBefore$stableprop // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_InsertBlockBefore$stableprop|#static{}io_github_linreal_cascade_editor_action_InsertBlockBefore$stableprop[0] +final val io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_MergeBlocks$stableprop // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_MergeBlocks$stableprop|#static{}io_github_linreal_cascade_editor_action_MergeBlocks$stableprop[0] +final val io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_MoveBlocks$stableprop // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_MoveBlocks$stableprop|#static{}io_github_linreal_cascade_editor_action_MoveBlocks$stableprop[0] +final val io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_NavigateSlashBack$stableprop // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_NavigateSlashBack$stableprop|#static{}io_github_linreal_cascade_editor_action_NavigateSlashBack$stableprop[0] +final val io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_NavigateSlashSubmenu$stableprop // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_NavigateSlashSubmenu$stableprop|#static{}io_github_linreal_cascade_editor_action_NavigateSlashSubmenu$stableprop[0] +final val io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_OpenSlashCommand$stableprop // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_OpenSlashCommand$stableprop|#static{}io_github_linreal_cascade_editor_action_OpenSlashCommand$stableprop[0] +final val io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_RemoveSpanStyle$stableprop // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_RemoveSpanStyle$stableprop|#static{}io_github_linreal_cascade_editor_action_RemoveSpanStyle$stableprop[0] +final val io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_ReplaceBlock$stableprop // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_ReplaceBlock$stableprop|#static{}io_github_linreal_cascade_editor_action_ReplaceBlock$stableprop[0] +final val io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_SelectAll$stableprop // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_SelectAll$stableprop|#static{}io_github_linreal_cascade_editor_action_SelectAll$stableprop[0] +final val io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_SelectBlock$stableprop // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_SelectBlock$stableprop|#static{}io_github_linreal_cascade_editor_action_SelectBlock$stableprop[0] +final val io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_SelectBlockRange$stableprop // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_SelectBlockRange$stableprop|#static{}io_github_linreal_cascade_editor_action_SelectBlockRange$stableprop[0] +final val io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_SplitBlock$stableprop // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_SplitBlock$stableprop|#static{}io_github_linreal_cascade_editor_action_SplitBlock$stableprop[0] +final val io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_StartDrag$stableprop // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_StartDrag$stableprop|#static{}io_github_linreal_cascade_editor_action_StartDrag$stableprop[0] +final val io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_ToggleBlockSelection$stableprop // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_ToggleBlockSelection$stableprop|#static{}io_github_linreal_cascade_editor_action_ToggleBlockSelection$stableprop[0] +final val io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_ToggleTodo$stableprop // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_ToggleTodo$stableprop|#static{}io_github_linreal_cascade_editor_action_ToggleTodo$stableprop[0] +final val io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_UpdateBlockContent$stableprop // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_UpdateBlockContent$stableprop|#static{}io_github_linreal_cascade_editor_action_UpdateBlockContent$stableprop[0] +final val io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_UpdateBlockText$stableprop // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_UpdateBlockText$stableprop|#static{}io_github_linreal_cascade_editor_action_UpdateBlockText$stableprop[0] +final val io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_UpdateDragTarget$stableprop // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_UpdateDragTarget$stableprop|#static{}io_github_linreal_cascade_editor_action_UpdateDragTarget$stableprop[0] +final val io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_UpdateSlashCommandSession$stableprop // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_UpdateSlashCommandSession$stableprop|#static{}io_github_linreal_cascade_editor_action_UpdateSlashCommandSession$stableprop[0] +final val io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_Block$stableprop // io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_Block$stableprop|#static{}io_github_linreal_cascade_editor_core_Block$stableprop[0] +final val io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_BlockAttributes$stableprop // io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_BlockAttributes$stableprop|#static{}io_github_linreal_cascade_editor_core_BlockAttributes$stableprop[0] +final val io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_BlockContent_Custom$stableprop // io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_BlockContent_Custom$stableprop|#static{}io_github_linreal_cascade_editor_core_BlockContent_Custom$stableprop[0] +final val io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_BlockContent_Empty$stableprop // io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_BlockContent_Empty$stableprop|#static{}io_github_linreal_cascade_editor_core_BlockContent_Empty$stableprop[0] +final val io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_BlockContent_Text$stableprop // io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_BlockContent_Text$stableprop|#static{}io_github_linreal_cascade_editor_core_BlockContent_Text$stableprop[0] +final val io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_BlockType_BulletList$stableprop // io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_BlockType_BulletList$stableprop|#static{}io_github_linreal_cascade_editor_core_BlockType_BulletList$stableprop[0] +final val io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_BlockType_Code$stableprop // io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_BlockType_Code$stableprop|#static{}io_github_linreal_cascade_editor_core_BlockType_Code$stableprop[0] +final val io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_BlockType_Divider$stableprop // io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_BlockType_Divider$stableprop|#static{}io_github_linreal_cascade_editor_core_BlockType_Divider$stableprop[0] +final val io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_BlockType_Heading$stableprop // io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_BlockType_Heading$stableprop|#static{}io_github_linreal_cascade_editor_core_BlockType_Heading$stableprop[0] +final val io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_BlockType_NumberedList$stableprop // io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_BlockType_NumberedList$stableprop|#static{}io_github_linreal_cascade_editor_core_BlockType_NumberedList$stableprop[0] +final val io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_BlockType_Paragraph$stableprop // io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_BlockType_Paragraph$stableprop|#static{}io_github_linreal_cascade_editor_core_BlockType_Paragraph$stableprop[0] +final val io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_BlockType_Quote$stableprop // io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_BlockType_Quote$stableprop|#static{}io_github_linreal_cascade_editor_core_BlockType_Quote$stableprop[0] +final val io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_BlockType_Todo$stableprop // io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_BlockType_Todo$stableprop|#static{}io_github_linreal_cascade_editor_core_BlockType_Todo$stableprop[0] +final val io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_SpanStyle_Bold$stableprop // io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_SpanStyle_Bold$stableprop|#static{}io_github_linreal_cascade_editor_core_SpanStyle_Bold$stableprop[0] +final val io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_SpanStyle_Custom$stableprop // io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_SpanStyle_Custom$stableprop|#static{}io_github_linreal_cascade_editor_core_SpanStyle_Custom$stableprop[0] +final val io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_SpanStyle_Highlight$stableprop // io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_SpanStyle_Highlight$stableprop|#static{}io_github_linreal_cascade_editor_core_SpanStyle_Highlight$stableprop[0] +final val io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_SpanStyle_InlineCode$stableprop // io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_SpanStyle_InlineCode$stableprop|#static{}io_github_linreal_cascade_editor_core_SpanStyle_InlineCode$stableprop[0] +final val io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_SpanStyle_Italic$stableprop // io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_SpanStyle_Italic$stableprop|#static{}io_github_linreal_cascade_editor_core_SpanStyle_Italic$stableprop[0] +final val io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_SpanStyle_Link$stableprop // io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_SpanStyle_Link$stableprop|#static{}io_github_linreal_cascade_editor_core_SpanStyle_Link$stableprop[0] +final val io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_SpanStyle_StrikeThrough$stableprop // io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_SpanStyle_StrikeThrough$stableprop|#static{}io_github_linreal_cascade_editor_core_SpanStyle_StrikeThrough$stableprop[0] +final val io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_SpanStyle_Underline$stableprop // io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_SpanStyle_Underline$stableprop|#static{}io_github_linreal_cascade_editor_core_SpanStyle_Underline$stableprop[0] +final val io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_TextSpan$stableprop // io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_TextSpan$stableprop|#static{}io_github_linreal_cascade_editor_core_TextSpan$stableprop[0] +final val io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_UnknownBlockType$stableprop // io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_UnknownBlockType$stableprop|#static{}io_github_linreal_cascade_editor_core_UnknownBlockType$stableprop[0] +final val io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_BlockSeparator_BlockTags$stableprop // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_BlockSeparator_BlockTags$stableprop|#static{}io_github_linreal_cascade_editor_htmlserialization_BlockSeparator_BlockTags$stableprop[0] +final val io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_BlockSeparator_Newline$stableprop // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_BlockSeparator_Newline$stableprop|#static{}io_github_linreal_cascade_editor_htmlserialization_BlockSeparator_Newline$stableprop[0] +final val io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_EntityDecode_None$stableprop // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_EntityDecode_None$stableprop|#static{}io_github_linreal_cascade_editor_htmlserialization_EntityDecode_None$stableprop[0] +final val io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_EntityDecode_Standard$stableprop // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_EntityDecode_Standard$stableprop|#static{}io_github_linreal_cascade_editor_htmlserialization_EntityDecode_Standard$stableprop[0] +final val io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_Html$stableprop // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_Html$stableprop|#static{}io_github_linreal_cascade_editor_htmlserialization_Html$stableprop[0] +final val io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeLimits$stableprop // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeLimits$stableprop|#static{}io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeLimits$stableprop[0] +final val io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeResult$stableprop // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeResult$stableprop|#static{}io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeResult$stableprop[0] +final val io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning$stableprop // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning$stableprop|#static{}io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning$stableprop[0] +final val io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_BlockInInlineContext$stableprop // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_BlockInInlineContext$stableprop|#static{}io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_BlockInInlineContext$stableprop[0] +final val io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_DecoderException$stableprop // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_DecoderException$stableprop|#static{}io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_DecoderException$stableprop[0] +final val io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_DroppedAttribute$stableprop // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_DroppedAttribute$stableprop|#static{}io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_DroppedAttribute$stableprop[0] +final val io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_DroppedContent$stableprop // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_DroppedContent$stableprop|#static{}io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_DroppedContent$stableprop[0] +final val io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_InputLimitExceeded$stableprop // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_InputLimitExceeded$stableprop|#static{}io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_InputLimitExceeded$stableprop[0] +final val io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_InvalidAttribute$stableprop // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_InvalidAttribute$stableprop|#static{}io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_InvalidAttribute$stableprop[0] +final val io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_MismatchedNesting$stableprop // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_MismatchedNesting$stableprop|#static{}io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_MismatchedNesting$stableprop[0] +final val io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_StrayClosingTag$stableprop // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_StrayClosingTag$stableprop|#static{}io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_StrayClosingTag$stableprop[0] +final val io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_UnclosedTag$stableprop // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_UnclosedTag$stableprop|#static{}io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_UnclosedTag$stableprop[0] +final val io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_UnknownAttribute$stableprop // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_UnknownAttribute$stableprop|#static{}io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_UnknownAttribute$stableprop[0] +final val io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_UnknownTag$stableprop // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_UnknownTag$stableprop|#static{}io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_UnknownTag$stableprop[0] +final val io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlEmit_Raw$stableprop // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlEmit_Raw$stableprop|#static{}io_github_linreal_cascade_editor_htmlserialization_HtmlEmit_Raw$stableprop[0] +final val io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlEmit_Skip$stableprop // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlEmit_Skip$stableprop|#static{}io_github_linreal_cascade_editor_htmlserialization_HtmlEmit_Skip$stableprop[0] +final val io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlEncodeContext$stableprop // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlEncodeContext$stableprop|#static{}io_github_linreal_cascade_editor_htmlserialization_HtmlEncodeContext$stableprop[0] +final val io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlEncodeResult$stableprop // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlEncodeResult$stableprop|#static{}io_github_linreal_cascade_editor_htmlserialization_HtmlEncodeResult$stableprop[0] +final val io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlEncodeWarning$stableprop // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlEncodeWarning$stableprop|#static{}io_github_linreal_cascade_editor_htmlserialization_HtmlEncodeWarning$stableprop[0] +final val io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlEncodeWarning_DroppedAttribute$stableprop // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlEncodeWarning_DroppedAttribute$stableprop|#static{}io_github_linreal_cascade_editor_htmlserialization_HtmlEncodeWarning_DroppedAttribute$stableprop[0] +final val io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlEncodeWarning_EncoderException$stableprop // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlEncodeWarning_EncoderException$stableprop|#static{}io_github_linreal_cascade_editor_htmlserialization_HtmlEncodeWarning_EncoderException$stableprop[0] +final val io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlNodeView_Element$stableprop // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlNodeView_Element$stableprop|#static{}io_github_linreal_cascade_editor_htmlserialization_HtmlNodeView_Element$stableprop[0] +final val io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlNodeView_Text$stableprop // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlNodeView_Text$stableprop|#static{}io_github_linreal_cascade_editor_htmlserialization_HtmlNodeView_Text$stableprop[0] +final val io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlNode_Element$stableprop // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlNode_Element$stableprop|#static{}io_github_linreal_cascade_editor_htmlserialization_HtmlNode_Element$stableprop[0] +final val io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlNode_Text$stableprop // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlNode_Text$stableprop|#static{}io_github_linreal_cascade_editor_htmlserialization_HtmlNode_Text$stableprop[0] +final val io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlPolicyApplier_PolicyPart_NewlineBreak$stableprop // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlPolicyApplier_PolicyPart_NewlineBreak$stableprop|#static{}io_github_linreal_cascade_editor_htmlserialization_HtmlPolicyApplier_PolicyPart_NewlineBreak$stableprop[0] +final val io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlPolicyApplier_PolicyPart_Node$stableprop // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlPolicyApplier_PolicyPart_Node$stableprop|#static{}io_github_linreal_cascade_editor_htmlserialization_HtmlPolicyApplier_PolicyPart_Node$stableprop[0] +final val io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlProfile$stableprop // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlProfile$stableprop|#static{}io_github_linreal_cascade_editor_htmlserialization_HtmlProfile$stableprop[0] +final val io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlProfileSupportSet$stableprop // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlProfileSupportSet$stableprop|#static{}io_github_linreal_cascade_editor_htmlserialization_HtmlProfileSupportSet$stableprop[0] +final val io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlSchema$stableprop // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlSchema$stableprop|#static{}io_github_linreal_cascade_editor_htmlserialization_HtmlSchema$stableprop[0] +final val io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlTagPair$stableprop // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlTagPair$stableprop|#static{}io_github_linreal_cascade_editor_htmlserialization_HtmlTagPair$stableprop[0] +final val io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlToken_CloseTag$stableprop // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlToken_CloseTag$stableprop|#static{}io_github_linreal_cascade_editor_htmlserialization_HtmlToken_CloseTag$stableprop[0] +final val io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlToken_OpenTag$stableprop // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlToken_OpenTag$stableprop|#static{}io_github_linreal_cascade_editor_htmlserialization_HtmlToken_OpenTag$stableprop[0] +final val io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlToken_Text$stableprop // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlToken_Text$stableprop|#static{}io_github_linreal_cascade_editor_htmlserialization_HtmlToken_Text$stableprop[0] +final val io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_InlineFragment$stableprop // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_InlineFragment$stableprop|#static{}io_github_linreal_cascade_editor_htmlserialization_InlineFragment$stableprop[0] +final val io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_InlineRoot_Drop$stableprop // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_InlineRoot_Drop$stableprop|#static{}io_github_linreal_cascade_editor_htmlserialization_InlineRoot_Drop$stableprop[0] +final val io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_InlineRoot_WrapInParagraph$stableprop // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_InlineRoot_WrapInParagraph$stableprop|#static{}io_github_linreal_cascade_editor_htmlserialization_InlineRoot_WrapInParagraph$stableprop[0] +final val io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_TagDecodeContext$stableprop // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_TagDecodeContext$stableprop|#static{}io_github_linreal_cascade_editor_htmlserialization_TagDecodeContext$stableprop[0] +final val io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_TagDecodeResult_AsBlock$stableprop // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_TagDecodeResult_AsBlock$stableprop|#static{}io_github_linreal_cascade_editor_htmlserialization_TagDecodeResult_AsBlock$stableprop[0] +final val io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_TagDecodeResult_AsBlocks$stableprop // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_TagDecodeResult_AsBlocks$stableprop|#static{}io_github_linreal_cascade_editor_htmlserialization_TagDecodeResult_AsBlocks$stableprop[0] +final val io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_TagDecodeResult_AsText$stableprop // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_TagDecodeResult_AsText$stableprop|#static{}io_github_linreal_cascade_editor_htmlserialization_TagDecodeResult_AsText$stableprop[0] +final val io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_TagDecodeResult_Drop$stableprop // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_TagDecodeResult_Drop$stableprop|#static{}io_github_linreal_cascade_editor_htmlserialization_TagDecodeResult_Drop$stableprop[0] +final val io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_UnknownTagPolicy_Custom$stableprop // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_UnknownTagPolicy_Custom$stableprop|#static{}io_github_linreal_cascade_editor_htmlserialization_UnknownTagPolicy_Custom$stableprop[0] +final val io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_UnknownTagPolicy_Preserve$stableprop // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_UnknownTagPolicy_Preserve$stableprop|#static{}io_github_linreal_cascade_editor_htmlserialization_UnknownTagPolicy_Preserve$stableprop[0] +final val io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_UnknownTagPolicy_Strip$stableprop // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_UnknownTagPolicy_Strip$stableprop|#static{}io_github_linreal_cascade_editor_htmlserialization_UnknownTagPolicy_Strip$stableprop[0] +final val io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_UnknownTagPolicy_WarnAndStrip$stableprop // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_UnknownTagPolicy_WarnAndStrip$stableprop|#static{}io_github_linreal_cascade_editor_htmlserialization_UnknownTagPolicy_WarnAndStrip$stableprop[0] +final val io.github.linreal.cascade.editor.indentation/io_github_linreal_cascade_editor_indentation_IndentationState$stableprop // io.github.linreal.cascade.editor.indentation/io_github_linreal_cascade_editor_indentation_IndentationState$stableprop|#static{}io_github_linreal_cascade_editor_indentation_IndentationState$stableprop[0] +final val io.github.linreal.cascade.editor.registry/io_github_linreal_cascade_editor_registry_BlockDescriptor$stableprop // io.github.linreal.cascade.editor.registry/io_github_linreal_cascade_editor_registry_BlockDescriptor$stableprop|#static{}io_github_linreal_cascade_editor_registry_BlockDescriptor$stableprop[0] +final val io.github.linreal.cascade.editor.registry/io_github_linreal_cascade_editor_registry_BlockRegistry$stableprop // io.github.linreal.cascade.editor.registry/io_github_linreal_cascade_editor_registry_BlockRegistry$stableprop|#static{}io_github_linreal_cascade_editor_registry_BlockRegistry$stableprop[0] +final val io.github.linreal.cascade.editor.registry/io_github_linreal_cascade_editor_registry_DefaultBlockCallbacks$stableprop // io.github.linreal.cascade.editor.registry/io_github_linreal_cascade_editor_registry_DefaultBlockCallbacks$stableprop|#static{}io_github_linreal_cascade_editor_registry_DefaultBlockCallbacks$stableprop[0] +final val io.github.linreal.cascade.editor.registry/io_github_linreal_cascade_editor_registry_LambdaBlockRenderer$stableprop // io.github.linreal.cascade.editor.registry/io_github_linreal_cascade_editor_registry_LambdaBlockRenderer$stableprop|#static{}io_github_linreal_cascade_editor_registry_LambdaBlockRenderer$stableprop[0] +final val io.github.linreal.cascade.editor.richtext/io_github_linreal_cascade_editor_richtext_FormattingState$stableprop // io.github.linreal.cascade.editor.richtext/io_github_linreal_cascade_editor_richtext_FormattingState$stableprop|#static{}io_github_linreal_cascade_editor_richtext_FormattingState$stableprop[0] +final val io.github.linreal.cascade.editor.richtext/io_github_linreal_cascade_editor_richtext_LinkActionDispatcher$stableprop // io.github.linreal.cascade.editor.richtext/io_github_linreal_cascade_editor_richtext_LinkActionDispatcher$stableprop|#static{}io_github_linreal_cascade_editor_richtext_LinkActionDispatcher$stableprop[0] +final val io.github.linreal.cascade.editor.richtext/io_github_linreal_cascade_editor_richtext_LinkState$stableprop // io.github.linreal.cascade.editor.richtext/io_github_linreal_cascade_editor_richtext_LinkState$stableprop|#static{}io_github_linreal_cascade_editor_richtext_LinkState$stableprop[0] +final val io.github.linreal.cascade.editor.richtext/io_github_linreal_cascade_editor_richtext_LinkTarget$stableprop // io.github.linreal.cascade.editor.richtext/io_github_linreal_cascade_editor_richtext_LinkTarget$stableprop|#static{}io_github_linreal_cascade_editor_richtext_LinkTarget$stableprop[0] +final val io.github.linreal.cascade.editor.richtext/io_github_linreal_cascade_editor_richtext_LinkUrlPolicy$stableprop // io.github.linreal.cascade.editor.richtext/io_github_linreal_cascade_editor_richtext_LinkUrlPolicy$stableprop|#static{}io_github_linreal_cascade_editor_richtext_LinkUrlPolicy$stableprop[0] +final val io.github.linreal.cascade.editor.richtext/io_github_linreal_cascade_editor_richtext_LinkValidationResult_Invalid$stableprop // io.github.linreal.cascade.editor.richtext/io_github_linreal_cascade_editor_richtext_LinkValidationResult_Invalid$stableprop|#static{}io_github_linreal_cascade_editor_richtext_LinkValidationResult_Invalid$stableprop[0] +final val io.github.linreal.cascade.editor.richtext/io_github_linreal_cascade_editor_richtext_LinkValidationResult_Valid$stableprop // io.github.linreal.cascade.editor.richtext/io_github_linreal_cascade_editor_richtext_LinkValidationResult_Valid$stableprop|#static{}io_github_linreal_cascade_editor_richtext_LinkValidationResult_Valid$stableprop[0] +final val io.github.linreal.cascade.editor.richtext/io_github_linreal_cascade_editor_richtext_SpanActionDispatcher$stableprop // io.github.linreal.cascade.editor.richtext/io_github_linreal_cascade_editor_richtext_SpanActionDispatcher$stableprop|#static{}io_github_linreal_cascade_editor_richtext_SpanActionDispatcher$stableprop[0] +final val io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_DocumentDecodeOptions$stableprop // io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_DocumentDecodeOptions$stableprop|#static{}io_github_linreal_cascade_editor_serialization_DocumentDecodeOptions$stableprop[0] +final val io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_DocumentDecodeResult$stableprop // io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_DocumentDecodeResult$stableprop|#static{}io_github_linreal_cascade_editor_serialization_DocumentDecodeResult$stableprop[0] +final val io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning$stableprop // io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning$stableprop|#static{}io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning$stableprop[0] +final val io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning_DocumentParseFailed$stableprop // io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning_DocumentParseFailed$stableprop|#static{}io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning_DocumentParseFailed$stableprop[0] +final val io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning_DuplicateIdRegenerated$stableprop // io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning_DuplicateIdRegenerated$stableprop|#static{}io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning_DuplicateIdRegenerated$stableprop[0] +final val io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning_InvalidBlockAttributeParam$stableprop // io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning_InvalidBlockAttributeParam$stableprop|#static{}io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning_InvalidBlockAttributeParam$stableprop[0] +final val io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning_InvalidBlockTypeParam$stableprop // io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning_InvalidBlockTypeParam$stableprop|#static{}io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning_InvalidBlockTypeParam$stableprop[0] +final val io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning_MalformedBlockSkipped$stableprop // io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning_MalformedBlockSkipped$stableprop|#static{}io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning_MalformedBlockSkipped$stableprop[0] +final val io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning_MissingIdRegenerated$stableprop // io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning_MissingIdRegenerated$stableprop|#static{}io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning_MissingIdRegenerated$stableprop[0] +final val io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning_UnknownBlockTypePreserved$stableprop // io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning_UnknownBlockTypePreserved$stableprop|#static{}io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning_UnknownBlockTypePreserved$stableprop[0] +final val io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning_UnknownContentKind$stableprop // io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning_UnknownContentKind$stableprop|#static{}io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning_UnknownContentKind$stableprop[0] +final val io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning_UnsupportedCustomDataDropped$stableprop // io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning_UnsupportedCustomDataDropped$stableprop|#static{}io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning_UnsupportedCustomDataDropped$stableprop[0] +final val io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_DocumentEncodeOptions$stableprop // io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_DocumentEncodeOptions$stableprop|#static{}io_github_linreal_cascade_editor_serialization_DocumentEncodeOptions$stableprop[0] +final val io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_DocumentSchema$stableprop // io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_DocumentSchema$stableprop|#static{}io_github_linreal_cascade_editor_serialization_DocumentSchema$stableprop[0] +final val io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_RichTextSchema$stableprop // io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_RichTextSchema$stableprop|#static{}io_github_linreal_cascade_editor_serialization_RichTextSchema$stableprop[0] +final val io.github.linreal.cascade.editor.slash/io_github_linreal_cascade_editor_slash_BuiltInBlockSlashBehavior_AlwaysInsert$stableprop // io.github.linreal.cascade.editor.slash/io_github_linreal_cascade_editor_slash_BuiltInBlockSlashBehavior_AlwaysInsert$stableprop|#static{}io_github_linreal_cascade_editor_slash_BuiltInBlockSlashBehavior_AlwaysInsert$stableprop[0] +final val io.github.linreal.cascade.editor.slash/io_github_linreal_cascade_editor_slash_BuiltInBlockSlashBehavior_ConvertInPlace$stableprop // io.github.linreal.cascade.editor.slash/io_github_linreal_cascade_editor_slash_BuiltInBlockSlashBehavior_ConvertInPlace$stableprop|#static{}io_github_linreal_cascade_editor_slash_BuiltInBlockSlashBehavior_ConvertInPlace$stableprop[0] +final val io.github.linreal.cascade.editor.slash/io_github_linreal_cascade_editor_slash_BuiltInSlashCommandSpec$stableprop // io.github.linreal.cascade.editor.slash/io_github_linreal_cascade_editor_slash_BuiltInSlashCommandSpec$stableprop|#static{}io_github_linreal_cascade_editor_slash_BuiltInSlashCommandSpec$stableprop[0] +final val io.github.linreal.cascade.editor.slash/io_github_linreal_cascade_editor_slash_SlashCommandAction$stableprop // io.github.linreal.cascade.editor.slash/io_github_linreal_cascade_editor_slash_SlashCommandAction$stableprop|#static{}io_github_linreal_cascade_editor_slash_SlashCommandAction$stableprop[0] +final val io.github.linreal.cascade.editor.slash/io_github_linreal_cascade_editor_slash_SlashCommandContext$stableprop // io.github.linreal.cascade.editor.slash/io_github_linreal_cascade_editor_slash_SlashCommandContext$stableprop|#static{}io_github_linreal_cascade_editor_slash_SlashCommandContext$stableprop[0] +final val io.github.linreal.cascade.editor.slash/io_github_linreal_cascade_editor_slash_SlashCommandMenu$stableprop // io.github.linreal.cascade.editor.slash/io_github_linreal_cascade_editor_slash_SlashCommandMenu$stableprop|#static{}io_github_linreal_cascade_editor_slash_SlashCommandMenu$stableprop[0] +final val io.github.linreal.cascade.editor.slash/io_github_linreal_cascade_editor_slash_SlashCommandRegistry$stableprop // io.github.linreal.cascade.editor.slash/io_github_linreal_cascade_editor_slash_SlashCommandRegistry$stableprop|#static{}io_github_linreal_cascade_editor_slash_SlashCommandRegistry$stableprop[0] +final val io.github.linreal.cascade.editor.slash/io_github_linreal_cascade_editor_slash_SlashCommandResult_Done$stableprop // io.github.linreal.cascade.editor.slash/io_github_linreal_cascade_editor_slash_SlashCommandResult_Done$stableprop|#static{}io_github_linreal_cascade_editor_slash_SlashCommandResult_Done$stableprop[0] +final val io.github.linreal.cascade.editor.slash/io_github_linreal_cascade_editor_slash_SlashCommandResult_Failure$stableprop // io.github.linreal.cascade.editor.slash/io_github_linreal_cascade_editor_slash_SlashCommandResult_Failure$stableprop|#static{}io_github_linreal_cascade_editor_slash_SlashCommandResult_Failure$stableprop[0] +final val io.github.linreal.cascade.editor.slash/io_github_linreal_cascade_editor_slash_SlashCommandResult_KeepOpen$stableprop // io.github.linreal.cascade.editor.slash/io_github_linreal_cascade_editor_slash_SlashCommandResult_KeepOpen$stableprop|#static{}io_github_linreal_cascade_editor_slash_SlashCommandResult_KeepOpen$stableprop[0] +final val io.github.linreal.cascade.editor.state/io_github_linreal_cascade_editor_state_BlockSpanStates$stableprop // io.github.linreal.cascade.editor.state/io_github_linreal_cascade_editor_state_BlockSpanStates$stableprop|#static{}io_github_linreal_cascade_editor_state_BlockSpanStates$stableprop[0] +final val io.github.linreal.cascade.editor.state/io_github_linreal_cascade_editor_state_BlockTextStates$stableprop // io.github.linreal.cascade.editor.state/io_github_linreal_cascade_editor_state_BlockTextStates$stableprop|#static{}io_github_linreal_cascade_editor_state_BlockTextStates$stableprop[0] +final val io.github.linreal.cascade.editor.state/io_github_linreal_cascade_editor_state_DragState$stableprop // io.github.linreal.cascade.editor.state/io_github_linreal_cascade_editor_state_DragState$stableprop|#static{}io_github_linreal_cascade_editor_state_DragState$stableprop[0] +final val io.github.linreal.cascade.editor.state/io_github_linreal_cascade_editor_state_EditorState$stableprop // io.github.linreal.cascade.editor.state/io_github_linreal_cascade_editor_state_EditorState$stableprop|#static{}io_github_linreal_cascade_editor_state_EditorState$stableprop[0] +final val io.github.linreal.cascade.editor.state/io_github_linreal_cascade_editor_state_EditorStateHolder$stableprop // io.github.linreal.cascade.editor.state/io_github_linreal_cascade_editor_state_EditorStateHolder$stableprop|#static{}io_github_linreal_cascade_editor_state_EditorStateHolder$stableprop[0] +final val io.github.linreal.cascade.editor.state/io_github_linreal_cascade_editor_state_MergePolicy_Isolate$stableprop // io.github.linreal.cascade.editor.state/io_github_linreal_cascade_editor_state_MergePolicy_Isolate$stableprop|#static{}io_github_linreal_cascade_editor_state_MergePolicy_Isolate$stableprop[0] +final val io.github.linreal.cascade.editor.state/io_github_linreal_cascade_editor_state_MergePolicy_TryMerge$stableprop // io.github.linreal.cascade.editor.state/io_github_linreal_cascade_editor_state_MergePolicy_TryMerge$stableprop|#static{}io_github_linreal_cascade_editor_state_MergePolicy_TryMerge$stableprop[0] +final val io.github.linreal.cascade.editor.state/io_github_linreal_cascade_editor_state_SlashCommandState$stableprop // io.github.linreal.cascade.editor.state/io_github_linreal_cascade_editor_state_SlashCommandState$stableprop|#static{}io_github_linreal_cascade_editor_state_SlashCommandState$stableprop[0] +final val io.github.linreal.cascade.editor.state/io_github_linreal_cascade_editor_state_SlashQueryRange$stableprop // io.github.linreal.cascade.editor.state/io_github_linreal_cascade_editor_state_SlashQueryRange$stableprop|#static{}io_github_linreal_cascade_editor_state_SlashQueryRange$stableprop[0] +final val io.github.linreal.cascade.editor.theme/io_github_linreal_cascade_editor_theme_BlockLocalizedStrings$stableprop // io.github.linreal.cascade.editor.theme/io_github_linreal_cascade_editor_theme_BlockLocalizedStrings$stableprop|#static{}io_github_linreal_cascade_editor_theme_BlockLocalizedStrings$stableprop[0] +final val io.github.linreal.cascade.editor.theme/io_github_linreal_cascade_editor_theme_CascadeEditorBlockStrings$stableprop // io.github.linreal.cascade.editor.theme/io_github_linreal_cascade_editor_theme_CascadeEditorBlockStrings$stableprop|#static{}io_github_linreal_cascade_editor_theme_CascadeEditorBlockStrings$stableprop[0] +final val io.github.linreal.cascade.editor.theme/io_github_linreal_cascade_editor_theme_CascadeEditorColors$stableprop // io.github.linreal.cascade.editor.theme/io_github_linreal_cascade_editor_theme_CascadeEditorColors$stableprop|#static{}io_github_linreal_cascade_editor_theme_CascadeEditorColors$stableprop[0] +final val io.github.linreal.cascade.editor.theme/io_github_linreal_cascade_editor_theme_CascadeEditorDimensions$stableprop // io.github.linreal.cascade.editor.theme/io_github_linreal_cascade_editor_theme_CascadeEditorDimensions$stableprop|#static{}io_github_linreal_cascade_editor_theme_CascadeEditorDimensions$stableprop[0] +final val io.github.linreal.cascade.editor.theme/io_github_linreal_cascade_editor_theme_CascadeEditorStrings$stableprop // io.github.linreal.cascade.editor.theme/io_github_linreal_cascade_editor_theme_CascadeEditorStrings$stableprop|#static{}io_github_linreal_cascade_editor_theme_CascadeEditorStrings$stableprop[0] +final val io.github.linreal.cascade.editor.theme/io_github_linreal_cascade_editor_theme_CascadeEditorTheme$stableprop // io.github.linreal.cascade.editor.theme/io_github_linreal_cascade_editor_theme_CascadeEditorTheme$stableprop|#static{}io_github_linreal_cascade_editor_theme_CascadeEditorTheme$stableprop[0] +final val io.github.linreal.cascade.editor.theme/io_github_linreal_cascade_editor_theme_CascadeEditorTypography$stableprop // io.github.linreal.cascade.editor.theme/io_github_linreal_cascade_editor_theme_CascadeEditorTypography$stableprop|#static{}io_github_linreal_cascade_editor_theme_CascadeEditorTypography$stableprop[0] +final val io.github.linreal.cascade.editor.ui.renderers/io_github_linreal_cascade_editor_ui_renderers_DividerBlockRenderer$stableprop // io.github.linreal.cascade.editor.ui.renderers/io_github_linreal_cascade_editor_ui_renderers_DividerBlockRenderer$stableprop|#static{}io_github_linreal_cascade_editor_ui_renderers_DividerBlockRenderer$stableprop[0] +final val io.github.linreal.cascade.editor.ui.renderers/io_github_linreal_cascade_editor_ui_renderers_TextBlockRenderer$stableprop // io.github.linreal.cascade.editor.ui.renderers/io_github_linreal_cascade_editor_ui_renderers_TextBlockRenderer$stableprop|#static{}io_github_linreal_cascade_editor_ui_renderers_TextBlockRenderer$stableprop[0] +final val io.github.linreal.cascade.editor.ui.renderers/io_github_linreal_cascade_editor_ui_renderers_TodoBlockRenderer$stableprop // io.github.linreal.cascade.editor.ui.renderers/io_github_linreal_cascade_editor_ui_renderers_TodoBlockRenderer$stableprop|#static{}io_github_linreal_cascade_editor_ui_renderers_TodoBlockRenderer$stableprop[0] +final val io.github.linreal.cascade.editor.ui.utils/io_github_linreal_cascade_editor_ui_utils_Dividers$stableprop // io.github.linreal.cascade.editor.ui.utils/io_github_linreal_cascade_editor_ui_utils_Dividers$stableprop|#static{}io_github_linreal_cascade_editor_ui_utils_Dividers$stableprop[0] +final val io.github.linreal.cascade.editor.ui.utils/io_github_linreal_cascade_editor_ui_utils_Spacers$stableprop // io.github.linreal.cascade.editor.ui.utils/io_github_linreal_cascade_editor_ui_utils_Spacers$stableprop|#static{}io_github_linreal_cascade_editor_ui_utils_Spacers$stableprop[0] +final val io.github.linreal.cascade.editor.ui/LocalBlockSpanStates // io.github.linreal.cascade.editor.ui/LocalBlockSpanStates|{}LocalBlockSpanStates[0] + final fun (): androidx.compose.runtime/ProvidableCompositionLocal // io.github.linreal.cascade.editor.ui/LocalBlockSpanStates.|(){}[0] +final val io.github.linreal.cascade.editor.ui/LocalBlockTextStates // io.github.linreal.cascade.editor.ui/LocalBlockTextStates|{}LocalBlockTextStates[0] + final fun (): androidx.compose.runtime/ProvidableCompositionLocal // io.github.linreal.cascade.editor.ui/LocalBlockTextStates.|(){}[0] +final val io.github.linreal.cascade.editor.ui/LocalCascadeEditorConfig // io.github.linreal.cascade.editor.ui/LocalCascadeEditorConfig|{}LocalCascadeEditorConfig[0] + final fun (): androidx.compose.runtime/ProvidableCompositionLocal // io.github.linreal.cascade.editor.ui/LocalCascadeEditorConfig.|(){}[0] +final val io.github.linreal.cascade.editor.ui/LocalFormattingActions // io.github.linreal.cascade.editor.ui/LocalFormattingActions|{}LocalFormattingActions[0] + final fun (): androidx.compose.runtime/ProvidableCompositionLocal // io.github.linreal.cascade.editor.ui/LocalFormattingActions.|(){}[0] +final val io.github.linreal.cascade.editor.ui/LocalIndentationActions // io.github.linreal.cascade.editor.ui/LocalIndentationActions|{}LocalIndentationActions[0] + final fun (): androidx.compose.runtime/ProvidableCompositionLocal // io.github.linreal.cascade.editor.ui/LocalIndentationActions.|(){}[0] +final val io.github.linreal.cascade.editor.ui/LocalIndentationState // io.github.linreal.cascade.editor.ui/LocalIndentationState|{}LocalIndentationState[0] + final fun (): androidx.compose.runtime/ProvidableCompositionLocal?> // io.github.linreal.cascade.editor.ui/LocalIndentationState.|(){}[0] +final val io.github.linreal.cascade.editor.ui/LocalLinkActions // io.github.linreal.cascade.editor.ui/LocalLinkActions|{}LocalLinkActions[0] + final fun (): androidx.compose.runtime/ProvidableCompositionLocal // io.github.linreal.cascade.editor.ui/LocalLinkActions.|(){}[0] +final val io.github.linreal.cascade.editor.ui/LocalLinkState // io.github.linreal.cascade.editor.ui/LocalLinkState|{}LocalLinkState[0] + final fun (): androidx.compose.runtime/ProvidableCompositionLocal?> // io.github.linreal.cascade.editor.ui/LocalLinkState.|(){}[0] +final val io.github.linreal.cascade.editor.ui/LocalSpanActionDispatcher // io.github.linreal.cascade.editor.ui/LocalSpanActionDispatcher|{}LocalSpanActionDispatcher[0] + final fun (): androidx.compose.runtime/ProvidableCompositionLocal // io.github.linreal.cascade.editor.ui/LocalSpanActionDispatcher.|(){}[0] +final val io.github.linreal.cascade.editor.ui/io_github_linreal_cascade_editor_ui_CascadeEditorConfig$stableprop // io.github.linreal.cascade.editor.ui/io_github_linreal_cascade_editor_ui_CascadeEditorConfig$stableprop|#static{}io_github_linreal_cascade_editor_ui_CascadeEditorConfig$stableprop[0] +final val io.github.linreal.cascade.editor.ui/io_github_linreal_cascade_editor_ui_FocusedBlockScrollTarget_By$stableprop // io.github.linreal.cascade.editor.ui/io_github_linreal_cascade_editor_ui_FocusedBlockScrollTarget_By$stableprop|#static{}io_github_linreal_cascade_editor_ui_FocusedBlockScrollTarget_By$stableprop[0] +final val io.github.linreal.cascade.editor.ui/io_github_linreal_cascade_editor_ui_FocusedBlockScrollTarget_ToItem$stableprop // io.github.linreal.cascade.editor.ui/io_github_linreal_cascade_editor_ui_FocusedBlockScrollTarget_ToItem$stableprop|#static{}io_github_linreal_cascade_editor_ui_FocusedBlockScrollTarget_ToItem$stableprop[0] +final val io.github.linreal.cascade.editor.ui/io_github_linreal_cascade_editor_ui_LinkPopupSlot_Custom$stableprop // io.github.linreal.cascade.editor.ui/io_github_linreal_cascade_editor_ui_LinkPopupSlot_Custom$stableprop|#static{}io_github_linreal_cascade_editor_ui_LinkPopupSlot_Custom$stableprop[0] +final val io.github.linreal.cascade.editor.ui/io_github_linreal_cascade_editor_ui_LinkPopupSlot_Default$stableprop // io.github.linreal.cascade.editor.ui/io_github_linreal_cascade_editor_ui_LinkPopupSlot_Default$stableprop|#static{}io_github_linreal_cascade_editor_ui_LinkPopupSlot_Default$stableprop[0] +final val io.github.linreal.cascade.editor.ui/io_github_linreal_cascade_editor_ui_LinkPopupSlot_None$stableprop // io.github.linreal.cascade.editor.ui/io_github_linreal_cascade_editor_ui_LinkPopupSlot_None$stableprop|#static{}io_github_linreal_cascade_editor_ui_LinkPopupSlot_None$stableprop[0] +final val io.github.linreal.cascade.editor.ui/io_github_linreal_cascade_editor_ui_LinkPopupState$stableprop // io.github.linreal.cascade.editor.ui/io_github_linreal_cascade_editor_ui_LinkPopupState$stableprop|#static{}io_github_linreal_cascade_editor_ui_LinkPopupState$stableprop[0] +final val io.github.linreal.cascade.editor.ui/io_github_linreal_cascade_editor_ui_RichTextToolbarConfig$stableprop // io.github.linreal.cascade.editor.ui/io_github_linreal_cascade_editor_ui_RichTextToolbarConfig$stableprop|#static{}io_github_linreal_cascade_editor_ui_RichTextToolbarConfig$stableprop[0] +final val io.github.linreal.cascade.editor.ui/io_github_linreal_cascade_editor_ui_SlashCommandSlot_Default$stableprop // io.github.linreal.cascade.editor.ui/io_github_linreal_cascade_editor_ui_SlashCommandSlot_Default$stableprop|#static{}io_github_linreal_cascade_editor_ui_SlashCommandSlot_Default$stableprop[0] +final val io.github.linreal.cascade.editor.ui/io_github_linreal_cascade_editor_ui_SlashCommandSlot_None$stableprop // io.github.linreal.cascade.editor.ui/io_github_linreal_cascade_editor_ui_SlashCommandSlot_None$stableprop|#static{}io_github_linreal_cascade_editor_ui_SlashCommandSlot_None$stableprop[0] +final val io.github.linreal.cascade.editor.ui/io_github_linreal_cascade_editor_ui_ToolbarButtonSpec$stableprop // io.github.linreal.cascade.editor.ui/io_github_linreal_cascade_editor_ui_ToolbarButtonSpec$stableprop|#static{}io_github_linreal_cascade_editor_ui_ToolbarButtonSpec$stableprop[0] +final val io.github.linreal.cascade.editor.ui/io_github_linreal_cascade_editor_ui_ToolbarSlot_Custom$stableprop // io.github.linreal.cascade.editor.ui/io_github_linreal_cascade_editor_ui_ToolbarSlot_Custom$stableprop|#static{}io_github_linreal_cascade_editor_ui_ToolbarSlot_Custom$stableprop[0] +final val io.github.linreal.cascade.editor.ui/io_github_linreal_cascade_editor_ui_ToolbarSlot_Default$stableprop // io.github.linreal.cascade.editor.ui/io_github_linreal_cascade_editor_ui_ToolbarSlot_Default$stableprop|#static{}io_github_linreal_cascade_editor_ui_ToolbarSlot_Default$stableprop[0] +final val io.github.linreal.cascade.editor.ui/io_github_linreal_cascade_editor_ui_ToolbarSlot_None$stableprop // io.github.linreal.cascade.editor.ui/io_github_linreal_cascade_editor_ui_ToolbarSlot_None$stableprop|#static{}io_github_linreal_cascade_editor_ui_ToolbarSlot_None$stableprop[0] +final val io.github.linreal.cascade.editor/io_github_linreal_cascade_editor_CascadeError$stableprop // io.github.linreal.cascade.editor/io_github_linreal_cascade_editor_CascadeError$stableprop|#static{}io_github_linreal_cascade_editor_CascadeError$stableprop[0] + +final fun (androidx.compose.foundation.text.input/TextFieldState).io.github.linreal.cascade.editor.ui/selectedVisibleText(): kotlin/String // io.github.linreal.cascade.editor.ui/selectedVisibleText|selectedVisibleText@androidx.compose.foundation.text.input.TextFieldState(){}[0] +final fun (androidx.compose.foundation.text.input/TextFieldState).io.github.linreal.cascade.editor.ui/visibleCursorPosition(): kotlin/Int // io.github.linreal.cascade.editor.ui/visibleCursorPosition|visibleCursorPosition@androidx.compose.foundation.text.input.TextFieldState(){}[0] +final fun (androidx.compose.foundation.text.input/TextFieldState).io.github.linreal.cascade.editor.ui/visibleSelection(): androidx.compose.ui.text/TextRange // io.github.linreal.cascade.editor.ui/visibleSelection|visibleSelection@androidx.compose.foundation.text.input.TextFieldState(){}[0] +final fun (androidx.compose.foundation.text.input/TextFieldState).io.github.linreal.cascade.editor.ui/visibleText(): kotlin/String // io.github.linreal.cascade.editor.ui/visibleText|visibleText@androidx.compose.foundation.text.input.TextFieldState(){}[0] +final fun (androidx.compose.ui/Modifier).io.github.linreal.cascade.editor.ui/draggableAfterLongPress(kotlin/Any, kotlin/Boolean = ..., kotlin/Long? = ..., kotlin/Function1, kotlin/Function1, kotlin/Function0, kotlin/Function0 = ...): androidx.compose.ui/Modifier // io.github.linreal.cascade.editor.ui/draggableAfterLongPress|draggableAfterLongPress@androidx.compose.ui.Modifier(kotlin.Any;kotlin.Boolean;kotlin.Long?;kotlin.Function1;kotlin.Function1;kotlin.Function0;kotlin.Function0){}[0] +final fun (io.github.linreal.cascade.editor.registry/BlockRegistry).io.github.linreal.cascade.editor.ui/registerBuiltInRenderers() // io.github.linreal.cascade.editor.ui/registerBuiltInRenderers|registerBuiltInRenderers@io.github.linreal.cascade.editor.registry.BlockRegistry(){}[0] +final fun (io.github.linreal.cascade.editor.state/EditorStateHolder).io.github.linreal.cascade.editor.htmlserialization/loadFromHtml(kotlin/String, io.github.linreal.cascade.editor.state/BlockTextStates, io.github.linreal.cascade.editor.state/BlockSpanStates, io.github.linreal.cascade.editor.htmlserialization/HtmlProfile, io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeLimits = ...): io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeResult // io.github.linreal.cascade.editor.htmlserialization/loadFromHtml|loadFromHtml@io.github.linreal.cascade.editor.state.EditorStateHolder(kotlin.String;io.github.linreal.cascade.editor.state.BlockTextStates;io.github.linreal.cascade.editor.state.BlockSpanStates;io.github.linreal.cascade.editor.htmlserialization.HtmlProfile;io.github.linreal.cascade.editor.htmlserialization.HtmlDecodeLimits){}[0] +final fun (io.github.linreal.cascade.editor.state/EditorStateHolder).io.github.linreal.cascade.editor.htmlserialization/toHtml(io.github.linreal.cascade.editor.state/BlockTextStates, io.github.linreal.cascade.editor.state/BlockSpanStates, io.github.linreal.cascade.editor.htmlserialization/HtmlProfile): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/toHtml|toHtml@io.github.linreal.cascade.editor.state.EditorStateHolder(io.github.linreal.cascade.editor.state.BlockTextStates;io.github.linreal.cascade.editor.state.BlockSpanStates;io.github.linreal.cascade.editor.htmlserialization.HtmlProfile){}[0] +final fun (io.github.linreal.cascade.editor.state/EditorStateHolder).io.github.linreal.cascade.editor.serialization/loadFromJson(kotlin/String, io.github.linreal.cascade.editor.state/BlockTextStates, io.github.linreal.cascade.editor.state/BlockSpanStates, io.github.linreal.cascade.editor.serialization/DocumentDecodeOptions = ..., io.github.linreal.cascade.editor.serialization/BlockTypeCodec? = ..., io.github.linreal.cascade.editor.serialization/BlockContentCodec? = ...): io.github.linreal.cascade.editor.serialization/DocumentDecodeResult // io.github.linreal.cascade.editor.serialization/loadFromJson|loadFromJson@io.github.linreal.cascade.editor.state.EditorStateHolder(kotlin.String;io.github.linreal.cascade.editor.state.BlockTextStates;io.github.linreal.cascade.editor.state.BlockSpanStates;io.github.linreal.cascade.editor.serialization.DocumentDecodeOptions;io.github.linreal.cascade.editor.serialization.BlockTypeCodec?;io.github.linreal.cascade.editor.serialization.BlockContentCodec?){}[0] +final fun (io.github.linreal.cascade.editor.state/EditorStateHolder).io.github.linreal.cascade.editor.serialization/resolveDocumentBlocks(io.github.linreal.cascade.editor.state/BlockTextStates, io.github.linreal.cascade.editor.state/BlockSpanStates): kotlin.collections/List // io.github.linreal.cascade.editor.serialization/resolveDocumentBlocks|resolveDocumentBlocks@io.github.linreal.cascade.editor.state.EditorStateHolder(io.github.linreal.cascade.editor.state.BlockTextStates;io.github.linreal.cascade.editor.state.BlockSpanStates){}[0] +final fun (io.github.linreal.cascade.editor.state/EditorStateHolder).io.github.linreal.cascade.editor.serialization/toJson(io.github.linreal.cascade.editor.state/BlockTextStates, io.github.linreal.cascade.editor.state/BlockSpanStates, io.github.linreal.cascade.editor.serialization/DocumentEncodeOptions = ..., io.github.linreal.cascade.editor.serialization/BlockTypeCodec? = ..., io.github.linreal.cascade.editor.serialization/BlockContentCodec? = ...): kotlin/String // io.github.linreal.cascade.editor.serialization/toJson|toJson@io.github.linreal.cascade.editor.state.EditorStateHolder(io.github.linreal.cascade.editor.state.BlockTextStates;io.github.linreal.cascade.editor.state.BlockSpanStates;io.github.linreal.cascade.editor.serialization.DocumentEncodeOptions;io.github.linreal.cascade.editor.serialization.BlockTypeCodec?;io.github.linreal.cascade.editor.serialization.BlockContentCodec?){}[0] +final fun <#A: io.github.linreal.cascade.editor.core/BlockType> io.github.linreal.cascade.editor.registry/blockRenderer(kotlin/Function7): io.github.linreal.cascade.editor.registry/BlockRenderer<#A> // io.github.linreal.cascade.editor.registry/blockRenderer|blockRenderer(kotlin.Function7){0§}[0] +final fun cascadeeditor.editor.generated.resources/cascadeeditor_editor_generated_resources_Res_array$stableprop_getter(): kotlin/Int // cascadeeditor.editor.generated.resources/cascadeeditor_editor_generated_resources_Res_array$stableprop_getter|cascadeeditor_editor_generated_resources_Res_array$stableprop_getter(){}[0] +final fun cascadeeditor.editor.generated.resources/cascadeeditor_editor_generated_resources_Res_drawable$stableprop_getter(): kotlin/Int // cascadeeditor.editor.generated.resources/cascadeeditor_editor_generated_resources_Res_drawable$stableprop_getter|cascadeeditor_editor_generated_resources_Res_drawable$stableprop_getter(){}[0] +final fun cascadeeditor.editor.generated.resources/cascadeeditor_editor_generated_resources_Res_font$stableprop_getter(): kotlin/Int // cascadeeditor.editor.generated.resources/cascadeeditor_editor_generated_resources_Res_font$stableprop_getter|cascadeeditor_editor_generated_resources_Res_font$stableprop_getter(){}[0] +final fun cascadeeditor.editor.generated.resources/cascadeeditor_editor_generated_resources_Res_plurals$stableprop_getter(): kotlin/Int // cascadeeditor.editor.generated.resources/cascadeeditor_editor_generated_resources_Res_plurals$stableprop_getter|cascadeeditor_editor_generated_resources_Res_plurals$stableprop_getter(){}[0] +final fun cascadeeditor.editor.generated.resources/cascadeeditor_editor_generated_resources_Res_string$stableprop_getter(): kotlin/Int // cascadeeditor.editor.generated.resources/cascadeeditor_editor_generated_resources_Res_string$stableprop_getter|cascadeeditor_editor_generated_resources_Res_string$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_AddBlockRangeToSelection$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_AddBlockRangeToSelection$stableprop_getter|io_github_linreal_cascade_editor_action_AddBlockRangeToSelection$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_ApplySpanStyle$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_ApplySpanStyle$stableprop_getter|io_github_linreal_cascade_editor_action_ApplySpanStyle$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_CancelDrag$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_CancelDrag$stableprop_getter|io_github_linreal_cascade_editor_action_CancelDrag$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_ClearFocus$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_ClearFocus$stableprop_getter|io_github_linreal_cascade_editor_action_ClearFocus$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_ClearSelection$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_ClearSelection$stableprop_getter|io_github_linreal_cascade_editor_action_ClearSelection$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_CloseSlashCommand$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_CloseSlashCommand$stableprop_getter|io_github_linreal_cascade_editor_action_CloseSlashCommand$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_CompleteDrag$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_CompleteDrag$stableprop_getter|io_github_linreal_cascade_editor_action_CompleteDrag$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_ConvertBlockType$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_ConvertBlockType$stableprop_getter|io_github_linreal_cascade_editor_action_ConvertBlockType$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_DeleteBlock$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_DeleteBlock$stableprop_getter|io_github_linreal_cascade_editor_action_DeleteBlock$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_DeleteBlocks$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_DeleteBlocks$stableprop_getter|io_github_linreal_cascade_editor_action_DeleteBlocks$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_DeleteSelectedOrFocused$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_DeleteSelectedOrFocused$stableprop_getter|io_github_linreal_cascade_editor_action_DeleteSelectedOrFocused$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_FocusBlock$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_FocusBlock$stableprop_getter|io_github_linreal_cascade_editor_action_FocusBlock$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_FocusNextBlock$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_FocusNextBlock$stableprop_getter|io_github_linreal_cascade_editor_action_FocusNextBlock$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_FocusPreviousBlock$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_FocusPreviousBlock$stableprop_getter|io_github_linreal_cascade_editor_action_FocusPreviousBlock$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_HighlightSlashCommand$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_HighlightSlashCommand$stableprop_getter|io_github_linreal_cascade_editor_action_HighlightSlashCommand$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_IndentBackward$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_IndentBackward$stableprop_getter|io_github_linreal_cascade_editor_action_IndentBackward$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_IndentForward$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_IndentForward$stableprop_getter|io_github_linreal_cascade_editor_action_IndentForward$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_InsertBlock$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_InsertBlock$stableprop_getter|io_github_linreal_cascade_editor_action_InsertBlock$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_InsertBlockAfter$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_InsertBlockAfter$stableprop_getter|io_github_linreal_cascade_editor_action_InsertBlockAfter$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_InsertBlockBefore$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_InsertBlockBefore$stableprop_getter|io_github_linreal_cascade_editor_action_InsertBlockBefore$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_MergeBlocks$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_MergeBlocks$stableprop_getter|io_github_linreal_cascade_editor_action_MergeBlocks$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_MoveBlocks$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_MoveBlocks$stableprop_getter|io_github_linreal_cascade_editor_action_MoveBlocks$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_NavigateSlashBack$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_NavigateSlashBack$stableprop_getter|io_github_linreal_cascade_editor_action_NavigateSlashBack$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_NavigateSlashSubmenu$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_NavigateSlashSubmenu$stableprop_getter|io_github_linreal_cascade_editor_action_NavigateSlashSubmenu$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_OpenSlashCommand$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_OpenSlashCommand$stableprop_getter|io_github_linreal_cascade_editor_action_OpenSlashCommand$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_RemoveSpanStyle$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_RemoveSpanStyle$stableprop_getter|io_github_linreal_cascade_editor_action_RemoveSpanStyle$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_ReplaceBlock$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_ReplaceBlock$stableprop_getter|io_github_linreal_cascade_editor_action_ReplaceBlock$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_SelectAll$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_SelectAll$stableprop_getter|io_github_linreal_cascade_editor_action_SelectAll$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_SelectBlock$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_SelectBlock$stableprop_getter|io_github_linreal_cascade_editor_action_SelectBlock$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_SelectBlockRange$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_SelectBlockRange$stableprop_getter|io_github_linreal_cascade_editor_action_SelectBlockRange$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_SplitBlock$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_SplitBlock$stableprop_getter|io_github_linreal_cascade_editor_action_SplitBlock$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_StartDrag$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_StartDrag$stableprop_getter|io_github_linreal_cascade_editor_action_StartDrag$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_ToggleBlockSelection$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_ToggleBlockSelection$stableprop_getter|io_github_linreal_cascade_editor_action_ToggleBlockSelection$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_ToggleTodo$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_ToggleTodo$stableprop_getter|io_github_linreal_cascade_editor_action_ToggleTodo$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_UpdateBlockContent$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_UpdateBlockContent$stableprop_getter|io_github_linreal_cascade_editor_action_UpdateBlockContent$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_UpdateBlockText$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_UpdateBlockText$stableprop_getter|io_github_linreal_cascade_editor_action_UpdateBlockText$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_UpdateDragTarget$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_UpdateDragTarget$stableprop_getter|io_github_linreal_cascade_editor_action_UpdateDragTarget$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_UpdateSlashCommandSession$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.action/io_github_linreal_cascade_editor_action_UpdateSlashCommandSession$stableprop_getter|io_github_linreal_cascade_editor_action_UpdateSlashCommandSession$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_Block$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_Block$stableprop_getter|io_github_linreal_cascade_editor_core_Block$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_BlockAttributes$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_BlockAttributes$stableprop_getter|io_github_linreal_cascade_editor_core_BlockAttributes$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_BlockContent_Custom$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_BlockContent_Custom$stableprop_getter|io_github_linreal_cascade_editor_core_BlockContent_Custom$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_BlockContent_Empty$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_BlockContent_Empty$stableprop_getter|io_github_linreal_cascade_editor_core_BlockContent_Empty$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_BlockContent_Text$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_BlockContent_Text$stableprop_getter|io_github_linreal_cascade_editor_core_BlockContent_Text$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_BlockType_BulletList$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_BlockType_BulletList$stableprop_getter|io_github_linreal_cascade_editor_core_BlockType_BulletList$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_BlockType_Code$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_BlockType_Code$stableprop_getter|io_github_linreal_cascade_editor_core_BlockType_Code$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_BlockType_Divider$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_BlockType_Divider$stableprop_getter|io_github_linreal_cascade_editor_core_BlockType_Divider$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_BlockType_Heading$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_BlockType_Heading$stableprop_getter|io_github_linreal_cascade_editor_core_BlockType_Heading$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_BlockType_NumberedList$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_BlockType_NumberedList$stableprop_getter|io_github_linreal_cascade_editor_core_BlockType_NumberedList$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_BlockType_Paragraph$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_BlockType_Paragraph$stableprop_getter|io_github_linreal_cascade_editor_core_BlockType_Paragraph$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_BlockType_Quote$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_BlockType_Quote$stableprop_getter|io_github_linreal_cascade_editor_core_BlockType_Quote$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_BlockType_Todo$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_BlockType_Todo$stableprop_getter|io_github_linreal_cascade_editor_core_BlockType_Todo$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_SpanStyle_Bold$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_SpanStyle_Bold$stableprop_getter|io_github_linreal_cascade_editor_core_SpanStyle_Bold$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_SpanStyle_Custom$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_SpanStyle_Custom$stableprop_getter|io_github_linreal_cascade_editor_core_SpanStyle_Custom$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_SpanStyle_Highlight$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_SpanStyle_Highlight$stableprop_getter|io_github_linreal_cascade_editor_core_SpanStyle_Highlight$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_SpanStyle_InlineCode$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_SpanStyle_InlineCode$stableprop_getter|io_github_linreal_cascade_editor_core_SpanStyle_InlineCode$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_SpanStyle_Italic$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_SpanStyle_Italic$stableprop_getter|io_github_linreal_cascade_editor_core_SpanStyle_Italic$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_SpanStyle_Link$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_SpanStyle_Link$stableprop_getter|io_github_linreal_cascade_editor_core_SpanStyle_Link$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_SpanStyle_StrikeThrough$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_SpanStyle_StrikeThrough$stableprop_getter|io_github_linreal_cascade_editor_core_SpanStyle_StrikeThrough$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_SpanStyle_Underline$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_SpanStyle_Underline$stableprop_getter|io_github_linreal_cascade_editor_core_SpanStyle_Underline$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_TextSpan$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_TextSpan$stableprop_getter|io_github_linreal_cascade_editor_core_TextSpan$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_UnknownBlockType$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.core/io_github_linreal_cascade_editor_core_UnknownBlockType$stableprop_getter|io_github_linreal_cascade_editor_core_UnknownBlockType$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_BlockSeparator_BlockTags$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_BlockSeparator_BlockTags$stableprop_getter|io_github_linreal_cascade_editor_htmlserialization_BlockSeparator_BlockTags$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_BlockSeparator_Newline$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_BlockSeparator_Newline$stableprop_getter|io_github_linreal_cascade_editor_htmlserialization_BlockSeparator_Newline$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_EntityDecode_None$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_EntityDecode_None$stableprop_getter|io_github_linreal_cascade_editor_htmlserialization_EntityDecode_None$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_EntityDecode_Standard$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_EntityDecode_Standard$stableprop_getter|io_github_linreal_cascade_editor_htmlserialization_EntityDecode_Standard$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_Html$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_Html$stableprop_getter|io_github_linreal_cascade_editor_htmlserialization_Html$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeLimits$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeLimits$stableprop_getter|io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeLimits$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeResult$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeResult$stableprop_getter|io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeResult$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning$stableprop_getter|io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_BlockInInlineContext$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_BlockInInlineContext$stableprop_getter|io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_BlockInInlineContext$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_DecoderException$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_DecoderException$stableprop_getter|io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_DecoderException$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_DroppedAttribute$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_DroppedAttribute$stableprop_getter|io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_DroppedAttribute$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_DroppedContent$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_DroppedContent$stableprop_getter|io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_DroppedContent$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_InputLimitExceeded$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_InputLimitExceeded$stableprop_getter|io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_InputLimitExceeded$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_InvalidAttribute$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_InvalidAttribute$stableprop_getter|io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_InvalidAttribute$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_MismatchedNesting$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_MismatchedNesting$stableprop_getter|io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_MismatchedNesting$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_StrayClosingTag$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_StrayClosingTag$stableprop_getter|io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_StrayClosingTag$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_UnclosedTag$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_UnclosedTag$stableprop_getter|io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_UnclosedTag$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_UnknownAttribute$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_UnknownAttribute$stableprop_getter|io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_UnknownAttribute$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_UnknownTag$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_UnknownTag$stableprop_getter|io_github_linreal_cascade_editor_htmlserialization_HtmlDecodeWarning_UnknownTag$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlEmit_Raw$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlEmit_Raw$stableprop_getter|io_github_linreal_cascade_editor_htmlserialization_HtmlEmit_Raw$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlEmit_Skip$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlEmit_Skip$stableprop_getter|io_github_linreal_cascade_editor_htmlserialization_HtmlEmit_Skip$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlEncodeContext$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlEncodeContext$stableprop_getter|io_github_linreal_cascade_editor_htmlserialization_HtmlEncodeContext$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlEncodeResult$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlEncodeResult$stableprop_getter|io_github_linreal_cascade_editor_htmlserialization_HtmlEncodeResult$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlEncodeWarning$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlEncodeWarning$stableprop_getter|io_github_linreal_cascade_editor_htmlserialization_HtmlEncodeWarning$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlEncodeWarning_DroppedAttribute$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlEncodeWarning_DroppedAttribute$stableprop_getter|io_github_linreal_cascade_editor_htmlserialization_HtmlEncodeWarning_DroppedAttribute$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlEncodeWarning_EncoderException$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlEncodeWarning_EncoderException$stableprop_getter|io_github_linreal_cascade_editor_htmlserialization_HtmlEncodeWarning_EncoderException$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlNodeView_Element$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlNodeView_Element$stableprop_getter|io_github_linreal_cascade_editor_htmlserialization_HtmlNodeView_Element$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlNodeView_Text$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlNodeView_Text$stableprop_getter|io_github_linreal_cascade_editor_htmlserialization_HtmlNodeView_Text$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlNode_Element$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlNode_Element$stableprop_getter|io_github_linreal_cascade_editor_htmlserialization_HtmlNode_Element$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlNode_Text$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlNode_Text$stableprop_getter|io_github_linreal_cascade_editor_htmlserialization_HtmlNode_Text$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlPolicyApplier_PolicyPart_NewlineBreak$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlPolicyApplier_PolicyPart_NewlineBreak$stableprop_getter|io_github_linreal_cascade_editor_htmlserialization_HtmlPolicyApplier_PolicyPart_NewlineBreak$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlPolicyApplier_PolicyPart_Node$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlPolicyApplier_PolicyPart_Node$stableprop_getter|io_github_linreal_cascade_editor_htmlserialization_HtmlPolicyApplier_PolicyPart_Node$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlProfile$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlProfile$stableprop_getter|io_github_linreal_cascade_editor_htmlserialization_HtmlProfile$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlProfileSupportSet$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlProfileSupportSet$stableprop_getter|io_github_linreal_cascade_editor_htmlserialization_HtmlProfileSupportSet$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlSchema$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlSchema$stableprop_getter|io_github_linreal_cascade_editor_htmlserialization_HtmlSchema$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlTagPair$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlTagPair$stableprop_getter|io_github_linreal_cascade_editor_htmlserialization_HtmlTagPair$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlToken_CloseTag$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlToken_CloseTag$stableprop_getter|io_github_linreal_cascade_editor_htmlserialization_HtmlToken_CloseTag$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlToken_OpenTag$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlToken_OpenTag$stableprop_getter|io_github_linreal_cascade_editor_htmlserialization_HtmlToken_OpenTag$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlToken_Text$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_HtmlToken_Text$stableprop_getter|io_github_linreal_cascade_editor_htmlserialization_HtmlToken_Text$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_InlineFragment$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_InlineFragment$stableprop_getter|io_github_linreal_cascade_editor_htmlserialization_InlineFragment$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_InlineRoot_Drop$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_InlineRoot_Drop$stableprop_getter|io_github_linreal_cascade_editor_htmlserialization_InlineRoot_Drop$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_InlineRoot_WrapInParagraph$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_InlineRoot_WrapInParagraph$stableprop_getter|io_github_linreal_cascade_editor_htmlserialization_InlineRoot_WrapInParagraph$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_TagDecodeContext$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_TagDecodeContext$stableprop_getter|io_github_linreal_cascade_editor_htmlserialization_TagDecodeContext$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_TagDecodeResult_AsBlock$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_TagDecodeResult_AsBlock$stableprop_getter|io_github_linreal_cascade_editor_htmlserialization_TagDecodeResult_AsBlock$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_TagDecodeResult_AsBlocks$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_TagDecodeResult_AsBlocks$stableprop_getter|io_github_linreal_cascade_editor_htmlserialization_TagDecodeResult_AsBlocks$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_TagDecodeResult_AsText$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_TagDecodeResult_AsText$stableprop_getter|io_github_linreal_cascade_editor_htmlserialization_TagDecodeResult_AsText$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_TagDecodeResult_Drop$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_TagDecodeResult_Drop$stableprop_getter|io_github_linreal_cascade_editor_htmlserialization_TagDecodeResult_Drop$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_UnknownTagPolicy_Custom$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_UnknownTagPolicy_Custom$stableprop_getter|io_github_linreal_cascade_editor_htmlserialization_UnknownTagPolicy_Custom$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_UnknownTagPolicy_Preserve$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_UnknownTagPolicy_Preserve$stableprop_getter|io_github_linreal_cascade_editor_htmlserialization_UnknownTagPolicy_Preserve$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_UnknownTagPolicy_Strip$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_UnknownTagPolicy_Strip$stableprop_getter|io_github_linreal_cascade_editor_htmlserialization_UnknownTagPolicy_Strip$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_UnknownTagPolicy_WarnAndStrip$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_UnknownTagPolicy_WarnAndStrip$stableprop_getter|io_github_linreal_cascade_editor_htmlserialization_UnknownTagPolicy_WarnAndStrip$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.htmlserialization/openTagWithCascadeIndentation(kotlin/String, io.github.linreal.cascade.editor.core/Block): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/openTagWithCascadeIndentation|openTagWithCascadeIndentation(kotlin.String;io.github.linreal.cascade.editor.core.Block){}[0] +final fun io.github.linreal.cascade.editor.indentation/io_github_linreal_cascade_editor_indentation_IndentationState$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.indentation/io_github_linreal_cascade_editor_indentation_IndentationState$stableprop_getter|io_github_linreal_cascade_editor_indentation_IndentationState$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.registry/io_github_linreal_cascade_editor_registry_BlockDescriptor$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.registry/io_github_linreal_cascade_editor_registry_BlockDescriptor$stableprop_getter|io_github_linreal_cascade_editor_registry_BlockDescriptor$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.registry/io_github_linreal_cascade_editor_registry_BlockRegistry$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.registry/io_github_linreal_cascade_editor_registry_BlockRegistry$stableprop_getter|io_github_linreal_cascade_editor_registry_BlockRegistry$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.registry/io_github_linreal_cascade_editor_registry_DefaultBlockCallbacks$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.registry/io_github_linreal_cascade_editor_registry_DefaultBlockCallbacks$stableprop_getter|io_github_linreal_cascade_editor_registry_DefaultBlockCallbacks$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.registry/io_github_linreal_cascade_editor_registry_LambdaBlockRenderer$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.registry/io_github_linreal_cascade_editor_registry_LambdaBlockRenderer$stableprop_getter|io_github_linreal_cascade_editor_registry_LambdaBlockRenderer$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.richtext/io_github_linreal_cascade_editor_richtext_FormattingState$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.richtext/io_github_linreal_cascade_editor_richtext_FormattingState$stableprop_getter|io_github_linreal_cascade_editor_richtext_FormattingState$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.richtext/io_github_linreal_cascade_editor_richtext_LinkActionDispatcher$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.richtext/io_github_linreal_cascade_editor_richtext_LinkActionDispatcher$stableprop_getter|io_github_linreal_cascade_editor_richtext_LinkActionDispatcher$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.richtext/io_github_linreal_cascade_editor_richtext_LinkState$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.richtext/io_github_linreal_cascade_editor_richtext_LinkState$stableprop_getter|io_github_linreal_cascade_editor_richtext_LinkState$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.richtext/io_github_linreal_cascade_editor_richtext_LinkTarget$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.richtext/io_github_linreal_cascade_editor_richtext_LinkTarget$stableprop_getter|io_github_linreal_cascade_editor_richtext_LinkTarget$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.richtext/io_github_linreal_cascade_editor_richtext_LinkUrlPolicy$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.richtext/io_github_linreal_cascade_editor_richtext_LinkUrlPolicy$stableprop_getter|io_github_linreal_cascade_editor_richtext_LinkUrlPolicy$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.richtext/io_github_linreal_cascade_editor_richtext_LinkValidationResult_Invalid$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.richtext/io_github_linreal_cascade_editor_richtext_LinkValidationResult_Invalid$stableprop_getter|io_github_linreal_cascade_editor_richtext_LinkValidationResult_Invalid$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.richtext/io_github_linreal_cascade_editor_richtext_LinkValidationResult_Valid$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.richtext/io_github_linreal_cascade_editor_richtext_LinkValidationResult_Valid$stableprop_getter|io_github_linreal_cascade_editor_richtext_LinkValidationResult_Valid$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.richtext/io_github_linreal_cascade_editor_richtext_SpanActionDispatcher$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.richtext/io_github_linreal_cascade_editor_richtext_SpanActionDispatcher$stableprop_getter|io_github_linreal_cascade_editor_richtext_SpanActionDispatcher$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_DocumentDecodeOptions$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_DocumentDecodeOptions$stableprop_getter|io_github_linreal_cascade_editor_serialization_DocumentDecodeOptions$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_DocumentDecodeResult$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_DocumentDecodeResult$stableprop_getter|io_github_linreal_cascade_editor_serialization_DocumentDecodeResult$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning$stableprop_getter|io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning_DocumentParseFailed$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning_DocumentParseFailed$stableprop_getter|io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning_DocumentParseFailed$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning_DuplicateIdRegenerated$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning_DuplicateIdRegenerated$stableprop_getter|io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning_DuplicateIdRegenerated$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning_InvalidBlockAttributeParam$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning_InvalidBlockAttributeParam$stableprop_getter|io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning_InvalidBlockAttributeParam$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning_InvalidBlockTypeParam$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning_InvalidBlockTypeParam$stableprop_getter|io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning_InvalidBlockTypeParam$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning_MalformedBlockSkipped$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning_MalformedBlockSkipped$stableprop_getter|io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning_MalformedBlockSkipped$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning_MissingIdRegenerated$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning_MissingIdRegenerated$stableprop_getter|io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning_MissingIdRegenerated$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning_UnknownBlockTypePreserved$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning_UnknownBlockTypePreserved$stableprop_getter|io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning_UnknownBlockTypePreserved$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning_UnknownContentKind$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning_UnknownContentKind$stableprop_getter|io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning_UnknownContentKind$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning_UnsupportedCustomDataDropped$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning_UnsupportedCustomDataDropped$stableprop_getter|io_github_linreal_cascade_editor_serialization_DocumentDecodeWarning_UnsupportedCustomDataDropped$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_DocumentEncodeOptions$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_DocumentEncodeOptions$stableprop_getter|io_github_linreal_cascade_editor_serialization_DocumentEncodeOptions$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_DocumentSchema$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_DocumentSchema$stableprop_getter|io_github_linreal_cascade_editor_serialization_DocumentSchema$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_RichTextSchema$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.serialization/io_github_linreal_cascade_editor_serialization_RichTextSchema$stableprop_getter|io_github_linreal_cascade_editor_serialization_RichTextSchema$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.slash/builtInBlockSlashCommandId(kotlin/String): io.github.linreal.cascade.editor.slash/SlashCommandId // io.github.linreal.cascade.editor.slash/builtInBlockSlashCommandId|builtInBlockSlashCommandId(kotlin.String){}[0] +final fun io.github.linreal.cascade.editor.slash/io_github_linreal_cascade_editor_slash_BuiltInBlockSlashBehavior_AlwaysInsert$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.slash/io_github_linreal_cascade_editor_slash_BuiltInBlockSlashBehavior_AlwaysInsert$stableprop_getter|io_github_linreal_cascade_editor_slash_BuiltInBlockSlashBehavior_AlwaysInsert$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.slash/io_github_linreal_cascade_editor_slash_BuiltInBlockSlashBehavior_ConvertInPlace$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.slash/io_github_linreal_cascade_editor_slash_BuiltInBlockSlashBehavior_ConvertInPlace$stableprop_getter|io_github_linreal_cascade_editor_slash_BuiltInBlockSlashBehavior_ConvertInPlace$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.slash/io_github_linreal_cascade_editor_slash_BuiltInSlashCommandSpec$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.slash/io_github_linreal_cascade_editor_slash_BuiltInSlashCommandSpec$stableprop_getter|io_github_linreal_cascade_editor_slash_BuiltInSlashCommandSpec$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.slash/io_github_linreal_cascade_editor_slash_SlashCommandAction$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.slash/io_github_linreal_cascade_editor_slash_SlashCommandAction$stableprop_getter|io_github_linreal_cascade_editor_slash_SlashCommandAction$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.slash/io_github_linreal_cascade_editor_slash_SlashCommandContext$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.slash/io_github_linreal_cascade_editor_slash_SlashCommandContext$stableprop_getter|io_github_linreal_cascade_editor_slash_SlashCommandContext$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.slash/io_github_linreal_cascade_editor_slash_SlashCommandMenu$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.slash/io_github_linreal_cascade_editor_slash_SlashCommandMenu$stableprop_getter|io_github_linreal_cascade_editor_slash_SlashCommandMenu$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.slash/io_github_linreal_cascade_editor_slash_SlashCommandRegistry$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.slash/io_github_linreal_cascade_editor_slash_SlashCommandRegistry$stableprop_getter|io_github_linreal_cascade_editor_slash_SlashCommandRegistry$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.slash/io_github_linreal_cascade_editor_slash_SlashCommandResult_Done$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.slash/io_github_linreal_cascade_editor_slash_SlashCommandResult_Done$stableprop_getter|io_github_linreal_cascade_editor_slash_SlashCommandResult_Done$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.slash/io_github_linreal_cascade_editor_slash_SlashCommandResult_Failure$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.slash/io_github_linreal_cascade_editor_slash_SlashCommandResult_Failure$stableprop_getter|io_github_linreal_cascade_editor_slash_SlashCommandResult_Failure$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.slash/io_github_linreal_cascade_editor_slash_SlashCommandResult_KeepOpen$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.slash/io_github_linreal_cascade_editor_slash_SlashCommandResult_KeepOpen$stableprop_getter|io_github_linreal_cascade_editor_slash_SlashCommandResult_KeepOpen$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.state/io_github_linreal_cascade_editor_state_BlockSpanStates$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.state/io_github_linreal_cascade_editor_state_BlockSpanStates$stableprop_getter|io_github_linreal_cascade_editor_state_BlockSpanStates$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.state/io_github_linreal_cascade_editor_state_BlockTextStates$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.state/io_github_linreal_cascade_editor_state_BlockTextStates$stableprop_getter|io_github_linreal_cascade_editor_state_BlockTextStates$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.state/io_github_linreal_cascade_editor_state_DragState$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.state/io_github_linreal_cascade_editor_state_DragState$stableprop_getter|io_github_linreal_cascade_editor_state_DragState$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.state/io_github_linreal_cascade_editor_state_EditorState$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.state/io_github_linreal_cascade_editor_state_EditorState$stableprop_getter|io_github_linreal_cascade_editor_state_EditorState$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.state/io_github_linreal_cascade_editor_state_EditorStateHolder$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.state/io_github_linreal_cascade_editor_state_EditorStateHolder$stableprop_getter|io_github_linreal_cascade_editor_state_EditorStateHolder$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.state/io_github_linreal_cascade_editor_state_MergePolicy_Isolate$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.state/io_github_linreal_cascade_editor_state_MergePolicy_Isolate$stableprop_getter|io_github_linreal_cascade_editor_state_MergePolicy_Isolate$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.state/io_github_linreal_cascade_editor_state_MergePolicy_TryMerge$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.state/io_github_linreal_cascade_editor_state_MergePolicy_TryMerge$stableprop_getter|io_github_linreal_cascade_editor_state_MergePolicy_TryMerge$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.state/io_github_linreal_cascade_editor_state_SlashCommandState$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.state/io_github_linreal_cascade_editor_state_SlashCommandState$stableprop_getter|io_github_linreal_cascade_editor_state_SlashCommandState$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.state/io_github_linreal_cascade_editor_state_SlashQueryRange$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.state/io_github_linreal_cascade_editor_state_SlashQueryRange$stableprop_getter|io_github_linreal_cascade_editor_state_SlashQueryRange$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.state/rememberEditorState(io.github.linreal.cascade.editor.state/EditorState, androidx.compose.runtime/Composer?, kotlin/Int): io.github.linreal.cascade.editor.state/EditorStateHolder // io.github.linreal.cascade.editor.state/rememberEditorState|rememberEditorState(io.github.linreal.cascade.editor.state.EditorState;androidx.compose.runtime.Composer?;kotlin.Int){}[0] +final fun io.github.linreal.cascade.editor.state/rememberEditorState(kotlin.collections/List?, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int): io.github.linreal.cascade.editor.state/EditorStateHolder // io.github.linreal.cascade.editor.state/rememberEditorState|rememberEditorState(kotlin.collections.List?;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){}[0] +final fun io.github.linreal.cascade.editor.theme/io_github_linreal_cascade_editor_theme_BlockLocalizedStrings$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.theme/io_github_linreal_cascade_editor_theme_BlockLocalizedStrings$stableprop_getter|io_github_linreal_cascade_editor_theme_BlockLocalizedStrings$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.theme/io_github_linreal_cascade_editor_theme_CascadeEditorBlockStrings$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.theme/io_github_linreal_cascade_editor_theme_CascadeEditorBlockStrings$stableprop_getter|io_github_linreal_cascade_editor_theme_CascadeEditorBlockStrings$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.theme/io_github_linreal_cascade_editor_theme_CascadeEditorColors$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.theme/io_github_linreal_cascade_editor_theme_CascadeEditorColors$stableprop_getter|io_github_linreal_cascade_editor_theme_CascadeEditorColors$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.theme/io_github_linreal_cascade_editor_theme_CascadeEditorDimensions$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.theme/io_github_linreal_cascade_editor_theme_CascadeEditorDimensions$stableprop_getter|io_github_linreal_cascade_editor_theme_CascadeEditorDimensions$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.theme/io_github_linreal_cascade_editor_theme_CascadeEditorStrings$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.theme/io_github_linreal_cascade_editor_theme_CascadeEditorStrings$stableprop_getter|io_github_linreal_cascade_editor_theme_CascadeEditorStrings$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.theme/io_github_linreal_cascade_editor_theme_CascadeEditorTheme$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.theme/io_github_linreal_cascade_editor_theme_CascadeEditorTheme$stableprop_getter|io_github_linreal_cascade_editor_theme_CascadeEditorTheme$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.theme/io_github_linreal_cascade_editor_theme_CascadeEditorTypography$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.theme/io_github_linreal_cascade_editor_theme_CascadeEditorTypography$stableprop_getter|io_github_linreal_cascade_editor_theme_CascadeEditorTypography$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.ui.renderers/io_github_linreal_cascade_editor_ui_renderers_DividerBlockRenderer$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.ui.renderers/io_github_linreal_cascade_editor_ui_renderers_DividerBlockRenderer$stableprop_getter|io_github_linreal_cascade_editor_ui_renderers_DividerBlockRenderer$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.ui.renderers/io_github_linreal_cascade_editor_ui_renderers_TextBlockRenderer$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.ui.renderers/io_github_linreal_cascade_editor_ui_renderers_TextBlockRenderer$stableprop_getter|io_github_linreal_cascade_editor_ui_renderers_TextBlockRenderer$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.ui.renderers/io_github_linreal_cascade_editor_ui_renderers_TodoBlockRenderer$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.ui.renderers/io_github_linreal_cascade_editor_ui_renderers_TodoBlockRenderer$stableprop_getter|io_github_linreal_cascade_editor_ui_renderers_TodoBlockRenderer$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.ui.utils/calculateDropIndicatorY(androidx.compose.foundation.lazy/LazyListLayoutInfo, kotlin/Int?): kotlin/Float? // io.github.linreal.cascade.editor.ui.utils/calculateDropIndicatorY|calculateDropIndicatorY(androidx.compose.foundation.lazy.LazyListLayoutInfo;kotlin.Int?){}[0] +final fun io.github.linreal.cascade.editor.ui.utils/calculateDropTargetIndex(androidx.compose.foundation.lazy/LazyListLayoutInfo, kotlin/Float, kotlin/Int): kotlin/Int? // io.github.linreal.cascade.editor.ui.utils/calculateDropTargetIndex|calculateDropTargetIndex(androidx.compose.foundation.lazy.LazyListLayoutInfo;kotlin.Float;kotlin.Int){}[0] +final fun io.github.linreal.cascade.editor.ui.utils/convertVisualGapToMoveBlocksIndex(kotlin/Int, kotlin/Int, kotlin/Int): kotlin/Int? // io.github.linreal.cascade.editor.ui.utils/convertVisualGapToMoveBlocksIndex|convertVisualGapToMoveBlocksIndex(kotlin.Int;kotlin.Int;kotlin.Int){}[0] +final fun io.github.linreal.cascade.editor.ui.utils/io_github_linreal_cascade_editor_ui_utils_Dividers$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.ui.utils/io_github_linreal_cascade_editor_ui_utils_Dividers$stableprop_getter|io_github_linreal_cascade_editor_ui_utils_Dividers$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.ui.utils/io_github_linreal_cascade_editor_ui_utils_Spacers$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.ui.utils/io_github_linreal_cascade_editor_ui_utils_Spacers$stableprop_getter|io_github_linreal_cascade_editor_ui_utils_Spacers$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.ui/BackspaceAwareTextField(androidx.compose.foundation.text.input/TextFieldState, androidx.compose.ui/Modifier?, androidx.compose.ui.text/TextStyle?, androidx.compose.ui.graphics/Brush?, androidx.compose.foundation.text.input/OutputTransformation?, androidx.compose.ui.focus/FocusRequester?, kotlin/Function0, kotlin/Function1, kotlin/Boolean, kotlin/Function2, kotlin/Unit>?, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int) // io.github.linreal.cascade.editor.ui/BackspaceAwareTextField|BackspaceAwareTextField(androidx.compose.foundation.text.input.TextFieldState;androidx.compose.ui.Modifier?;androidx.compose.ui.text.TextStyle?;androidx.compose.ui.graphics.Brush?;androidx.compose.foundation.text.input.OutputTransformation?;androidx.compose.ui.focus.FocusRequester?;kotlin.Function0;kotlin.Function1;kotlin.Boolean;kotlin.Function2,kotlin.Unit>?;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){}[0] +final fun io.github.linreal.cascade.editor.ui/CascadeEditor(io.github.linreal.cascade.editor.state/EditorStateHolder, io.github.linreal.cascade.editor.state/BlockTextStates?, io.github.linreal.cascade.editor.state/BlockSpanStates?, io.github.linreal.cascade.editor.registry/BlockRegistry?, io.github.linreal.cascade.editor.slash/SlashCommandRegistry?, io.github.linreal.cascade.editor.ui/SlashCommandSlot?, io.github.linreal.cascade.editor.theme/CascadeEditorTheme?, io.github.linreal.cascade.editor.theme/CascadeEditorStrings?, io.github.linreal.cascade.editor.theme/CascadeEditorBlockStrings?, androidx.compose.ui/Modifier?, io.github.linreal.cascade.editor.ui/ToolbarSlot?, io.github.linreal.cascade.editor.ui/LinkPopupSlot?, kotlin/Function1?, kotlin/Function1?, io.github.linreal.cascade.editor.ui/CascadeEditorConfig?, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int, kotlin/Int) // io.github.linreal.cascade.editor.ui/CascadeEditor|CascadeEditor(io.github.linreal.cascade.editor.state.EditorStateHolder;io.github.linreal.cascade.editor.state.BlockTextStates?;io.github.linreal.cascade.editor.state.BlockSpanStates?;io.github.linreal.cascade.editor.registry.BlockRegistry?;io.github.linreal.cascade.editor.slash.SlashCommandRegistry?;io.github.linreal.cascade.editor.ui.SlashCommandSlot?;io.github.linreal.cascade.editor.theme.CascadeEditorTheme?;io.github.linreal.cascade.editor.theme.CascadeEditorStrings?;io.github.linreal.cascade.editor.theme.CascadeEditorBlockStrings?;androidx.compose.ui.Modifier?;io.github.linreal.cascade.editor.ui.ToolbarSlot?;io.github.linreal.cascade.editor.ui.LinkPopupSlot?;kotlin.Function1?;kotlin.Function1?;io.github.linreal.cascade.editor.ui.CascadeEditorConfig?;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int;kotlin.Int){}[0] +final fun io.github.linreal.cascade.editor.ui/HideKeyboardToolbarButton(kotlin/Function0, androidx.compose.ui/Modifier?, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int) // io.github.linreal.cascade.editor.ui/HideKeyboardToolbarButton|HideKeyboardToolbarButton(kotlin.Function0;androidx.compose.ui.Modifier?;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){}[0] +final fun io.github.linreal.cascade.editor.ui/createEditorRegistry(): io.github.linreal.cascade.editor.registry/BlockRegistry // io.github.linreal.cascade.editor.ui/createEditorRegistry|createEditorRegistry(){}[0] +final fun io.github.linreal.cascade.editor.ui/io_github_linreal_cascade_editor_ui_CascadeEditorConfig$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.ui/io_github_linreal_cascade_editor_ui_CascadeEditorConfig$stableprop_getter|io_github_linreal_cascade_editor_ui_CascadeEditorConfig$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.ui/io_github_linreal_cascade_editor_ui_FocusedBlockScrollTarget_By$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.ui/io_github_linreal_cascade_editor_ui_FocusedBlockScrollTarget_By$stableprop_getter|io_github_linreal_cascade_editor_ui_FocusedBlockScrollTarget_By$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.ui/io_github_linreal_cascade_editor_ui_FocusedBlockScrollTarget_ToItem$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.ui/io_github_linreal_cascade_editor_ui_FocusedBlockScrollTarget_ToItem$stableprop_getter|io_github_linreal_cascade_editor_ui_FocusedBlockScrollTarget_ToItem$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.ui/io_github_linreal_cascade_editor_ui_LinkPopupSlot_Custom$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.ui/io_github_linreal_cascade_editor_ui_LinkPopupSlot_Custom$stableprop_getter|io_github_linreal_cascade_editor_ui_LinkPopupSlot_Custom$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.ui/io_github_linreal_cascade_editor_ui_LinkPopupSlot_Default$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.ui/io_github_linreal_cascade_editor_ui_LinkPopupSlot_Default$stableprop_getter|io_github_linreal_cascade_editor_ui_LinkPopupSlot_Default$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.ui/io_github_linreal_cascade_editor_ui_LinkPopupSlot_None$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.ui/io_github_linreal_cascade_editor_ui_LinkPopupSlot_None$stableprop_getter|io_github_linreal_cascade_editor_ui_LinkPopupSlot_None$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.ui/io_github_linreal_cascade_editor_ui_LinkPopupState$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.ui/io_github_linreal_cascade_editor_ui_LinkPopupState$stableprop_getter|io_github_linreal_cascade_editor_ui_LinkPopupState$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.ui/io_github_linreal_cascade_editor_ui_RichTextToolbarConfig$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.ui/io_github_linreal_cascade_editor_ui_RichTextToolbarConfig$stableprop_getter|io_github_linreal_cascade_editor_ui_RichTextToolbarConfig$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.ui/io_github_linreal_cascade_editor_ui_SlashCommandSlot_Default$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.ui/io_github_linreal_cascade_editor_ui_SlashCommandSlot_Default$stableprop_getter|io_github_linreal_cascade_editor_ui_SlashCommandSlot_Default$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.ui/io_github_linreal_cascade_editor_ui_SlashCommandSlot_None$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.ui/io_github_linreal_cascade_editor_ui_SlashCommandSlot_None$stableprop_getter|io_github_linreal_cascade_editor_ui_SlashCommandSlot_None$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.ui/io_github_linreal_cascade_editor_ui_ToolbarButtonSpec$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.ui/io_github_linreal_cascade_editor_ui_ToolbarButtonSpec$stableprop_getter|io_github_linreal_cascade_editor_ui_ToolbarButtonSpec$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.ui/io_github_linreal_cascade_editor_ui_ToolbarSlot_Custom$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.ui/io_github_linreal_cascade_editor_ui_ToolbarSlot_Custom$stableprop_getter|io_github_linreal_cascade_editor_ui_ToolbarSlot_Custom$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.ui/io_github_linreal_cascade_editor_ui_ToolbarSlot_Default$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.ui/io_github_linreal_cascade_editor_ui_ToolbarSlot_Default$stableprop_getter|io_github_linreal_cascade_editor_ui_ToolbarSlot_Default$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.ui/io_github_linreal_cascade_editor_ui_ToolbarSlot_None$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.ui/io_github_linreal_cascade_editor_ui_ToolbarSlot_None$stableprop_getter|io_github_linreal_cascade_editor_ui_ToolbarSlot_None$stableprop_getter(){}[0] +final fun io.github.linreal.cascade.editor.ui/rememberCascadeEditorToolbarController(io.github.linreal.cascade.editor.state/EditorStateHolder, io.github.linreal.cascade.editor.state/BlockTextStates, io.github.linreal.cascade.editor.state/BlockSpanStates, kotlin.collections/List?, io.github.linreal.cascade.editor.ui/CascadeEditorConfig?, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int): io.github.linreal.cascade.editor.ui/CascadeEditorToolbarController // io.github.linreal.cascade.editor.ui/rememberCascadeEditorToolbarController|rememberCascadeEditorToolbarController(io.github.linreal.cascade.editor.state.EditorStateHolder;io.github.linreal.cascade.editor.state.BlockTextStates;io.github.linreal.cascade.editor.state.BlockSpanStates;kotlin.collections.List?;io.github.linreal.cascade.editor.ui.CascadeEditorConfig?;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){}[0] +final fun io.github.linreal.cascade.editor/io_github_linreal_cascade_editor_CascadeError$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor/io_github_linreal_cascade_editor_CascadeError$stableprop_getter|io_github_linreal_cascade_editor_CascadeError$stableprop_getter(){}[0] diff --git a/editor/build.gradle.kts b/editor/build.gradle.kts index 29e6925..7579be7 100644 --- a/editor/build.gradle.kts +++ b/editor/build.gradle.kts @@ -6,6 +6,18 @@ plugins { alias(libs.plugins.composeMultiplatform) alias(libs.plugins.composeCompiler) alias(libs.plugins.vanniktechPublish) + alias(libs.plugins.binaryCompatibilityValidator) +} + +// Public-API snapshots under api/ are verified by `apiCheck` (wired into `check`): +// .api files cover the JVM/Android surface, .klib.api covers klib-backed targets +// (iOS/wasm) at Kotlin-declaration level. After an intentional API change, refresh +// the baseline with `./gradlew :editor:apiDump` and commit the diff. +apiValidation { + @OptIn(kotlinx.validation.ExperimentalBCVApi::class) + klib { + enabled = true + } } kotlin { @@ -33,7 +45,7 @@ kotlin { iosSimulatorArm64() ).forEach { iosTarget -> iosTarget.binaries.framework { - baseName = "CascadeEditor" + baseName = "CascadeEditorCore" isStatic = true } } diff --git a/editor/src/androidMain/kotlin/io/github/linreal/cascade/editor/Platform.android.kt b/editor/src/androidMain/kotlin/io/github/linreal/cascade/editor/Platform.android.kt index 2ddf042..2938c27 100644 --- a/editor/src/androidMain/kotlin/io/github/linreal/cascade/editor/Platform.android.kt +++ b/editor/src/androidMain/kotlin/io/github/linreal/cascade/editor/Platform.android.kt @@ -1,3 +1,9 @@ package io.github.linreal.cascade.editor +import androidx.compose.foundation.text.KeyboardOptions + internal actual val isIos: Boolean = false + +internal actual fun platformKeyboardOptions(useNativeIosTextInput: Boolean): KeyboardOptions { + return KeyboardOptions.Default +} diff --git a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/Platform.kt b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/Platform.kt index 4bd0ba1..46af000 100644 --- a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/Platform.kt +++ b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/Platform.kt @@ -1,6 +1,11 @@ package io.github.linreal.cascade.editor +import androidx.compose.foundation.text.KeyboardOptions + /** * `true` when running on iOS, `false` otherwise. */ internal expect val isIos: Boolean + +/** Creates keyboard options with platform-specific text-input behavior. */ +internal expect fun platformKeyboardOptions(useNativeIosTextInput: Boolean): KeyboardOptions diff --git a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/registry/BlockRegistry.kt b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/registry/BlockRegistry.kt index eeab42b..8857cb3 100644 --- a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/registry/BlockRegistry.kt +++ b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/registry/BlockRegistry.kt @@ -1,5 +1,6 @@ package io.github.linreal.cascade.editor.registry +import androidx.compose.runtime.mutableIntStateOf import io.github.linreal.cascade.editor.core.Block import io.github.linreal.cascade.editor.core.BlockContent import io.github.linreal.cascade.editor.core.BlockType @@ -22,11 +23,19 @@ public class BlockRegistry { private val renderers = mutableMapOf>() private var unknownBlockFallback: BlockRenderer<*>? = null + // Snapshot-backed change counter. Bumped on every mutation so composables that + // derive from the registry (e.g. the slash-command menu) can observe registrations + // made while the editor is already mounted. Read it as a remember/derivedStateOf + // key to re-derive when the registry changes reference-identically in place. + private val revisionState = mutableIntStateOf(0) + internal val revision: Int get() = revisionState.intValue + /** * Registers a block descriptor. */ public fun registerDescriptor(descriptor: BlockDescriptor) { descriptors[descriptor.typeId] = descriptor + revisionState.intValue++ } /** @@ -34,6 +43,7 @@ public class BlockRegistry { */ public fun registerRenderer(typeId: String, renderer: BlockRenderer) { renderers[typeId] = renderer + revisionState.intValue++ } /** @@ -73,6 +83,7 @@ public class BlockRegistry { */ public fun setUnknownBlockRenderer(renderer: BlockRenderer<*>) { unknownBlockFallback = renderer + revisionState.intValue++ } /** diff --git a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/registry/BlockRenderer.kt b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/registry/BlockRenderer.kt index 170b835..66c7150 100644 --- a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/registry/BlockRenderer.kt +++ b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/registry/BlockRenderer.kt @@ -615,6 +615,20 @@ public interface BlockRenderer { */ public val handlesSelectionVisual: Boolean get() = false + /** + * Whether this renderer can be live-composed a second time as the floating + * drag-preview ghost. + * + * The drag preview re-invokes [Render] for the dragged block inside a + * translated overlay while the original block stays in the list. Renderers + * that host stateful platform views (e.g. a UIKit view controller) must + * opt out by returning `false`: instantiating a duplicate platform view + * mid-gesture is expensive, and interop views do not follow the preview's + * draw-phase translation. When `false`, the editor renders a generic + * placeholder ghost instead. + */ + public val supportsDragPreview: Boolean get() = true + /** * Renders the block content. * diff --git a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/serialization/DocumentSerializationExt.kt b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/serialization/DocumentSerializationExt.kt index bae2949..f990887 100644 --- a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/serialization/DocumentSerializationExt.kt +++ b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/serialization/DocumentSerializationExt.kt @@ -26,6 +26,24 @@ public fun EditorStateHolder.toJson( return DocumentSchema.encodeToString(resolvedBlocks, options, typeCodec, contentCodec) } +/** + * Resolves the current authoritative document blocks, incorporating live runtime + * text and span edits, without encoding to JSON. + * + * Runtime text/span state (from [textStates]/[spanStates]) takes priority over the + * snapshot content in [EditorStateHolder.state], exactly as [toJson] does. Blocks + * with no live edits keep their original object identity. + * + * This is the JSON-free primitive [toJson] is built on. Comparing consecutive + * results by structural equality is a cheap content-change signal that catches + * text/span edits which never alter [EditorState] identity — useful for change + * observers that must not pay full serialization cost on every snapshot tick. + */ +public fun EditorStateHolder.resolveDocumentBlocks( + textStates: BlockTextStates, + spanStates: BlockSpanStates, +): List = resolveCurrentBlocks(this, textStates, spanStates) + /** * Resolves the current authoritative document blocks without JSON encoding. * diff --git a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/slash/BuiltInSlashCommandFactory.kt b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/slash/BuiltInSlashCommandFactory.kt index aaf29a5..ae252a9 100644 --- a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/slash/BuiltInSlashCommandFactory.kt +++ b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/slash/BuiltInSlashCommandFactory.kt @@ -3,6 +3,19 @@ package io.github.linreal.cascade.editor.slash import io.github.linreal.cascade.editor.registry.BlockDescriptor import io.github.linreal.cascade.editor.theme.CascadeEditorBlockStrings +/** Stable prefix shared by every built-in block slash command id. */ +public const val BUILTIN_BLOCK_SLASH_COMMAND_ID_PREFIX: String = "builtin.block." + +/** + * Returns the stable [SlashCommandId] the built-in slash command generated for the + * block type [typeId] is keyed by. + * + * Built-in block commands are registered under these ids, so this is the value to + * compare against when detecting id collisions between custom and built-in commands. + */ +public fun builtInBlockSlashCommandId(typeId: String): SlashCommandId = + SlashCommandId("$BUILTIN_BLOCK_SLASH_COMMAND_ID_PREFIX$typeId") + /** * Generates [SlashCommandAction] instances from [BlockDescriptor]s that carry * [BuiltInSlashCommandSpec] metadata. @@ -47,7 +60,7 @@ internal class BuiltInSlashCommandFactory( val localized = blockStrings?.forType(typeId) SlashCommandAction( - id = SlashCommandId("$ID_PREFIX$typeId"), + id = builtInBlockSlashCommandId(typeId), title = localized?.displayName ?: descriptor.displayName, description = localized?.description ?: descriptor.description, keywords = if (localized != null) { @@ -61,9 +74,4 @@ internal class BuiltInSlashCommandFactory( ) } } - - internal companion object { - /** Stable prefix for all built-in block slash command IDs. */ - internal const val ID_PREFIX: String = "builtin.block." - } } diff --git a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/slash/SlashCommandExecutor.kt b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/slash/SlashCommandExecutor.kt index 325a29a..4f23bb9 100644 --- a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/slash/SlashCommandExecutor.kt +++ b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/slash/SlashCommandExecutor.kt @@ -2,6 +2,8 @@ package io.github.linreal.cascade.editor.slash import io.github.linreal.cascade.editor.action.ConvertBlockType import io.github.linreal.cascade.editor.action.NavigateSlashSubmenu +import io.github.linreal.cascade.editor.action.ReplaceBlock +import io.github.linreal.cascade.editor.core.BlockContent import io.github.linreal.cascade.editor.registry.BlockRegistry import io.github.linreal.cascade.editor.state.BlockSpanStates import io.github.linreal.cascade.editor.state.BlockTextStates @@ -20,9 +22,15 @@ import kotlinx.coroutines.launch * not on [SlashCommandRegistry], so it can be created before the merged registry is available. * * When behavior is [ConvertInPlace][BuiltInBlockSlashBehavior.ConvertInPlace]: - * the anchor block's type is changed in-place via [ConvertBlockType]. Query text - * is already removed (all built-in actions use [SlashQueryTextPolicy.RemoveBeforeExecute]), - * so remaining text and spans are preserved as-is. + * for a text target the anchor block's type is changed in-place via [ConvertBlockType]. + * Query text is already removed (all built-in actions use [SlashQueryTextPolicy.RemoveBeforeExecute]), + * so remaining text and spans are preserved as-is. For a non-text target (e.g. a custom + * block whose default content is [BlockContent.Custom]/[BlockContent.Empty]) the anchor's + * text content is not a valid shape for the new type: when the anchor is blank after + * query removal the whole block is replaced with the descriptor's default block — + * preserving the anchor's id and position — and when text remains the anchor keeps it + * and the new block is inserted after the anchor instead, so converting never silently + * discards user-typed text. * * When behavior is [AlwaysInsert][BuiltInBlockSlashBehavior.AlwaysInsert]: * a new block is created from the descriptor factory and inserted above the anchor @@ -40,8 +48,26 @@ internal fun createBuiltInSlashExecutor( } else { when (behavior) { is BuiltInBlockSlashBehavior.ConvertInPlace -> { - val targetType = descriptor.createBlock(anchorBlockId).type - stateHolder.dispatch(ConvertBlockType(anchorBlockId, targetType)) + val target = descriptor.createBlock(anchorBlockId) + if (target.content is BlockContent.Text) { + // Text target: swap type only, keeping the anchor's text/spans. + stateHolder.dispatch(ConvertBlockType(anchorBlockId, target.type)) + } else if (editor.getAnchorVisibleText().isNullOrBlank()) { + // Non-text target on a blank anchor: the anchor's text is not a + // valid shape for the new type. Replace the whole block, + // preserving id and position. + editor.replaceAnchorBlock(target, preserveAnchorId = true, requestFocus = false) + // SlashCommandEditorHost currently rebuilds a replacement with + // the anchor id and otherwise preserves only type/content. Restore + // descriptor-provided attributes so custom indentation/defaults are + // not lost by this built-in conversion path. + stateHolder.dispatch(ReplaceBlock(anchorBlockId, target.copy(id = anchorBlockId))) + } else { + // Non-text target with text remaining after query removal: + // converting would discard that text, so keep the anchor and + // insert the new block right after it instead. + editor.insertBlockAfterAnchor(descriptor.createBlock(), requestFocus = false) + } SlashCommandResult.Done } is BuiltInBlockSlashBehavior.AlwaysInsert -> { diff --git a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/slash/SlashCommandRegistry.kt b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/slash/SlashCommandRegistry.kt index 17bd33a..3288b68 100644 --- a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/slash/SlashCommandRegistry.kt +++ b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/slash/SlashCommandRegistry.kt @@ -1,5 +1,7 @@ package io.github.linreal.cascade.editor.slash +import androidx.compose.runtime.mutableIntStateOf + /** * Central registry and search engine for slash command items. * @@ -20,12 +22,19 @@ public class SlashCommandRegistry { private val rootItems = linkedMapOf() + // Snapshot-backed change counter. Bumped on every registration so composables that + // derive from this registry (e.g. the merged slash registry the mounted editor + // searches) can observe commands registered while the editor is already mounted. + private val revisionState = mutableIntStateOf(0) + internal val revision: Int get() = revisionState.intValue + /** * Registers a root-level slash command item (action or menu). * If an item with the same [SlashCommandItem.id] is already registered, it is replaced. */ public fun register(item: SlashCommandItem) { rootItems[item.id] = IndexedItem(item) + revisionState.intValue++ } /** diff --git a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/state/EditorStateHolder.kt b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/state/EditorStateHolder.kt index e9dd323..f0a363a 100644 --- a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/state/EditorStateHolder.kt +++ b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/state/EditorStateHolder.kt @@ -8,6 +8,7 @@ import androidx.compose.runtime.remember import androidx.compose.runtime.setValue import io.github.linreal.cascade.editor.action.EditorAction import io.github.linreal.cascade.editor.core.Block +import io.github.linreal.cascade.editor.loge import io.github.linreal.cascade.editor.core.BlockContent import io.github.linreal.cascade.editor.core.BlockId @@ -308,13 +309,32 @@ public class EditorStateHolder(initialState: EditorState = EditorState.Empty) { } /** - * Convenience wrapper for single-action structural edit sources. + * Dispatches a structural action as one history entry. + * + * This is the public integration point for external editor chrome and SDK + * bridges that need the same undo/redo semantics as built-in split, merge, + * slash, drag, and custom-renderer mutations. + * + * **History requires runtime holders.** The undo checkpoint snapshots live + * text/span state, so an entry is only recorded when holders are available — + * either bound by a composed `CascadeEditor` (the defaults) or passed + * explicitly by the caller. When neither is available (e.g. the action fires + * before the editor is first composed) the action still mutates the snapshot + * but records **no undo entry** — the mutation is not undoable. Callers that + * can run before first composition should pass their own [textStates] and + * [spanStates] explicitly, or gate the call on the editor being mounted. */ - internal fun dispatchStructuralAction( + public fun dispatchStructuralAction( action: EditorAction, textStates: BlockTextStates? = boundHistoryTextStates, spanStates: BlockSpanStates? = boundHistorySpanStates, ) { + if (textStates == null || spanStates == null) { + loge( + "dispatchStructuralAction($action) applied without history: no runtime " + + "text/span holders are bound or provided, so this mutation is not undoable." + ) + } runStructuralHistoryTransaction(textStates, spanStates) { dispatch(action) } diff --git a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/ui/BackspaceAwareTextEdit.kt b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/ui/BackspaceAwareTextEdit.kt index 89ce93b..9190951 100644 --- a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/ui/BackspaceAwareTextEdit.kt +++ b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/ui/BackspaceAwareTextEdit.kt @@ -1,7 +1,6 @@ package io.github.linreal.cascade.editor.ui import androidx.compose.foundation.text.BasicTextField -import androidx.compose.foundation.text.KeyboardOptions import androidx.compose.foundation.text.input.InputTransformation import androidx.compose.foundation.text.input.OutputTransformation import androidx.compose.foundation.text.input.TextFieldState @@ -27,6 +26,7 @@ import androidx.compose.ui.text.TextStyle import androidx.compose.ui.text.input.ImeAction import androidx.compose.ui.unit.Density import androidx.compose.ui.unit.sp +import io.github.linreal.cascade.editor.platformKeyboardOptions // The invisible zero-width space character used as a sentinel @@ -149,7 +149,9 @@ public fun BackspaceAwareTextField( modifier = keyGuardModifier, onTextLayout = onTextLayout, readOnly = readOnly, - keyboardOptions = KeyboardOptions( + keyboardOptions = platformKeyboardOptions( + useNativeIosTextInput = true, + ).copy( imeAction = ImeAction.Next, ), onKeyboardAction = { diff --git a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/ui/CascadeEditor.kt b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/ui/CascadeEditor.kt index 631c333..f5240a5 100644 --- a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/ui/CascadeEditor.kt +++ b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/ui/CascadeEditor.kt @@ -209,7 +209,9 @@ public fun CascadeEditor( if (slashEnabled) createBuiltInSlashExecutor(stateHolder, registry) else null } - val builtInSlashItems = remember(registry, builtInExecutor, blockStrings) { + // registry.revision is a snapshot key: re-derive when descriptors are registered + // after mount (e.g. the iOS SDK's registerBlock), not only when the reference changes. + val builtInSlashItems = remember(registry, registry.revision, builtInExecutor, blockStrings) { if (builtInExecutor == null) { emptyList() } else { @@ -218,9 +220,10 @@ public fun CascadeEditor( } } - // Use slashRegistry reference (stable) as the remember key — not getRootItems() - // which creates a new List on every recomposition with fragile data-class equality. - val effectiveSlashRegistry = remember(builtInSlashItems, slashRegistry, slashEnabled) { + // Use slashRegistry reference (stable) plus its revision as the remember key — not + // getRootItems() which creates a new List on every recomposition with fragile + // data-class equality. The revision catches commands registered after mount. + val effectiveSlashRegistry = remember(builtInSlashItems, slashRegistry, slashRegistry.revision, slashEnabled) { if (slashEnabled) { createMergedSlashRegistry( builtInItems = builtInSlashItems, @@ -572,8 +575,15 @@ public fun CascadeEditor( state.dragState?.draggingBlockIds?.contains(block.id) == true val hasSelection = state.hasSelection - // Look up renderer for this block type (includes unknown-block fallback) - val renderer = registry.getRenderer(block.type) + // Look up renderer for this block type (includes unknown-block fallback). + // registry.revision is snapshot state: keying on it subscribes the + // item to registrations made after mount (e.g. the iOS SDK's + // registerBlock), so an already-visible block swaps from the + // unknown-block fallback to its real renderer without waiting for an + // unrelated state change. + val renderer = remember(registry, registry.revision, block.type) { + registry.getRenderer(block.type) + } Box( modifier = Modifier diff --git a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/ui/DragPreview.kt b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/ui/DragPreview.kt index da05c4c..bdf4f18 100644 --- a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/ui/DragPreview.kt +++ b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/ui/DragPreview.kt @@ -7,6 +7,7 @@ import androidx.compose.foundation.layout.Box import androidx.compose.foundation.layout.fillMaxWidth import androidx.compose.foundation.layout.padding import androidx.compose.foundation.shape.CircleShape +import androidx.compose.foundation.shape.RoundedCornerShape import androidx.compose.foundation.text.BasicText import androidx.compose.runtime.Composable import androidx.compose.runtime.getValue @@ -20,6 +21,7 @@ import io.github.linreal.cascade.editor.core.BlockAttributes import io.github.linreal.cascade.editor.registry.BlockCallbacks import io.github.linreal.cascade.editor.registry.BlockRenderScope import io.github.linreal.cascade.editor.registry.BlockRegistry +import io.github.linreal.cascade.editor.registry.BlockRenderer import io.github.linreal.cascade.editor.theme.LocalCascadeTheme /** @@ -122,19 +124,32 @@ internal fun DragPreview( shadowElevation = DragPreviewDefaults.ShadowElevationDp } ) { - RenderRegisteredBlock( - renderer = renderer, - block = previewBlock, - isSelected = false, - isFocused = false, - // Match the same padding as regular blocks in CascadeEditor - modifier = Modifier.padding( - horizontal = theme.dimensions.blockHorizontalPadding, - vertical = 4.dp, - ), - callbacks = callbacks, - scope = scope, - ) + if (renderer.supportsDragPreview) { + RenderRegisteredBlock( + renderer = renderer, + block = previewBlock, + isSelected = false, + isFocused = false, + // Match the same padding as regular blocks in CascadeEditor + modifier = Modifier.padding( + horizontal = theme.dimensions.blockHorizontalPadding, + vertical = 4.dp, + ), + callbacks = callbacks, + scope = scope, + ) + } else { + // Renderers hosting stateful platform views opt out of live preview + // composition; show a lightweight labeled ghost instead. + DragPreviewPlaceholder( + label = registry.getDescriptor(previewBlock.type.typeId)?.displayName + ?: previewBlock.type.typeId, + modifier = Modifier.padding( + horizontal = theme.dimensions.blockHorizontalPadding, + vertical = 4.dp, + ), + ) + } if (badgeText != null) { BasicText( text = badgeText, @@ -158,6 +173,32 @@ internal fun DragPreview( } } +/** + * Generic ghost used when the dragged block's renderer opts out of live + * drag-preview composition ([BlockRenderer.supportsDragPreview] is false). + */ +@Composable +private fun DragPreviewPlaceholder( + label: String, + modifier: Modifier = Modifier, +) { + val theme = LocalCascadeTheme.current + Box( + modifier = modifier + .fillMaxWidth() + .background( + color = theme.colors.unknownBlockBackground, + shape = RoundedCornerShape(8.dp), + ) + .padding(16.dp), + ) { + BasicText( + text = label, + style = theme.typography.body.copy(color = theme.colors.text), + ) + } +} + /** * Rewrites only the preview copy so the ghost renders in the resolved future lane. */ diff --git a/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/BlockRegistryTest.kt b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/BlockRegistryTest.kt index abef3ea..9eb6b14 100644 --- a/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/BlockRegistryTest.kt +++ b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/BlockRegistryTest.kt @@ -273,6 +273,26 @@ class BlockRegistryTest { ) } + @Test + fun `revision increments on registration so mounted derivations can observe changes`() { + val registry = createEditorRegistry() + val startRevision = registry.revision + + registry.registerDescriptor( + BlockDescriptor( + typeId = "custom:rev", + displayName = "Rev", + description = "", + factory = { id -> Block(id, BlockType.Paragraph, BlockContent.Text("")) }, + ), + ) + assertTrue(registry.revision > startRevision, "registering a descriptor must bump the revision") + + val afterDescriptor = registry.revision + registry.registerRenderer("custom:rev", registry.getRenderer("paragraph")!!) + assertTrue(registry.revision > afterDescriptor, "registering a renderer must bump the revision") + } + @Test fun `custom descriptor with slash spec is preserved`() { val registry = BlockRegistry.create() diff --git a/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/BuiltInBlockSlashCommandIdTest.kt b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/BuiltInBlockSlashCommandIdTest.kt new file mode 100644 index 0000000..71ab9fa --- /dev/null +++ b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/BuiltInBlockSlashCommandIdTest.kt @@ -0,0 +1,36 @@ +package io.github.linreal.cascade.editor + +import io.github.linreal.cascade.editor.registry.BlockRegistry +import io.github.linreal.cascade.editor.slash.BUILTIN_BLOCK_SLASH_COMMAND_ID_PREFIX +import io.github.linreal.cascade.editor.slash.BuiltInSlashCommandFactory +import io.github.linreal.cascade.editor.slash.SlashCommandResult +import io.github.linreal.cascade.editor.slash.builtInBlockSlashCommandId +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertTrue + +class BuiltInBlockSlashCommandIdTest { + + @Test + fun idIsPrefixedTypeId() { + assertEquals( + "${BUILTIN_BLOCK_SLASH_COMMAND_ID_PREFIX}paragraph", + builtInBlockSlashCommandId("paragraph").value, + ) + } + + @Test + fun matchesTheIdsTheFactoryGenerates() { + val factory = BuiltInSlashCommandFactory { _, _ -> SlashCommandResult.Done } + val descriptors = BlockRegistry.createDefault().getAllDescriptors() + + val generatedIds = factory.generate(descriptors).map { it.id }.toSet() + val derivedIds = descriptors + .filter { it.slash != null } + .map { builtInBlockSlashCommandId(it.typeId) } + .toSet() + + assertTrue(generatedIds.isNotEmpty()) + assertEquals(generatedIds, derivedIds) + } +} diff --git a/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/DocumentSerializationExtTest.kt b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/DocumentSerializationExtTest.kt index 898a9e9..a7e68f4 100644 --- a/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/DocumentSerializationExtTest.kt +++ b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/DocumentSerializationExtTest.kt @@ -335,6 +335,29 @@ class DocumentSerializationExtTest { assertNull(spanStates.get(oldId)) } + @Test + fun `loadFromJson hard replaces document and runtime state on parse failure`() { + val keptId = BlockId("kept") + val holder = EditorStateHolder( + EditorState.withBlocks( + listOf(Block(keptId, BlockType.Paragraph, BlockContent.Text("Keep me"))), + ), + ) + val textStates = BlockTextStates() + val spanStates = BlockSpanStates() + textStates.getOrCreate(keptId, "Keep me edited") + + val result = holder.loadFromJson("{ not json", textStates, spanStates) + + assertTrue(result.warnings.any { it is DocumentDecodeWarning.DocumentParseFailed }) + assertEquals(1, holder.state.blocks.size) + assertTrue(holder.state.blocks.single().content is BlockContent.Text) + assertEquals("", (holder.state.blocks.single().content as BlockContent.Text).text) + assertTrue(holder.state.blocks.none { it.id == keptId }) + assertNull(textStates.get(keptId)) + assertNull(spanStates.get(keptId)) + } + @Test fun `loadFromJson returns warnings for duplicate IDs`() { val holder = EditorStateHolder() diff --git a/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/SlashCommandExecutorTest.kt b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/SlashCommandExecutorTest.kt index c9c9b41..5c62ddb 100644 --- a/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/SlashCommandExecutorTest.kt +++ b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/SlashCommandExecutorTest.kt @@ -1,15 +1,22 @@ package io.github.linreal.cascade.editor import io.github.linreal.cascade.editor.core.Block +import io.github.linreal.cascade.editor.core.BlockAttributes import io.github.linreal.cascade.editor.core.BlockContent import io.github.linreal.cascade.editor.core.BlockId import io.github.linreal.cascade.editor.core.BlockType +import io.github.linreal.cascade.editor.core.CustomBlockType import io.github.linreal.cascade.editor.core.SpanStyle import io.github.linreal.cascade.editor.core.TextSpan +import io.github.linreal.cascade.editor.core.UnknownBlockType +import io.github.linreal.cascade.editor.registry.BlockDescriptor import io.github.linreal.cascade.editor.registry.BlockRegistry +import io.github.linreal.cascade.editor.slash.BuiltInBlockSlashBehavior import io.github.linreal.cascade.editor.slash.BuiltInSlashCommandFactory +import io.github.linreal.cascade.editor.slash.BuiltInSlashCommandSpec import io.github.linreal.cascade.editor.slash.SlashCommandAction import io.github.linreal.cascade.editor.slash.SlashCommandExecutor +import io.github.linreal.cascade.editor.slash.builtInBlockSlashCommandId import io.github.linreal.cascade.editor.slash.createBuiltInSlashExecutor import io.github.linreal.cascade.editor.slash.SlashCommandId import io.github.linreal.cascade.editor.slash.SlashCommandMenu @@ -216,6 +223,96 @@ class SlashCommandExecutorTest { assertEquals(BlockType.Divider, insertedBlock.type) } + @Test + fun `ConvertInPlace to a non-text custom target replaces the whole block preserving id`() = runTest { + val env = createExecutorEnv( + text = "/widget", + queryRange = SlashQueryRange(0, 7), + query = "widget", + ) + val widgetType = object : CustomBlockType { + override val typeId: String = "widget" + override val displayName: String = "Widget" + override val supportsIndentation: Boolean = true + } + val descriptor = BlockDescriptor( + typeId = "widget", + displayName = "Widget", + description = "A custom widget", + slash = BuiltInSlashCommandSpec(behavior = BuiltInBlockSlashBehavior.ConvertInPlace), + factory = { id -> + Block( + id = id, + type = widgetType, + content = BlockContent.Custom("widget", mapOf("k" to "v")), + attributes = BlockAttributes(indentationLevel = 2), + ) + }, + ) + env.blockRegistry.registerDescriptor(descriptor) + val action = BuiltInSlashCommandFactory(env.executor.builtInExecutor) + .generate(listOf(descriptor)) + .single() + env.registry.register(action) + + env.executor.executeNow(builtInBlockSlashCommandId("widget")) + + val block = env.stateHolder.state.getBlock(env.anchorId) + assertNotNull(block) + // Same block id/position, but now a valid custom-content block — not the old + // shape (custom type + leftover BlockContent.Text). + assertEquals(env.anchorId, block.id) + assertEquals(widgetType, block.type) + assertEquals(2, block.attributes.indentationLevel) + val content = block.content + assertTrue(content is BlockContent.Custom, "expected BlockContent.Custom, got $content") + assertEquals("v", content.data["k"]) + assertNull(env.stateHolder.state.slashCommandState) + } + + @Test + fun `ConvertInPlace to a non-text target with remaining text keeps the anchor and inserts after`() = runTest { + val env = createExecutorEnv( + text = "Q3 notes /widget", + queryRange = SlashQueryRange(9, 16), // "/widget" + query = "widget", + ) + val descriptor = BlockDescriptor( + typeId = "widget", + displayName = "Widget", + description = "A custom widget", + slash = BuiltInSlashCommandSpec(behavior = BuiltInBlockSlashBehavior.ConvertInPlace), + factory = { id -> + Block(id, UnknownBlockType("widget", "{}"), BlockContent.Custom("widget", mapOf("k" to "v"))) + }, + ) + env.blockRegistry.registerDescriptor(descriptor) + val action = BuiltInSlashCommandFactory(env.executor.builtInExecutor) + .generate(listOf(descriptor)) + .single() + env.registry.register(action) + + env.executor.executeNow(builtInBlockSlashCommandId("widget")) + + // The anchor keeps its type and its remaining text — converting must not + // silently discard user-typed content. + val anchor = env.stateHolder.state.getBlock(env.anchorId) + assertNotNull(anchor) + assertEquals(BlockType.Paragraph, anchor.type) + assertEquals("Q3 notes ", env.textStates.getVisibleText(env.anchorId)) + + // The new block is inserted immediately after the anchor instead. + val blocks = env.stateHolder.state.blocks + val anchorIndex = blocks.indexOfFirst { it.id == env.anchorId } + val inserted = blocks.getOrNull(anchorIndex + 1) + assertNotNull(inserted, "expected a block inserted after the anchor") + assertEquals(UnknownBlockType("widget", "{}"), inserted.type) + val content = inserted.content + assertTrue(content is BlockContent.Custom, "expected BlockContent.Custom, got $content") + assertEquals("v", content.data["k"]) + assertNull(env.stateHolder.state.slashCommandState) + } + // -- Exception handling -- @Test diff --git a/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/SlashCommandRegistryTest.kt b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/SlashCommandRegistryTest.kt index 17ed570..40d9b1e 100644 --- a/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/SlashCommandRegistryTest.kt +++ b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/SlashCommandRegistryTest.kt @@ -39,6 +39,21 @@ class SlashCommandRegistryTest { children = children, ) + // --- Revision signal --- + + @Test + fun `revision increments on registration so mounted derivations can observe changes`() { + val registry = SlashCommandRegistry() + val startRevision = registry.revision + + registry.register(action("one", "One")) + assertTrue(registry.revision > startRevision, "registering a command must bump the revision") + + val afterFirst = registry.revision + registry.register(action("two", "Two")) + assertTrue(registry.revision > afterFirst, "each registration must bump the revision") + } + // --- Registration order --- @Test diff --git a/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/serialization/ResolveDocumentBlocksTest.kt b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/serialization/ResolveDocumentBlocksTest.kt new file mode 100644 index 0000000..937828d --- /dev/null +++ b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/serialization/ResolveDocumentBlocksTest.kt @@ -0,0 +1,45 @@ +package io.github.linreal.cascade.editor.serialization + +import io.github.linreal.cascade.editor.core.Block +import io.github.linreal.cascade.editor.core.BlockContent +import io.github.linreal.cascade.editor.state.BlockSpanStates +import io.github.linreal.cascade.editor.state.BlockTextStates +import io.github.linreal.cascade.editor.state.EditorState +import io.github.linreal.cascade.editor.state.EditorStateHolder +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertNotEquals +import kotlin.test.assertSame + +class ResolveDocumentBlocksTest { + + @Test + fun resolveDocumentBlocks_preservesSnapshotIdentity_whenNoRuntimeEdits() { + val holder = EditorStateHolder(EditorState.withBlocks(listOf(Block.paragraph("Hello")))) + val textStates = BlockTextStates() + val spanStates = BlockSpanStates() + + val resolved = holder.resolveDocumentBlocks(textStates, spanStates) + + // Blocks with no live runtime edits keep their original object identity, so + // structural equality over consecutive results stays cheap. + assertSame(holder.state.blocks.first(), resolved.first()) + } + + @Test + fun resolveDocumentBlocks_reflectsRuntimeTextEdits() { + val holder = EditorStateHolder(EditorState.withBlocks(listOf(Block.paragraph("Hello")))) + val textStates = BlockTextStates() + val spanStates = BlockSpanStates() + val blockId = holder.state.blocks.first().id + textStates.getOrCreate(blockId, "Hello") + + val before = holder.resolveDocumentBlocks(textStates, spanStates) + textStates.setText(blockId, "Hello world") + val after = holder.resolveDocumentBlocks(textStates, spanStates) + + assertEquals("Hello", (before.first().content as BlockContent.Text).text) + assertEquals("Hello world", (after.first().content as BlockContent.Text).text) + assertNotEquals(before, after) + } +} diff --git a/editor/src/desktopMain/kotlin/io/github/linreal/cascade/editor/Platform.desktop.kt b/editor/src/desktopMain/kotlin/io/github/linreal/cascade/editor/Platform.desktop.kt index 2ddf042..2938c27 100644 --- a/editor/src/desktopMain/kotlin/io/github/linreal/cascade/editor/Platform.desktop.kt +++ b/editor/src/desktopMain/kotlin/io/github/linreal/cascade/editor/Platform.desktop.kt @@ -1,3 +1,9 @@ package io.github.linreal.cascade.editor +import androidx.compose.foundation.text.KeyboardOptions + internal actual val isIos: Boolean = false + +internal actual fun platformKeyboardOptions(useNativeIosTextInput: Boolean): KeyboardOptions { + return KeyboardOptions.Default +} diff --git a/editor/src/iosMain/kotlin/io/github/linreal/cascade/editor/Platform.ios.kt b/editor/src/iosMain/kotlin/io/github/linreal/cascade/editor/Platform.ios.kt index 29adb43..feaa626 100644 --- a/editor/src/iosMain/kotlin/io/github/linreal/cascade/editor/Platform.ios.kt +++ b/editor/src/iosMain/kotlin/io/github/linreal/cascade/editor/Platform.ios.kt @@ -1,3 +1,18 @@ package io.github.linreal.cascade.editor +import androidx.compose.foundation.text.KeyboardOptions +import androidx.compose.ui.ExperimentalComposeUiApi +import androidx.compose.ui.text.input.PlatformImeOptions + internal actual val isIos: Boolean = true + +@OptIn(ExperimentalComposeUiApi::class) +internal actual fun platformKeyboardOptions(useNativeIosTextInput: Boolean): KeyboardOptions { + if (!useNativeIosTextInput) return KeyboardOptions.Default + return KeyboardOptions( + platformImeOptions = PlatformImeOptions { + // TODO: enable after fix of https://youtrack.jetbrains.com/projects/CMP/issues/CMP-10404/iOS-keyboard-dismisses-and-re-presents-yoyos-when-focus-moves-between-TextFields-with-usingNativeTextInputtrue + usingNativeTextInput(false) + }, + ) +} diff --git a/editor/src/wasmJsMain/kotlin/io/github/linreal/cascade/editor/Platform.wasmJs.kt b/editor/src/wasmJsMain/kotlin/io/github/linreal/cascade/editor/Platform.wasmJs.kt index 2ddf042..2938c27 100644 --- a/editor/src/wasmJsMain/kotlin/io/github/linreal/cascade/editor/Platform.wasmJs.kt +++ b/editor/src/wasmJsMain/kotlin/io/github/linreal/cascade/editor/Platform.wasmJs.kt @@ -1,3 +1,9 @@ package io.github.linreal.cascade.editor +import androidx.compose.foundation.text.KeyboardOptions + internal actual val isIos: Boolean = false + +internal actual fun platformKeyboardOptions(useNativeIosTextInput: Boolean): KeyboardOptions { + return KeyboardOptions.Default +} diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml index 36f652c..3dba253 100644 --- a/gradle/libs.versions.toml +++ b/gradle/libs.versions.toml @@ -5,7 +5,8 @@ android-minSdk = "28" android-targetSdk = "36" androidx-activity = "1.13.0" androidx-lifecycle = "2.10.0" -composeMultiplatform = "1.11.0" +binaryCompatibilityValidator = "0.18.1" +composeMultiplatform = "1.11.1" kotlin = "2.3.21" kotlinxCoroutinesTest = "1.11.0" kotlinxDatetime = "0.8.0" @@ -34,6 +35,7 @@ kotlinx-serialization-json = { module = "org.jetbrains.kotlinx:kotlinx-serializa [plugins] androidApplication = { id = "com.android.application", version.ref = "agp" } androidLibrary = { id = "com.android.library", version.ref = "agp" } +binaryCompatibilityValidator = { id = "org.jetbrains.kotlinx.binary-compatibility-validator", version.ref = "binaryCompatibilityValidator" } composeMultiplatform = { id = "org.jetbrains.compose", version.ref = "composeMultiplatform" } composeCompiler = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" } kotlinMultiplatform = { id = "org.jetbrains.kotlin.multiplatform", version.ref = "kotlin" } diff --git a/iosNativeSample/iosNativeSample.xcodeproj/project.pbxproj b/iosNativeSample/iosNativeSample.xcodeproj/project.pbxproj new file mode 100644 index 0000000..5d42d59 --- /dev/null +++ b/iosNativeSample/iosNativeSample.xcodeproj/project.pbxproj @@ -0,0 +1,400 @@ +// !$*UTF8*$! +{ + archiveVersion = 1; + classes = { + }; + objectVersion = 77; + objects = { + +/* Begin PBXBuildFile section */ + CA5CADE000000000000000A7 /* CascadeEditor.xcframework in Frameworks */ = {isa = PBXBuildFile; fileRef = CA5CADE000000000000000A6 /* CascadeEditor.xcframework */; }; +/* End PBXBuildFile section */ + +/* Begin PBXFileReference section */ + CA5CADE000000000000000A5 /* iosNativeSample.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = iosNativeSample.app; sourceTree = BUILT_PRODUCTS_DIR; }; + CA5CADE000000000000000A6 /* CascadeEditor.xcframework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.xcframework; name = CascadeEditor.xcframework; path = "../editor-ios-sdk/build/XCFrameworks/debug/CascadeEditor.xcframework"; sourceTree = ""; }; +/* End PBXFileReference section */ + +/* Begin PBXFileSystemSynchronizedBuildFileExceptionSet section */ + CA5CADE000000000000000A8 /* Exceptions for "iosNativeSample" folder in "iosNativeSample" target */ = { + isa = PBXFileSystemSynchronizedBuildFileExceptionSet; + membershipExceptions = ( + Info.plist, + ); + target = CA5CADE000000000000000B0 /* iosNativeSample */; + }; +/* End PBXFileSystemSynchronizedBuildFileExceptionSet section */ + +/* Begin PBXFileSystemSynchronizedRootGroup section */ + CA5CADE000000000000000A4 /* iosNativeSample */ = { + isa = PBXFileSystemSynchronizedRootGroup; + exceptions = ( + CA5CADE000000000000000A8 /* Exceptions for "iosNativeSample" folder in "iosNativeSample" target */, + ); + path = iosNativeSample; + sourceTree = ""; + }; +/* End PBXFileSystemSynchronizedRootGroup section */ + +/* Begin PBXFrameworksBuildPhase section */ + CA5CADE000000000000000B3 /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + CA5CADE000000000000000A7 /* CascadeEditor.xcframework in Frameworks */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXFrameworksBuildPhase section */ + +/* Begin PBXGroup section */ + CA5CADE000000000000000A1 = { + isa = PBXGroup; + children = ( + CA5CADE000000000000000A4 /* iosNativeSample */, + CA5CADE000000000000000A3 /* Frameworks */, + CA5CADE000000000000000A2 /* Products */, + ); + sourceTree = ""; + }; + CA5CADE000000000000000A2 /* Products */ = { + isa = PBXGroup; + children = ( + CA5CADE000000000000000A5 /* iosNativeSample.app */, + ); + name = Products; + sourceTree = ""; + }; + CA5CADE000000000000000A3 /* Frameworks */ = { + isa = PBXGroup; + children = ( + CA5CADE000000000000000A6 /* CascadeEditor.xcframework */, + ); + name = Frameworks; + sourceTree = ""; + }; +/* End PBXGroup section */ + +/* Begin PBXNativeTarget section */ + CA5CADE000000000000000B0 /* iosNativeSample */ = { + isa = PBXNativeTarget; + buildConfigurationList = CA5CADE000000000000000C3 /* Build configuration list for PBXNativeTarget "iosNativeSample" */; + buildPhases = ( + CA5CADE000000000000000B1 /* Build CascadeEditor XCFramework */, + CA5CADE000000000000000B2 /* Sources */, + CA5CADE000000000000000B3 /* Frameworks */, + CA5CADE000000000000000B4 /* Resources */, + CA5CADE000000000000000B5 /* Copy Compose Resources */, + ); + buildRules = ( + ); + dependencies = ( + ); + fileSystemSynchronizedGroups = ( + CA5CADE000000000000000A4 /* iosNativeSample */, + ); + name = iosNativeSample; + packageProductDependencies = ( + ); + productName = iosNativeSample; + productReference = CA5CADE000000000000000A5 /* iosNativeSample.app */; + productType = "com.apple.product-type.application"; + }; +/* End PBXNativeTarget section */ + +/* Begin PBXProject section */ + CA5CADE000000000000000A0 /* Project object */ = { + isa = PBXProject; + attributes = { + BuildIndependentTargetsInParallel = 1; + LastSwiftUpdateCheck = 1620; + LastUpgradeCheck = 1620; + TargetAttributes = { + CA5CADE000000000000000B0 = { + CreatedOnToolsVersion = 16.2; + }; + }; + }; + buildConfigurationList = CA5CADE000000000000000C0 /* Build configuration list for PBXProject "iosNativeSample" */; + developmentRegion = en; + hasScannedForEncodings = 0; + knownRegions = ( + en, + Base, + ); + mainGroup = CA5CADE000000000000000A1; + minimizedProjectReferenceProxies = 1; + preferredProjectObjectVersion = 77; + productRefGroup = CA5CADE000000000000000A2 /* Products */; + projectDirPath = ""; + projectRoot = ""; + targets = ( + CA5CADE000000000000000B0 /* iosNativeSample */, + ); + }; +/* End PBXProject section */ + +/* Begin PBXResourcesBuildPhase section */ + CA5CADE000000000000000B4 /* Resources */ = { + isa = PBXResourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXResourcesBuildPhase section */ + +/* Begin PBXShellScriptBuildPhase section */ + CA5CADE000000000000000B1 /* Build CascadeEditor XCFramework */ = { + isa = PBXShellScriptBuildPhase; + alwaysOutOfDate = 1; + buildActionMask = 2147483647; + files = ( + ); + inputFileListPaths = ( + ); + inputPaths = ( + ); + name = "Build CascadeEditor XCFramework"; + outputFileListPaths = ( + ); + outputPaths = ( + ); + runOnlyForDeploymentPostprocessing = 0; + shellPath = /bin/sh; + shellScript = "\"$SRCROOT/../scripts/build-xcframework.sh\"\n"; + }; + CA5CADE000000000000000B5 /* Copy Compose Resources */ = { + isa = PBXShellScriptBuildPhase; + alwaysOutOfDate = 1; + buildActionMask = 2147483647; + files = ( + ); + inputFileListPaths = ( + ); + inputPaths = ( + ); + name = "Copy Compose Resources"; + outputFileListPaths = ( + ); + outputPaths = ( + ); + runOnlyForDeploymentPostprocessing = 0; + shellPath = /bin/sh; + shellScript = "# CascadeEditor is a static framework, so it is never embedded into the app\n# bundle and the compose resources packed inside it are invisible at runtime.\n# Compose Multiplatform's iOS resource reader falls back to a directory named\n# \"compose-resources\" in the main bundle, so copy the framework's resources\n# there, picking the slice that matches the platform being built.\ncase \"$PLATFORM_NAME\" in\n *simulator*) SLICE=\"ios-arm64-simulator\" ;;\n *) SLICE=\"ios-arm64\" ;;\nesac\nFRAMEWORK_RESOURCES=\"$SRCROOT/../editor-ios-sdk/build/XCFrameworks/debug/CascadeEditor.xcframework/$SLICE/CascadeEditor.framework/composeResources\"\nDEST=\"$TARGET_BUILD_DIR/$UNLOCALIZED_RESOURCES_FOLDER_PATH/compose-resources\"\nrm -rf \"$DEST\"\nmkdir -p \"$DEST\"\nif [ -d \"$FRAMEWORK_RESOURCES\" ]; then\n cp -R \"$FRAMEWORK_RESOURCES\" \"$DEST/\"\nfi\n"; + }; +/* End PBXShellScriptBuildPhase section */ + +/* Begin PBXSourcesBuildPhase section */ + CA5CADE000000000000000B2 /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXSourcesBuildPhase section */ + +/* Begin XCBuildConfiguration section */ + CA5CADE000000000000000C1 /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + ARCHS = arm64; + ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES; + CLANG_ANALYZER_NONNULL = YES; + CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++20"; + CLANG_ENABLE_MODULES = YES; + CLANG_ENABLE_OBJC_ARC = YES; + CLANG_ENABLE_OBJC_WEAK = YES; + CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES; + CLANG_WARN_BOOL_CONVERSION = YES; + CLANG_WARN_COMMA = YES; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES; + CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; + CLANG_WARN_DOCUMENTATION_COMMENTS = YES; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INFINITE_RECURSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES; + CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES; + CLANG_WARN_OBJC_LITERAL_CONVERSION = YES; + CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; + CLANG_WARN_QUOTED_INCLUDE_IN_FRAMEWORK_HEADER = YES; + CLANG_WARN_RANGE_LOOP_ANALYSIS = YES; + CLANG_WARN_STRICT_PROTOTYPES = YES; + CLANG_WARN_SUSPICIOUS_MOVE = YES; + CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE; + CLANG_WARN_UNREACHABLE_CODE = YES; + CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; + COPY_PHASE_STRIP = NO; + DEBUG_INFORMATION_FORMAT = dwarf; + ENABLE_STRICT_OBJC_MSGSEND = YES; + ENABLE_TESTABILITY = YES; + ENABLE_USER_SCRIPT_SANDBOXING = NO; + GCC_C_LANGUAGE_STANDARD = gnu17; + GCC_DYNAMIC_NO_PIC = NO; + GCC_NO_COMMON_BLOCKS = YES; + GCC_OPTIMIZATION_LEVEL = 0; + GCC_PREPROCESSOR_DEFINITIONS = ( + "DEBUG=1", + "$(inherited)", + ); + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; + GCC_WARN_UNDECLARED_SELECTOR = YES; + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + GCC_WARN_UNUSED_FUNCTION = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + IPHONEOS_DEPLOYMENT_TARGET = 18.2; + LOCALIZATION_PREFERS_STRING_CATALOGS = YES; + MTL_ENABLE_DEBUG_INFO = INCLUDE_SOURCE; + MTL_FAST_MATH = YES; + ONLY_ACTIVE_ARCH = YES; + SDKROOT = iphoneos; + SWIFT_ACTIVE_COMPILATION_CONDITIONS = "DEBUG $(inherited)"; + SWIFT_OPTIMIZATION_LEVEL = "-Onone"; + }; + name = Debug; + }; + CA5CADE000000000000000C2 /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + ARCHS = arm64; + ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES; + CLANG_ANALYZER_NONNULL = YES; + CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++20"; + CLANG_ENABLE_MODULES = YES; + CLANG_ENABLE_OBJC_ARC = YES; + CLANG_ENABLE_OBJC_WEAK = YES; + CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES; + CLANG_WARN_BOOL_CONVERSION = YES; + CLANG_WARN_COMMA = YES; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES; + CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; + CLANG_WARN_DOCUMENTATION_COMMENTS = YES; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INFINITE_RECURSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES; + CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES; + CLANG_WARN_OBJC_LITERAL_CONVERSION = YES; + CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; + CLANG_WARN_QUOTED_INCLUDE_IN_FRAMEWORK_HEADER = YES; + CLANG_WARN_RANGE_LOOP_ANALYSIS = YES; + CLANG_WARN_STRICT_PROTOTYPES = YES; + CLANG_WARN_SUSPICIOUS_MOVE = YES; + CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE; + CLANG_WARN_UNREACHABLE_CODE = YES; + CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; + COPY_PHASE_STRIP = NO; + DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; + ENABLE_NS_ASSERTIONS = NO; + ENABLE_STRICT_OBJC_MSGSEND = YES; + ENABLE_USER_SCRIPT_SANDBOXING = NO; + GCC_C_LANGUAGE_STANDARD = gnu17; + GCC_NO_COMMON_BLOCKS = YES; + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; + GCC_WARN_UNDECLARED_SELECTOR = YES; + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + GCC_WARN_UNUSED_FUNCTION = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + IPHONEOS_DEPLOYMENT_TARGET = 18.2; + LOCALIZATION_PREFERS_STRING_CATALOGS = YES; + MTL_ENABLE_DEBUG_INFO = NO; + MTL_FAST_MATH = YES; + SDKROOT = iphoneos; + SWIFT_COMPILATION_MODE = wholemodule; + VALIDATE_PRODUCT = YES; + }; + name = Release; + }; + CA5CADE000000000000000C4 /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + CODE_SIGN_STYLE = Automatic; + CURRENT_PROJECT_VERSION = 1; + DEVELOPMENT_TEAM = LR4H2F7AM7; + ENABLE_PREVIEWS = YES; + GENERATE_INFOPLIST_FILE = YES; + INFOPLIST_FILE = iosNativeSample/Info.plist; + INFOPLIST_KEY_CFBundleDisplayName = "Cascade Native"; + INFOPLIST_KEY_UIApplicationSceneManifest_Generation = YES; + INFOPLIST_KEY_UIApplicationSupportsIndirectInputEvents = YES; + INFOPLIST_KEY_UILaunchScreen_Generation = YES; + INFOPLIST_KEY_UISupportedInterfaceOrientations_iPad = "UIInterfaceOrientationPortrait UIInterfaceOrientationPortraitUpsideDown UIInterfaceOrientationLandscapeLeft UIInterfaceOrientationLandscapeRight"; + INFOPLIST_KEY_UISupportedInterfaceOrientations_iPhone = "UIInterfaceOrientationPortrait UIInterfaceOrientationLandscapeLeft UIInterfaceOrientationLandscapeRight"; + LD_RUNPATH_SEARCH_PATHS = ( + "$(inherited)", + "@executable_path/Frameworks", + ); + MARKETING_VERSION = 1.0; + PRODUCT_BUNDLE_IDENTIFIER = io.github.linreal.cascade.iosNativeSample; + PRODUCT_NAME = "$(TARGET_NAME)"; + SWIFT_EMIT_LOC_STRINGS = YES; + SWIFT_VERSION = 5.0; + TARGETED_DEVICE_FAMILY = "1,2"; + }; + name = Debug; + }; + CA5CADE000000000000000C5 /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + CODE_SIGN_STYLE = Automatic; + CURRENT_PROJECT_VERSION = 1; + DEVELOPMENT_TEAM = LR4H2F7AM7; + ENABLE_PREVIEWS = YES; + GENERATE_INFOPLIST_FILE = YES; + INFOPLIST_FILE = iosNativeSample/Info.plist; + INFOPLIST_KEY_CFBundleDisplayName = "Cascade Native"; + INFOPLIST_KEY_UIApplicationSceneManifest_Generation = YES; + INFOPLIST_KEY_UIApplicationSupportsIndirectInputEvents = YES; + INFOPLIST_KEY_UILaunchScreen_Generation = YES; + INFOPLIST_KEY_UISupportedInterfaceOrientations_iPad = "UIInterfaceOrientationPortrait UIInterfaceOrientationPortraitUpsideDown UIInterfaceOrientationLandscapeLeft UIInterfaceOrientationLandscapeRight"; + INFOPLIST_KEY_UISupportedInterfaceOrientations_iPhone = "UIInterfaceOrientationPortrait UIInterfaceOrientationLandscapeLeft UIInterfaceOrientationLandscapeRight"; + LD_RUNPATH_SEARCH_PATHS = ( + "$(inherited)", + "@executable_path/Frameworks", + ); + MARKETING_VERSION = 1.0; + PRODUCT_BUNDLE_IDENTIFIER = io.github.linreal.cascade.iosNativeSample; + PRODUCT_NAME = "$(TARGET_NAME)"; + SWIFT_EMIT_LOC_STRINGS = YES; + SWIFT_VERSION = 5.0; + TARGETED_DEVICE_FAMILY = "1,2"; + }; + name = Release; + }; +/* End XCBuildConfiguration section */ + +/* Begin XCConfigurationList section */ + CA5CADE000000000000000C0 /* Build configuration list for PBXProject "iosNativeSample" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + CA5CADE000000000000000C1 /* Debug */, + CA5CADE000000000000000C2 /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + CA5CADE000000000000000C3 /* Build configuration list for PBXNativeTarget "iosNativeSample" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + CA5CADE000000000000000C4 /* Debug */, + CA5CADE000000000000000C5 /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; +/* End XCConfigurationList section */ + }; + rootObject = CA5CADE000000000000000A0 /* Project object */; +} diff --git a/iosNativeSample/iosNativeSample.xcodeproj/xcshareddata/xcschemes/iosNativeSample.xcscheme b/iosNativeSample/iosNativeSample.xcodeproj/xcshareddata/xcschemes/iosNativeSample.xcscheme new file mode 100644 index 0000000..f981389 --- /dev/null +++ b/iosNativeSample/iosNativeSample.xcodeproj/xcshareddata/xcschemes/iosNativeSample.xcscheme @@ -0,0 +1,78 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/iosNativeSample/iosNativeSample/App/AppTheme.swift b/iosNativeSample/iosNativeSample/App/AppTheme.swift new file mode 100644 index 0000000..50eaf64 --- /dev/null +++ b/iosNativeSample/iosNativeSample/App/AppTheme.swift @@ -0,0 +1,123 @@ +import SwiftUI + +/// Fixed violet design system mirroring the Compose sample's palette, so the +/// native host looks like the KMP one. Light/dark is driven by the app-level +/// theme toggle (which also flips the editor via `setDarkMode`), not by the +/// system appearance. +struct AppTheme { + let isDark: Bool + + // Material-scheme equivalents used by the shared chrome. + let primary: Color + let onPrimary: Color + let background: Color + let surface: Color + let onBackground: Color + let onSurface: Color + /// Muted icon/label ink (the Compose chrome's onSurfaceVariant). + let mutedInk: Color + /// Hairline divider inside grouped chrome containers. + let divider: Color + let destructive: Color + let savedGreen = Color(rgb: 0x34C77B) + + // Landing-screen accents. + let subtitle: Color + let cardBackground: Color + let cardBorder: Color + let cardTitle: Color + let cardDescription: Color + let caret: Color + let badgeBackground: Color + let badgeBorder: Color + let badgeText: Color + let badgeDot = Color(rgb: 0xFF6B4A) + let heroGradient = [Color(rgb: 0x6C3DE8), Color(rgb: 0x8B5CF6), Color(rgb: 0xA855F7)] + let tileBlocksBackground: Color + let tileBlocksIcon: Color + let tileCommentsBackground: Color + let tileCommentsIcon: Color + + static let light = AppTheme( + isDark: false, + primary: Color(rgb: 0x6C3DE8), + onPrimary: .white, + background: Color(rgb: 0xF6F2FF), + surface: .white, + onBackground: Color(rgb: 0x1C1238), + onSurface: Color(rgb: 0x1C1238), + mutedInk: Color(rgb: 0x4A4360), + divider: Color(rgb: 0xE4DAFB), + destructive: Color(rgb: 0xB3261E), + subtitle: Color(rgb: 0x4A4360), + cardBackground: .white, + cardBorder: Color(rgb: 0xEDE6FB), + cardTitle: Color(rgb: 0x1C1238), + cardDescription: Color(rgb: 0x6B6580), + caret: Color(rgb: 0xCBB8EC), + badgeBackground: .white, + badgeBorder: Color(rgb: 0xE4DAFB), + badgeText: Color(rgb: 0x6C3DE8), + tileBlocksBackground: Color(rgb: 0xF0E9FE), + tileBlocksIcon: Color(rgb: 0x6C3DE8), + tileCommentsBackground: Color(rgb: 0xFFEDE7), + tileCommentsIcon: Color(rgb: 0xFF6B4A) + ) + + static let dark = AppTheme( + isDark: true, + primary: Color(rgb: 0xA78BFA), + onPrimary: Color(rgb: 0x1B1230), + background: Color(rgb: 0x120C24), + surface: Color(rgb: 0x1E1832), + onBackground: Color(rgb: 0xF4F1FB), + onSurface: Color(rgb: 0xF4F1FB), + mutedInk: Color(rgb: 0x9B93B8), + divider: Color(rgb: 0x3A3354), + destructive: Color(rgb: 0xF2B8B5), + subtitle: Color(rgb: 0x9B93B8), + cardBackground: Color(argb: 0x0AFFFFFF), + cardBorder: Color(argb: 0x14FFFFFF), + cardTitle: .white, + cardDescription: Color(rgb: 0x8A82A6), + caret: Color(rgb: 0x5A5278), + badgeBackground: Color(argb: 0x248B5CF6), + badgeBorder: Color(argb: 0x4D8B5CF6), + badgeText: Color(rgb: 0xC4B5FD), + tileBlocksBackground: Color(argb: 0x2E8B5CF6), + tileBlocksIcon: Color(rgb: 0xC4B5FD), + tileCommentsBackground: Color(argb: 0x29FF6B4A), + tileCommentsIcon: Color(rgb: 0xFF8A6B) + ) + + static func theme(isDark: Bool) -> AppTheme { + isDark ? .dark : .light + } +} + +extension Color { + /// Opaque color from a 0xRRGGBB literal. + init(rgb: UInt32) { + self.init( + red: Double((rgb >> 16) & 0xFF) / 255.0, + green: Double((rgb >> 8) & 0xFF) / 255.0, + blue: Double(rgb & 0xFF) / 255.0 + ) + } + + /// Color from a 0xAARRGGBB literal (the Compose `Color(0x...)` spelling). + init(argb: UInt32) { + self.init( + .sRGB, + red: Double((argb >> 16) & 0xFF) / 255.0, + green: Double((argb >> 8) & 0xFF) / 255.0, + blue: Double(argb & 0xFF) / 255.0, + opacity: Double((argb >> 24) & 0xFF) / 255.0 + ) + } + + /// Color from the editor's rich-text span `argb` payload (sign-carrying Int64). + init(spanArgb: Int64) { + self.init(argb: UInt32(truncatingIfNeeded: spanArgb)) + } +} diff --git a/iosNativeSample/iosNativeSample/App/LandingView.swift b/iosNativeSample/iosNativeSample/App/LandingView.swift new file mode 100644 index 0000000..4daa4ef --- /dev/null +++ b/iosNativeSample/iosNativeSample/App/LandingView.swift @@ -0,0 +1,161 @@ +import SwiftUI + +/// Landing page: brand header, a hero card for the Editor Demo, and module +/// cards for the remaining screens — a native retelling of the KMP sample's +/// landing screen. +struct LandingView: View { + let theme: AppTheme + let onNavigate: (SampleDestination) -> Void + + var body: some View { + ScrollView { + VStack(alignment: .leading, spacing: 0) { + Spacer().frame(height: 24) + badge + Spacer().frame(height: 22) + title + Spacer().frame(height: 16) + Text("A block-based document editor, embedded natively from CascadeEditor.xcframework.") + .font(.system(size: 17)) + .lineSpacing(4) + .foregroundStyle(theme.subtitle) + .frame(maxWidth: 320, alignment: .leading) + Spacer().frame(height: 26) + heroCard + Spacer().frame(height: 34) + HStack { + Text("EXPLORE") + .font(.system(size: 15, weight: .bold)) + .kerning(2.2) + .foregroundStyle(theme.onBackground) + Spacer() + Text("3 modules") + .font(.system(size: 13, weight: .medium)) + .foregroundStyle(theme.cardDescription) + } + Spacer().frame(height: 16) + VStack(spacing: 12) { + moduleCard( + title: "Comments", + description: "Editor as a chat composer with rich-text bubbles", + systemImage: "bubble.left", + tileBackground: theme.tileCommentsBackground, + tileIcon: theme.tileCommentsIcon, + destination: .comments + ) + moduleCard( + title: "Custom Blocks", + description: "Native SwiftUI blocks and slash commands", + systemImage: "puzzlepiece", + tileBackground: theme.tileBlocksBackground, + tileIcon: theme.tileBlocksIcon, + destination: .customBlocks + ) + } + Spacer().frame(height: 32) + } + .padding(.horizontal, 18) + } + .background(theme.background) + } + + private var badge: some View { + HStack(spacing: 8) { + Circle() + .fill(theme.badgeDot) + .frame(width: 7, height: 7) + Text("Native Swift · XCFramework") + .font(.system(size: 13, weight: .semibold)) + .foregroundStyle(theme.badgeText) + } + .padding(.horizontal, 12) + .padding(.vertical, 7) + .background(theme.badgeBackground) + .clipShape(Capsule()) + .overlay(Capsule().strokeBorder(theme.badgeBorder, lineWidth: 1)) + } + + private var title: some View { + VStack(alignment: .leading, spacing: 0) { + Text("Cascade") + .foregroundStyle(theme.onBackground) + Text("Editor") + .foregroundStyle(theme.primary) + } + .font(.system(size: 44, weight: .bold)) + } + + private var heroCard: some View { + Button { + onNavigate(.editorDemo) + } label: { + VStack(alignment: .leading, spacing: 10) { + HStack { + Image(systemName: "doc.richtext") + .font(.system(size: 22, weight: .medium)) + Spacer() + Image(systemName: "arrow.up.right") + .font(.system(size: 17, weight: .semibold)) + .opacity(0.85) + } + Spacer().frame(height: 22) + Text("Editor Demo") + .font(.system(size: 24, weight: .bold)) + Text("The full editing experience: formatting, links, selection, autosave.") + .font(.system(size: 14)) + .opacity(0.9) + } + .foregroundStyle(.white) + .padding(22) + .frame(maxWidth: .infinity, alignment: .leading) + .background( + LinearGradient(colors: theme.heroGradient, startPoint: .top, endPoint: .bottom) + ) + .clipShape(RoundedRectangle(cornerRadius: 24)) + .shadow(color: theme.heroGradient[0].opacity(0.4), radius: 14, y: 8) + } + .buttonStyle(.plain) + .accessibilityLabel("Editor Demo") + } + + private func moduleCard( + title: String, + description: String, + systemImage: String, + tileBackground: Color, + tileIcon: Color, + destination: SampleDestination + ) -> some View { + Button { + onNavigate(destination) + } label: { + HStack(spacing: 14) { + Image(systemName: systemImage) + .font(.system(size: 17, weight: .medium)) + .foregroundStyle(tileIcon) + .frame(width: 42, height: 42) + .background(tileBackground) + .clipShape(RoundedRectangle(cornerRadius: 12)) + VStack(alignment: .leading, spacing: 3) { + Text(title) + .font(.system(size: 16, weight: .semibold)) + .foregroundStyle(theme.cardTitle) + Text(description) + .font(.system(size: 13)) + .foregroundStyle(theme.cardDescription) + .multilineTextAlignment(.leading) + } + Spacer() + Image(systemName: "chevron.right") + .font(.system(size: 14, weight: .semibold)) + .foregroundStyle(theme.caret) + } + .padding(14) + .background(theme.cardBackground) + .clipShape(RoundedRectangle(cornerRadius: 18)) + .overlay(RoundedRectangle(cornerRadius: 18).strokeBorder(theme.cardBorder, lineWidth: 1)) + } + .buttonStyle(.plain) + .accessibilityLabel(title) + } +} diff --git a/iosNativeSample/iosNativeSample/App/NativeSampleApp.swift b/iosNativeSample/iosNativeSample/App/NativeSampleApp.swift new file mode 100644 index 0000000..21bb8dc --- /dev/null +++ b/iosNativeSample/iosNativeSample/App/NativeSampleApp.swift @@ -0,0 +1,51 @@ +import SwiftUI + +@main +struct NativeSampleApp: App { + @State private var isDark = false + + var body: some Scene { + WindowGroup { + RootView(isDark: $isDark) + .preferredColorScheme(isDark ? .dark : .light) + } + } +} + +enum SampleDestination: Hashable { + case editorDemo + case comments + case customBlocks +} + +struct RootView: View { + @Binding var isDark: Bool + @State private var path: [SampleDestination] = [] + + private var theme: AppTheme { AppTheme.theme(isDark: isDark) } + + var body: some View { + NavigationStack(path: $path) { + LandingView(theme: theme) { destination in + path.append(destination) + } + .navigationDestination(for: SampleDestination.self) { destination in + destinationView(for: destination) + .navigationBarBackButtonHidden(true) + .toolbar(.hidden, for: .navigationBar) + } + } + } + + @ViewBuilder + private func destinationView(for destination: SampleDestination) -> some View { + switch destination { + case .editorDemo: + EditorDemoScreen(isDark: $isDark) + case .comments: + CommentsScreen(isDark: $isDark) + case .customBlocks: + CustomBlocksScreen(isDark: $isDark) + } + } +} diff --git a/iosNativeSample/iosNativeSample/Editor/CascadeEditorHost.swift b/iosNativeSample/iosNativeSample/Editor/CascadeEditorHost.swift new file mode 100644 index 0000000..9aa06a7 --- /dev/null +++ b/iosNativeSample/iosNativeSample/Editor/CascadeEditorHost.swift @@ -0,0 +1,17 @@ +import SwiftUI +import UIKit + +/// Thin `UIViewControllerRepresentable` embedding the SDK's editor view +/// controller. The view controller is created (and cached) by the model, so +/// SwiftUI re-evaluating this representable never remounts the Compose tree. +struct CascadeEditorHost: UIViewControllerRepresentable { + let model: EditorScreenModel + + func makeUIViewController(context: Context) -> UIViewController { + model.editorViewController + } + + func updateUIViewController(_ uiViewController: UIViewController, context: Context) { + // All editor updates flow through the controller API; nothing to sync here. + } +} diff --git a/iosNativeSample/iosNativeSample/Editor/EditorScreenModel.swift b/iosNativeSample/iosNativeSample/Editor/EditorScreenModel.swift new file mode 100644 index 0000000..7c11f3c --- /dev/null +++ b/iosNativeSample/iosNativeSample/Editor/EditorScreenModel.swift @@ -0,0 +1,92 @@ +import Combine +import UIKit +import CascadeEditor + +/// Observable wrapper around `CascadeEditorController` that turns the +/// controller's pull-based state (`canUndo`, `hasSelection`, …) into +/// `@Published` values the SwiftUI chrome can bind to. +/// +/// The controller pushes change signals through its callbacks; the model +/// re-reads the derived properties on every signal instead of tracking deltas, +/// which keeps it correct for any mutation source (typing, undo, loads, +/// configuration changes). +@MainActor +final class EditorScreenModel: ObservableObject { + let controller: CascadeEditorController + + @Published private(set) var canUndo = false + @Published private(set) var canRedo = false + @Published private(set) var hasSelection = false + @Published private(set) var selectedCount = 0 + @Published private(set) var isReadOnly: Bool + @Published private(set) var toolbarState = CascadeToolbarState.companion.Empty + + /// Screen-level hook invoked whenever document content changes (Task-level + /// consumers use it for autosave). Fires on the main thread. + var onDocumentChanged: (() -> Void)? + /// Screen-level hook for link taps inside the editor. + var onOpenLink: ((String) -> Void)? + + /// The hosted editor. Created once per controller and cached so SwiftUI + /// re-parenting never spawns a second Compose tree over the same state. + private(set) lazy var editorViewController: UIViewController = controller.makeViewController() + + init(configuration: CascadeEditorConfiguration) { + controller = CascadeEditorController(initialJson: nil, configuration: configuration) + isReadOnly = configuration.readOnly + + controller.onStateChanged = { [weak self] in self?.refreshEditorState() } + controller.onDocumentChanged = { [weak self] in self?.onDocumentChanged?() } + controller.onToolbarStateChanged = { [weak self] state in self?.toolbarState = state } + controller.onOpenLink = { [weak self] url in self?.onOpenLink?(url) } + controller.onInternalError = { message in + #if DEBUG + print("CascadeEditor internal error: \(message)") + #endif + } + } + + func setReadOnly(_ value: Bool) { + controller.setReadOnly(value: value) + } + + func setDarkMode(_ value: Bool) { + controller.setDarkMode(value: value) + } + + func undo() { controller.undo() } + func redo() { controller.redo() } + func clearSelection() { controller.clearSelection() } + func deleteSelectedOrFocused() { controller.deleteSelectedOrFocused() } + + private func refreshEditorState() { + canUndo = controller.canUndo + canRedo = controller.canRedo + hasSelection = controller.hasSelection + selectedCount = Int(controller.selectedBlockCount) + isReadOnly = controller.configuration.readOnly + } +} + +extension CascadeEditorConfiguration { + /// The sample's baseline editor configuration; screens override the pieces + /// they need (`isDark`, chrome toggles) from here. + static func standard( + isDark: Bool, + readOnly: Bool = false, + toolbarMode: CascadeToolbarMode = .builtIn, + slashCommandsEnabled: Bool = true, + blockSelectionEnabled: Bool = true, + blockDraggingEnabled: Bool = true + ) -> CascadeEditorConfiguration { + CascadeEditorConfiguration( + readOnly: readOnly, + toolbarMode: toolbarMode, + slashCommandsEnabled: slashCommandsEnabled, + blockSelectionEnabled: blockSelectionEnabled, + blockDraggingEnabled: blockDraggingEnabled, + isDark: isDark, + crashPolicy: .containAndReport + ) + } +} diff --git a/iosNativeSample/iosNativeSample/Info.plist b/iosNativeSample/iosNativeSample/Info.plist new file mode 100644 index 0000000..11845e1 --- /dev/null +++ b/iosNativeSample/iosNativeSample/Info.plist @@ -0,0 +1,8 @@ + + + + + CADisableMinimumFrameDurationOnPhone + + + diff --git a/iosNativeSample/iosNativeSample/Resources/default_document.json b/iosNativeSample/iosNativeSample/Resources/default_document.json new file mode 100644 index 0000000..c90f98c --- /dev/null +++ b/iosNativeSample/iosNativeSample/Resources/default_document.json @@ -0,0 +1,467 @@ +{ + "version": 2, + "blocks": [ + { + "id": "welcome-1", + "type": { + "typeId": "heading_1" + }, + "content": { + "kind": "text", + "version": 1, + "text": "Welcome to Cascade Editor", + "spans": [ + { + "start": 0, + "end": 25, + "style": { + "type": "bold" + } + } + ] + } + }, + { + "id": "welcome-2", + "type": { + "typeId": "paragraph" + }, + "content": { + "kind": "text", + "version": 1, + "text": "A block-based document editor for Compose Multiplatform. Everything you see here is editable \u2014 try it out!", + "spans": [ + { + "start": 2, + "end": 29, + "style": { + "type": "bold" + } + }, + { + "start": 34, + "end": 55, + "style": { + "type": "italic" + } + } + ] + } + }, + { + "id": "welcome-3", + "type": { + "typeId": "divider" + }, + "content": { + "kind": "empty" + } + }, + { + "id": "try-1", + "type": { + "typeId": "heading_2" + }, + "content": { + "kind": "text", + "version": 1, + "text": "Try These", + "spans": [ + { + "start": 0, + "end": 9, + "style": { + "type": "bold" + } + } + ] + } + }, + { + "id": "try-format-1", + "type": { + "typeId": "todo" + }, + "content": { + "kind": "text", + "version": 1, + "text": "Mix bold, italic, underline, strikethrough, code, and highlights in any block.", + "spans": [ + { + "start": 4, + "end": 8, + "style": { + "type": "bold" + } + }, + { + "start": 10, + "end": 16, + "style": { + "type": "italic" + } + }, + { + "start": 18, + "end": 27, + "style": { + "type": "underline" + } + }, + { + "start": 29, + "end": 42, + "style": { + "type": "strikethrough" + } + }, + { + "start": 44, + "end": 48, + "style": { + "type": "inline_code" + } + }, + { + "start": 54, + "end": 64, + "style": { + "type": "highlight", + "colorArgb": 4294961979 + } + }, + { + "start": 65, + "end": 71, + "style": { + "type": "link", + "url": "https://github.com/linreal/cascade-editor" + } + } + ] + } + }, + + { + "id": "try-2", + "type": { + "typeId": "todo", + "checked": false + }, + "content": { + "kind": "text", + "version": 1, + "text": "Tap here and start typing", + "spans": [] + } + }, + { + "id": "try-3", + "type": { + "typeId": "todo", + "checked": false + }, + "content": { + "kind": "text", + "version": 1, + "text": "Select text, then use the toolbar to make it bold or italic", + "spans": [ + { + "start": 26, + "end": 33, + "style": { + "type": "bold" + } + } + ] + } + }, + { + "id": "try-4", + "type": { + "typeId": "todo", + "checked": false + }, + "content": { + "kind": "text", + "version": 1, + "text": "Type / to open slash commands (or just use / icon from the toolbar)", + "spans": [ + { + "start": 5, + "end": 6, + "style": { + "type": "inline_code" + } + } + ] + } + }, + { + "id": "try-5", + "type": { + "typeId": "todo", + "checked": false + }, + "content": { + "kind": "text", + "version": 1, + "text": "Use indentation to group related tasks", + "spans": [] + } + }, + { + "id": "try-nested-todo-1", + "type": { + "typeId": "todo", + "checked": false + }, + "attributes": { + "indentationLevel": 1 + }, + "content": { + "kind": "text", + "version": 1, + "text": "Subtasks can sit under a parent todo", + "spans": [] + } + }, + { + "id": "try-nested-todo-2", + "type": { + "typeId": "todo", + "checked": false + }, + "attributes": { + "indentationLevel": 2 + }, + "content": { + "kind": "text", + "version": 1, + "text": "Deeper todo levels stay attached to the outline", + "spans": [] + } + }, + { + "id": "try-nested-todo-3", + "type": { + "typeId": "todo", + "checked": false + }, + "attributes": { + "indentationLevel": 1 + }, + "content": { + "kind": "text", + "version": 1, + "text": "Outdent again when the group is done", + "spans": [] + } + }, + { + "id": "try-6", + "type": { + "typeId": "todo", + "checked": false + }, + "content": { + "kind": "text", + "version": 1, + "text": "Hold and drag any block to reorder it", + "spans": [] + } + }, + { + "id": "try-7", + "type": { + "typeId": "todo", + "checked": false + }, + "content": { + "kind": "text", + "version": 1, + "text": "Long-press a block to select it, then tap others to multi-select and delete", + "spans": [] + } + }, + { + "id": "try-8", + "type": { + "typeId": "todo", + "checked": false + }, + "content": { + "kind": "text", + "version": 1, + "text": "Press Enter at the end of this line to create a new block", + "spans": [] + } + }, + { + "id": "blocks-1", + "type": { + "typeId": "heading_2" + }, + "content": { + "kind": "text", + "version": 1, + "text": "Block Types", + "spans": [ + { + "start": 0, + "end": 11, + "style": { + "type": "bold" + } + } + ] + } + }, + { + "id": "blocks-2", + "type": { + "typeId": "bullet_list" + }, + "content": { + "kind": "text", + "version": 1, + "text": "Bullet lists for unordered content", + "spans": [] + } + }, + { + "id": "blocks-3", + "type": { + "typeId": "bullet_list" + }, + "attributes": { + "indentationLevel": 1 + }, + "content": { + "kind": "text", + "version": 1, + "text": "Nest ideas without numbering", + "spans": [] + } + }, + { + "id": "blocks-4", + "type": { + "typeId": "numbered_list", + "number": 1 + }, + "content": { + "kind": "text", + "version": 1, + "text": "Numbered lists auto-increment", + "spans": [] + } + }, + { + "id": "blocks-5", + "type": { + "typeId": "numbered_list", + "number": 1 + }, + "attributes": { + "indentationLevel": 1 + }, + "content": { + "kind": "text", + "version": 1, + "text": "Indented numbered items keep their own sequence", + "spans": [] + } + }, + { + "id": "blocks-6", + "type": { + "typeId": "numbered_list", + "number": 1 + }, + "attributes": { + "indentationLevel": 2 + }, + "content": { + "kind": "text", + "version": 1, + "text": "Deeper levels can explain a step in detail", + "spans": [] + } + }, + { + "id": "blocks-7", + "type": { + "typeId": "numbered_list", + "number": 2 + }, + "attributes": { + "indentationLevel": 1 + }, + "content": { + "kind": "text", + "version": 1, + "text": "Sibling nested items continue at the same depth", + "spans": [] + } + }, + { + "id": "blocks-numbered-root-2", + "type": { + "typeId": "numbered_list", + "number": 2 + }, + "content": { + "kind": "text", + "version": 1, + "text": "Delete or reorder and every level renumbers", + "spans": [] + } + }, + { + "id": "blocks-8", + "type": { + "typeId": "quote" + }, + "content": { + "kind": "text", + "version": 1, + "text": "The best way to predict the future is to invent it. \u2014 Alan Kay", + "spans": [] + } + }, + { + "id": "blocks-code-1", + "type": { + "typeId": "code" + }, + "content": { + "kind": "text", + "version": 1, + "text": "fun greet(name: String) {\n println(\"Hello, $name!\")\n}", + "spans": [] + } + }, + { + "id": "blocks-9", + "type": { + "typeId": "divider" + }, + "content": { + "kind": "empty" + } + }, + { + "id": "blocks-10", + "type": { + "typeId": "paragraph" + }, + "content": { + "kind": "text", + "version": 1, + "text": "Your changes are saved automatically. Hit Reset in the toolbar to start fresh.", + "spans": [] + } + } + ] +} diff --git a/iosNativeSample/iosNativeSample/Screens/Comments/CommentModels.swift b/iosNativeSample/iosNativeSample/Screens/Comments/CommentModels.swift new file mode 100644 index 0000000..9c7c39b --- /dev/null +++ b/iosNativeSample/iosNativeSample/Screens/Comments/CommentModels.swift @@ -0,0 +1,198 @@ +import SwiftUI +import UIKit + +/// A single comment in the demo feed: plain text plus style runs — the same +/// shape the editor's rich-text snapshot exports, kept independent of SDK +/// types so seed data and sent comments share one renderer. +struct Comment: Identifiable { + let id: Int + let authorName: String + let initials: String + let avatarColor: Color + let timestamp: String + let isOwn: Bool + let text: String + let spans: [CommentSpan] +} + +/// One style run over [start, end) in UTF-16 units (matching both Kotlin +/// string indices and NSAttributedString ranges). +struct CommentSpan { + enum Kind { + case bold + case italic + case underline + case strikeThrough + case inlineCode + case highlight(argb: Int64) + case link + } + + let start: Int + let end: Int + let kind: Kind +} + +/// Accumulates plain and styled segments while computing span offsets, so seed +/// data can be authored without manual index arithmetic. +struct CommentTextBuilder { + private(set) var text = "" + private(set) var spans: [CommentSpan] = [] + + mutating func plain(_ segment: String) { + text += segment + } + + mutating func styled(_ segment: String, _ kinds: CommentSpan.Kind...) { + let start = text.utf16.count + text += segment + let end = text.utf16.count + for kind in kinds { + spans.append(CommentSpan(start: start, end: end, kind: kind)) + } + } +} + +private func buildComment( + id: Int, + authorName: String, + initials: String, + avatarColor: Color, + timestamp: String, + isOwn: Bool, + _ build: (inout CommentTextBuilder) -> Void +) -> Comment { + var builder = CommentTextBuilder() + build(&builder) + return Comment( + id: id, + authorName: authorName, + initials: initials, + avatarColor: avatarColor, + timestamp: timestamp, + isOwn: isOwn, + text: builder.text, + spans: builder.spans + ) +} + +enum SelfAuthor { + static let name = "You" + static let initials = "You" + static let color = Color(rgb: 0x160B2E) +} + +private let avatarMaya = Color(rgb: 0x6C3DE8) +private let avatarTheo = Color(rgb: 0xE2B23A) +private let avatarJordan = Color(rgb: 0x34C77B) + +/// Seed feed mirroring the KMP sample's comment thread. +func seedComments() -> [Comment] { + [ + buildComment( + id: 1, authorName: "Maya Reyes", initials: "MR", avatarColor: avatarMaya, + timestamp: "9:32 AM", isOwn: false + ) { builder in + builder.plain("The new ") + builder.styled("onboarding flow", .bold) + builder.plain(" feels so much smoother. Nice work shipping it this sprint.") + }, + buildComment( + id: 2, authorName: "Theo Kane", initials: "TK", avatarColor: avatarTheo, + timestamp: "9:41 AM", isOwn: false + ) { builder in + builder.plain("One thing — the ") + builder.styled("empty state", .italic) + builder.plain(" on step 2 still says ") + builder.styled("TODO", .inlineCode) + builder.plain(". Can we fill that in before the demo?") + }, + buildComment( + id: 3, authorName: "Jordan Park", initials: "JP", avatarColor: avatarJordan, + timestamp: "9:48 AM", isOwn: false + ) { builder in + builder.plain("Good catch. I'll have copy ready by ") + builder.styled("this afternoon", .underline) + builder.plain(" and ping you to review.") + }, + buildComment( + id: 4, authorName: SelfAuthor.name, initials: SelfAuthor.initials, + avatarColor: SelfAuthor.color, timestamp: "9:50 AM", isOwn: true + ) { builder in + builder.plain("Perfect. I'll hold the build until the ") + builder.styled("copy lands", .bold) + builder.plain(" — flag me if anything blocks you.") + }, + buildComment( + id: 5, authorName: "Theo Kane", initials: "TK", avatarColor: avatarTheo, + timestamp: "9:53 AM", isOwn: false + ) { builder in + builder.plain("Nothing blocking — ") + builder.styled("thanks both", .italic) + builder.plain(". Drafting now.") + }, + ] +} + +/// Renders a comment's style runs onto an `AttributedString` for a bubble. +/// +/// Bold/italic merge symbolic font traits with whatever font is already in the +/// range, so overlapping runs compose instead of overwriting each other. Links +/// are styled (color + underline) but carry no `.link` attribute — bubbles are +/// intentionally non-interactive. +func commentAttributedString( + text: String, + spans: [CommentSpan], + textColor: UIColor, + inlineCodeBackground: UIColor, + linkColor: UIColor +) -> AttributedString { + let baseFont = UIFont.systemFont(ofSize: 15) + let result = NSMutableAttributedString( + string: text, + attributes: [.font: baseFont, .foregroundColor: textColor] + ) + let length = result.length + + for span in spans { + let start = max(0, min(span.start, length)) + let end = max(start, min(span.end, length)) + guard end > start else { continue } + let range = NSRange(location: start, length: end - start) + + switch span.kind { + case .bold: + result.mergeFontTraits(.traitBold, in: range) + case .italic: + result.mergeFontTraits(.traitItalic, in: range) + case .underline: + result.addAttribute(.underlineStyle, value: NSUnderlineStyle.single.rawValue, range: range) + case .strikeThrough: + result.addAttribute(.strikethroughStyle, value: NSUnderlineStyle.single.rawValue, range: range) + case .inlineCode: + result.addAttribute(.font, value: UIFont.monospacedSystemFont(ofSize: 14, weight: .regular), range: range) + result.addAttribute(.backgroundColor, value: inlineCodeBackground, range: range) + case .highlight(let argb): + result.addAttribute(.backgroundColor, value: UIColor(Color(spanArgb: argb)), range: range) + case .link: + result.addAttribute(.foregroundColor, value: linkColor, range: range) + result.addAttribute(.underlineStyle, value: NSUnderlineStyle.single.rawValue, range: range) + } + } + + return AttributedString(result) +} + +private extension NSMutableAttributedString { + /// Adds a symbolic trait to every font run inside `range`, preserving the + /// runs' existing traits and sizes. + func mergeFontTraits(_ trait: UIFontDescriptor.SymbolicTraits, in range: NSRange) { + enumerateAttribute(.font, in: range) { value, subrange, _ in + let current = (value as? UIFont) ?? UIFont.systemFont(ofSize: 15) + let traits = current.fontDescriptor.symbolicTraits.union(trait) + if let descriptor = current.fontDescriptor.withSymbolicTraits(traits) { + addAttribute(.font, value: UIFont(descriptor: descriptor, size: current.pointSize), range: subrange) + } + } + } +} diff --git a/iosNativeSample/iosNativeSample/Screens/Comments/CommentsModel.swift b/iosNativeSample/iosNativeSample/Screens/Comments/CommentsModel.swift new file mode 100644 index 0000000..e6d7b08 --- /dev/null +++ b/iosNativeSample/iosNativeSample/Screens/Comments/CommentsModel.swift @@ -0,0 +1,94 @@ +import SwiftUI +import CascadeEditor + +/// Screen logic for the comments demo: a chromeless composer editor plus the +/// in-memory feed. Sending flattens the composer's rich-text snapshot into a +/// single bubble and resets the composer to one empty paragraph. +@MainActor +final class CommentsModel: ObservableObject { + let editor: EditorScreenModel + + @Published private(set) var comments: [Comment] + @Published private(set) var canSend = false + + private var nextId: Int + + init(editor: EditorScreenModel) { + self.editor = editor + let seeded = seedComments() + comments = seeded + nextId = (seeded.map(\.id).max() ?? 0) + 1 + editor.onDocumentChanged = { [weak self] in self?.refreshCanSend() } + resetComposer() + } + + /// Flattens the composer document into one comment: block texts joined + /// with newlines and every block's spans shifted into the combined + /// coordinate space (all offsets in UTF-16 units, matching the SDK's). + func send() { + let snapshot = editor.controller.exportRichText() + var combined = "" + var spans: [CommentSpan] = [] + for (index, block) in snapshot.blocks.enumerated() { + if index > 0 { combined += "\n" } + let base = combined.utf16.count + for span in block.spans { + spans.append( + CommentSpan( + start: base + Int(span.start), + end: base + Int(span.end), + kind: span.commentSpanKind + ) + ) + } + combined += block.text + } + guard !combined.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else { return } + + comments.append( + Comment( + id: nextId, + authorName: SelfAuthor.name, + initials: SelfAuthor.initials, + avatarColor: SelfAuthor.color, + timestamp: "Now", + isOwn: true, + text: combined, + spans: spans + ) + ) + nextId += 1 + resetComposer() + editor.controller.clearFocus() + } + + /// Returns the composer to a single empty paragraph (clears history too). + private func resetComposer() { + _ = editor.controller.loadJson(json: Self.emptyDocumentJson) + refreshCanSend() + } + + private func refreshCanSend() { + let text = editor.controller.exportPlainText() + canSend = !text.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty + } + + private static let emptyDocumentJson: String = + CascadeEditorDocumentBuilder().paragraph(text: "").buildJson() +} + +extension CascadeRichTextSpan { + /// Maps the SDK span onto the feed's renderer-agnostic span kind. + var commentSpanKind: CommentSpan.Kind { + switch kind { + case .bold: return .bold + case .italic: return .italic + case .underline: return .underline + case .strikeThrough: return .strikeThrough + case .inlineCode: return .inlineCode + case .highlight: return .highlight(argb: argb) + case .link: return .link + default: return .bold + } + } +} diff --git a/iosNativeSample/iosNativeSample/Screens/CommentsScreen.swift b/iosNativeSample/iosNativeSample/Screens/CommentsScreen.swift new file mode 100644 index 0000000..7cb8d56 --- /dev/null +++ b/iosNativeSample/iosNativeSample/Screens/CommentsScreen.swift @@ -0,0 +1,254 @@ +import SwiftUI +import CascadeEditor + +/// Editor-as-composer demo: a feed of rich-text bubbles above a pinned +/// composer whose formatting bar fades in while the editor is focused. +struct CommentsScreen: View { + @Binding var isDark: Bool + @Environment(\.dismiss) private var dismiss + @StateObject private var editor: EditorScreenModel + @StateObject private var model: CommentsModel + + init(isDark: Binding) { + _isDark = isDark + let editorModel = EditorScreenModel( + configuration: .standard( + isDark: isDark.wrappedValue, + toolbarMode: CascadeToolbarMode.none, + slashCommandsEnabled: false, + blockSelectionEnabled: false, + blockDraggingEnabled: false + ) + ) + _editor = StateObject(wrappedValue: editorModel) + _model = StateObject(wrappedValue: CommentsModel(editor: editorModel)) + } + + private var theme: AppTheme { AppTheme.theme(isDark: isDark) } + + var body: some View { + VStack(spacing: 0) { + TitledEditorTopBar( + theme: theme, + title: "Comments", + onBack: { dismiss() }, + onToggleTheme: { isDark.toggle() } + ) + feed + composer + } + .padding(.horizontal, 12) + .background(theme.background) + .onChange(of: isDark) { _, newValue in + editor.setDarkMode(newValue) + } + } + + private var feed: some View { + ScrollViewReader { proxy in + ScrollView { + LazyVStack(spacing: 18) { + ForEach(model.comments) { comment in + CommentBubble(theme: theme, comment: comment) + .id(comment.id) + } + } + .padding(.top, 16) + .padding(.bottom, 20) + } + .onChange(of: model.comments.count) { _, _ in + if let last = model.comments.last { + withAnimation { + proxy.scrollTo(last.id, anchor: .bottom) + } + } + } + } + } + + private var composer: some View { + VStack(spacing: 0) { + if editor.toolbarState.focused { + FormattingBar(theme: theme, editor: editor) + .transition(.opacity.combined(with: .move(edge: .bottom))) + } + HStack(spacing: 8) { + CascadeEditorHost(model: editor) + .frame(height: 64) + .clipShape(RoundedRectangle(cornerRadius: 20)) + SendButton(theme: theme, enabled: model.canSend) { + model.send() + } + } + .padding(EdgeInsets(top: 4, leading: 6, bottom: 4, trailing: 8)) + .background(theme.surface) + .clipShape(RoundedRectangle(cornerRadius: 24)) + } + .padding(.top, 8) + .padding(.bottom, 12) + .animation(.default, value: editor.toolbarState.focused) + } +} + +private struct CommentBubble: View { + let theme: AppTheme + let comment: Comment + + var body: some View { + let bubbleColor = comment.isOwn ? theme.primary : theme.surface + let textColor = comment.isOwn ? theme.onPrimary : theme.onSurface + let inlineCodeBackground = UIColor(textColor).withAlphaComponent(comment.isOwn ? 0.18 : 0.08) + let linkColor = comment.isOwn ? UIColor(theme.onPrimary) : UIColor(theme.primary) + + HStack(alignment: .top, spacing: 11) { + if comment.isOwn { + Spacer(minLength: 40) + } else { + Avatar(comment: comment) + } + + VStack(alignment: comment.isOwn ? .trailing : .leading, spacing: 6) { + HStack(spacing: 8) { + Text(comment.authorName) + .font(.system(size: 14, weight: .semibold)) + .foregroundStyle(theme.onBackground) + Text(comment.timestamp) + .font(.system(size: 12)) + .foregroundStyle(theme.onBackground.opacity(0.5)) + } + Text( + commentAttributedString( + text: comment.text, + spans: comment.spans, + textColor: UIColor(textColor), + inlineCodeBackground: inlineCodeBackground, + linkColor: linkColor + ) + ) + .font(.system(size: 15)) + .lineSpacing(4) + .padding(.horizontal, 14) + .padding(.vertical, 11) + .background(bubbleColor) + .clipShape(BubbleShape(isOwn: comment.isOwn)) + } + .frame(maxWidth: 300, alignment: comment.isOwn ? .trailing : .leading) + + if comment.isOwn { + Avatar(comment: comment) + } else { + Spacer(minLength: 40) + } + } + .frame(maxWidth: .infinity, alignment: comment.isOwn ? .trailing : .leading) + } +} + +private struct BubbleShape: Shape { + let isOwn: Bool + + func path(in rect: CGRect) -> Path { + let sharpCorner: UIRectCorner = isOwn ? .topRight : .topLeft + let rounded = UIBezierPath( + roundedRect: rect, + byRoundingCorners: UIRectCorner.allCorners.subtracting(sharpCorner), + cornerRadii: CGSize(width: 16, height: 16) + ) + let sharp = UIBezierPath( + roundedRect: rect, + byRoundingCorners: sharpCorner, + cornerRadii: CGSize(width: 4, height: 4) + ) + var path = Path(rounded.cgPath) + path = path.intersection(Path(sharp.cgPath)) + return path + } +} + +private struct Avatar: View { + let comment: Comment + + var body: some View { + Text(comment.initials) + .font(.system(size: 13, weight: .semibold)) + .foregroundStyle(.white) + .frame(width: 36, height: 36) + .background(comment.avatarColor) + .clipShape(Circle()) + } +} + +/// Formatting bar shown while the composer is focused. Buttons drive the +/// controller's toolbar actions; SwiftUI buttons never become first responder, +/// so tapping them keeps the editor focused. +private struct FormattingBar: View { + let theme: AppTheme + @ObservedObject var editor: EditorScreenModel + + var body: some View { + HStack(spacing: 6) { + formatButton("bold", "Bold", editor.toolbarState.bold) { editor.controller.toggleBold() } + formatButton("italic", "Italic", editor.toolbarState.italic) { editor.controller.toggleItalic() } + formatButton("underline", "Underline", editor.toolbarState.underline) { editor.controller.toggleUnderline() } + Rectangle() + .fill(theme.onSurface.opacity(0.12)) + .frame(width: 1, height: 20) + .padding(.horizontal, 3) + formatButton("strikethrough", "Strikethrough", editor.toolbarState.strikeThrough) { + editor.controller.toggleStrikeThrough() + } + formatButton("chevron.left.forwardslash.chevron.right", "Inline code", editor.toolbarState.inlineCode) { + editor.controller.toggleInlineCode() + } + Spacer() + } + .padding(.horizontal, 4) + .padding(.vertical, 8) + } + + private func formatButton( + _ systemImage: String, + _ label: String, + _ state: CascadeStyleState, + action: @escaping () -> Void + ) -> some View { + let enabled = editor.toolbarState.canFormat + let active = state == CascadeStyleState.active || state == CascadeStyleState.mixed + let background: Color = !enabled ? .clear : (active ? theme.primary.opacity(0.16) : theme.surface) + let tint: Color = !enabled + ? theme.onSurface.opacity(0.3) + : (active ? theme.primary : theme.onSurface.opacity(0.7)) + + return Button(action: action) { + Image(systemName: systemImage) + .font(.system(size: 14, weight: .medium)) + .foregroundStyle(tint) + .frame(width: 38, height: 38) + .background(background) + .clipShape(RoundedRectangle(cornerRadius: 9)) + } + .buttonStyle(.plain) + .disabled(!enabled) + .accessibilityLabel(label) + } +} + +private struct SendButton: View { + let theme: AppTheme + let enabled: Bool + let action: () -> Void + + var body: some View { + Button(action: action) { + Image(systemName: "paperplane.fill") + .font(.system(size: 17, weight: .medium)) + .foregroundStyle(theme.onPrimary) + .frame(width: 44, height: 44) + .background(theme.primary.opacity(enabled ? 1 : 0.3)) + .clipShape(Circle()) + } + .buttonStyle(.plain) + .disabled(!enabled) + .accessibilityLabel("Send comment") + } +} diff --git a/iosNativeSample/iosNativeSample/Screens/CustomBlocks/BlockContextModel.swift b/iosNativeSample/iosNativeSample/Screens/CustomBlocks/BlockContextModel.swift new file mode 100644 index 0000000..21decd3 --- /dev/null +++ b/iosNativeSample/iosNativeSample/Screens/CustomBlocks/BlockContextModel.swift @@ -0,0 +1,88 @@ +import SwiftUI +import UIKit +import CascadeEditor + +/// Observable wrapper around a block's `CascadeCustomBlockContext`. +/// +/// The context is pull-based: it always exposes current values, and its +/// `onChange` fires after any editor-side change (payload, focus, selection, +/// read-only, theme). This model turns that signal into `objectWillChange`, so +/// SwiftUI block views re-read the context on every editor change — including +/// undo/redo and document reloads the native view could not otherwise observe. +@MainActor +final class BlockContextModel: ObservableObject { + let context: CascadeCustomBlockContext + + init(context: CascadeCustomBlockContext) { + self.context = context + context.onChange = { [weak self] in + self?.objectWillChange.send() + } + } +} + +/// Hosts a SwiftUI block view inside the editor and keeps the Compose-side +/// host sized to the view's ideal height. +/// +/// Compose gives the hosted controller a fixed frame (starting at the +/// registration's estimated height); after every layout pass this controller +/// measures the SwiftUI content's fitting height for the current width and +/// reports it through `setPreferredHeight`, converging in one round trip. +/// The half-point tolerance breaks the report → relayout → report cycle. +final class NativeBlockHostController: UIHostingController { + private let model: BlockContextModel + private var lastReportedHeight: CGFloat = 0 + + init(model: BlockContextModel, rootView: Content) { + self.model = model + super.init(rootView: rootView) + view.backgroundColor = .clear + } + + @available(*, unavailable) + @MainActor required dynamic init?(coder aDecoder: NSCoder) { + fatalError("init(coder:) is not supported") + } + + override func viewDidLayoutSubviews() { + super.viewDidLayoutSubviews() + reportPreferredHeight() + } + + private func reportPreferredHeight() { + let width = view.bounds.width + guard width > 0 else { return } + let height = sizeThatFits(in: CGSize(width: width, height: .greatestFiniteMagnitude)).height + guard height > 0, abs(height - lastReportedHeight) > 0.5 else { return } + lastReportedHeight = height + model.context.setPreferredHeight(height: Double(height)) + } +} + +/// Builds the `UIViewController` a block registration's renderer factory +/// returns: a measuring hosting controller around a context-observing view. +@MainActor +func makeBlockHost( + context: CascadeCustomBlockContext, + @ViewBuilder content: (BlockContextModel) -> Content +) -> UIViewController { + let model = BlockContextModel(context: context) + return NativeBlockHostController(model: model, rootView: content(model)) +} + +/// Minimal JSON-object bridging for custom-block payload strings. +enum PayloadJson { + static func object(from json: String) -> [String: Any] { + let parsed = try? JSONSerialization.jsonObject(with: Data(json.utf8)) + return parsed as? [String: Any] ?? [:] + } + + static func string(from object: [String: Any]) -> String { + guard let data = try? JSONSerialization.data(withJSONObject: object), + let json = String(data: data, encoding: .utf8) + else { + return "{}" + } + return json + } +} diff --git a/iosNativeSample/iosNativeSample/Screens/CustomBlocks/CustomBlocksModel.swift b/iosNativeSample/iosNativeSample/Screens/CustomBlocks/CustomBlocksModel.swift new file mode 100644 index 0000000..7c95c5c --- /dev/null +++ b/iosNativeSample/iosNativeSample/Screens/CustomBlocks/CustomBlocksModel.swift @@ -0,0 +1,168 @@ +import SwiftUI +import CascadeEditor + +/// Screen logic for the custom-blocks demo: registers the three native block +/// types and two slash commands, then loads the demo document. +/// +/// Registration happens before the initial load so the demo document's custom +/// type ids decode straight into renderable native blocks. +@MainActor +final class CustomBlocksModel: ObservableObject { + let editor: EditorScreenModel + + init(editor: EditorScreenModel) { + self.editor = editor + registerBlocks() + registerSlashCommands() + _ = editor.controller.loadJson(json: Self.demoDocumentJson()) + } + + /// In-memory reset: reloads a freshly built demo document (history clears + /// with the load). There is deliberately no storage on this screen. + func reset() { + _ = editor.controller.reset(toJson: Self.demoDocumentJson()) + } + + private func registerBlocks() { + editor.controller.registerBlock( + registration: CascadeCustomBlockRegistration( + typeId: "table", + displayName: "Table", + description: "Interactive table with editable cells", + keywords: ["table", "grid", "rows", "columns", "cells"], + slashBehavior: .insert, + defaultPayloadJson: TableModel.default.payloadJson(), + estimatedHeight: 320, + rendererFactory: { context in + makeBlockHost(context: context) { model in + TableBlockView(model: model) + } + } + ) + ) + editor.controller.registerBlock( + registration: CascadeCustomBlockRegistration( + typeId: "metric", + displayName: "Metric Card", + description: "Stat card with value, label, and trend indicator", + keywords: ["metric", "stat", "number", "kpi", "card", "dashboard"], + slashBehavior: .insert, + defaultPayloadJson: + #"{"value":"1,234","label":"Total Items","trend":"up","trendValue":"8.2%"}"#, + estimatedHeight: 110, + rendererFactory: { context in + makeBlockHost(context: context) { model in + MetricBlockView(model: model) + } + } + ) + ) + editor.controller.registerBlock( + registration: CascadeCustomBlockRegistration( + typeId: "palette", + displayName: "Color Palette", + description: "Color swatch palette with hex labels", + keywords: ["palette", "color", "swatch", "colors", "theme", "design"], + slashBehavior: .insert, + defaultPayloadJson: + #"{"name":"Custom Palette","colors":"1A73E8,34A853,FBBC04,EA4335"}"#, + estimatedHeight: 130, + rendererFactory: { context in + makeBlockHost(context: context) { model in + PaletteBlockView(model: model) + } + } + ) + ) + } + + private func registerSlashCommands() { + editor.controller.registerSlashCommand( + command: CascadeSlashCommand( + id: "custom.timestamp", + title: "Timestamp", + description: "Insert current date and time", + keywords: ["date", "time", "now", "timestamp"], + handler: { context in + let formatter = DateFormatter() + formatter.dateFormat = "yyyy-MM-dd HH:mm:ss" + context.replaceQueryText(replacement: formatter.string(from: Date())) + return CascadeSlashCommandResult.companion.done + } + ) + ) + editor.controller.registerSlashCommand( + command: CascadeSlashCommand( + id: "custom.lorem", + title: "Lorem Ipsum", + description: "Insert placeholder text", + keywords: ["lorem", "ipsum", "placeholder", "dummy", "text"], + handler: { context in + context.replaceQueryText( + replacement: "Lorem ipsum dolor sit amet, consectetur adipiscing elit. " + + "Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. " + + "Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris." + ) + return CascadeSlashCommandResult.companion.done + } + ) + ) + } + + private static func demoDocumentJson() -> String { + CascadeEditorDocumentBuilder() + .heading(level: 1, text: "Custom Blocks & Commands") + .paragraph( + text: "This demo shows how to extend CascadeEditor with custom block types and slash commands." + ) + .heading(level: 2, text: "Interactive Tables") + .paragraph( + text: "Table blocks are implemented by the sample app with public custom block APIs." + ) + .customBlock(typeId: "table", payloadJson: TableModel.default.payloadJson()) + .paragraph(text: "Type /table to insert another table.") + .divider() + .heading(level: 2, text: "Metric Cards") + .paragraph( + text: "Metric cards are non-editable custom blocks — perfect for dashboards and status displays:" + ) + .customBlock( + typeId: "metric", + payloadJson: #"{"value":"2,847","label":"Downloads","trend":"up","trendValue":"12.5%"}"# + ) + .customBlock( + typeId: "metric", + payloadJson: #"{"value":"99.9%","label":"Uptime","trend":"up","trendValue":"0.1%"}"# + ) + .customBlock( + typeId: "metric", + payloadJson: #"{"value":"142ms","label":"Avg Latency","trend":"down","trendValue":"23%"}"# + ) + .paragraph(text: "Type /metric to insert a new metric card.") + .divider() + .heading(level: 2, text: "Color Palettes") + .paragraph( + text: "Color palette blocks showcase full native rendering — circles, hex labels, and layout:" + ) + .customBlock( + typeId: "palette", + payloadJson: #"{"name":"Ocean Breeze","colors":"0077B6,00B4D8,90E0EF,CAF0F8"}"# + ) + .customBlock( + typeId: "palette", + payloadJson: #"{"name":"Sunset Warmth","colors":"FF6B6B,FFA06B,FFD93D,6BCB77"}"# + ) + .paragraph(text: "Type /palette to insert a new color palette.") + .divider() + .heading(level: 2, text: "Custom Slash Commands") + .paragraph(text: "Type /timestamp to insert the current date and time.") + .paragraph(text: "Type /lorem to insert placeholder text.") + .paragraph(text: "These custom commands coexist with all built-in commands in the slash popup.") + .divider() + .heading(level: 2, text: "Try It Out") + .paragraph(text: "Click on any empty paragraph and type / to see all available commands:") + .paragraph(text: "") + .paragraph(text: "") + .buildJson() + } +} diff --git a/iosNativeSample/iosNativeSample/Screens/CustomBlocks/MetricBlockView.swift b/iosNativeSample/iosNativeSample/Screens/CustomBlocks/MetricBlockView.swift new file mode 100644 index 0000000..f7f9ba7 --- /dev/null +++ b/iosNativeSample/iosNativeSample/Screens/CustomBlocks/MetricBlockView.swift @@ -0,0 +1,41 @@ +import SwiftUI + +/// Read-only metric card block: value, label, and a trend badge. +struct MetricBlockView: View { + @ObservedObject var model: BlockContextModel + + var body: some View { + let payload = PayloadJson.object(from: model.context.payloadJson) + let value = payload["value"] as? String ?? "0" + let label = payload["label"] as? String ?? "" + let trend = payload["trend"] as? String ?? "up" + let trendValue = payload["trendValue"] as? String ?? "" + let isDark = model.context.isDark + let trendColor = trend == "up" ? Color(rgb: 0x34A853) : Color(rgb: 0xEA4335) + + HStack(alignment: .bottom) { + VStack(alignment: .leading, spacing: 4) { + Text(value) + .font(.system(size: 32, weight: .bold)) + .foregroundStyle(isDark ? Color(rgb: 0xF4F1FB) : Color(rgb: 0x1C1238)) + Text(label) + .font(.system(size: 14)) + .foregroundStyle(isDark ? Color(rgb: 0x9B93B8) : Color(rgb: 0x6B6580)) + } + Spacer() + if !trendValue.isEmpty { + Text("\(trend == "up" ? "↑" : "↓") \(trendValue)") + .font(.system(size: 14, weight: .semibold)) + .foregroundStyle(trendColor) + .padding(.horizontal, 8) + .padding(.vertical, 4) + .background(trendColor.opacity(0.12)) + .clipShape(RoundedRectangle(cornerRadius: 6)) + } + } + .padding(16) + .frame(maxWidth: .infinity, alignment: .leading) + .background(isDark ? Color(rgb: 0x2A2340) : Color(rgb: 0xF0EAFB)) + .clipShape(RoundedRectangle(cornerRadius: 12)) + } +} diff --git a/iosNativeSample/iosNativeSample/Screens/CustomBlocks/PaletteBlockView.swift b/iosNativeSample/iosNativeSample/Screens/CustomBlocks/PaletteBlockView.swift new file mode 100644 index 0000000..f53dd57 --- /dev/null +++ b/iosNativeSample/iosNativeSample/Screens/CustomBlocks/PaletteBlockView.swift @@ -0,0 +1,40 @@ +import SwiftUI + +/// Read-only color-palette block: named swatch row with hex labels. +struct PaletteBlockView: View { + @ObservedObject var model: BlockContextModel + + var body: some View { + let payload = PayloadJson.object(from: model.context.payloadJson) + let name = payload["name"] as? String ?? "Palette" + let colorsValue = payload["colors"] as? String ?? "" + let hexes = colorsValue + .split(separator: ",") + .map { $0.trimmingCharacters(in: .whitespaces).replacingOccurrences(of: "#", with: "") } + .filter { !$0.isEmpty } + let isDark = model.context.isDark + + VStack(alignment: .leading, spacing: 12) { + Text(name) + .font(.system(size: 14, weight: .semibold)) + .foregroundStyle(isDark ? Color(rgb: 0xF4F1FB) : Color(rgb: 0x1C1238)) + HStack { + ForEach(hexes, id: \.self) { hex in + VStack(spacing: 4) { + Circle() + .fill(Color(rgb: UInt32(hex, radix: 16) ?? 0x888888)) + .frame(width: 40, height: 40) + Text("#\(hex)") + .font(.system(size: 10)) + .foregroundStyle(isDark ? Color(rgb: 0x9B93B8) : Color(rgb: 0x6B6580)) + } + .frame(maxWidth: .infinity) + } + } + } + .padding(16) + .frame(maxWidth: .infinity, alignment: .leading) + .background(isDark ? Color(rgb: 0x2A2340) : Color(rgb: 0xF0EAFB)) + .clipShape(RoundedRectangle(cornerRadius: 12)) + } +} diff --git a/iosNativeSample/iosNativeSample/Screens/CustomBlocks/TableBlockView.swift b/iosNativeSample/iosNativeSample/Screens/CustomBlocks/TableBlockView.swift new file mode 100644 index 0000000..ca6563a --- /dev/null +++ b/iosNativeSample/iosNativeSample/Screens/CustomBlocks/TableBlockView.swift @@ -0,0 +1,329 @@ +import SwiftUI + +private struct TableCellKey: Hashable { + let row: Int + let column: Int +} + +/// Palette for the table card, mirroring the KMP sample's fixed light/dark +/// table colors. +private struct TableColors { + let card: Color + let cardBorder: Color + let accentBorder: Color + let gridBorder: Color + let cellBorder: Color + let divider: Color + let headerBackground: Color + let trailingBackground: Color + let iconTileBackground: Color + let iconTint: Color + let title: Color + let headerText: Color + let bodyText: Color + let placeholder: Color + let mutedLabel: Color + let accent: Color + let pillBackground: Color + let rowDeleteIdle: Color + + static func palette(isDark: Bool) -> TableColors { + if isDark { + return TableColors( + card: Color(rgb: 0x1B1430), + cardBorder: Color(argb: 0x1FFFFFFF), + accentBorder: Color(rgb: 0xA78BFA), + gridBorder: Color(argb: 0x1FFFFFFF), + cellBorder: Color(argb: 0x14FFFFFF), + divider: Color(argb: 0x14FFFFFF), + headerBackground: Color(argb: 0x248B5CF6), + trailingBackground: Color(argb: 0x0AFFFFFF), + iconTileBackground: Color(argb: 0x2E8B5CF6), + iconTint: Color(rgb: 0xC4B5FD), + title: Color(rgb: 0xF4F1FB), + headerText: Color(rgb: 0xF4F1FB), + bodyText: Color(rgb: 0xD8D2E8), + placeholder: Color(rgb: 0x6F6690), + mutedLabel: Color(rgb: 0x9B93B8), + accent: Color(rgb: 0xA78BFA), + pillBackground: Color(argb: 0x1F8B5CF6), + rowDeleteIdle: Color(rgb: 0x6F6690) + ) + } + return TableColors( + card: .white, + cardBorder: Color(rgb: 0xEFE9FB), + accentBorder: Color(rgb: 0x6C3DE8), + gridBorder: Color(rgb: 0xE9E1F8), + cellBorder: Color(rgb: 0xEDE6F8), + divider: Color(rgb: 0xF1ECFB), + headerBackground: Color(rgb: 0xF4EFFE), + trailingBackground: Color(rgb: 0xFBF9FF), + iconTileBackground: Color(rgb: 0xF0E9FE), + iconTint: Color(rgb: 0x6C3DE8), + title: Color(rgb: 0x1C1238), + headerText: Color(rgb: 0x1C1238), + bodyText: Color(rgb: 0x332A4D), + placeholder: Color(rgb: 0xBCB2D6), + mutedLabel: Color(rgb: 0x6B6580), + accent: Color(rgb: 0x6C3DE8), + pillBackground: Color(rgb: 0xF1ECFB), + rowDeleteIdle: Color(rgb: 0xCDBFF0) + ) + } +} + +private let columnWidth: CGFloat = 132 +private let trailingColumnWidth: CGFloat = 40 +private let cellMinHeight: CGFloat = 44 + +/// Interactive table block: editable cells, header-row toggle, and add/delete +/// row/column controls. +/// +/// Cell edits are held in local drafts and committed to the block payload on +/// submit or focus loss (one undo step per commit rather than per keystroke). +/// Structural changes fold pending drafts in before transforming, so an +/// in-progress edit is not lost when a row or column is added. +struct TableBlockView: View { + @ObservedObject var model: BlockContextModel + @State private var drafts: [TableCellKey: String] = [:] + @FocusState private var focusedCell: TableCellKey? + + var body: some View { + let table = TableModel.fromPayload(model.context.payloadJson) + let colors = TableColors.palette(isDark: model.context.isDark) + let canMutate = !model.context.readOnly && model.context.canUpdateBlock + let highlighted = model.context.isFocused || model.context.isSelected + + VStack(spacing: 0) { + toolbar(table: table, colors: colors, canMutate: canMutate) + Rectangle() + .fill(colors.divider) + .frame(height: 1) + grid(table: table, colors: colors, canMutate: canMutate) + footer(colors: colors, canMutate: canMutate) + } + .background(colors.card) + .clipShape(RoundedRectangle(cornerRadius: 22)) + .overlay( + RoundedRectangle(cornerRadius: 22) + .strokeBorder( + highlighted ? colors.accentBorder : colors.cardBorder, + lineWidth: highlighted ? 2 : 1 + ) + ) + .onChange(of: focusedCell) { previous, _ in + if let previous { + commitDraft(for: previous) + } + } + } + + private func toolbar(table: TableModel, colors: TableColors, canMutate: Bool) -> some View { + HStack { + Image(systemName: "tablecells") + .font(.system(size: 13, weight: .medium)) + .foregroundStyle(colors.iconTint) + .frame(width: 30, height: 30) + .background(colors.iconTileBackground) + .clipShape(RoundedRectangle(cornerRadius: 9)) + Text("Table") + .font(.system(size: 15, weight: .semibold)) + .foregroundStyle(colors.title) + .padding(.leading, 10) + Spacer() + Toggle(isOn: Binding( + get: { table.headerRow }, + set: { enabled in + updateTable { $0.headerRow = enabled } + } + )) { + Text("Header row") + .font(.system(size: 12, weight: .medium)) + .foregroundStyle(colors.mutedLabel) + } + .toggleStyle(.switch) + .tint(colors.accent) + .fixedSize() + .disabled(!canMutate) + .accessibilityLabel("Toggle header row") + } + .padding(.horizontal, 16) + .padding(.vertical, 12) + } + + private func grid(table: TableModel, colors: TableColors, canMutate: Bool) -> some View { + ScrollView(.horizontal, showsIndicators: false) { + VStack(spacing: 0) { + ForEach(0.. some View { + let isHeaderRow = row == 0 + let isHeaderStyled = isHeaderRow && table.headerRow + let background = isHeaderStyled ? colors.headerBackground : Color.clear + let textColor = isHeaderStyled ? colors.headerText : colors.bodyText + + return HStack(spacing: 0) { + ForEach(0.. 1 + ) + .frame(width: columnWidth) + .frame(minHeight: cellMinHeight) + .background(background) + .overlay(alignment: .trailing) { + Rectangle().fill(colors.cellBorder).frame(width: 1) + } + } + trailingCell(row: row, colors: colors, canMutate: canMutate, isHeaderRow: isHeaderRow) + } + .overlay(alignment: .bottom) { + if row < table.rowCount - 1 { + Rectangle().fill(colors.cellBorder).frame(height: 1) + } + } + } + + private func cell( + key: TableCellKey, + table: TableModel, + colors: TableColors, + canMutate: Bool, + textColor: Color, + isHeaderStyled: Bool, + showColumnDelete: Bool + ) -> some View { + let persisted = table.value(row: key.row, column: key.column) + let weight: Font.Weight = isHeaderStyled ? .semibold : .regular + + return ZStack(alignment: .topTrailing) { + TextField( + key.row == 0 ? "Field" : "—", + text: Binding( + get: { drafts[key] ?? persisted }, + set: { drafts[key] = $0 } + ) + ) + .font(.system(size: 13.5, weight: weight)) + .foregroundStyle(textColor) + .tint(colors.accent) + .focused($focusedCell, equals: key) + .onSubmit { commitDraft(for: key) } + .disabled(!canMutate) + .padding(.leading, 12) + .padding(.trailing, showColumnDelete ? 26 : 12) + .padding(.vertical, 11) + + if showColumnDelete { + Button { + updateTable { $0.deleteColumn(key.column) } + } label: { + Image(systemName: "xmark") + .font(.system(size: 9, weight: .semibold)) + .foregroundStyle(colors.rowDeleteIdle) + .frame(width: 20, height: 20) + } + .buttonStyle(.plain) + .padding(5) + .accessibilityLabel("Delete column \(key.column + 1)") + } + } + } + + private func trailingCell(row: Int, colors: TableColors, canMutate: Bool, isHeaderRow: Bool) -> some View { + ZStack { + colors.trailingBackground + if !isHeaderRow && canMutate { + Button { + updateTable { $0.deleteRow(row) } + } label: { + Image(systemName: "trash") + .font(.system(size: 13)) + .foregroundStyle(colors.rowDeleteIdle) + .frame(width: 28, height: 28) + } + .buttonStyle(.plain) + .accessibilityLabel("Delete row \(row)") + } + } + .frame(width: trailingColumnWidth) + .frame(maxHeight: .infinity) + } + + private func footer(colors: TableColors, canMutate: Bool) -> some View { + HStack(spacing: 8) { + addPill(label: "Add row", colors: colors, canMutate: canMutate) { + updateTable { $0.addRow() } + } + addPill(label: "Add column", colors: colors, canMutate: canMutate) { + updateTable { $0.addColumn() } + } + Spacer() + } + .padding(.horizontal, 16) + .padding(.top, 12) + .padding(.bottom, 16) + } + + private func addPill( + label: String, + colors: TableColors, + canMutate: Bool, + action: @escaping () -> Void + ) -> some View { + Button(action: action) { + HStack(spacing: 6) { + Image(systemName: "plus") + .font(.system(size: 10, weight: .semibold)) + Text(label) + .font(.system(size: 13, weight: .semibold)) + } + .foregroundStyle(colors.accent) + .padding(.horizontal, 14) + .padding(.vertical, 8) + .background(colors.pillBackground) + .clipShape(Capsule()) + .opacity(canMutate ? 1 : 0.5) + } + .buttonStyle(.plain) + .disabled(!canMutate) + .accessibilityLabel(label) + } + + /// Commits a single cell draft (if it changed) as one payload replacement. + private func commitDraft(for key: TableCellKey) { + guard let draft = drafts.removeValue(forKey: key) else { return } + var table = TableModel.fromPayload(model.context.payloadJson) + guard table.value(row: key.row, column: key.column) != draft else { return } + table.editCell(row: key.row, column: key.column, value: draft) + _ = model.context.replacePayloadJson(payloadJson: table.payloadJson()) + } + + /// Applies a structural transform on top of the current payload, folding + /// pending cell drafts in first so an in-flight edit is not dropped. + private func updateTable(_ transform: (inout TableModel) -> Void) { + var table = TableModel.fromPayload(model.context.payloadJson) + for (key, value) in drafts { + table.editCell(row: key.row, column: key.column, value: value) + } + drafts.removeAll() + transform(&table) + _ = model.context.replacePayloadJson(payloadJson: table.payloadJson()) + } +} diff --git a/iosNativeSample/iosNativeSample/Screens/CustomBlocks/TableModel.swift b/iosNativeSample/iosNativeSample/Screens/CustomBlocks/TableModel.swift new file mode 100644 index 0000000..304c070 --- /dev/null +++ b/iosNativeSample/iosNativeSample/Screens/CustomBlocks/TableModel.swift @@ -0,0 +1,78 @@ +import Foundation + +/// Value model behind the interactive table block's payload +/// (`{"rows": [[String]], "headerRow": Bool}`), mirroring the KMP sample's +/// normalization: rows padded to a rectangular grid, at least one row and +/// column, defaulting to the demo table when the payload is unusable. +struct TableModel { + var rows: [[String]] + var headerRow: Bool + + var rowCount: Int { rows.count } + var columnCount: Int { rows.first?.count ?? 1 } + + static let `default` = TableModel( + rows: [ + ["Name", "Role", "Status"], + ["Ada", "Engineer", "Active"], + ["Linus", "Maintainer", "Review"], + ], + headerRow: true + ) + + static func fromPayload(_ json: String) -> TableModel { + let payload = PayloadJson.object(from: json) + let rawRows = payload["rows"] as? [[Any]] ?? [] + let parsed = rawRows.map { row in + row.map { cell in cell as? String ?? String(describing: cell) } + } + let headerRow = payload["headerRow"] as? Bool ?? false + return normalized(parsed, headerRow: headerRow) + } + + func payloadJson() -> String { + PayloadJson.string(from: ["rows": rows, "headerRow": headerRow]) + } + + func value(row: Int, column: Int) -> String { + guard rows.indices.contains(row), rows[row].indices.contains(column) else { return "" } + return rows[row][column] + } + + mutating func editCell(row: Int, column: Int, value: String) { + guard rows.indices.contains(row), rows[row].indices.contains(column) else { return } + rows[row][column] = value + } + + mutating func addRow() { + rows.append(Array(repeating: "", count: columnCount)) + } + + mutating func deleteRow(_ row: Int) { + guard rows.count > 1, rows.indices.contains(row) else { return } + rows.remove(at: row) + } + + mutating func addColumn() { + rows = rows.map { $0 + [""] } + } + + mutating func deleteColumn(_ column: Int) { + guard columnCount > 1, (0.. TableModel { + let nonEmpty = candidate.filter { !$0.isEmpty } + guard !nonEmpty.isEmpty else { return .default } + let width = max(1, nonEmpty.map(\.count).max() ?? 1) + let padded = nonEmpty.map { row in + row + Array(repeating: "", count: width - row.count) + } + return TableModel(rows: padded, headerRow: headerRow) + } +} diff --git a/iosNativeSample/iosNativeSample/Screens/CustomBlocksScreen.swift b/iosNativeSample/iosNativeSample/Screens/CustomBlocksScreen.swift new file mode 100644 index 0000000..5a18df5 --- /dev/null +++ b/iosNativeSample/iosNativeSample/Screens/CustomBlocksScreen.swift @@ -0,0 +1,57 @@ +import SwiftUI +import CascadeEditor + +/// Native custom blocks and slash commands demo: SwiftUI-rendered table, +/// metric, and palette blocks living inside the editor document. +struct CustomBlocksScreen: View { + @Binding var isDark: Bool + @Environment(\.dismiss) private var dismiss + @StateObject private var editor: EditorScreenModel + @StateObject private var model: CustomBlocksModel + + init(isDark: Binding) { + _isDark = isDark + let editorModel = EditorScreenModel(configuration: .standard(isDark: isDark.wrappedValue)) + _editor = StateObject(wrappedValue: editorModel) + _model = StateObject(wrappedValue: CustomBlocksModel(editor: editorModel)) + } + + private var theme: AppTheme { AppTheme.theme(isDark: isDark) } + + var body: some View { + VStack(spacing: 0) { + header + CascadeEditorHost(model: editor) + } + .background(theme.background) + .onChange(of: isDark) { _, newValue in + editor.setDarkMode(newValue) + } + } + + @ViewBuilder + private var header: some View { + if editor.hasSelection { + SelectionTopBar( + theme: theme, + selectedCount: editor.selectedCount, + isReadOnly: editor.isReadOnly, + onCancelSelection: { editor.clearSelection() }, + onDeleteSelected: { editor.deleteSelectedOrFocused() } + ) + } else { + EditorTopBar( + theme: theme, + isReadOnly: editor.isReadOnly, + canUndo: editor.canUndo, + canRedo: editor.canRedo, + onBack: { dismiss() }, + onUndo: { editor.undo() }, + onRedo: { editor.redo() }, + onToggleReadOnly: { editor.setReadOnly(!editor.isReadOnly) }, + onToggleTheme: { isDark.toggle() }, + onReset: { model.reset() } + ) + } + } +} diff --git a/iosNativeSample/iosNativeSample/Screens/DocumentStore.swift b/iosNativeSample/iosNativeSample/Screens/DocumentStore.swift new file mode 100644 index 0000000..7e31e9d --- /dev/null +++ b/iosNativeSample/iosNativeSample/Screens/DocumentStore.swift @@ -0,0 +1,23 @@ +import Foundation + +/// Plain-file persistence for the editor demo's autosaved document JSON. +struct DocumentStore { + let fileURL: URL + + static func editorDemo() -> DocumentStore { + let documents = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask)[0] + return DocumentStore(fileURL: documents.appendingPathComponent("editor_demo_document.json")) + } + + func read() -> String? { + try? String(contentsOf: fileURL, encoding: .utf8) + } + + func write(_ json: String) { + try? json.write(to: fileURL, atomically: true, encoding: .utf8) + } + + func delete() { + try? FileManager.default.removeItem(at: fileURL) + } +} diff --git a/iosNativeSample/iosNativeSample/Screens/EditorDemoModel.swift b/iosNativeSample/iosNativeSample/Screens/EditorDemoModel.swift new file mode 100644 index 0000000..9fe842c --- /dev/null +++ b/iosNativeSample/iosNativeSample/Screens/EditorDemoModel.swift @@ -0,0 +1,107 @@ +import SwiftUI +import UIKit +import CascadeEditor + +/// Screen logic for the editor demo: initial load with corrupt-storage +/// recovery, debounced autosave, save-on-exit, reset, and the two status pills. +@MainActor +final class EditorDemoModel: ObservableObject { + let editor: EditorScreenModel + + @Published private(set) var saveStatus = "" + @Published private(set) var lastOpenedLink = "" + + private let store = DocumentStore.editorDemo() + private var isLoaded = false + private var autosaveTask: Task? + private var statusClearTask: Task? + private var linkClearTask: Task? + + init(editor: EditorScreenModel) { + self.editor = editor + editor.onDocumentChanged = { [weak self] in self?.scheduleAutosave() } + editor.onOpenLink = { [weak self] url in self?.openLink(url) } + loadInitialDocument() + } + + /// Loads the autosaved document, falling back to the bundled fixture. A + /// corrupt saved file (parse failure) deletes storage and reloads the + /// fixture exactly once — the fixture result is not re-checked, so a bad + /// fixture cannot cause a recovery loop. + private func loadInitialDocument() { + let json = store.read() ?? Self.bundledDocumentJson() + let result = editor.controller.loadJson(json: json) + if !result.success { + store.delete() + _ = editor.controller.loadJson(json: Self.bundledDocumentJson()) + } + isLoaded = true + } + + /// Debounces the document-change signal; the JSON export happens only when + /// a save actually fires, never per keystroke. + private func scheduleAutosave() { + guard isLoaded else { return } + autosaveTask?.cancel() + autosaveTask = Task { [weak self] in + try? await Task.sleep(for: .seconds(2)) + guard !Task.isCancelled else { return } + self?.autosave() + } + } + + private func autosave() { + guard isLoaded, !editor.isReadOnly else { return } + statusClearTask?.cancel() + saveStatus = "Saving..." + store.write(editor.controller.exportJson()) + saveStatus = "Saved" + statusClearTask = Task { [weak self] in + try? await Task.sleep(for: .seconds(2)) + guard !Task.isCancelled else { return } + self?.saveStatus = "" + } + } + + /// Immediate save used on back navigation, separate from the debounce. + func saveOnExit() { + autosaveTask?.cancel() + guard isLoaded, !editor.isReadOnly else { return } + store.write(editor.controller.exportJson()) + } + + /// Reset deletes the autosave storage and reloads the bundled fixture + /// (which also clears editor history). + func reset() { + autosaveTask?.cancel() + store.delete() + _ = editor.controller.reset(toJson: Self.bundledDocumentJson()) + } + + /// Opens the link natively and shows the pill for three seconds. The + /// equality check keeps an older timer from clearing a newer link when the + /// same or another URL is opened in quick succession. + private func openLink(_ url: String) { + lastOpenedLink = url + linkClearTask?.cancel() + linkClearTask = Task { [weak self] in + try? await Task.sleep(for: .seconds(3)) + guard !Task.isCancelled else { return } + if self?.lastOpenedLink == url { + self?.lastOpenedLink = "" + } + } + if let parsed = URL(string: url), UIApplication.shared.canOpenURL(parsed) { + UIApplication.shared.open(parsed) + } + } + + private static func bundledDocumentJson() -> String { + guard let url = Bundle.main.url(forResource: "default_document", withExtension: "json"), + let json = try? String(contentsOf: url, encoding: .utf8) + else { + return "{\"version\":2,\"blocks\":[]}" + } + return json + } +} diff --git a/iosNativeSample/iosNativeSample/Screens/EditorDemoScreen.swift b/iosNativeSample/iosNativeSample/Screens/EditorDemoScreen.swift new file mode 100644 index 0000000..1d837de --- /dev/null +++ b/iosNativeSample/iosNativeSample/Screens/EditorDemoScreen.swift @@ -0,0 +1,69 @@ +import SwiftUI +import CascadeEditor + +/// Full editing experience: shared chrome over a persisted document with +/// debounced autosave, link opening, and corrupt-storage recovery. +struct EditorDemoScreen: View { + @Binding var isDark: Bool + @Environment(\.dismiss) private var dismiss + @StateObject private var editor: EditorScreenModel + @StateObject private var demo: EditorDemoModel + + init(isDark: Binding) { + _isDark = isDark + let editorModel = EditorScreenModel(configuration: .standard(isDark: isDark.wrappedValue)) + _editor = StateObject(wrappedValue: editorModel) + _demo = StateObject(wrappedValue: EditorDemoModel(editor: editorModel)) + } + + private var theme: AppTheme { AppTheme.theme(isDark: isDark) } + + var body: some View { + VStack(spacing: 0) { + header + ZStack(alignment: .top) { + CascadeEditorHost(model: editor) + VStack(spacing: 6) { + SavedPill(theme: theme, status: demo.saveStatus) + OpenedLinkPill(theme: theme, link: demo.lastOpenedLink) + } + .padding(.top, 8) + .animation(.default, value: demo.saveStatus) + .animation(.default, value: demo.lastOpenedLink) + } + } + .background(theme.background) + .onChange(of: isDark) { _, newValue in + editor.setDarkMode(newValue) + } + } + + @ViewBuilder + private var header: some View { + if editor.hasSelection { + SelectionTopBar( + theme: theme, + selectedCount: editor.selectedCount, + isReadOnly: editor.isReadOnly, + onCancelSelection: { editor.clearSelection() }, + onDeleteSelected: { editor.deleteSelectedOrFocused() } + ) + } else { + EditorTopBar( + theme: theme, + isReadOnly: editor.isReadOnly, + canUndo: editor.canUndo, + canRedo: editor.canRedo, + onBack: { + demo.saveOnExit() + dismiss() + }, + onUndo: { editor.undo() }, + onRedo: { editor.redo() }, + onToggleReadOnly: { editor.setReadOnly(!editor.isReadOnly) }, + onToggleTheme: { isDark.toggle() }, + onReset: { demo.reset() } + ) + } + } +} diff --git a/iosNativeSample/iosNativeSample/Shell/EditorChrome.swift b/iosNativeSample/iosNativeSample/Shell/EditorChrome.swift new file mode 100644 index 0000000..79338f0 --- /dev/null +++ b/iosNativeSample/iosNativeSample/Shell/EditorChrome.swift @@ -0,0 +1,223 @@ +import SwiftUI + +// Shared chrome for the sample's editor screens, mirroring the Compose +// sample's EditorChrome: a floating back chip on the left, a grouped +// soft-container of editor actions in the center, and an accented Reset pill +// on the right. A selection variant replaces the bar while blocks are selected. + +private let chipCornerRadius: CGFloat = 12 +private let groupCornerRadius: CGFloat = 14 +private let groupButtonCornerRadius: CGFloat = 10 + +struct EditorTopBar: View { + let theme: AppTheme + let isReadOnly: Bool + let canUndo: Bool + let canRedo: Bool + let onBack: () -> Void + let onUndo: () -> Void + let onRedo: () -> Void + let onToggleReadOnly: () -> Void + let onToggleTheme: () -> Void + let onReset: () -> Void + + var body: some View { + HStack { + ChromeChip(theme: theme, systemImage: "chevron.left", label: "Back", action: onBack) + Spacer() + ChromeActionGroup(theme: theme) { + GroupButton( + theme: theme, + systemImage: "arrow.uturn.backward", + label: "Undo", + enabled: !isReadOnly && canUndo, + action: onUndo + ) + GroupButton( + theme: theme, + systemImage: "arrow.uturn.forward", + label: "Redo", + enabled: !isReadOnly && canRedo, + action: onRedo + ) + GroupDivider(theme: theme) + GroupButton( + theme: theme, + systemImage: isReadOnly ? "pencil.slash" : "pencil", + label: isReadOnly ? "Read-only" : "Editable", + action: onToggleReadOnly + ) + GroupButton( + theme: theme, + systemImage: theme.isDark ? "sun.max" : "moon", + label: theme.isDark ? "Switch to light" : "Switch to dark", + action: onToggleTheme + ) + } + Spacer() + ResetPill(theme: theme, enabled: !isReadOnly, action: onReset) + } + .padding(.horizontal, 4) + .padding(.vertical, 8) + } +} + +/// Titled variant for screens without undo/redo or reset (the comments demo): +/// back chip plus screen title on the left, theme toggle on the right. +struct TitledEditorTopBar: View { + let theme: AppTheme + let title: String + let onBack: () -> Void + let onToggleTheme: () -> Void + + var body: some View { + HStack { + HStack(spacing: 12) { + ChromeChip(theme: theme, systemImage: "chevron.left", label: "Back", action: onBack) + Text(title) + .font(.title2.weight(.semibold)) + .foregroundStyle(theme.onBackground) + } + Spacer() + ChromeActionGroup(theme: theme) { + GroupButton( + theme: theme, + systemImage: theme.isDark ? "sun.max" : "moon", + label: theme.isDark ? "Switch to light" : "Switch to dark", + action: onToggleTheme + ) + } + } + .padding(.horizontal, 4) + .padding(.vertical, 8) + } +} + +struct SelectionTopBar: View { + let theme: AppTheme + let selectedCount: Int + let isReadOnly: Bool + let onCancelSelection: () -> Void + let onDeleteSelected: () -> Void + + var body: some View { + HStack { + HStack(spacing: 4) { + Button("Cancel", action: onCancelSelection) + .font(.body.weight(.medium)) + .tint(theme.primary) + .accessibilityLabel("Cancel selection") + Text("\(selectedCount) selected") + .font(.headline) + .foregroundStyle(theme.onBackground) + } + Spacer() + ChromeChip( + theme: theme, + systemImage: "trash", + label: "Delete selected blocks", + tint: theme.destructive.opacity(isReadOnly ? 0.38 : 1), + enabled: !isReadOnly, + action: onDeleteSelected + ) + } + .padding(.horizontal, 4) + .padding(.vertical, 8) + } +} + +private struct ChromeChip: View { + let theme: AppTheme + let systemImage: String + let label: String + var tint: Color? + var enabled: Bool = true + let action: () -> Void + + var body: some View { + Button(action: action) { + Image(systemName: systemImage) + .font(.system(size: 17, weight: .medium)) + .foregroundStyle(tint ?? theme.onSurface) + .frame(width: 42, height: 42) + .background(theme.surface) + .clipShape(RoundedRectangle(cornerRadius: chipCornerRadius)) + .shadow(color: .black.opacity(enabled ? 0.12 : 0), radius: 3, y: 1) + } + .buttonStyle(.plain) + .disabled(!enabled) + .accessibilityLabel(label) + } +} + +private struct ChromeActionGroup: View { + let theme: AppTheme + @ViewBuilder let content: Content + + var body: some View { + HStack(spacing: 2) { + content + } + .padding(4) + .background(theme.surface) + .clipShape(RoundedRectangle(cornerRadius: groupCornerRadius)) + .shadow(color: .black.opacity(0.12), radius: 3, y: 1) + } +} + +private struct GroupButton: View { + let theme: AppTheme + let systemImage: String + let label: String + var enabled: Bool = true + let action: () -> Void + + var body: some View { + Button(action: action) { + Image(systemName: systemImage) + .font(.system(size: 15, weight: .medium)) + .foregroundStyle(theme.mutedInk.opacity(enabled ? 1 : 0.38)) + .frame(width: 38, height: 38) + .contentShape(RoundedRectangle(cornerRadius: groupButtonCornerRadius)) + } + .buttonStyle(.plain) + .disabled(!enabled) + .accessibilityLabel(label) + } +} + +private struct GroupDivider: View { + let theme: AppTheme + + var body: some View { + Rectangle() + .fill(theme.divider) + .frame(width: 1, height: 22) + } +} + +private struct ResetPill: View { + let theme: AppTheme + let enabled: Bool + let action: () -> Void + + var body: some View { + Button(action: action) { + HStack(spacing: 6) { + Image(systemName: "arrow.counterclockwise") + .font(.system(size: 12, weight: .semibold)) + Text("Reset") + .font(.footnote.weight(.semibold)) + } + .foregroundStyle(theme.onPrimary) + .padding(.horizontal, 16) + .padding(.vertical, 9) + .background(theme.primary.opacity(enabled ? 1 : 0.4)) + .clipShape(Capsule()) + .shadow(color: theme.primary.opacity(enabled ? 0.35 : 0), radius: 6, y: 2) + } + .buttonStyle(.plain) + .disabled(!enabled) + .accessibilityLabel("Reset document") + } +} diff --git a/iosNativeSample/iosNativeSample/Shell/StatusPills.swift b/iosNativeSample/iosNativeSample/Shell/StatusPills.swift new file mode 100644 index 0000000..08e8f38 --- /dev/null +++ b/iosNativeSample/iosNativeSample/Shell/StatusPills.swift @@ -0,0 +1,59 @@ +import SwiftUI + +/// Floating "Saved" indicator shown below the top bar while autosave runs, +/// mirroring the Compose sample's SavedPill. +struct SavedPill: View { + let theme: AppTheme + let status: String + + var body: some View { + if !status.isEmpty { + HStack(spacing: 8) { + ZStack { + Circle() + .fill(theme.savedGreen.opacity(0.18)) + .frame(width: 14, height: 14) + Circle() + .fill(theme.savedGreen) + .frame(width: 8, height: 8) + } + Text(status) + .font(.caption.weight(.semibold)) + .foregroundStyle(theme.mutedInk) + } + .padding(.horizontal, 15) + .padding(.vertical, 8) + .background(theme.surface) + .clipShape(Capsule()) + .shadow(color: .black.opacity(0.15), radius: 6, y: 2) + .transition(.opacity) + } + } +} + +/// Floating indicator echoing the last opened link, styled like the Saved pill. +struct OpenedLinkPill: View { + let theme: AppTheme + let link: String + + var body: some View { + if !link.isEmpty { + HStack(spacing: 8) { + Circle() + .fill(theme.primary) + .frame(width: 8, height: 8) + Text("Opened: \(link)") + .font(.caption.weight(.semibold)) + .foregroundStyle(theme.primary) + .lineLimit(1) + .truncationMode(.tail) + } + .padding(.horizontal, 15) + .padding(.vertical, 8) + .background(theme.surface) + .clipShape(Capsule()) + .shadow(color: .black.opacity(0.15), radius: 6, y: 2) + .transition(.opacity) + } + } +} diff --git a/scripts/build-xcframework.sh b/scripts/build-xcframework.sh new file mode 100755 index 0000000..7ad815d --- /dev/null +++ b/scripts/build-xcframework.sh @@ -0,0 +1,18 @@ +#!/bin/sh +# Builds the Debug CascadeEditor.xcframework consumed by iosNativeSample and any +# local Swift host. Debug is the local-development variant; the Release variant +# (assembleCascadeEditorReleaseXCFramework) is reserved for a future external +# publish and is intentionally not part of this flow. +# +# Output (canonical local consumption path, referenced by the Xcode project): +# editor-ios-sdk/build/XCFrameworks/debug/CascadeEditor.xcframework +# +# Contains ios-arm64 and ios-arm64-simulator slices. Safe to re-run; Gradle +# skips up-to-date work. +set -eu + +REPO_ROOT="$(cd "$(dirname "$0")/.." && pwd)" + +"$REPO_ROOT/gradlew" -p "$REPO_ROOT" :editor-ios-sdk:assembleCascadeEditorDebugXCFramework "$@" + +echo "XCFramework: $REPO_ROOT/editor-ios-sdk/build/XCFrameworks/debug/CascadeEditor.xcframework" diff --git a/settings.gradle.kts b/settings.gradle.kts index 39669c6..d2e3fc0 100644 --- a/settings.gradle.kts +++ b/settings.gradle.kts @@ -30,3 +30,4 @@ dependencyResolutionManagement { include(":sample") include(":editor") +include(":editor-ios-sdk")