notionary 0.2.22__py3-none-any.whl → 0.2.24__py3-none-any.whl

notionary/__init__.py

@@ -4,7 +4,7 @@ bootstrap_blocks()
 
 from .database import DatabaseFilterBuilder, NotionDatabase
 from .file_upload import NotionFileUpload
-from .markdown.markdown_builder import MarkdownBuilder
+from .blocks.markdown.markdown_builder import MarkdownBuilder
 from .page.notion_page import NotionPage
 from .user import NotionBotUser, NotionUser, NotionUserManager
 from .workspace import NotionWorkspace

notionary/blocks/__init__.py

@@ -1,3 +1,5 @@
 from ._bootstrap import bootstrap_blocks
 
-__all__ = ["bootstrap_blocks"]
+__all__ = [
+    "bootstrap_blocks",
+]

notionary/blocks/audio/__init__.py

@@ -1,6 +1,5 @@
 from notionary.blocks.audio.audio_element import AudioElement
 from notionary.blocks.audio.audio_markdown_node import (
-    AudioMarkdownBlockParams,
     AudioMarkdownNode,
 )
 from notionary.blocks.audio.audio_models import CreateAudioBlock
@@ -9,5 +8,4 @@ __all__ = [
     "AudioElement",
     "CreateAudioBlock",
     "AudioMarkdownNode",
-    "AudioMarkdownBlockParams",
 ]

notionary/blocks/audio/audio_element.py

@@ -1,46 +1,38 @@
 from __future__ import annotations
 
 import re
+from pathlib import Path
 from typing import Optional
 
 from notionary.blocks.audio.audio_models import CreateAudioBlock
 from notionary.blocks.base_block_element import BaseBlockElement
-from notionary.blocks.file.file_element_models import ExternalFile, FileBlock, FileType
+from notionary.blocks.file.file_element_models import (
+    ExternalFile,
+    FileBlock,
+    FileType,
+    FileUploadFile,
+)
 from notionary.blocks.mixins.captions import CaptionMixin
+from notionary.blocks.mixins.file_upload.file_upload_mixin import FileUploadMixin
 from notionary.blocks.syntax_prompt_builder import BlockElementMarkdownInformation
 from notionary.blocks.models import Block, BlockCreateResult, BlockType
+from notionary.util.logging_mixin import LoggingMixin
 
 
-class AudioElement(BaseBlockElement, CaptionMixin):
-    """
+class AudioElement(BaseBlockElement, FileUploadMixin, LoggingMixin, CaptionMixin):
+    r"""
     Handles conversion between Markdown audio embeds and Notion audio blocks.
 
