@lap v0.3
# Machine-readable API spec. Each @endpoint block is one API call.
@api X API v2
@base https://api.x.com
@version 2.168
@auth Bearer bearer | OAuth2 | Bearer OAuth
@endpoints 195
@hint download_for_search
@toc 2(195)

@endpoint GET /2/account
@returns(200) {data: map{account_id: str, created_at: str, name: str}, errors: [any]}

@endpoint POST /2/account
@optional {metadata: str}
@returns(200) {data: map{account_id: str, created: bool}, errors: [any]}

@endpoint GET /2/account_activity/subscriptions/count
@returns(200) {data: map{account_name: str, provisioned_count: str, subscriptions_count_all: str, subscriptions_count_direct_messages: str}, errors: [any]}

@endpoint GET /2/account_activity/webhooks/{webhook_id}/subscriptions/all
@required {webhook_id: str}
@returns(200) {data: map{subscribed: bool}, errors: [any]}

@endpoint POST /2/account_activity/webhooks/{webhook_id}/subscriptions/all
@required {webhook_id: str}
@returns(200) {data: map{subscribed: bool}, errors: [any]}

@endpoint GET /2/account_activity/webhooks/{webhook_id}/subscriptions/all/list
@required {webhook_id: str}
@returns(200) {data: map{application_id: str, subscriptions: [map], webhook_id: str, webhook_url: str}, errors: [any]}

@endpoint DELETE /2/account_activity/webhooks/{webhook_id}/subscriptions/{user_id}/all
@required {webhook_id: str, user_id: str}
@returns(200) {data: map{subscribed: bool}, errors: [any]}

@endpoint GET /2/activity/stream
@optional {backfill_minutes: int(int32), start_time: str(date-time), end_time: str(date-time)}
@returns(200) {data: map{event_type: str, event_uuid: str, filter: map{direction: str, keyword: str, user_id: str}, includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}, payload: any, tag: str}, errors: [any]}

@endpoint DELETE /2/activity/subscriptions
@required {ids: [str]}
@returns(200) {data: [map], errors: [map], meta: map{total_subscriptions: int(int32)}}

@endpoint GET /2/activity/subscriptions
@optional {max_results: int(int32)=1000, pagination_token: str}
@returns(200) {data: [map], errors: [any]}

@endpoint POST /2/activity/subscriptions
@required {event_type: str(profile.update.bio/profile.update.profile_picture/profile.update.banner_picture/profile.update.screenname/profile.update.geo/profile.update.url/profile.update.verified_badge/profile.update.affiliate_badge/profile.update.handle/news.new/follow.follow/follow.unfollow/subscriptions.subscribe/subscriptions.unsubscribe/spaces.start/spaces.end/broadcast.start/broadcast.end/broadcast.chat/chat.received/chat.sent/chat.conversation.join/chat.conversation_join/chat.conversation.member_added/chat.conversation.member_removed/chat.conversation.admin_added/chat.conversation.admin_removed/chat.update.group_name/chat.update.restrictions/dm.sent/dm.received/dm.indicate_typing/dm.read/post.create/post.delete/post.mention.create/post.reply.create/post.quote.create/post.repost.create/like.create/mute.mute/mute.unmute/block.block/block.unblock), filter: map{direction: str, keyword: str, qualifiers: map, user_id: str}}
@optional {tag: str, webhook_id: str}
@returns(200) {data: map{subscription: map{created_at: str, event_type: str, filter: map{direction: str, keyword: str, qualifiers: map, user_id: str}, subscription_id: str, tag: str, updated_at: str, webhook_id: str}}, errors: [any]}

@endpoint DELETE /2/activity/subscriptions/{subscription_id}
@required {subscription_id: str}
@returns(200) {data: map{deleted: bool}, errors: [any]}

@endpoint PUT /2/activity/subscriptions/{subscription_id}
@required {subscription_id: str}
@optional {tag: str, webhook_id: str}
@returns(200) {data: map{subscription: map{created_at: str, event_type: str, filter: map{direction: str, keyword: str, qualifiers: map, user_id: str}, subscription_id: str, tag: str, updated_at: str, webhook_id: str}, total_subscriptions: int}, errors: [any]}

@endpoint POST /2/articles/draft
@required {content_state: map{blocks!: [map], entities!: [map]}, title: str}
@optional {cover_media: map{media_category!: str, media_id!: str}}
@returns(201) {data: map{id: str, title: str}, errors: [any]}

@endpoint POST /2/articles/{article_id}/publish
@required {article_id: str}
@returns(200) {data: map{post_id: str}, errors: [any]}

@endpoint GET /2/bots
@optional {user.fields: [str], expansions: [str], post.fields: [str]}
@returns(200) {data: [map], errors: [any], includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}, meta: map{max_bots: int, result_count: int(int32)}}

@endpoint POST /2/bots
@required {handle: str}
@optional {display_name: str, scopes: [str]}
@returns(201) {data: map{id: str, name: str, scopes: [str], token: str, token_expires_at_ms: int, username: str}, errors: [any]}

@endpoint DELETE /2/bots/{id}
@required {id: str}
@returns(200) {data: map{deleted: bool}, errors: [any]}

@endpoint PUT /2/bots/{id}
@required {id: str}
@optional {display_name: str, dm_permission: str(everyone/premium/no_one), handle: str}
@returns(200) {data: map{updated: bool}, errors: [any]}

@endpoint DELETE /2/bots/{id}/token
@required {id: str}
@returns(200) {data: map{revoked: bool}, errors: [any]}

@endpoint POST /2/bots/{id}/token
@required {id: str}
@optional {scopes: [str]}
@returns(200) {data: map{id: str, name: str, scopes: [str], token: str, token_expires_at_ms: int, username: str}, errors: [any]}

@endpoint GET /2/broadcasts
@optional {ids: [str], max_results: int(int32), pagination_token: str, broadcast.fields: [str]}
@returns(200) {data: [map], errors: [any], meta: map{next_token: str, result_count: int(int32)}}

@endpoint GET /2/broadcasts/chat/moderators
@optional {user.fields: [str], expansions: [str], post.fields: [str]}
@returns(200) {data: [map], errors: [any], includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}, meta: map{result_count: int(int32)}}

@endpoint POST /2/broadcasts/chat/moderators
@required {user_id: str}
@returns(200) {data: map{moderator_user_ids: [str]}, errors: [any]}

@endpoint DELETE /2/broadcasts/chat/moderators/{user_id}
@required {user_id: str}
@returns(200) {data: map{moderator_user_ids: [str]}, errors: [any]}

@endpoint GET /2/broadcasts/scheduled
@optional {max_results: int(int32), oldest_start_time: str, newest_start_time: str, pagination_token: str}
@returns(200) {data: [map], errors: [any]}

@endpoint POST /2/broadcasts/scheduled
@required {scheduled_start_ms: str, source_id: str}
@optional {available_for_replay: bool, chat_option: str, description: str, is_locked: bool, locale: str, manual_publish: bool, recurrence: map{frequency!: str, repeats!: str}, scheduled_end_ms: str, telecast_id: str, thumbnail_media_id: str, title: str}
@returns(201) {data: map{available_for_replay: bool, broadcast_id: str, chat_option: str, description: str, locale: str, manual_publish: bool, recurring_schedule_id: str, scheduled_broadcast_id: str, scheduled_end_ms: str, scheduled_start_ms: str, source_id: str, state: str, telecast_id: str, thumbnail_media_id: str, title: str}, errors: [any]}

@endpoint DELETE /2/broadcasts/scheduled/{id}
@required {id: str}
@optional {roll_forward: bool}
@returns(200) {data: map{deleted: bool}, errors: [any]}

@endpoint GET /2/broadcasts/scheduled/{id}
@required {id: str}
@returns(200) {data: map{available_for_replay: bool, broadcast_id: str, chat_option: str, description: str, locale: str, manual_publish: bool, recurring_schedule_id: str, scheduled_broadcast_id: str, scheduled_end_ms: str, scheduled_start_ms: str, source_id: str, state: str, telecast_id: str, thumbnail_media_id: str, title: str}, errors: [any]}

@endpoint PUT /2/broadcasts/scheduled/{id}
@required {id: str, scheduled_broadcast_id: str, scheduled_end_ms: str, scheduled_start_ms: str}
@optional {available_for_replay: bool, chat_option: str, description: str, is_locked: bool, locale: str, manual_publish: bool, roll_forward: bool, source_id: str, thumbnail_media_id: str, title: str}
@returns(200) {data: map{available_for_replay: bool, broadcast_id: str, chat_option: str, description: str, locale: str, manual_publish: bool, recurring_schedule_id: str, scheduled_broadcast_id: str, scheduled_end_ms: str, scheduled_start_ms: str, source_id: str, state: str, telecast_id: str, thumbnail_media_id: str, title: str}, errors: [any]}

@endpoint POST /2/broadcasts/scheduled/{id}/live
@required {id: str}
@returns(200) {data: map{available_for_replay: bool, broadcast_id: str, chat_option: str, description: str, locale: str, manual_publish: bool, recurring_schedule_id: str, scheduled_broadcast_id: str, scheduled_end_ms: str, scheduled_start_ms: str, source_id: str, state: str, telecast_id: str, thumbnail_media_id: str, title: str}, errors: [any]}

