Args:
    subreddit: Name of the subreddit to post in (with or without 'r/' prefix)
    title: Title of the post (max 300 characters)
    content: Content of the post (text for self posts, URL for link posts)
    flair: Flair to add to the post. Must be an available flair in the subreddit
    is_self: Whether this is a self (text) post (True) or link post (False)

Returns:
    Dictionary containing information about the created post

Raises:
    ValueError: If input validation fails or flair is invalid
    RuntimeError: For other errors during post creation

Args:
    submission_id: The ID of the Reddit submission to retrieve (can be full URL or just ID)
    include_comments: If True, load and return the full comment forest for the post
    comment_replace_more_limit: Limit for replacing "MoreComments" objects (0 for none, None for all)

Returns:
    Dictionary containing structured submission information with the following structure:
    {
        'id': str,  # Submission ID (e.g., 'abc123')
        'title': str,  # Submission title
        'author': str,  # Author's username or '[deleted]' if deleted
        'subreddit': str,  # Subreddit name
        'score': int,  # Post score (upvotes - downvotes)
        'upvote_ratio': float,  # Ratio of upvotes to total votes
        'num_comments': int,  # Number of comments
        'created_utc': float,  # Post creation timestamp (UTC)
        'url': str,  # Full URL to the post
        'permalink': str,  # Relative URL to the post
        'is_self': bool,  # Whether it's a self (text) post
        'selftext': str,  # Content of self post (if any)
        'selftext_html': Optional[str],  # HTML formatted content
        'link_url': str,  # URL for link posts (if any)
        'domain': str,  # Domain of the linked content
        'over_18': bool,  # Whether marked as NSFW
        'spoiler': bool,  # Whether marked as spoiler
        'stickied': bool,  # Whether stickied in the subreddit
        'locked': bool,  # Whether comments are locked
        'archived': bool,  # Whether the post is archived
        'distinguished': Optional[str],  # Distinguishing type (e.g., 'moderator')
        'flair': Optional[Dict],  # Post flair information if any
        'media': Optional[Dict],  # Media information if any
        'preview': Optional[Dict],  # Preview information if available
        'awards': List[Dict],  # List of awards received
        'comments': Optional[List[Dict]],  # present if include_comments is True
        'metadata': {
            'fetched_at': float,  # Timestamp when data was fetched
            'subreddit_id': str,  # Subreddit full ID
            'author_id': str,  # Author's full ID if available
            'is_original_content': bool,  # Whether marked as OC
            'is_meta': bool,  # Whether marked as meta
            'is_crosspostable': bool,  # Whether can be crossposted
            'is_reddit_media_domain': bool,  # Whether media is hosted on Reddit
            'is_robot_indexable': bool,  # Whether search engines should index
            'is_created_from_ads_ui': bool,  # Whether created via ads UI
            'is_video': bool,  # Whether the post is a video
            'pinned': bool,  # Whether the post is pinned in the subreddit
            'gilded': int,  # Number of times gilded
            'total_awards_received': int,  # Total number of awards received
            'view_count': Optional[int],  # View count if available
            'visited': bool,  # Whether the current user has visited
        }
    }

Raises:
    ValueError: If submission_id is invalid or submission not found
    RuntimeError: For other errors during the operation

Args:
    url: The URL of the Reddit submission to retrieve
    include_comments: If True, load and return the full comment forest for the post
    comment_replace_more_limit: Limit for replacing "MoreComments" objects (0 for none, None for all)