-    Markdown audio syntax:
-    - [audio](https://example.com/audio.mp3) - Simple audio embed
-    - [audio](https://example.com/audio.mp3)(caption:Episode 1) - Audio with caption
-    - (caption:Background music)[audio](https://example.com/song.mp3) - caption before URL
+    Supports both external URLs and local audio file uploads.
 
-    Where:
-    - URL is the required audio file URL
-    - Caption supports rich text formatting and is optional
+    Markdown audio syntax:
+    - [audio](https://example.com/audio.mp3) - External URL
+    - [audio](./local/song.mp3) - Local audio file (will be uploaded)
+    - [audio](C:\Music\podcast.wav) - Absolute local path (will be uploaded)
+    - [audio](https://example.com/audio.mp3)(caption:Episode 1) - URL with caption
     """
 
-    # Simple pattern that matches just the audio link, CaptionMixin handles caption separately
-    AUDIO_PATTERN = re.compile(r"\[audio\]\((https?://[^\s\"]+)\)")
-
-    @classmethod
-    def _extract_audio_url(cls, text: str) -> Optional[str]:
-        """Extract audio URL from text, handling caption patterns."""
-        # First remove any captions to get clean text for URL extraction
-        clean_text = cls.remove_caption(text)
-
-        # Now extract the URL from clean text
-        match = cls.AUDIO_PATTERN.search(clean_text)
-        if match:
-            return match.group(1)
-
-        return None
-
+    AUDIO_PATTERN = re.compile(r"\[audio\]\(([^)]+)\)")
     SUPPORTED_EXTENSIONS = {".mp3", ".wav", ".ogg", ".oga", ".m4a"}
 
     @classmethod
@@ -49,27 +41,62 @@ class AudioElement(BaseBlockElement, CaptionMixin):
         return block.type == BlockType.AUDIO
 
     @classmethod
-    async def markdown_to_notion(cls, text: str) -> BlockCreateResult:
+    async def markdown_to_notion(cls, text: str) -> Optional[BlockCreateResult]:
         """Convert markdown audio embed to Notion audio block."""
-        # Use our helper method to extract the URL
-        url = cls._extract_audio_url(text.strip())
-        if not url:
+        # Extract the path/URL
+        path = cls._extract_audio_path(text.strip())
+        if not path:
             return None
 
-        if not cls._is_likely_audio_url(url):
-            return None
+        # Check if it's a local file path
+        if cls._is_local_file_path(path):
+            # Verify file exists and has supported extension
+            audio_path = Path(path)
+            if not audio_path.exists():
+                cls.logger.warning(f"Audio file not found: {path}")
+                return None
 
-        # Use mixin to extract caption (if present anywhere in text)
-        caption_text = cls.extract_caption(text.strip())
-        caption_rich_text = cls.build_caption_rich_text(caption_text or "")
+            if audio_path.suffix.lower() not in cls.SUPPORTED_EXTENSIONS:
+                cls.logger.warning(f"Unsupported audio format: {audio_path.suffix}")
+                return None
 
-        audio_content = FileBlock(
-            type=FileType.EXTERNAL,
-            external=ExternalFile(url=url),
-            caption=caption_rich_text,
-        )
+            cls.logger.info(f"Uploading local audio file: {path}")
+
+            # Upload the local audio file
+            file_upload_id = await cls._upload_local_file(path, "audio")
+            if not file_upload_id:
+                cls.logger.error(f"Failed to upload audio file: {path}")
+                return None
 
-        return CreateAudioBlock(audio=audio_content)
+            cls.logger.info(
+                f"Successfully uploaded audio file with ID: {file_upload_id}"
+            )
+
+            # Use mixin to extract caption (if present anywhere in text)
+            caption_text = cls.extract_caption(text.strip())
+            caption_rich_text = cls.build_caption_rich_text(caption_text or "")
+
+            audio_content = FileBlock(
+                type=FileType.FILE_UPLOAD,
+                file_upload=FileUploadFile(id=file_upload_id),
+                caption=caption_rich_text,
+            )
+
+            return CreateAudioBlock(audio=audio_content)
+
+        else:
+            # Handle external URL - accept any URL (validation happens at API level)
+            # Use mixin to extract caption (if present anywhere in text)
+            caption_text = cls.extract_caption(text.strip())
+            caption_rich_text = cls.build_caption_rich_text(caption_text or "")
+
+            audio_content = FileBlock(
+                type=FileType.EXTERNAL,
+                external=ExternalFile(url=path),
+                caption=caption_rich_text,
+            )
+
+            return CreateAudioBlock(audio=audio_content)
 
     @classmethod
     async def notion_to_markdown(cls, block: Block) -> Optional[str]:
@@ -78,11 +105,14 @@ class AudioElement(BaseBlockElement, CaptionMixin):
             return None
 
         audio = block.audio
+        url = None
+
+        # Handle both external URLs and uploaded files
+        if audio.type == FileType.EXTERNAL and audio.external is not None:
+            url = audio.external.url
+        elif audio.type == FileType.FILE_UPLOAD and audio.file_upload is not None:
+            url = audio.file_upload.url
 
-        # Only handle external audio
-        if audio.type != FileType.EXTERNAL or audio.external is None:
-            return None
-        url = audio.external.url
         if not url:
             return None
 
@@ -100,16 +130,29 @@ class AudioElement(BaseBlockElement, CaptionMixin):
         """Get system prompt information for audio blocks."""
         return BlockElementMarkdownInformation(
             block_type=cls.__name__,
-            description="Audio blocks embed audio files from external URLs with optional captions",
+            description="Audio blocks embed audio files from external URLs or local files with optional captions",
             syntax_examples=[
                 "[audio](https://example.com/song.mp3)",
+                "[audio](./local/podcast.wav)",
+                "[audio](C:\\Music\\interview.mp3)",
                 "[audio](https://example.com/podcast.wav)(caption:Episode 1)",
-                "(caption:Background music)[audio](https://soundcloud.com/track/123)",
-                "[audio](https://example.com/interview.mp3)(caption:**Live** interview)",
+                "(caption:Background music)[audio](./song.mp3)",
+                "[audio](./interview.mp3)(caption:**Live** interview)",
             ],
-            usage_guidelines="Use for embedding audio files like music, podcasts, or sound effects. Supports common audio formats (mp3, wav, ogg, m4a). Caption supports rich text formatting and is optional.",
+            usage_guidelines="Use for embedding audio files like music, podcasts, or sound effects. Supports both external URLs and local file uploads. Supports common audio formats (mp3, wav, ogg, m4a). Caption supports rich text formatting and is optional.",
         )
 
     @classmethod
     def _is_likely_audio_url(cls, url: str) -> bool:
         return any(url.lower().endswith(ext) for ext in cls.SUPPORTED_EXTENSIONS)
+
+    @classmethod
+    def _extract_audio_path(cls, text: str) -> Optional[str]:
+        """Extract audio path/URL from text, handling caption patterns."""
+        clean_text = cls.remove_caption(text)
+
+        match = cls.AUDIO_PATTERN.search(clean_text)
+        if match:
+            return match.group(1).strip()
+
+        return None

notionary/blocks/audio/audio_markdown_node.py

@@ -1,30 +1,17 @@
-from __future__ import annotations
-
 from typing import Optional
 
-from pydantic import BaseModel
-
-from notionary.markdown.markdown_node import MarkdownNode
+from notionary.blocks.markdown.markdown_node import MarkdownNode
 from notionary.blocks.mixins.captions import CaptionMarkdownNodeMixin
 
 
-class AudioMarkdownBlockParams(BaseModel):
-    url: str
-    caption: Optional[str] = None
-
-
 class AudioMarkdownNode(MarkdownNode, CaptionMarkdownNodeMixin):
     """
+    Enhanced Audio node with Pydantic integration.
     Programmatic interface for creating Notion-style audio blocks.
     """
 
-    def __init__(self, url: str, caption: Optional[str] = None):
-        self.url = url
-        self.caption = caption
-
-    @classmethod
-    def from_params(cls, params: AudioMarkdownBlockParams) -> AudioMarkdownNode:
-        return cls(url=params.url, caption=params.caption)
+    url: str
+    caption: Optional[str] = None
 
     def to_markdown(self) -> str:
         """Return the Markdown representation.

notionary/blocks/bookmark/__init__.py

@@ -1,6 +1,5 @@
 from notionary.blocks.bookmark.bookmark_element import BookmarkElement
 from notionary.blocks.bookmark.bookmark_markdown_node import (
-    BookmarkMarkdownBlockParams,
     BookmarkMarkdownNode,
 )
 from notionary.blocks.bookmark.bookmark_models import BookmarkBlock, CreateBookmarkBlock
@@ -10,5 +9,4 @@ __all__ = [
     "BookmarkBlock",
     "CreateBookmarkBlock",
     "BookmarkMarkdownNode",
-    "BookmarkMarkdownBlockParams",
 ]

notionary/blocks/bookmark/bookmark_markdown_node.py

@@ -1,34 +1,18 @@
-from __future__ import annotations
-
 from typing import Optional
 
-from pydantic import BaseModel
-
-from notionary.markdown.markdown_node import MarkdownNode
+from notionary.blocks.markdown.markdown_node import MarkdownNode
 from notionary.blocks.mixins.captions import CaptionMarkdownNodeMixin
 
 
-class BookmarkMarkdownBlockParams(BaseModel):
-    url: str
-    title: Optional[str] = None
-    caption: Optional[str] = None
-
-
 class BookmarkMarkdownNode(MarkdownNode, CaptionMarkdownNodeMixin):
     """
+    Enhanced Bookmark node with Pydantic integration.
     Programmatic interface for creating Notion-style bookmark Markdown blocks.
     """
 
-    def __init__(
-        self, url: str, title: Optional[str] = None, caption: Optional[str] = None
-    ):
-        self.url = url
-        self.title = title
-        self.caption = caption
-
-    @classmethod
-    def from_params(cls, params: BookmarkMarkdownBlockParams) -> BookmarkMarkdownNode:
-        return cls(url=params.url, title=params.title, caption=params.caption)
+    url: str
+    title: Optional[str] = None
+    caption: Optional[str] = None
 
     def to_markdown(self) -> str:
         """Return the Markdown representation.

notionary/blocks/breadcrumbs/__init__.py

@@ -1,6 +1,5 @@
 from notionary.blocks.breadcrumbs.breadcrumb_element import BreadcrumbElement
 from notionary.blocks.breadcrumbs.breadcrumb_markdown_node import (
-    BreadcrumbMarkdownBlockParams,
     BreadcrumbMarkdownNode,
 )
 from notionary.blocks.breadcrumbs.breadcrumb_models import (
@@ -13,5 +12,4 @@ __all__ = [
     "BreadcrumbBlock",
     "CreateBreadcrumbBlock",
     "BreadcrumbMarkdownNode",
-    "BreadcrumbMarkdownBlockParams",
 ]

notionary/blocks/breadcrumbs/breadcrumb_markdown_node.py

@@ -1,32 +1,13 @@
-from __future__ import annotations
-
-from pydantic import BaseModel
-
-from notionary.markdown.markdown_node import MarkdownNode
-
-
-class BreadcrumbMarkdownBlockParams(BaseModel):
-    """Parameters for breadcrumb markdown block. No parameters needed."""
-
-    pass
+from notionary.blocks.markdown.markdown_node import MarkdownNode
 
 
 class BreadcrumbMarkdownNode(MarkdownNode):
     """
+    Enhanced Breadcrumb node with Pydantic integration.
     Programmatic interface for creating Markdown breadcrumb blocks.
     Example:
     [breadcrumb]
     """
 
-    def __init__(self):
-        # No parameters needed for breadcrumb
-        pass
-
-    @classmethod
-    def from_params(
-        cls, params: BreadcrumbMarkdownBlockParams
-    ) -> BreadcrumbMarkdownNode:
-        return cls()
-
     def to_markdown(self) -> str:
         return "[breadcrumb]"

notionary/blocks/bulleted_list/__init__.py

@@ -1,6 +1,5 @@
 from notionary.blocks.bulleted_list.bulleted_list_element import BulletedListElement
 from notionary.blocks.bulleted_list.bulleted_list_markdown_node import (
-    BulletedListMarkdownBlockParams,
     BulletedListMarkdownNode,
 )
 from notionary.blocks.bulleted_list.bulleted_list_models import (
@@ -13,5 +12,4 @@ __all__ = [
     "BulletedListItemBlock",
     "CreateBulletedListItemBlock",
     "BulletedListMarkdownNode",
-    "BulletedListMarkdownBlockParams",
 ]

notionary/blocks/bulleted_list/bulleted_list_markdown_node.py

@@ -1,16 +1,9 @@
-from __future__ import annotations
-
-from pydantic import BaseModel
-
-from notionary.markdown.markdown_node import MarkdownNode
-
-
-class BulletedListMarkdownBlockParams(BaseModel):
-    texts: list[str]
+from notionary.blocks.markdown.markdown_node import MarkdownNode
 
 
 class BulletedListMarkdownNode(MarkdownNode):
     """
+    Enhanced BulletedList node with Pydantic integration.
     Programmatic interface for creating Markdown bulleted list items.
     Example:
     - First item
@@ -18,14 +11,7 @@ class BulletedListMarkdownNode(MarkdownNode):
     - Third item
     """
 
-    def __init__(self, texts: list[str]):
-        self.texts = texts
-
-    @classmethod
-    def from_params(
-        cls, params: BulletedListMarkdownBlockParams
-    ) -> BulletedListMarkdownNode:
-        return cls(texts=params.texts)
+    texts: list[str]
 
     def to_markdown(self) -> str:
         result = []

notionary/blocks/bulleted_list/bulleted_list_models.py

@@ -10,7 +10,6 @@ from notionary.blocks.types import BlockColor
 class BulletedListItemBlock(BaseModel):
     rich_text: list[RichTextObject]
     color: BlockColor = BlockColor.DEFAULT
-    children: list[Block] = Field(default_factory=list)
 
 
 class CreateBulletedListItemBlock(BaseModel):

notionary/blocks/callout/__init__.py

@@ -1,6 +1,5 @@
 from notionary.blocks.callout.callout_element import CalloutElement
 from notionary.blocks.callout.callout_markdown_node import (
-    CalloutMarkdownBlockParams,
     CalloutMarkdownNode,
 )
 from notionary.blocks.callout.callout_models import CalloutBlock, CreateCalloutBlock
@@ -10,5 +9,4 @@ __all__ = [
     "CalloutBlock",
     "CreateCalloutBlock",
     "CalloutMarkdownNode",
-    "CalloutMarkdownBlockParams",
 ]

notionary/blocks/callout/callout_markdown_node.py

@@ -1,30 +1,16 @@
-from __future__ import annotations
-
 from typing import Optional
-
-from pydantic import BaseModel
-
-from notionary.markdown.markdown_node import MarkdownNode
-
-
-class CalloutMarkdownBlockParams(BaseModel):
-    text: str
-    emoji: Optional[str] = None
+from notionary.blocks.markdown.markdown_node import MarkdownNode
 
 
 class CalloutMarkdownNode(MarkdownNode):
     """
+    Enhanced Callout node with Pydantic integration.
     Programmatic interface for creating Notion-style callout Markdown blocks.
     Example: [callout](This is important "⚠️")
     """
 
-    def __init__(self, text: str, emoji: Optional[str] = None):
-        self.text = text
-        self.emoji = emoji
-
-    @classmethod
-    def from_params(cls, params: CalloutMarkdownBlockParams) -> CalloutMarkdownNode:
-        return cls(text=params.text, emoji=params.emoji)
+    text: str
+    emoji: Optional[str] = None
 
     def to_markdown(self) -> str:
         if self.emoji and self.emoji != "💡":

notionary/blocks/callout/callout_models.py

@@ -1,6 +1,6 @@
 from typing import Literal, Optional, Union
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, model_serializer
 
 from notionary.blocks.file.file_element_models import FileBlock
 from notionary.blocks.models import Block
@@ -23,10 +23,9 @@ IconObject = Union[EmojiIcon, FileIcon]
 
 class CalloutBlock(BaseModel):
     rich_text: list[RichTextObject]
-    icon: Optional[IconObject] = None
     color: BlockColor = BlockColor.DEFAULT
-    children: list[Block] = Field(default_factory=list)
-
+    icon: Optional[IconObject] = None
+    children: Optional[list[Block]] = None
 
 class CreateCalloutBlock(BaseModel):
     type: Literal["callout"] = "callout"

notionary/blocks/child_database/child_database_element.py

@@ -8,6 +8,7 @@ from notionary.blocks.syntax_prompt_builder import BlockElementMarkdownInformati
 from notionary.blocks.models import Block, BlockType
 from notionary.util import LoggingMixin
 
+
 class ChildDatabaseElement(BaseBlockElement, LoggingMixin):
     """
     Handles conversion between Markdown database references and Notion child database blocks.
@@ -23,14 +24,11 @@ class ChildDatabaseElement(BaseBlockElement, LoggingMixin):
         return block.type == BlockType.CHILD_DATABASE and block.child_database
 
     @classmethod
-    async def markdown_to_notion(
-        cls, text: str
-    ) -> Optional[str]:
+    async def markdown_to_notion(cls, text: str) -> Optional[str]:
         """
         Convert markdown database syntax to actual Notion database.
         Returns the database_id if successful, None otherwise.
         """
-        cls.logger.warning("Creating database from markdown is not supported via the block api. Call the create_child_page method in NotionPage instead.s")
         return None
 
     @classmethod

notionary/blocks/code/code_markdown_node.py

@@ -1,13 +1,11 @@
-from __future__ import annotations
-
 from typing import Optional
 
-from notionary.blocks.code.code_models import CodeBlock
-from notionary.markdown.markdown_node import MarkdownNode
+from notionary.blocks.markdown.markdown_node import MarkdownNode
 
 
 class CodeMarkdownNode(MarkdownNode):
     """
+    Enhanced Code node with Pydantic integration.
     Programmatic interface for creating Notion-style Markdown code blocks.
     Automatically handles indentation normalization for multiline strings.
 
@@ -17,21 +15,9 @@ class CodeMarkdownNode(MarkdownNode):
         ```
     """
 
-    def __init__(
-        self,
-        code: str,
-        language: Optional[str] = None,
-        caption: Optional[str] = None,
-    ):
-        self.code = code
-        self.language = language or ""
-        self.caption = caption
-
-    @classmethod
-    def from_params(cls, params: CodeBlock) -> CodeMarkdownNode:
-        return cls(
-            code=params.rich_text, language=params.language, caption=params.caption
-        )
+    code: str
+    language: Optional[str] = None
+    caption: Optional[str] = None
 
     def to_markdown(self) -> str:
         lang = self.language or ""

notionary/blocks/column/__init__.py

@@ -1,11 +1,9 @@
 from notionary.blocks.column.column_element import ColumnElement
 from notionary.blocks.column.column_list_element import ColumnListElement
 from notionary.blocks.column.column_list_markdown_node import (
-    ColumnListMarkdownBlockParams,
     ColumnListMarkdownNode,
 )
 from notionary.blocks.column.column_markdown_node import (
-    ColumnMarkdownBlockParams,
     ColumnMarkdownNode,
 )
 from notionary.blocks.column.column_models import (
@@ -23,7 +21,5 @@ __all__ = [
     "ColumnListBlock",
     "CreateColumnListBlock",
     "ColumnMarkdownNode",
-    "ColumnMarkdownBlockParams",
     "ColumnListMarkdownNode",
-    "ColumnListMarkdownBlockParams",
 ]

notionary/blocks/column/column_list_markdown_node.py

@@ -1,19 +1,10 @@
-from __future__ import annotations
-
-from pydantic import BaseModel
-
 from notionary.blocks.column.column_markdown_node import ColumnMarkdownNode
-from notionary.markdown.markdown_document_model import MarkdownBlock
-from notionary.markdown.markdown_node import MarkdownNode
-
-
-class ColumnListMarkdownBlockParams(BaseModel):
-    columns: list[list[MarkdownBlock]]
-    model_config = {"arbitrary_types_allowed": True}
+from notionary.blocks.markdown.markdown_node import MarkdownNode
 
 
 class ColumnListMarkdownNode(MarkdownNode):
     """
+    Enhanced Column List node with Pydantic integration.
     Programmatic interface for creating a Markdown column list container.
     This represents the `::: columns` container that holds multiple columns.
 
@@ -31,14 +22,7 @@ class ColumnListMarkdownNode(MarkdownNode):
     :::
     """
 
-    def __init__(self, columns: list[ColumnMarkdownNode]):
-        self.columns = columns
-
-    @classmethod
-    def from_params(
-        cls, params: ColumnListMarkdownBlockParams
-    ) -> ColumnListMarkdownNode:
-        return cls(columns=params.columns)
+    columns: list[ColumnMarkdownNode] = []
 
     def to_markdown(self) -> str:
         if not self.columns:

notionary/blocks/column/column_markdown_node.py

@@ -1,20 +1,10 @@
-from __future__ import annotations
-
 from typing import Optional
-
-from pydantic import BaseModel
-
-from notionary.markdown.markdown_node import MarkdownNode
-
-
-class ColumnMarkdownBlockParams(BaseModel):
-    children: list[MarkdownNode]
-    width_ratio: Optional[float] = None
-    model_config = {"arbitrary_types_allowed": True}
+from notionary.blocks.markdown.markdown_node import MarkdownNode
 
 
 class ColumnMarkdownNode(MarkdownNode):
     """
+    Enhanced Column node with Pydantic integration.
     Programmatic interface for creating a single Markdown column block
     with nested content and optional width ratio.
 
@@ -32,15 +22,8 @@ class ColumnMarkdownNode(MarkdownNode):
         :::
     """
 
-    def __init__(
-        self, children: list[MarkdownNode], width_ratio: Optional[float] = None
-    ):
-        self.children = children
-        self.width_ratio = width_ratio
-
-    @classmethod
-    def from_params(cls, params: ColumnMarkdownBlockParams) -> ColumnMarkdownNode:
-        return cls(children=params.children, width_ratio=params.width_ratio)
+    children: list[MarkdownNode] = []
+    width_ratio: Optional[float] = None
 
     def to_markdown(self) -> str:
         # Start tag with optional width ratio

notionary/blocks/divider/__init__.py

@@ -1,6 +1,5 @@
 from notionary.blocks.divider.divider_element import DividerElement
 from notionary.blocks.divider.divider_markdown_node import (
-    DividerMarkdownBlockParams,
     DividerMarkdownNode,
 )
 from notionary.blocks.divider.divider_models import CreateDividerBlock, DividerBlock
@@ -10,5 +9,4 @@ __all__ = [
     "DividerBlock",
     "CreateDividerBlock",
     "DividerMarkdownNode",
-    "DividerMarkdownBlockParams",
 ]