@endpoint GET /2/broadcasts/{id}
@required {id: str}
@optional {broadcast.fields: [str]}
@returns(200) {data: map{available_for_replay: bool, broadcast_id: str, chat_option: int, created_at_ms: str, end_ms: str, height: int, id: str, image_url: str, image_url_medium: str, image_url_small: str, is_high_latency: bool, language: str, media_key: str, scheduled_end_ms: str, scheduled_start_ms: str, share_url: str, source_id: str, start_ms: str, state: str, title: str, total_watched: str, total_watching: str, tweet_id: str, twitter_user_id: str, updated_at_ms: str, width: int}, errors: [any]}

@endpoint GET /2/broadcasts/{id}/chat
@required {id: str}
@optional {max_results: int(int32)=100, pagination_token: str, broadcast_chat_message.fields: [str], expansions: [str], user.fields: [str]}
@returns(200) {data: [map], errors: [any], includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}, meta: map{next_token: str, result_count: int(int32)}}

@endpoint POST /2/broadcasts/{id}/chat
@required {id: str, text: str}
@optional {reply_to: str}
@returns(200) {data: map{success: bool, timestamp: str}, errors: [any]}

@endpoint POST /2/broadcasts/{id}/chat/mutes
@required {id: str, user_id: str}
@optional {end_at_ms: str, message_id: str}
@returns(200) {data: map{muted: bool}, errors: [any]}

@endpoint DELETE /2/broadcasts/{id}/chat/mutes/{user_id}
@required {id: str, user_id: str}
@returns(200) {data: map{muted: bool}, errors: [any]}

@endpoint DELETE /2/broadcasts/{id}/chat/{message_id}
@required {id: str, message_id: str}
@returns(200) {data: map{deleted: bool}, errors: [any]}

@endpoint GET /2/chat/conversations
@optional {max_results: int(int32)=10, pagination_token: str, chat_conversation.fields: [str], expansions: [str], user.fields: [str]}
@returns(200) {data: [map], errors: [any], includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}, meta: map{has_message_requests: bool, has_more: bool, next_token: str, result_count: int(int32)}}

@endpoint POST /2/chat/conversations/group
@required {conversation_id: str, conversation_key_version: str, conversation_participant_keys: [map{encrypted_conversation_key: str, public_key_version: str, user_id: str}], group_members: [str]}
@optional {action_signatures: [map{encoded_message_event_detail!: str, message_event_signature!: map, message_id!: str, signature_payload: str}], base64_encoded_key_rotation: str, group_admins: [str], group_avatar_url: str, group_description: str, group_name: str, ttl_msec: str}
@returns(201) {data: map{conversation_id: str, conversation_key_change_sequence_id: str}, errors: [any]}

@endpoint POST /2/chat/conversations/group/initialize
@returns(200) {data: map{conversation_id: str}, errors: [any]}

@endpoint GET /2/chat/conversations/{id}
@required {id: str}
@optional {chat_conversation.fields: [str], expansions: [str], user.fields: [str]}
@returns(200) {data: map{admin_ids: [str], created_at: str(date-time), group_avatar_url: str, group_name: str, id: str, is_muted: bool, member_ids: [str], message_ttl_ms: int, participant_ids: [str], screen_capture_blocking_enabled: bool, screen_capture_detection_enabled: bool, type: str, updated_at: str(date-time)}, errors: [any], includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}}

@endpoint GET /2/chat/conversations/{id}/events
@required {id: str}
@optional {max_results: int(int32)=10, pagination_token: str, chat_message_event.fields: [str]}
@returns(200) {data: [map], errors: [any], meta: map{conversation_key_events: [str], has_more: bool, next_token: str, result_count: int(int32)}}

@endpoint POST /2/chat/conversations/{id}/keys
@required {id: str, conversation_key_version: str, conversation_participant_keys: [map{encrypted_conversation_key: str, public_key_version: str, user_id: str}]}
@optional {action_signatures: [map{encoded_message_event_detail!: str, message_event_signature!: map, message_id!: str, signature_payload: str}], base64_encoded_key_rotation: str}
@returns(200) {data: map{conversation_id: str, sequence_id: str}, errors: [any]}

@endpoint POST /2/chat/conversations/{id}/members
@required {id: str, user_ids: [str]}
@optional {action_signatures: [map{encoded_message_event_detail!: str, message_event_signature!: map, message_id!: str, signature_payload: str}], conversation_key_version: str, conversation_participant_keys: [map{encrypted_conversation_key: str, public_key_version: str, user_id: str}], encrypted_avatar_url: str, encrypted_title: str}
@returns(200) {data: map{article: map, article_title: map, attachments: map{media_keys: [str]?, media_source_tweet_id: [str]?, poll_ids: [str]?}, author_id: str, card_uri: str, community_id: str, context_annotations: [map], conversation_id: str, created_at: str(date-time), display_text_range: [int(int64)], edit_controls: map{editable_until: str?, edits_remaining: int(int64)?, is_edit_eligible: bool?}, edit_history_post_ids: [str], entities: map{cashtags: [map]?, hashtags: [map]?, mentions: [map]?, urls: [map]?}, geo: map{coordinates: map?{coordinates: [num(double)], type: str}, place_id: str?}, id: str, in_reply_to_user_id: str, lang: str, matched_media_notes: [map], media_metadata: [map], non_public_metrics: map, note_post: map{entities: map?{cashtags: [map]?, hashtags: [map]?, mentions: [map]?, urls: [map]?}, text: str}, note_request_suggestions: [map], organic_metrics: map, paid_partnership: bool, possibly_sensitive: bool, promoted_metrics: map, public_metrics: map{bookmark_count: int(int64), impression_count: int(int64), like_count: int(int64), quote_count: int(int64), reply_count: int(int64), repost_count: int(int64)}, referenced_posts: [map], reply_settings: str, scopes: map{followers: bool}, source: str, suggested_source_links: [str], suggested_source_links_with_counts: [map], text: str, username: str, withheld: map{copyright: bool, country_codes: [str], scope: str?}}, errors: [any]}

@endpoint POST /2/chat/conversations/{id}/messages
@required {id: str, encoded_message_create_event: str, message_id: str}
@optional {conversation_token: str, encoded_message_event_signature: str}
@returns(201) {data: map{encoded_message_event: str}, errors: [any]}

@endpoint POST /2/chat/conversations/{id}/messages/delete
@required {id: str, action_signatures: [map{encoded_message_event_detail!: str, message_event_signature!: map, message_id!: str, signature_payload: str}], delete_message_action: str(delete_for_all/delete_for_self), sequence_ids: [str]}
@optional {media_hash_keys: [str]}
@returns(200) {data: map{deleted: bool}, errors: [any]}

@endpoint POST /2/chat/conversations/{id}/read
@required {id: str, seen_until_sequence_id: str}
@returns(200) {data: map{success: bool}, errors: [any]}

@endpoint POST /2/chat/conversations/{id}/typing
@required {id: str}
@returns(200) {data: map{success: bool}, errors: [any]}

@endpoint POST /2/chat/media/upload/initialize
@required {conversation_id: str, total_bytes: int}
@returns(200) {data: map{conversation_id: str, media_hash_key: str, session_id: str}, errors: [any]}

@endpoint POST /2/chat/media/upload/{id}/append
@required {id: str, conversation_id: str, media: any, media_hash_key: str, segment_index: int}
@returns(200) {data: map{expires_at: int}, errors: [any]}

@endpoint POST /2/chat/media/upload/{id}/finalize
@required {id: str, conversation_id: str, media_hash_key: str, num_parts: str}
@optional {message_id: str, ttl_msec: str}
@returns(200) {data: map{success: bool}, errors: [any]}

@endpoint GET /2/chat/media/{id}/{media_hash_key}
@required {id: str, media_hash_key: str}
@returns(200)

@endpoint GET /2/communities/search
@required {query: str}
@optional {max_results: int(int32)=10, next_token: str, pagination_token: str, community.fields: [str]}
@returns(200) {data: [map], errors: [any], meta: map{next_token: str}}

@endpoint GET /2/communities/{id}
@required {id: str}
@optional {community.fields: [str]}
@returns(200) {data: map{access: str, created_at: str, description: str, id: str, join_policy: str, member_count: int, name: str}, errors: [any]}

@endpoint GET /2/compliance/jobs
@required {type: str(tweets/users)}
@optional {status: str(created/in_progress/failed/complete), compliance_job.fields: [str]}
@returns(200) {data: [map], errors: [any], meta: map{result_count: int(int32)}}

@endpoint POST /2/compliance/jobs
@required {type: str(tweets/users)}
@optional {compliance_job.fields: [str], name: str, resumable: bool}
@returns(200) {data: map{created_at: str, download_expires_at: str, download_url: str, id: str, name: str, resumable: bool, status: str, type: str, upload_expires_at: str, upload_url: str}, errors: [any]}

@endpoint DELETE /2/compliance/jobs/{id}
@required {id: str}
@optional {compliance_job.fields: [str]}
@returns(200) {data: map{created_at: str, download_expires_at: str, download_url: str, id: str, name: str, resumable: bool, status: str, type: str, upload_expires_at: str, upload_url: str}, errors: [any]}