Returns:
    Dictionary containing structured submission information with the following structure:
    {
        'id': str,  # Submission ID (e.g., 'abc123')
        'title': str,  # Submission title
        'author': str,  # Author's username or '[deleted]' if deleted
        'subreddit': str,  # Subreddit name
        'score': int,  # Post score (upvotes - downvotes)
        'upvote_ratio': float,  # Ratio of upvotes to total votes
        'num_comments': int,  # Number of comments
        'created_utc': float,  # Post creation timestamp (UTC)
        'url': str,  # Full URL to the post
        'permalink': str,  # Relative URL to the post
        'is_self': bool,  # Whether it's a self (text) post
        'selftext': str,  # Content of self post (if any)
        'selftext_html': Optional[str],  # HTML formatted content
        'link_url': str,  # URL for link posts (if any)
        'domain': str,  # Domain of the linked content
        'over_18': bool,  # Whether marked as NSFW
        'spoiler': bool,  # Whether marked as spoiler
        'stickied': bool,  # Whether stickied in the subreddit
        'locked': bool,  # Whether comments are locked
        'archived': bool,  # Whether the post is archived
        'distinguished': Optional[str],  # Distinguishing type (e.g., 'moderator')
        'flair': Optional[Dict],  # Post flair information if any
        'media': Optional[Dict],  # Media information if any
        'preview': Optional[Dict],  # Preview information if available
        'awards': List[Dict],  # List of awards received
        'comments': Optional[List[Dict]],  # present if include_comments is True
        'metadata': {
            'fetched_at': float,  # Timestamp when data was fetched
            'subreddit_id': str,  # Subreddit full ID
            'author_id': str,  # Author's full ID if available
            'is_original_content': bool,  # Whether marked as OC
            'is_meta': bool,  # Whether marked as meta
            'is_crosspostable': bool,  # Whether can be crossposted
            'is_reddit_media_domain': bool,  # Whether media is hosted on Reddit
            'is_robot_indexable': bool,  # Whether search engines should index
            'is_created_from_ads_ui': bool,  # Whether created via ads UI
            'is_video': bool,  # Whether the post is a video
            'pinned': bool,  # Whether the post is pinned in the subreddit
            'gilded': int,  # Number of times gilded
            'total_awards_received': int,  # Total number of awards received
            'view_count': Optional[int],  # View count if available
            'visited': bool,  # Whether the current user has visited
        }
    }

Raises:
    ValueError: If URL is invalid or submission not found
    RuntimeError: For other errors during the operation

Args:
    subreddit_name: Name of the subreddit (with or without 'r/' prefix)

Returns:
    Dictionary containing subreddit information

Raises:
    ValueError: If subreddit_name is invalid or subreddit not found
    RuntimeError: For other errors during the operation

Args:
    subreddit: Name of the subreddit (with or without 'r/' prefix)

Returns:
    Dictionary containing structured subreddit information with the following structure:
    {
        'id': str,  # Subreddit ID (e.g., '2qgzt')
        'display_name': str,  # Subreddit display name (without r/ prefix)
        'title': str,  # Subreddit title
        'public_description': str,  # Public description
        'description': str,  # Full description (can include markdown)
        'subscribers': int,  # Number of subscribers
        'active_user_count': Optional[int],  # Currently active users if available
        'created_utc': float,  # Creation timestamp (UTC)
        'over18': bool,  # Whether marked as NSFW
        'submission_type': str,  # Allowed submission types (any, link, self)
        'allow_images': bool,  # Whether image uploads are allowed
        'allow_videos': bool,  # Whether video uploads are allowed
        'allow_polls': bool,  # Whether polls are allowed
        'spoilers_enabled': bool,  # Whether spoiler tags are enabled
        'wikienabled': bool,  # Whether wiki is enabled
        'user_is_banned': bool,  # Whether current user is banned
        'user_is_moderator': bool,  # Whether current user is a moderator
        'user_is_subscriber': bool,  # Whether current user is a subscriber
        'mod_permissions': List[str],  # Moderator permissions if applicable
        'metadata': {
            'fetched_at': float,  # Timestamp when data was fetched
            'url': str,  # Full URL to the subreddit
            'moderators_count': int,  # Number of moderators
            'rules': List[Dict],  # Subreddit rules if available
            'features': Dict[str, bool],  # Enabled subreddit features
        }
    }

Raises:
    ValueError: If subreddit is invalid or not found
    RuntimeError: For other errors during the operation