@endpoint GET /2/compliance/jobs/{id}
@required {id: str}
@optional {compliance_job.fields: [str]}
@returns(200) {data: map{created_at: str, download_expires_at: str, download_url: str, id: str, name: str, resumable: bool, status: str, type: str, upload_expires_at: str, upload_url: str}, errors: [any]}

@endpoint GET /2/compliance/jobs/{id}/download
@required {id: str, token: str}
@optional {compliance_job.fields: [str]}
@returns(200)

@endpoint PUT /2/compliance/jobs/{id}/upload
@required {id: str, token: str}
@optional {compliance_job.fields: [str]}
@returns(200) {data: map{created_at: str, download_expires_at: str, download_url: str, id: str, name: str, resumable: bool, status: str, type: str, upload_expires_at: str, upload_url: str}, errors: [any]}

@endpoint DELETE /2/connections
@required {uuids: [str]}
@returns(200) {data: map{failed_kills: int, results: [map], successful_kills: int}, errors: [any]}

@endpoint GET /2/connections
@optional {status: str(active/inactive/all)=active, endpoints: [str], max_results: int(int32)=10, pagination_token: str, connection.fields: [str]}
@returns(200) {data: [map], errors: [any], meta: map{next_token: str, result_count: int(int32)}}

@endpoint DELETE /2/connections/all
@returns(200) {data: map{failed_kills: int, results: [map], successful_kills: int}, errors: [any]}

@endpoint DELETE /2/connections/{endpoint_id}
@required {endpoint_id: str(filtered_stream/sample_stream/sample10_stream/firehose_stream/tweets_compliance_stream/users_compliance_stream/tweet_label_stream/firehose_stream_lang_en/firehose_stream_lang_ja/firehose_stream_lang_ko/firehose_stream_lang_pt/likes_firehose_stream/likes_sample10_stream/likes_compliance_stream)}
@returns(200) {data: map{failed_kills: int, results: [map], successful_kills: int}, errors: [any]}

@endpoint POST /2/dm_conversations
@required {conversation_type: str, message: map{attachments: [map], text: str}, participant_ids: [str]}
@returns(201) {data: map{dm_conversation_id: str, dm_event_id: str}, errors: [any]}

@endpoint GET /2/dm_conversations/media/{dm_id}/{media_id}/{resource_id}
@required {dm_id: str, media_id: str, resource_id: str}
@returns(200)

@endpoint GET /2/dm_conversations/with/{participant_id}/dm_events
@required {participant_id: str}
@optional {max_results: int(int32)=100, pagination_token: str, event_types: [str]=MessageCreate,ParticipantsLeave,ParticipantsJoin, dm_event.fields: [str], expansions: [str], user.fields: [str], post.fields: [str], media.fields: [str]}
@returns(200) {data: [map], errors: [any], includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}, meta: map{next_token: str, previous_token: str, result_count: int(int32)}}

@endpoint POST /2/dm_conversations/with/{participant_id}/messages
@required {participant_id: str}
@optional {attachments: [map{media_id!: str}], text: str}
@returns(201) {data: map{dm_conversation_id: str, dm_event_id: str}, errors: [any]}

@endpoint POST /2/dm_conversations/{dm_conversation_id}/messages
@required {dm_conversation_id: str}
@optional {attachments: [map{media_id!: str}], text: str}
@returns(201) {data: map{dm_conversation_id: str, dm_event_id: str}, errors: [any]}

@endpoint GET /2/dm_conversations/{id}/dm_events
@required {id: str}
@optional {max_results: int(int32)=100, pagination_token: str, event_types: [str]=MessageCreate,ParticipantsLeave,ParticipantsJoin, dm_event.fields: [str], expansions: [str], user.fields: [str], post.fields: [str], media.fields: [str]}
@returns(200) {data: [map], errors: [any], includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}, meta: map{next_token: str, previous_token: str, result_count: int(int32)}}

@endpoint GET /2/dm_events
@optional {max_results: int(int32)=100, pagination_token: str, event_types: [str]=MessageCreate,ParticipantsLeave,ParticipantsJoin, dm_event.fields: [str], expansions: [str], user.fields: [str], post.fields: [str], media.fields: [str]}
@returns(200) {data: [map], errors: [any], includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}, meta: map{next_token: str, previous_token: str, result_count: int(int32)}}

@endpoint DELETE /2/dm_events/{event_id}
@required {event_id: str}
@returns(200) {data: map{deleted: bool}, errors: [any]}

@endpoint GET /2/dm_events/{event_id}
@required {event_id: str}
@optional {dm_event.fields: [str], expansions: [str], user.fields: [str], post.fields: [str], media.fields: [str]}
@returns(200) {data: map{attachments: map{card_ids: [str]?, media_keys: [str]?}, created_at: str(date-time), dm_conversation_id: str, entities: map{cashtags: [map]?, hashtags: [map]?, mentions: [map]?, urls: [map]?}, event_type: str, id: str, participant_ids: [str], referenced_posts: [map], sender_id: str, text: str}, errors: [any], includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}}

@endpoint GET /2/likes/compliance/stream
@optional {backfill_minutes: int(int32), start_time: str(date-time), end_time: str(date-time)}
@returns(200)

@endpoint GET /2/likes/firehose/stream
@required {partition: int(int32)}
@optional {backfill_minutes: int(int32), start_time: str(date-time), end_time: str(date-time), like_with_tweet_author.fields: [str], expansions: [str], media.fields: [str], user.fields: [str], tweet.fields: [str]}
@returns(200) {data: map{created_at: str(date-time), id: str, liked_tweet_id: str, timestamp_ms: int(int32), tweet_author_id: str}, errors: [any], includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}}

@endpoint GET /2/likes/sample10/stream
@required {partition: int(int32)}
@optional {backfill_minutes: int(int32), start_time: str(date-time), end_time: str(date-time), like_with_tweet_author.fields: [str], expansions: [str], media.fields: [str], user.fields: [str], tweet.fields: [str]}
@returns(200) {data: map{created_at: str(date-time), id: str, liked_tweet_id: str, timestamp_ms: int(int32), tweet_author_id: str}, errors: [any], includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}}

@endpoint POST /2/lists
@required {name: str}
@optional {description: str, private: bool}
@returns(201) {data: map{id: str, name: str}, errors: [any]}

@endpoint DELETE /2/lists/{id}
@required {id: str}
@returns(200) {data: map{deleted: bool}, errors: [any]}

@endpoint GET /2/lists/{id}
@required {id: str}
@optional {list.fields: [str], expansions: [str], user.fields: [str]}
@returns(200) {data: map{created_at: str, description: str, follower_count: int(int64), id: str, member_count: int(int64), name: str, owner_id: str, private: bool}, errors: [any], includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}}

@endpoint PUT /2/lists/{id}
@required {id: str}
@optional {description: str, name: str, private: bool}
@returns(200) {data: map{updated: bool}, errors: [any]}

@endpoint GET /2/lists/{id}/followers
@required {id: str}
@optional {max_results: int(int32)=100, pagination_token: str, user.fields: [str], expansions: [str], post.fields: [str]}
@returns(200) {data: [map], errors: [any], includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}, meta: map{next_token: str, previous_token: str, result_count: int(int32)}}

@endpoint GET /2/lists/{id}/members
@required {id: str}
@optional {max_results: int(int32)=100, pagination_token: str, user.fields: [str], expansions: [str], post.fields: [str]}
@returns(200) {data: [map], errors: [any], includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}, meta: map{next_token: str, previous_token: str, result_count: int(int32)}}

@endpoint POST /2/lists/{id}/members
@required {id: str, user_id: str}
@returns(200) {data: map{is_member: bool}, errors: [any]}

@endpoint DELETE /2/lists/{id}/members/{user_id}
@required {id: str, user_id: str}
@returns(200) {data: map{is_member: bool}, errors: [any]}

@endpoint GET /2/lists/{id}/tweets
@required {id: str}
@optional {max_results: int(int32)=100, pagination_token: str, post.fields: [str], expansions: [str], user.fields: [str], media.fields: [str], poll.fields: [str], place.fields: [str]}
@returns(200) {data: [map], errors: [any], includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}, meta: map{next_token: str, previous_token: str, result_count: int(int32)}}

@endpoint GET /2/media
@required {media_keys: [str]}
@optional {media.fields: [str]}
@returns(200) {data: [map], errors: [any]}

@endpoint GET /2/media/analytics
@required {media_keys: [str], start_time: str(date-time), end_time: str(date-time)}
@optional {granularity: str(hourly/daily/total)=daily, media_analytics.fields: [str]}
@returns(200) {data: [map], errors: [any]}

@endpoint POST /2/media/metadata
@required {id: str}
@optional {metadata: map{allow_download_status: map, alt_text: map, audience_policy: map, content_expiration: map, domain_restrictions: map, found_media_origin: map, geo_restrictions: map, management_info: map, preview_image: map, sensitive_media_warning: map, shared_info: map, sticker_info: map, upload_source: map}}
@returns(200) {data: map{associated_metadata: map, id: str}, errors: [any]}

@endpoint DELETE /2/media/subtitles
@required {id: str, language_code: str, media_category: str}
@returns(200) {data: map{deleted: bool}, errors: [any]}

@endpoint POST /2/media/subtitles
@optional {id: str, media_category: str(AmplifyVideo/TweetVideo), subtitles: map{display_name: str, id: str, language_code: str}}
@returns(200) {data: map{associated_subtitles: map, id: str, media_category: str}, errors: [any]}

@endpoint GET /2/media/upload
@required {media_id: str}
@optional {command: str}
@returns(200) {data: map{expires_after_secs: int, id: str, image: map{h: int, image_type: str, w: int}, media_key: str, processing_info: map{check_after_secs: int, progress_percent: int, state: str}, size: int, video: map{video_type: str}}, errors: [any]}

@endpoint POST /2/media/upload
@required {media: any, media_category: str(tweet_image/tweet_video/tweet_gif/dm_image/dm_video/dm_gif/subtitles)}
@optional {additional_owners: str}
@returns(200) {data: map{expires_after_secs: int, id: str, image: map{h: int, image_type: str, w: int}, media_key: str, processing_info: map{check_after_secs: int, progress_percent: int, state: str}, size: int, video: map{video_type: str}}, errors: [any]}

@endpoint POST /2/media/upload/initialize
@optional {additional_owners: [str], media_category: str(amplify_video/tweet_gif/tweet_image/tweet_video/dm_gif/dm_image/dm_video/subtitles), media_type: str(video/mp4/video/webm/video/mp2t/video/quicktime/text/srt/text/vtt/image/jpeg/image/gif/image/bmp/image/png/image/webp/image/pjpeg/image/tiff/model/gltf-binary/model/vnd.usdz+zip), shared: bool, total_bytes: int}
@returns(200) {data: map{expires_after_secs: int, id: str, media_key: str}, errors: [any]}

@endpoint POST /2/media/upload/{id}/append
@required {id: str, media: any, segment_index: int}
@returns(200) {data: map{expires_at: int}, errors: [any]}

@endpoint POST /2/media/upload/{id}/finalize
@required {id: str}
@returns(200) {data: map{expires_after_secs: int, id: str, image: map{h: int, image_type: str, w: int}, media_key: str, processing_info: map{check_after_secs: int, progress_percent: int, state: str}, size: int, video: map{video_type: str}}, errors: [any]}

@endpoint GET /2/media/{media_key}
@required {media_key: str}
@optional {media.fields: [str]}
@returns(200) {data: map{alt_text: str, duration_ms: int, height: int, media_key: str, non_public_metrics: map{playback_0_count: int(int64)?, playback_100_count: int(int64)?, playback_25_count: int(int64)?, playback_50_count: int(int64)?, playback_75_count: int(int64)?}, organic_metrics: map{playback_0_count: int(int64)?, playback_100_count: int(int64)?, playback_25_count: int(int64)?, playback_50_count: int(int64)?, playback_75_count: int(int64)?, view_count: int(int64)?}, preview_image_url: str, promoted_metrics: map{playback_0_count: int(int64)?, playback_100_count: int(int64)?, playback_25_count: int(int64)?, playback_50_count: int(int64)?, playback_75_count: int(int64)?, view_count: int(int64)?}, public_metrics: map{view_count: int(int64)}, type: str, url: str, variants: [map], width: int}, errors: [any]}

@endpoint GET /2/news/search
@required {query: str}
@optional {max_results: int(int32)=10, max_age_hours: int(int32)=168, news.fields: [str]}
@returns(200) {data: [map], errors: [any], meta: map{result_count: int(int32)}}

@endpoint GET /2/news/{id}
@required {id: str}
@optional {news.fields: [str]}
@returns(200) {data: map{category: str, cluster_posts_results: [map], contexts: map, disclaimer: str, hook: str, id: str, keywords: map, name: str, summary: str, updated_at: str}, errors: [any]}

@endpoint POST /2/notes
@required {info: map{classification!: str, is_media_note: bool, misleading_tags!: [str], text!: str, trustworthy_sources!: bool}, post_id: str, test_mode: bool}
@returns(201) {data: map{id: str}, errors: [any]}

@endpoint POST /2/notes/evaluate
@required {note_text: str, post_id: str}
@returns(200) {data: map{claim_opinion_score: num}, errors: [any]}

@endpoint GET /2/notes/search/notes_written
@required {test_mode: bool}
@optional {max_results: int(int32)=10, pagination_token: str, note.fields: [str]}
@returns(200) {data: [map], errors: [any], meta: map{next_token: str, result_count: int(int32)}}

@endpoint GET /2/notes/search/posts_eligible_for_notes
@required {test_mode: bool}
@optional {max_results: int(int32)=10, pagination_token: str, post_selection: str, post.fields: [str], expansions: [str], user.fields: [str], media.fields: [str], poll.fields: [str], place.fields: [str]}
@returns(200) {data: [map], errors: [any], includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}, meta: map{next_token: str, result_count: int(int32)}}

@endpoint DELETE /2/notes/{id}
@required {id: str}
@returns(200) {data: map{deleted: bool}, errors: [any]}

@endpoint GET /2/openapi.json
@returns(200)

@endpoint GET /2/spaces
@required {ids: [str]}
@optional {space.fields: [str], expansions: [str], user.fields: [str], topic.fields: [str]}
@returns(200) {data: [map], errors: [any], includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}}

@endpoint GET /2/spaces/by/creator_ids
@required {user_ids: [str]}
@optional {space.fields: [str], expansions: [str], user.fields: [str], topic.fields: [str]}
@returns(200) {data: [map], errors: [any], includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}, meta: map{result_count: int(int32)}}

@endpoint GET /2/spaces/search
@required {query: str}
@optional {state: str(live/scheduled/all)=all, max_results: int(int32)=100, space.fields: [str], expansions: [str], user.fields: [str], topic.fields: [str]}
@returns(200) {data: [map], errors: [any], includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}, meta: map{result_count: int(int32)}}

@endpoint GET /2/spaces/{id}
@required {id: str}
@optional {space.fields: [str], expansions: [str], user.fields: [str], topic.fields: [str]}
@returns(200) {data: map{created_at: str(date-time), creator_id: str, ended_at: str(date-time), host_ids: [str], id: str, invited_user_ids: [str], is_ticketed: bool, lang: str, participant_count: int, scheduled_start: str(date-time), speaker_ids: [str], started_at: str(date-time), state: str, subscriber_count: int, title: str, topic_ids: [str], updated_at: str(date-time)}, errors: [any], includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}}

@endpoint GET /2/spaces/{id}/buyers
@required {id: str}
@optional {max_results: int(int32)=100, pagination_token: str, user.fields: [str], expansions: [str], post.fields: [str]}
@returns(200) {data: [map], errors: [any], includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}, meta: map{next_token: str, previous_token: str, result_count: int(int32)}}

@endpoint GET /2/spaces/{id}/tweets
@required {id: str}
@optional {max_results: int(int32)=100, pagination_token: str, post.fields: [str], expansions: [str], user.fields: [str], media.fields: [str], poll.fields: [str], place.fields: [str]}
@returns(200) {data: [map], errors: [any], includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}, meta: map{next_token: str, previous_token: str, result_count: int(int32)}}

@endpoint GET /2/trends/by/woeid/{woeid}
@required {woeid: int(int32)}
@optional {max_trends: int(int32)=20, trend.fields: [str]}
@returns(200) {data: [map], errors: [any]}

@endpoint GET /2/tweets
@required {ids: [str]}
@optional {post.fields: [str], expansions: [str], user.fields: [str], media.fields: [str], poll.fields: [str], place.fields: [str]}
@returns(200) {data: [map], errors: [any], includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}, meta: map{result_count: int(int32)}}

@endpoint POST /2/tweets
@optional {card_uri: str, community_id: str, direct_message_deep_link: str, edit_options: map{previous_post_id!: str}, for_super_followers_only: bool, geo: map{place_id!: str}, made_with_ai: bool, media: map{call_to_actions: map, description: str, embeddable: bool, media_ids!: [str], preview_media_id: str, tagged_user_ids: [str], title: str}, nullcast: bool, paid_partnership: bool, poll: map{duration_minutes!: int, options!: [str], reply_settings: str}, quote_tweet_id: str, reply: map{auto_populate_reply_metadata: bool, exclude_reply_user_ids: [str], in_reply_to_tweet_id!: str}, reply_settings: str(following/mentionedUsers/subscribers/verified), share_with_followers: bool, text: str=}
@returns(201) {data: map{edit_history_post_ids: [str], id: str, text: str}, errors: [any]}

@endpoint GET /2/tweets/analytics
@required {ids: [str], start_time: str(date-time), end_time: str(date-time)}
@optional {granularity: str(hourly/weekly/daily/total)=total, analytics.fields: [str]}
@returns(200) {data: [map], errors: [any]}

@endpoint GET /2/tweets/compliance/stream
@required {partition: int(int32)}
@optional {backfill_minutes: int(int32), start_time: str(date-time), end_time: str(date-time)}
@returns(200)