Args:
    subreddit: Name of the subreddit (with or without 'r/' prefix)
    time_filter: Time period to filter posts (e.g. "day", "week", "month", "year", "all")
    limit: Number of posts to fetch (1-100)
    include_comments: If True, load and return the full comment forest for each post
    comment_replace_more_limit: Limit for replacing "MoreComments" objects (0 for none, None for all)

Returns:
    Dictionary containing structured post information with the following structure:
    {
        'subreddit': str,  # Subreddit name
        'time_filter': str,  # The time period used for filtering
        'posts': [  # List of posts, each with the following structure:
            {
                'id': str,  # Post ID
                'title': str,  # Post title
                'author': str,  # Author's username
                'score': int,  # Post score (upvotes - downvotes)
                'upvote_ratio': float,  # Ratio of upvotes to total votes
                'num_comments': int,  # Number of comments
                'created_utc': float,  # Post creation timestamp
                'url': str,  # URL to the post
                'permalink': str,  # Relative URL to the post
                'is_self': bool,  # Whether it's a self (text) post
                'selftext': str,  # Content of self post (if any)
                'link_url': str,  # URL for link posts (if any)
                'over_18': bool,  # Whether marked as NSFW
                'spoiler': bool,  # Whether marked as spoiler
                'stickied': bool,  # Whether stickied in the subreddit
                'locked': bool,  # Whether comments are locked
                'distinguished': Optional[str],  # Distinguishing type (e.g., 'moderator')
                'flair': Optional[Dict],  # Post flair information if any
                'comments': Optional[List[Dict]],  # present if include_comments is True
            },
            ...
        ],
        'metadata': {
            'fetched_at': float,  # Timestamp when data was fetched
            'post_count': int,  # Number of posts returned
        }
    }

Raises:
    ValueError: If subreddit is invalid or time_filter is not valid
    RuntimeError: For other errors during the operation

Args:
    limit: Maximum number of trending subreddits to return (1-50)

Returns:
    Dictionary containing list of trending subreddits with their basic info

Raises:
    ValueError: If limit is invalid
    RuntimeError: For errors during the operation

Args:
    username: The username of the Reddit user (with or without 'u/' prefix)
    sort: Sort order for comments - one of: "new", "hot", "top", "controversial"
    time_filter: Time period to filter comments (e.g. "hour", "day", "week", "month", "year", "all")
    limit: Number of comments to return (1-100)

Returns:
    Dictionary containing structured comment history with the following structure:
    {
        'username': str,  # The username
        'sort': str,  # Sort method used
        'time_filter': str,  # Time filter used
        'comments': [  # List of comments
            {
                'id': str,  # Comment ID
                'body': str,  # Comment text content
                'author': str,  # Author's username
                'subreddit': str,  # Subreddit where comment was posted
                'score': int,  # Comment score (upvotes - downvotes)
                'created_utc': float,  # Comment creation timestamp
                'permalink': str,  # Relative URL to the comment
                'link_title': str,  # Title of the post being commented on
                'link_id': str,  # ID of the post
                'parent_id': str,  # ID of parent comment or post
                'is_submitter': bool,  # Whether commenter is the post author
                'stickied': bool,  # Whether comment is stickied
                'distinguished': Optional[str],  # Distinguishing type (e.g., 'moderator')
                'edited': bool,  # Whether comment has been edited
                'gilded': int,  # Number of times gilded
                'controversiality': int,  # Controversy score
                'depth': int,  # Comment depth in thread (0 for top-level)
            },
            ...
        ],
        'metadata': {
            'fetched_at': float,  # Timestamp when data was fetched
            'comment_count': int,  # Number of comments returned
        }
    }

Raises:
    ValueError: If username is invalid, sort method is invalid, or time_filter is invalid
    RuntimeError: For other errors during the operation

Args:
    username: The username of the Reddit user to get info for