@endpoint GET /2/tweets/counts/all
@required {query: str}
@optional {start_time: str(date-time), end_time: str(date-time), since_id: str, until_id: str, next_token: str, pagination_token: str, granularity: str(minute/hour/day)=hour, search_count.fields: str}
@returns(200) {data: [map], errors: [any], meta: map{next_token: str, total_post_count: int(int64)}}

@endpoint GET /2/tweets/counts/recent
@required {query: str}
@optional {start_time: str(date-time), end_time: str(date-time), since_id: str, until_id: str, next_token: str, pagination_token: str, granularity: str(minute/hour/day)=hour, search_count.fields: str}
@returns(200) {data: [map], errors: [any], meta: map{next_token: str, total_post_count: int(int64)}}

@endpoint GET /2/tweets/firehose/stream
@required {partition: int(int32)}
@optional {backfill_minutes: int(int32), tweet.fields: [str], expansions: [str], media.fields: [str], poll.fields: [str], user.fields: [str], place.fields: [str], start_time: str(date-time), end_time: str(date-time)}
@returns(200) {data: map{article: map, article_title: map, attachments: map{media_keys: [str]?, media_source_tweet_id: [str]?, poll_ids: [str]?}, author_id: str, card_uri: str, community_id: str, context_annotations: [map], conversation_id: str, created_at: str(date-time), display_text_range: [int(int64)], edit_controls: map{editable_until: str?, edits_remaining: int(int64)?, is_edit_eligible: bool?}, edit_history_post_ids: [str], entities: map{cashtags: [map]?, hashtags: [map]?, mentions: [map]?, urls: [map]?}, geo: map{coordinates: map?{coordinates: [num(double)], type: str}, place_id: str?}, id: str, in_reply_to_user_id: str, lang: str, matched_media_notes: [map], media_metadata: [map], non_public_metrics: map, note_post: map{entities: map?{cashtags: [map]?, hashtags: [map]?, mentions: [map]?, urls: [map]?}, text: str}, note_request_suggestions: [map], organic_metrics: map, paid_partnership: bool, possibly_sensitive: bool, promoted_metrics: map, public_metrics: map{bookmark_count: int(int64), impression_count: int(int64), like_count: int(int64), quote_count: int(int64), reply_count: int(int64), repost_count: int(int64)}, referenced_posts: [map], reply_settings: str, scopes: map{followers: bool}, source: str, suggested_source_links: [str], suggested_source_links_with_counts: [map], text: str, username: str, withheld: map{copyright: bool, country_codes: [str], scope: str?}}, errors: [any], includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}}

@endpoint GET /2/tweets/firehose/stream/lang/en
@required {partition: int(int32)}
@optional {backfill_minutes: int(int32), tweet.fields: [str], expansions: [str], media.fields: [str], poll.fields: [str], user.fields: [str], place.fields: [str], start_time: str(date-time), end_time: str(date-time)}
@returns(200) {data: map{article: map, article_title: map, attachments: map{media_keys: [str]?, media_source_tweet_id: [str]?, poll_ids: [str]?}, author_id: str, card_uri: str, community_id: str, context_annotations: [map], conversation_id: str, created_at: str(date-time), display_text_range: [int(int64)], edit_controls: map{editable_until: str?, edits_remaining: int(int64)?, is_edit_eligible: bool?}, edit_history_post_ids: [str], entities: map{cashtags: [map]?, hashtags: [map]?, mentions: [map]?, urls: [map]?}, geo: map{coordinates: map?{coordinates: [num(double)], type: str}, place_id: str?}, id: str, in_reply_to_user_id: str, lang: str, matched_media_notes: [map], media_metadata: [map], non_public_metrics: map, note_post: map{entities: map?{cashtags: [map]?, hashtags: [map]?, mentions: [map]?, urls: [map]?}, text: str}, note_request_suggestions: [map], organic_metrics: map, paid_partnership: bool, possibly_sensitive: bool, promoted_metrics: map, public_metrics: map{bookmark_count: int(int64), impression_count: int(int64), like_count: int(int64), quote_count: int(int64), reply_count: int(int64), repost_count: int(int64)}, referenced_posts: [map], reply_settings: str, scopes: map{followers: bool}, source: str, suggested_source_links: [str], suggested_source_links_with_counts: [map], text: str, username: str, withheld: map{copyright: bool, country_codes: [str], scope: str?}}, errors: [any], includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}}

@endpoint GET /2/tweets/firehose/stream/lang/ja
@required {partition: int(int32)}
@optional {backfill_minutes: int(int32), tweet.fields: [str], expansions: [str], media.fields: [str], poll.fields: [str], user.fields: [str], place.fields: [str], start_time: str(date-time), end_time: str(date-time)}
@returns(200) {data: map{article: map, article_title: map, attachments: map{media_keys: [str]?, media_source_tweet_id: [str]?, poll_ids: [str]?}, author_id: str, card_uri: str, community_id: str, context_annotations: [map], conversation_id: str, created_at: str(date-time), display_text_range: [int(int64)], edit_controls: map{editable_until: str?, edits_remaining: int(int64)?, is_edit_eligible: bool?}, edit_history_post_ids: [str], entities: map{cashtags: [map]?, hashtags: [map]?, mentions: [map]?, urls: [map]?}, geo: map{coordinates: map?{coordinates: [num(double)], type: str}, place_id: str?}, id: str, in_reply_to_user_id: str, lang: str, matched_media_notes: [map], media_metadata: [map], non_public_metrics: map, note_post: map{entities: map?{cashtags: [map]?, hashtags: [map]?, mentions: [map]?, urls: [map]?}, text: str}, note_request_suggestions: [map], organic_metrics: map, paid_partnership: bool, possibly_sensitive: bool, promoted_metrics: map, public_metrics: map{bookmark_count: int(int64), impression_count: int(int64), like_count: int(int64), quote_count: int(int64), reply_count: int(int64), repost_count: int(int64)}, referenced_posts: [map], reply_settings: str, scopes: map{followers: bool}, source: str, suggested_source_links: [str], suggested_source_links_with_counts: [map], text: str, username: str, withheld: map{copyright: bool, country_codes: [str], scope: str?}}, errors: [any], includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}}

@endpoint GET /2/tweets/firehose/stream/lang/ko
@required {partition: int(int32)}
@optional {backfill_minutes: int(int32), tweet.fields: [str], expansions: [str], media.fields: [str], poll.fields: [str], user.fields: [str], place.fields: [str], start_time: str(date-time), end_time: str(date-time)}
@returns(200) {data: map{article: map, article_title: map, attachments: map{media_keys: [str]?, media_source_tweet_id: [str]?, poll_ids: [str]?}, author_id: str, card_uri: str, community_id: str, context_annotations: [map], conversation_id: str, created_at: str(date-time), display_text_range: [int(int64)], edit_controls: map{editable_until: str?, edits_remaining: int(int64)?, is_edit_eligible: bool?}, edit_history_post_ids: [str], entities: map{cashtags: [map]?, hashtags: [map]?, mentions: [map]?, urls: [map]?}, geo: map{coordinates: map?{coordinates: [num(double)], type: str}, place_id: str?}, id: str, in_reply_to_user_id: str, lang: str, matched_media_notes: [map], media_metadata: [map], non_public_metrics: map, note_post: map{entities: map?{cashtags: [map]?, hashtags: [map]?, mentions: [map]?, urls: [map]?}, text: str}, note_request_suggestions: [map], organic_metrics: map, paid_partnership: bool, possibly_sensitive: bool, promoted_metrics: map, public_metrics: map{bookmark_count: int(int64), impression_count: int(int64), like_count: int(int64), quote_count: int(int64), reply_count: int(int64), repost_count: int(int64)}, referenced_posts: [map], reply_settings: str, scopes: map{followers: bool}, source: str, suggested_source_links: [str], suggested_source_links_with_counts: [map], text: str, username: str, withheld: map{copyright: bool, country_codes: [str], scope: str?}}, errors: [any], includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}}

@endpoint GET /2/tweets/firehose/stream/lang/pt
@required {partition: int(int32)}
@optional {backfill_minutes: int(int32), tweet.fields: [str], expansions: [str], media.fields: [str], poll.fields: [str], user.fields: [str], place.fields: [str], start_time: str(date-time), end_time: str(date-time)}
@returns(200) {data: map{article: map, article_title: map, attachments: map{media_keys: [str]?, media_source_tweet_id: [str]?, poll_ids: [str]?}, author_id: str, card_uri: str, community_id: str, context_annotations: [map], conversation_id: str, created_at: str(date-time), display_text_range: [int(int64)], edit_controls: map{editable_until: str?, edits_remaining: int(int64)?, is_edit_eligible: bool?}, edit_history_post_ids: [str], entities: map{cashtags: [map]?, hashtags: [map]?, mentions: [map]?, urls: [map]?}, geo: map{coordinates: map?{coordinates: [num(double)], type: str}, place_id: str?}, id: str, in_reply_to_user_id: str, lang: str, matched_media_notes: [map], media_metadata: [map], non_public_metrics: map, note_post: map{entities: map?{cashtags: [map]?, hashtags: [map]?, mentions: [map]?, urls: [map]?}, text: str}, note_request_suggestions: [map], organic_metrics: map, paid_partnership: bool, possibly_sensitive: bool, promoted_metrics: map, public_metrics: map{bookmark_count: int(int64), impression_count: int(int64), like_count: int(int64), quote_count: int(int64), reply_count: int(int64), repost_count: int(int64)}, referenced_posts: [map], reply_settings: str, scopes: map{followers: bool}, source: str, suggested_source_links: [str], suggested_source_links_with_counts: [map], text: str, username: str, withheld: map{copyright: bool, country_codes: [str], scope: str?}}, errors: [any], includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}}

@endpoint GET /2/tweets/label/stream
@optional {backfill_minutes: int(int32), start_time: str(date-time), end_time: str(date-time)}
@returns(200)

@endpoint GET /2/tweets/sample/stream
@optional {backfill_minutes: int(int32), tweet.fields: [str], expansions: [str], media.fields: [str], poll.fields: [str], user.fields: [str], place.fields: [str]}
@returns(200) {data: map{article: map, article_title: map, attachments: map{media_keys: [str]?, media_source_tweet_id: [str]?, poll_ids: [str]?}, author_id: str, card_uri: str, community_id: str, context_annotations: [map], conversation_id: str, created_at: str(date-time), display_text_range: [int(int64)], edit_controls: map{editable_until: str?, edits_remaining: int(int64)?, is_edit_eligible: bool?}, edit_history_post_ids: [str], entities: map{cashtags: [map]?, hashtags: [map]?, mentions: [map]?, urls: [map]?}, geo: map{coordinates: map?{coordinates: [num(double)], type: str}, place_id: str?}, id: str, in_reply_to_user_id: str, lang: str, matched_media_notes: [map], media_metadata: [map], non_public_metrics: map, note_post: map{entities: map?{cashtags: [map]?, hashtags: [map]?, mentions: [map]?, urls: [map]?}, text: str}, note_request_suggestions: [map], organic_metrics: map, paid_partnership: bool, possibly_sensitive: bool, promoted_metrics: map, public_metrics: map{bookmark_count: int(int64), impression_count: int(int64), like_count: int(int64), quote_count: int(int64), reply_count: int(int64), repost_count: int(int64)}, referenced_posts: [map], reply_settings: str, scopes: map{followers: bool}, source: str, suggested_source_links: [str], suggested_source_links_with_counts: [map], text: str, username: str, withheld: map{copyright: bool, country_codes: [str], scope: str?}}, errors: [any], includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}}

@endpoint GET /2/tweets/sample10/stream
@required {partition: int(int32)}
@optional {backfill_minutes: int(int32), tweet.fields: [str], expansions: [str], media.fields: [str], poll.fields: [str], user.fields: [str], place.fields: [str], start_time: str(date-time), end_time: str(date-time)}
@returns(200) {data: map{article: map, article_title: map, attachments: map{media_keys: [str]?, media_source_tweet_id: [str]?, poll_ids: [str]?}, author_id: str, card_uri: str, community_id: str, context_annotations: [map], conversation_id: str, created_at: str(date-time), display_text_range: [int(int64)], edit_controls: map{editable_until: str?, edits_remaining: int(int64)?, is_edit_eligible: bool?}, edit_history_post_ids: [str], entities: map{cashtags: [map]?, hashtags: [map]?, mentions: [map]?, urls: [map]?}, geo: map{coordinates: map?{coordinates: [num(double)], type: str}, place_id: str?}, id: str, in_reply_to_user_id: str, lang: str, matched_media_notes: [map], media_metadata: [map], non_public_metrics: map, note_post: map{entities: map?{cashtags: [map]?, hashtags: [map]?, mentions: [map]?, urls: [map]?}, text: str}, note_request_suggestions: [map], organic_metrics: map, paid_partnership: bool, possibly_sensitive: bool, promoted_metrics: map, public_metrics: map{bookmark_count: int(int64), impression_count: int(int64), like_count: int(int64), quote_count: int(int64), reply_count: int(int64), repost_count: int(int64)}, referenced_posts: [map], reply_settings: str, scopes: map{followers: bool}, source: str, suggested_source_links: [str], suggested_source_links_with_counts: [map], text: str, username: str, withheld: map{copyright: bool, country_codes: [str], scope: str?}}, errors: [any], includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}}

@endpoint GET /2/tweets/search/all
@required {query: str}
@optional {start_time: str(date-time), end_time: str(date-time), since_id: str, until_id: str, max_results: int(int32)=10, next_token: str, pagination_token: str, sort_order: str(recency/relevancy), post.fields: [str], expansions: [str], user.fields: [str], media.fields: [str], poll.fields: [str], place.fields: [str]}
@returns(200) {data: [map], errors: [any], includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}, meta: map{newest_id: str, next_token: str, oldest_id: str, previous_token: str, result_count: int(int32)}}

@endpoint GET /2/tweets/search/recent
@required {query: str}
@optional {max_results: int(int32)=10, next_token: str, pagination_token: str, start_time: str(date-time), end_time: str(date-time), since_id: str, until_id: str, sort_order: str(recency/relevancy), post.fields: [str], expansions: [str], user.fields: [str], media.fields: [str], poll.fields: [str], place.fields: [str]}
@returns(200) {data: [map], errors: [any], includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}, meta: map{newest_id: str, next_token: str, oldest_id: str, previous_token: str, result_count: int(int32)}}

@endpoint GET /2/tweets/search/stream
@optional {backfill_minutes: int(int32), start_time: str(date-time), end_time: str(date-time), tweet.fields: [str], expansions: [str], media.fields: [str], poll.fields: [str], user.fields: [str], place.fields: [str]}
@returns(200) {data: map{article: map, article_title: map, attachments: map{media_keys: [str]?, media_source_tweet_id: [str]?, poll_ids: [str]?}, author_id: str, card_uri: str, community_id: str, context_annotations: [map], conversation_id: str, created_at: str(date-time), display_text_range: [int(int64)], edit_controls: map{editable_until: str?, edits_remaining: int(int64)?, is_edit_eligible: bool?}, edit_history_post_ids: [str], entities: map{cashtags: [map]?, hashtags: [map]?, mentions: [map]?, urls: [map]?}, geo: map{coordinates: map?{coordinates: [num(double)], type: str}, place_id: str?}, id: str, in_reply_to_user_id: str, lang: str, matched_media_notes: [map], media_metadata: [map], non_public_metrics: map, note_post: map{entities: map?{cashtags: [map]?, hashtags: [map]?, mentions: [map]?, urls: [map]?}, text: str}, note_request_suggestions: [map], organic_metrics: map, paid_partnership: bool, possibly_sensitive: bool, promoted_metrics: map, public_metrics: map{bookmark_count: int(int64), impression_count: int(int64), like_count: int(int64), quote_count: int(int64), reply_count: int(int64), repost_count: int(int64)}, referenced_posts: [map], reply_settings: str, scopes: map{followers: bool}, source: str, suggested_source_links: [str], suggested_source_links_with_counts: [map], text: str, username: str, withheld: map{copyright: bool, country_codes: [str], scope: str?}}, errors: [any], includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}, matching_rules: [map]}

@endpoint GET /2/tweets/search/stream/rules
@optional {ids: [str], max_results: int(int32)=1000, pagination_token: str}
@returns(200) {data: [map], errors: [any], meta: map{next_token: str, result_count: int(int32)}}

@endpoint POST /2/tweets/search/stream/rules
@optional {dry_run: bool, delete_all: bool, add: [map{tag: str, value!: str}], delete: map{ids: [str], values: [str]}}
@returns(200) {data: [map], errors: [any], meta: map{sent: str, summary: map}}

@endpoint GET /2/tweets/search/stream/rules/counts
@optional {rules_count.fields: str}
@returns(200) {data: map{all_project_client_apps: [map], cap_per_client_app: str, cap_per_project: str, client_app_rules_count: map{client_app_id: str, rule_count: int}, project_rules_count: str}, errors: [any]}

@endpoint GET /2/tweets/search/webhooks
@returns(200) {data: [map], errors: [any]}

@endpoint DELETE /2/tweets/search/webhooks/{webhook_id}
@required {webhook_id: str}
@returns(200) {data: map{deleted: bool}, errors: [any]}

@endpoint POST /2/tweets/search/webhooks/{webhook_id}
@required {webhook_id: str}
@returns(200) {data: map{provisioned: bool}, errors: [any]}

@endpoint DELETE /2/tweets/{id}
@required {id: str}
@returns(200) {data: map{deleted: bool}, errors: [any]}