Returns:
    Dictionary containing user information with the following structure:
    {
        'username': str,  # User's username
        'created_utc': float,  # Account creation timestamp
        'comment_karma': int,  # User's comment karma
        'link_karma': int,  # User's post/link karma
        'has_verified_email': bool,  # Whether email is verified
        'is_mod': bool,  # Whether user is a moderator
        'is_gold': bool,  # Whether user has Reddit premium
        'has_subscribed': bool,  # Whether user has subscribed to premium
        'is_employee': bool,  # Whether user is a Reddit employee
        'over_18': bool,  # Whether user is marked as NSFW
        'is_suspended': bool,  # Whether account is suspended
        'suspension_expiration_utc': Optional[float],  # When suspension ends if suspended
        'total_karma': int,  # Total karma (comments + posts)
        'subreddit': Optional[Dict],  # User's profile subreddit info if exists
    }

Raises:
    ValueError: If the username is invalid or not found
    RuntimeError: For other errors during the operation

Args:
    username: The username of the Reddit user (with or without 'u/' prefix)
    sort: Sort order for posts - one of: "new", "hot", "top", "controversial"
    time_filter: Time period to filter posts (e.g. "hour", "day", "week", "month", "year", "all")
    limit: Number of posts to return (1-100)

Returns:
    Dictionary containing structured post history with the following structure:
    {
        'username': str,  # The username
        'sort': str,  # Sort method used
        'time_filter': str,  # Time filter used
        'posts': [  # List of posts
            {
                'id': str,  # Post ID
                'title': str,  # Post title
                'author': str,  # Author's username
                'subreddit': str,  # Subreddit name
                'score': int,  # Post score (upvotes - downvotes)
                'upvote_ratio': float,  # Ratio of upvotes to total votes
                'num_comments': int,  # Number of comments
                'created_utc': float,  # Post creation timestamp
                'url': str,  # Full URL to the post
                'permalink': str,  # Relative URL to the post
                'is_self': bool,  # Whether it's a self (text) post
                'selftext': str,  # Content of self post (if any)
                'link_url': str,  # URL for link posts (if any)
                'domain': str,  # Domain of the linked content
                'over_18': bool,  # Whether marked as NSFW
                'spoiler': bool,  # Whether marked as spoiler
                'stickied': bool,  # Whether stickied in the subreddit
                'locked': bool,  # Whether comments are locked
                'distinguished': Optional[str],  # Distinguishing type (e.g., 'moderator')
                'gilded': int,  # Number of times gilded
            },
            ...
        ],
        'metadata': {
            'fetched_at': float,  # Timestamp when data was fetched
            'post_count': int,  # Number of posts returned
        }
    }

Raises:
    ValueError: If username is invalid, sort method is invalid, or time_filter is invalid
    RuntimeError: For other errors during the operation

Args:
    subreddit_name: Name of the subreddit to join/leave (with or without 'r/' prefix)
    unsubscribe: If True, leave the subreddit instead of joining

Returns:
    Dictionary containing information about the action and subreddit

Raises:
    ValueError: If subreddit name is invalid or subreddit not found
    RuntimeError: For other errors during the operation

Args:
    comment_id: The ID of the comment to reply to (can be full URL, permalink, or just ID)
    content: The content of the reply (1-10000 characters)

Returns:
    Dictionary containing information about the created reply and parent comment

Raises:
    ValueError: If input validation fails or comment is not found
    RuntimeError: For other errors during reply creation

Args:
    post_id: The ID of the post to reply to (can be full URL, permalink, or just ID)
    content: The content of the reply (1-10000 characters)
    subreddit: The subreddit name if known (for validation, with or without 'r/' prefix)

Returns:
    Dictionary containing information about the created reply and parent post

Raises:
    ValueError: If input validation fails or post is not found
    RuntimeError: For other errors during reply creation

Args:
    query: The search query/term to search for
    subreddit: Optional subreddit to limit search to (with or without 'r/' prefix). If None, searches all of Reddit
    sort: Sort order for results - one of: "relevance", "hot", "top", "new", "comments"
    time_filter: Time period to filter results (e.g. "hour", "day", "week", "month", "year", "all")
    limit: Number of posts to return (1-100)