@endpoint GET /2/tweets/{id}
@required {id: str}
@optional {post.fields: [str], expansions: [str], user.fields: [str], media.fields: [str], poll.fields: [str], place.fields: [str]}
@returns(200) {data: map{article: map, article_title: map, attachments: map{media_keys: [str]?, media_source_tweet_id: [str]?, poll_ids: [str]?}, author_id: str, card_uri: str, community_id: str, context_annotations: [map], conversation_id: str, created_at: str(date-time), display_text_range: [int(int64)], edit_controls: map{editable_until: str?, edits_remaining: int(int64)?, is_edit_eligible: bool?}, edit_history_post_ids: [str], entities: map{cashtags: [map]?, hashtags: [map]?, mentions: [map]?, urls: [map]?}, geo: map{coordinates: map?{coordinates: [num(double)], type: str}, place_id: str?}, id: str, in_reply_to_user_id: str, lang: str, matched_media_notes: [map], media_metadata: [map], non_public_metrics: map, note_post: map{entities: map?{cashtags: [map]?, hashtags: [map]?, mentions: [map]?, urls: [map]?}, text: str}, note_request_suggestions: [map], organic_metrics: map, paid_partnership: bool, possibly_sensitive: bool, promoted_metrics: map, public_metrics: map{bookmark_count: int(int64), impression_count: int(int64), like_count: int(int64), quote_count: int(int64), reply_count: int(int64), repost_count: int(int64)}, referenced_posts: [map], reply_settings: str, scopes: map{followers: bool}, source: str, suggested_source_links: [str], suggested_source_links_with_counts: [map], text: str, username: str, withheld: map{copyright: bool, country_codes: [str], scope: str?}}, errors: [any], includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}}

@endpoint GET /2/tweets/{id}/liking_users
@required {id: str}
@optional {max_results: int(int32)=100, pagination_token: str, user.fields: [str], expansions: [str], post.fields: [str]}
@returns(200) {data: [map], errors: [any], includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}, meta: map{next_token: str, previous_token: str, result_count: int(int32)}}

@endpoint GET /2/tweets/{id}/quote_tweets
@required {id: str}
@optional {max_results: int(int32)=10, pagination_token: str, exclude: [str], post.fields: [str], expansions: [str], user.fields: [str], media.fields: [str], poll.fields: [str], place.fields: [str]}
@returns(200) {data: [map], errors: [any], includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}, meta: map{next_token: str, result_count: int(int32)}}

@endpoint GET /2/tweets/{id}/retweeted_by
@required {id: str}
@optional {max_results: int(int32)=100, pagination_token: str, user.fields: [str], expansions: [str], post.fields: [str]}
@returns(200) {data: [map], errors: [any], includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}, meta: map{next_token: str, previous_token: str, result_count: int(int32)}}

@endpoint GET /2/tweets/{id}/retweets
@required {id: str}
@optional {max_results: int(int32)=100, pagination_token: str, post.fields: [str], expansions: [str], user.fields: [str], media.fields: [str], poll.fields: [str], place.fields: [str]}
@returns(200) {data: [map], errors: [any], includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}, meta: map{next_token: str, previous_token: str, result_count: int(int32)}}

@endpoint PUT /2/tweets/{tweet_id}/hidden
@required {tweet_id: str, hidden: bool}
@returns(200) {data: map{hidden: bool}, errors: [any]}

@endpoint GET /2/usage/credits
@returns(200) {data: map{free_balance: num, free_grants: [map], prepaid_balance: num, total_balance: num}, errors: [any]}

@endpoint GET /2/usage/tweets
@optional {days: int(int32)=7, usage.fields: [str]}
@returns(200) {data: map{cap_reset_day: int, daily_client_app_usage: [map], daily_project_usage: map{project_id: str?, usage: [map]?}, project_cap: str, project_id: str, project_usage: str}, errors: [any]}

@endpoint GET /2/users
@required {ids: [str]}
@optional {user.fields: [str], expansions: [str], post.fields: [str]}
@returns(200) {data: [map], errors: [any], includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}}

@endpoint GET /2/users/by
@required {usernames: [str]}
@optional {user.fields: [str], expansions: [str], post.fields: [str]}
@returns(200) {data: [map], errors: [any], includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}}

@endpoint GET /2/users/by/username/{username}
@required {username: str}
@optional {user.fields: [str], expansions: [str], post.fields: [str]}
@returns(200) {data: map{affiliation: map{badge_url: str?, description: str?, url: str?, user_id: [str]?}, confirmed_email: str, connection_status: [str], created_at: str(date-time), description: str, entities: map{description: map?{cashtags: [map]?, hashtags: [map]?, mentions: [map]?, urls: [map]?}, url: map?{urls: [map]?}}, id: str, is_identity_verified: bool, location: str, most_recent_post_id: str, name: str, parody: bool, pinned_post_id: str, profile_banner_url: str, profile_image_url: str, protected: bool, public_metrics: map{followers_count: int(int64), following_count: int(int64), like_count: int(int64)?, listed_count: int(int64), media_count: int(int64)?, post_count: int(int64)}, receives_your_dm: bool, subscriber_count: int, subscribes_to_you: bool, subscription: map{subscribes_to_you: bool}, subscription_type: str, url: str, username: str, verified: bool, verified_followers_count: int, verified_type: str, withheld: map{country_codes: [str]?, scope: str?}}, errors: [any], includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}}

@endpoint GET /2/users/compliance/stream
@required {partition: int(int32)}
@optional {backfill_minutes: int(int32), start_time: str(date-time), end_time: str(date-time)}
@returns(200)

@endpoint GET /2/users/me
@optional {user.fields: [str], expansions: [str], post.fields: [str]}
@returns(200) {data: map{affiliation: map{badge_url: str?, description: str?, url: str?, user_id: [str]?}, confirmed_email: str, connection_status: [str], created_at: str(date-time), description: str, entities: map{description: map?{cashtags: [map]?, hashtags: [map]?, mentions: [map]?, urls: [map]?}, url: map?{urls: [map]?}}, id: str, is_identity_verified: bool, location: str, most_recent_post_id: str, name: str, parody: bool, pinned_post_id: str, profile_banner_url: str, profile_image_url: str, protected: bool, public_metrics: map{followers_count: int(int64), following_count: int(int64), like_count: int(int64)?, listed_count: int(int64), media_count: int(int64)?, post_count: int(int64)}, receives_your_dm: bool, subscriber_count: int, subscribes_to_you: bool, subscription: map{subscribes_to_you: bool}, subscription_type: str, url: str, username: str, verified: bool, verified_followers_count: int, verified_type: str, withheld: map{country_codes: [str]?, scope: str?}}, errors: [any], includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}}

@endpoint GET /2/users/personalized_trends
@optional {personalized_trend.fields: [str]}
@returns(200) {data: [map], errors: [any]}

@endpoint GET /2/users/public_keys
@required {ids: [str]}
@optional {public_key.fields: [str]}
@returns(200) {data: [map], errors: [any]}

@endpoint GET /2/users/reposts_of_me
@optional {max_results: int(int32)=100, pagination_token: str, post.fields: [str], expansions: [str], user.fields: [str], media.fields: [str], poll.fields: [str], place.fields: [str]}
@returns(200) {data: [map], errors: [any], includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}, meta: map{next_token: str, previous_token: str, result_count: int(int32)}}

@endpoint GET /2/users/search
@required {query: str}
@optional {max_results: int(int32)=100, next_token: str, user.fields: [str], expansions: [str], post.fields: [str]}
@returns(200) {data: [map], errors: [any], includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}, meta: map{next_token: str, previous_token: str}}

@endpoint GET /2/users/{id}
@required {id: str}
@optional {user.fields: [str], expansions: [str], post.fields: [str]}
@returns(200) {data: map{affiliation: map{badge_url: str?, description: str?, url: str?, user_id: [str]?}, confirmed_email: str, connection_status: [str], created_at: str(date-time), description: str, entities: map{description: map?{cashtags: [map]?, hashtags: [map]?, mentions: [map]?, urls: [map]?}, url: map?{urls: [map]?}}, id: str, is_identity_verified: bool, location: str, most_recent_post_id: str, name: str, parody: bool, pinned_post_id: str, profile_banner_url: str, profile_image_url: str, protected: bool, public_metrics: map{followers_count: int(int64), following_count: int(int64), like_count: int(int64)?, listed_count: int(int64), media_count: int(int64)?, post_count: int(int64)}, receives_your_dm: bool, subscriber_count: int, subscribes_to_you: bool, subscription: map{subscribes_to_you: bool}, subscription_type: str, url: str, username: str, verified: bool, verified_followers_count: int, verified_type: str, withheld: map{country_codes: [str]?, scope: str?}}, errors: [any], includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}}

@endpoint GET /2/users/{id}/affiliates
@required {id: str}
@optional {max_results: int(int32), pagination_token: str, user.fields: [str], expansions: [str], post.fields: [str]}
@returns(200) {data: [map], errors: [any], includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}, meta: map{next_token: str, previous_token: str, result_count: int(int32)}}

@endpoint GET /2/users/{id}/blocking
@required {id: str}
@optional {max_results: int(int32), pagination_token: str, user.fields: [str], expansions: [str], post.fields: [str]}
@returns(200) {data: [map], errors: [any], includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}, meta: map{next_token: str, previous_token: str, result_count: int(int32)}}

@endpoint POST /2/users/{id}/blocking
@required {id: str, target_user_id: str}
@returns(200) {data: map{blocking: bool}, errors: [any]}

@endpoint GET /2/users/{id}/bookmarks
@required {id: str}
@optional {max_results: int(int32), pagination_token: str, post.fields: [str], expansions: [str], user.fields: [str], media.fields: [str], poll.fields: [str], place.fields: [str]}
@returns(200) {data: [map], errors: [any], includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}, meta: map{next_token: str, previous_token: str, result_count: int(int32)}}