Returns:
    Dictionary containing structured search results with the following structure:
    {
        'query': str,  # The search query used
        'subreddit': Optional[str],  # Subreddit searched (None if searching all of Reddit)
        'sort': str,  # Sort method used
        'time_filter': str,  # Time filter used
        'posts': [  # List of matching posts
            {
                'id': str,  # Post ID
                'title': str,  # Post title
                'author': str,  # Author's username
                'subreddit': str,  # Subreddit name
                'score': int,  # Post score (upvotes - downvotes)
                'upvote_ratio': float,  # Ratio of upvotes to total votes
                'num_comments': int,  # Number of comments
                'created_utc': float,  # Post creation timestamp
                'url': str,  # URL to the post
                'permalink': str,  # Relative URL to the post
                'is_self': bool,  # Whether it's a self (text) post
                'selftext': str,  # Content of self post (if any)
                'link_url': str,  # URL for link posts (if any)
                'over_18': bool,  # Whether marked as NSFW
                'spoiler': bool,  # Whether marked as spoiler
                'stickied': bool,  # Whether stickied in the subreddit
                'locked': bool,  # Whether comments are locked
                'distinguished': Optional[str],  # Distinguishing type (e.g., 'moderator')
                'flair': Optional[Dict],  # Post flair information if any
            },
            ...
        ],
        'metadata': {
            'fetched_at': float,  # Timestamp when data was fetched
            'result_count': int,  # Number of results returned
            'search_scope': str,  # "all" or subreddit name
        }
    }

Raises:
    ValueError: If query is empty, sort method is invalid, or time_filter is invalid
    RuntimeError: For other errors during the operation

Returns:
    Dictionary containing structured user information with the following structure:
    {
        'id': str,  # Full user ID (e.g., 't2_abc123')
        'name': str,  # Username
        'created_utc': float,  # Account creation timestamp
        'comment_karma': int,  # Comment karma
        'link_karma': int,  # Post/link karma
        'total_karma': int,  # Total karma (comments + posts)
        'awardee_karma': int,  # Karma from awards received
        'awarder_karma': int,  # Karma from awards given
        'has_verified_email': bool,  # Whether email is verified
        'is_employee': bool,  # Whether user is a Reddit employee
        'is_friend': bool,  # Whether user is a friend
        'is_gold': bool,  # Whether user has Reddit Premium
        'is_mod': bool,  # Whether user is a moderator
        'is_suspended': bool,  # Whether account is suspended
        'verified': bool,  # Whether account is verified
        'has_subscribed': bool,  # Whether user has subscribed to Premium
        'snoovatar_img': str,  # URL to snoovatar image
        'icon_img': str,  # URL to user's icon
        'pref_show_snoovatar': bool,  # Whether to show snoovatar
        'snoovatar_size': Optional[List[int]],  # Snoovatar dimensions
        'subreddit': Optional[Dict],  # User's profile subreddit info
        'metadata': {
            'fetched_at': float,  # Timestamp when data was fetched
            'is_authenticated': bool,  # Whether user is authenticated
            'is_moderator': bool,  # Whether user is a moderator
            'has_verified_email': bool,  # Whether email is verified
            'has_mail': bool,  # Whether user has unread messages
            'has_mod_mail': bool,  # Whether user has mod mail
            'has_subscribed': bool,  # Whether user has subscribed to Premium
            'in_chat': bool,  # Whether user is in chat
            'in_redesign_beta': bool,  # Whether user is in redesign beta
            'new_modmail_exists': bool,  # Whether user has new modmail
            'pref_no_profanity': bool,  # Whether to filter profanity
            'suspension_expiration_utc': Optional[float],  # When suspension ends if suspended
        }
    }

Raises:
    ValueError: If user authentication is not available
    RuntimeError: For other errors during the operation