@endpoint POST /2/users/{id}/bookmarks
@required {id: str}
@optional {folder_id: str, tweet_id: str, tweet_ids: [str]}
@returns(200)

@endpoint GET /2/users/{id}/bookmarks/folders
@required {id: str}
@optional {max_results: int(int32), pagination_token: str}
@returns(200) {data: [map], errors: [any]}

@endpoint POST /2/users/{id}/bookmarks/folders
@required {id: str, name: str}
@returns(201) {data: map{id: str, name: str}, errors: [any]}

@endpoint GET /2/users/{id}/bookmarks/folders/{folder_id}
@required {id: str, folder_id: str}
@optional {max_results: int(int32), pagination_token: str}
@returns(200) {data: [map], errors: [any]}

@endpoint DELETE /2/users/{id}/bookmarks/{tweet_id}
@required {id: str, tweet_id: str}
@returns(200) {data: map{bookmarked: bool}, errors: [any]}

@endpoint POST /2/users/{id}/dm/block
@required {id: str}
@returns(200) {data: map{blocked: bool}, errors: [any]}

@endpoint POST /2/users/{id}/dm/unblock
@required {id: str}
@returns(200) {data: map{blocked: bool}, errors: [any]}

@endpoint GET /2/users/{id}/followed_lists
@required {id: str}
@optional {max_results: int(int32)=100, pagination_token: str, list.fields: [str], expansions: [str], user.fields: [str]}
@returns(200) {data: [map], errors: [any], includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}, meta: map{next_token: str, previous_token: str, result_count: int(int32)}}

@endpoint POST /2/users/{id}/followed_lists
@required {id: str, list_id: str}
@returns(200) {data: map{following: bool}, errors: [any]}

@endpoint DELETE /2/users/{id}/followed_lists/{list_id}
@required {id: str, list_id: str}
@returns(200) {data: map{following: bool}, errors: [any]}

@endpoint GET /2/users/{id}/followers
@required {id: str}
@optional {max_results: int(int32), pagination_token: str, user.fields: [str], expansions: [str], post.fields: [str]}
@returns(200) {data: [map], errors: [any], includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}, meta: map{next_token: str, previous_token: str, result_count: int(int32)}}

@endpoint GET /2/users/{id}/following
@required {id: str}
@optional {max_results: int(int32), pagination_token: str, user.fields: [str], expansions: [str], post.fields: [str]}
@returns(200) {data: [map], errors: [any], includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}, meta: map{next_token: str, previous_token: str, result_count: int(int32)}}

@endpoint POST /2/users/{id}/following
@required {id: str, target_user_id: str}
@returns(200) {data: map{following: bool, pending_follow: bool}, errors: [any]}

@endpoint GET /2/users/{id}/liked_tweets
@required {id: str}
@optional {max_results: int(int32), pagination_token: str, post.fields: [str], expansions: [str], user.fields: [str], media.fields: [str], poll.fields: [str], place.fields: [str]}
@returns(200) {data: [map], errors: [any], includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}, meta: map{next_token: str, previous_token: str, result_count: int(int32)}}

@endpoint POST /2/users/{id}/likes
@required {id: str, tweet_id: str}
@returns(200) {data: map{liked: bool}, errors: [any]}

@endpoint DELETE /2/users/{id}/likes/{tweet_id}
@required {id: str, tweet_id: str}
@returns(200) {data: map{liked: bool}, errors: [any]}

@endpoint GET /2/users/{id}/list_memberships
@required {id: str}
@optional {max_results: int(int32)=100, pagination_token: str, list.fields: [str], expansions: [str], user.fields: [str]}
@returns(200) {data: [map], errors: [any], includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}, meta: map{next_token: str, previous_token: str, result_count: int(int32)}}

@endpoint GET /2/users/{id}/mentions
@required {id: str}
@optional {max_results: int(int32), pagination_token: str, start_time: str(date-time), end_time: str(date-time), since_id: str, until_id: str, post.fields: [str], expansions: [str], user.fields: [str], media.fields: [str], poll.fields: [str], place.fields: [str]}
@returns(200) {data: [map], errors: [any], includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}, meta: map{newest_id: str, next_token: str, oldest_id: str, previous_token: str, result_count: int(int32)}}

@endpoint GET /2/users/{id}/muting
@required {id: str}
@optional {max_results: int(int32)=100, pagination_token: str, user.fields: [str], expansions: [str], post.fields: [str]}
@returns(200) {data: [map], errors: [any], includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}, meta: map{next_token: str, previous_token: str, result_count: int(int32)}}

@endpoint POST /2/users/{id}/muting
@required {id: str, target_user_id: str}
@returns(200) {data: map{muting: bool}, errors: [any]}

@endpoint GET /2/users/{id}/owned_lists
@required {id: str}
@optional {max_results: int(int32)=100, pagination_token: str, list.fields: [str], expansions: [str], user.fields: [str]}
@returns(200) {data: [map], errors: [any], includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}, meta: map{next_token: str, previous_token: str, result_count: int(int32)}}

@endpoint GET /2/users/{id}/pinned_lists
@required {id: str}
@optional {list.fields: [str], expansions: [str], user.fields: [str]}
@returns(200) {data: [map], errors: [any], includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}, meta: map{result_count: int(int32)}}

@endpoint POST /2/users/{id}/pinned_lists
@required {id: str, list_id: str}
@returns(200) {data: map{pinned: bool}, errors: [any]}

@endpoint DELETE /2/users/{id}/pinned_lists/{list_id}
@required {id: str, list_id: str}
@returns(200) {data: map{pinned: bool}, errors: [any]}

@endpoint GET /2/users/{id}/public_keys
@required {id: str}
@optional {public_key.fields: [str]}
@returns(200) {data: [map], errors: [any]}

@endpoint POST /2/users/{id}/public_keys
@required {id: str, public_key: map{identity_public_key_signature: str, public_key: str, public_key_fingerprint: str, registration_method: str, signing_public_key: str, signing_public_key_signature: str}, version: str}
@optional {generate_version: bool}
@returns(200) {data: map{juicebox_config: map, public_key_version: str}, errors: [any]}

@endpoint POST /2/users/{id}/retweets
@required {id: str, tweet_id: str}
@returns(200) {data: map{rest_id: str, retweeted: bool}, errors: [any]}

@endpoint DELETE /2/users/{id}/retweets/{source_tweet_id}
@required {id: str, source_tweet_id: str}
@returns(200) {data: map{retweeted: bool}, errors: [any]}

@endpoint GET /2/users/{id}/timelines/reverse_chronological
@required {id: str}
@optional {max_results: int(int32), pagination_token: str, start_time: str(date-time), end_time: str(date-time), since_id: str, until_id: str, exclude: [str], post.fields: [str], expansions: [str], user.fields: [str], media.fields: [str], poll.fields: [str], place.fields: [str]}
@returns(200) {data: [map], errors: [any], includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}, meta: map{newest_id: str, next_token: str, oldest_id: str, previous_token: str, result_count: int(int32)}}

@endpoint GET /2/users/{id}/tweets
@required {id: str}
@optional {max_results: int(int32), pagination_token: str, start_time: str(date-time), end_time: str(date-time), since_id: str, until_id: str, exclude: [str], post.fields: [str], expansions: [str], user.fields: [str], media.fields: [str], poll.fields: [str], place.fields: [str]}
@returns(200) {data: [map], errors: [any], includes: map{media: [map], places: [map], polls: [map], posts: [map], topics: [map], users: [map]}, meta: map{newest_id: str, next_token: str, oldest_id: str, previous_token: str, result_count: int(int32)}}

@endpoint DELETE /2/users/{source_user_id}/blocking/{target_user_id}
@required {source_user_id: str, target_user_id: str}
@returns(200) {data: map{blocking: bool}, errors: [any]}

@endpoint DELETE /2/users/{source_user_id}/following/{target_user_id}
@required {source_user_id: str, target_user_id: str}
@returns(200) {data: map{following: bool}, errors: [any]}

@endpoint DELETE /2/users/{source_user_id}/muting/{target_user_id}
@required {source_user_id: str, target_user_id: str}
@returns(200) {data: map{muting: bool}, errors: [any]}

@endpoint GET /2/webhooks
@optional {webhook_config.fields: [str]}
@returns(200) {data: [map], errors: [any], meta: map{result_count: int(int32)}}

@endpoint POST /2/webhooks
@required {url: str}
@returns(200) {data: map{created_at: str, id: str, url: str, valid: bool}, errors: [any]}

@endpoint POST /2/webhooks/replay
@required {from_date: str, to_date: str, webhook_id: str}
@returns(200) {data: map{created_at: str, job_id: str}, errors: [any]}

@endpoint DELETE /2/webhooks/{webhook_id}
@required {webhook_id: str}
@returns(200) {data: map{deleted: bool}, errors: [any]}

@endpoint PUT /2/webhooks/{webhook_id}
@required {webhook_id: str}
@returns(200) {data: map{valid: bool}, errors: [any]}

@end