🥮 mooncakes.io
README

marianoguerra/slack/typed does not have a README file

#
TypedError

source
pub(all) suberror TypedError {
  Slack(
SlackError)
  ResponseShapeError(api_method~ : String, key~ : String)
} derive(
Debug)

A typed call's failure.
impl Show for TypedError

#
TypedError::code

source
fn TypedError::code(self : TypedError) -> String

node-slack-sdk's ErrorCode for the wrapped case, and this package's own for the case node has no name for.

#
TypedError::describe_error

source
fn TypedError::describe_error(self : TypedError) -> String

#
TypedError::slack

source

The wrapped SlackError, for the cases that actually happen.

ResponseShapeError is the rare one and the wrapping puts it in the way of the common ones, so this is the shortcut: if e.slack() is Some(err) gets back to a rate limit or a missing_scope in one step.

#
Api

source
pub struct Api {
  client : 
Client
}

A Client, and the extraction step that turns its answers into @model values.

Holds the client rather than replacing it: Api::client is always there, and mixing the two levels in one function is the expected way to use this.

#
Api::auth_revoke

source
async fn Api::auth_revoke(self : Api, dry_run? : Bool) -> Bool raise TypedError

auth.revoke, answering whether the token was actually revoked.

dry_run reports what would happen without doing it, which is the whole reason this answers a Bool rather than Unit.

#
Api::auth_test

source
async fn Api::auth_test(self : Api) -> Identity raise TypedError

auth.test: who this token is. The first call most apps make.

#
Api::bookmarks_add

source
async fn Api::bookmarks_add(self : Api, channel_id~ : String, title~ : String, type_~ : String, link? : String, emoji? : String, entity_id? : String, parent_id? : String) -> 
Bookmark raise TypedError

bookmarks.add, as the bookmark it created.

#
Api::bookmarks_list

source
async fn Api::bookmarks_list(self : Api, channel_id~ : String) -> Array[
Bookmark] raise TypedError

bookmarks.list, which is not paginated.

#
Api::chat_delete

source
async fn Api::chat_delete(self : Api, channel~ : String, ts~ : String, as_user? : Bool) -> Posted raise TypedError

chat.delete, as what it deleted.

#
Api::chat_delete_scheduled_message

source
async fn Api::chat_delete_scheduled_message(self : Api, channel~ : String, scheduled_message_id~ : String, as_user? : Bool) -> Unit raise TypedError

chat.deleteScheduledMessage: cancel one before it is sent.
async fn Api::chat_get_permalink(self : Api, channel~ : String, message_ts~ : String) -> String raise TypedError

chat.getPermalink, as the URL.

#
Api::chat_me_message

source
async fn Api::chat_me_message(self : Api, channel~ : String, text~ : String) -> Posted raise TypedError

chat.meMessage, as where it landed.

#
Api::chat_post_ephemeral

source
async fn Api::chat_post_ephemeral(self : Api, channel~ : String, user~ : String, text? : String, blocks? : Array[
LayoutBlock], attachments? : Json, thread_ts? : String, parse? : String, link_names? : Bool, username? : String, icon_emoji? : String, icon_url? : String, markdown_text? : String) -> String raise TypedError

chat.postEphemeral, as the ts of the message only that user can see.

A bare ts and not a Posted: an ephemeral message has no channel echoed back and cannot be updated or deleted, so there is nothing else to carry.

#
Api::chat_post_message

source
async fn Api::chat_post_message(self : Api, channel~ : String, text? : String, blocks? : Array[
LayoutBlock], attachments? : Json, thread_ts? : String, reply_broadcast? : Bool, unfurl_links? : Bool, unfurl_media? : Bool, mrkdwn? : Bool, parse? : String, link_names? : Bool, username? : String, icon_emoji? : String, icon_url? : String, metadata? : Json, markdown_text? : String) -> Posted raise TypedError

chat.postMessage, as where it landed.

Posted.channel is an id and not a Channel, because that is what Slack answers here -- even when the request named the channel by name.

#
Api::chat_schedule_message

source
async fn Api::chat_schedule_message(self : Api, channel~ : String, post_at~ : Int64, text? : String, blocks? : Array[
LayoutBlock], attachments? : Json, thread_ts? : String, reply_broadcast? : Bool, unfurl_links? : Bool, unfurl_media? : Bool, metadata? : Json, markdown_text? : String) -> Scheduled raise TypedError

chat.scheduleMessage, as the handle to cancel it with.

#
Api::chat_scheduled_messages_list

source
async fn Api::chat_scheduled_messages_list(self : Api, channel? : String, cursor? : String, limit? : Int, latest? : String, oldest? : String) -> Page[
ScheduledMessage] raise TypedError

One page of chat.scheduledMessages.list.

#
Api::chat_unfurl

source
async fn Api::chat_unfurl(self : Api, channel~ : String, ts~ : String, unfurls~ : Json, user_auth_required? : Bool, user_auth_message? : String, user_auth_url? : String, user_auth_blocks? : Array[
LayoutBlock]) -> Unit raise TypedError

chat.unfurl: attach a preview to a link someone posted.

#
Api::chat_update

source
async fn Api::chat_update(self : Api, channel~ : String, ts~ : String, text? : String, blocks? : Array[
LayoutBlock], attachments? : Json, link_names? : Bool, parse? : String, metadata? : Json, markdown_text? : String) -> Posted raise TypedError

chat.update, as where the edited message is.

#
Api::client

source

The low-level client, for everything this package does not wrap.

Not an escape hatch so much as the other half of the API: Client::call reaches every one of Slack's 326 methods, and ApiResponse.raw reaches every field of every response.

#
Api::conversations_archive

source
async fn Api::conversations_archive(self : Api, channel~ : String) -> Unit raise TypedError

conversations.archive.

#
Api::conversations_close

source
async fn Api::conversations_close(self : Api, channel~ : String) -> Unit raise TypedError

conversations.close.

#
Api::conversations_create

source
async fn Api::conversations_create(self : Api, name~ : String, is_private? : Bool) -> 
Channel raise TypedError

conversations.create, as the channel it created.

#
Api::conversations_history

source
async fn Api::conversations_history(self : Api, channel~ : String, cursor? : String, limit? : Int, latest? : String, oldest? : String, inclusive? : Bool, include_all_metadata? : Bool) -> Page[
Message] raise TypedError

One page of conversations.history.

#
Api::conversations_history_all

source
async fn Api::conversations_history_all(self : Api, channel~ : String, latest? : String, oldest? : String, page_size? : Int, max_pages? : Int) -> Array[
Message] raise TypedError

Every page of conversations.history.

#
Api::conversations_info

source
async fn Api::conversations_info(self : Api, channel~ : String, include_locale? : Bool, include_num_members? : Bool) -> 
Channel raise TypedError

conversations.info, as a Channel.

#
Api::conversations_invite

source
async fn Api::conversations_invite(self : Api, channel~ : String, users~ : Array[String], force? : Bool) -> 
Channel raise TypedError

conversations.invite, as the channel with its new members.

#
Api::conversations_join

source
async fn Api::conversations_join(self : Api, channel~ : String) -> 
Channel raise TypedError

conversations.join, as the channel just joined.

#
Api::conversations_kick

source
async fn Api::conversations_kick(self : Api, channel~ : String, user~ : String) -> Unit raise TypedError

conversations.kick.

#
Api::conversations_leave

source
async fn Api::conversations_leave(self : Api, channel~ : String) -> Unit raise TypedError

conversations.leave.

#
Api::conversations_list

source
async fn Api::conversations_list(self : Api, types? : Array[String], exclude_archived? : Bool, limit? : Int, cursor? : String) -> Page[
Channel] raise TypedError

One page of conversations.list.

#
Api::conversations_list_all

source
async fn Api::conversations_list_all(self : Api, types? : Array[String], exclude_archived? : Bool, page_size? : Int, max_pages? : Int) -> Array[
Channel] raise TypedError

Every page of conversations.list.

max_pages is worth setting: this is a Tier 2 method, and a big workspace will rate-limit a full walk.

#
Api::conversations_mark

source
async fn Api::conversations_mark(self : Api, channel~ : String, ts~ : String) -> Unit raise TypedError

conversations.mark: move the read cursor.

#
Api::conversations_members

source
async fn Api::conversations_members(self : Api, channel~ : String, cursor? : String, limit? : Int) -> Page[String] raise TypedError

One page of conversations.members, which is ids rather than users.

The key is members, the same key users.list uses for whole user objects. Two methods, one key name, two types -- which is the argument against a generic extractor, in one line.

#
Api::conversations_members_all

source
async fn Api::conversations_members_all(self : Api, channel~ : String, page_size? : Int, max_pages? : Int) -> Array[String] raise TypedError

Every page of conversations.members.

#
Api::conversations_open

source
async fn Api::conversations_open(self : Api, channel? : String, users? : Array[String], return_im? : Bool, prevent_creation? : Bool) -> 
Channel raise TypedError

conversations.open, as the DM or MPIM it opened or found.

#
Api::conversations_rename

source
async fn Api::conversations_rename(self : Api, channel~ : String, name~ : String) -> 
Channel raise TypedError

conversations.rename, as the channel under its new name.

#
Api::conversations_replies

source
async fn Api::conversations_replies(self : Api, channel~ : String, ts~ : String, cursor? : String, limit? : Int, latest? : String, oldest? : String, inclusive? : Bool) -> Page[
Message] raise TypedError

One page of conversations.replies: a thread's parent and its replies.

The parent comes back first and carries thread_ts == ts, which Message::is_thread_reply is the way to tell apart.

#
Api::conversations_set_purpose

source
async fn Api::conversations_set_purpose(self : Api, channel~ : String, purpose~ : String) -> 
Channel raise TypedError

conversations.setPurpose, as the channel with its new purpose.

#
Api::conversations_set_topic

source
async fn Api::conversations_set_topic(self : Api, channel~ : String, topic~ : String) -> 
Channel raise TypedError

conversations.setTopic, as the channel with its new topic.

#
Api::files_complete_upload_external

source
async fn Api::files_complete_upload_external(self : Api, files~ : Json, channel_id? : String, initial_comment? : String, thread_ts? : String) -> Array[
File] raise TypedError

files.completeUploadExternal, as the files it finished.

#
Api::files_delete

source
async fn Api::files_delete(self : Api, file~ : String) -> Unit raise TypedError

files.delete.

#
Api::files_get_upload_url_external

source
async fn Api::files_get_upload_url_external(self : Api, filename~ : String, length~ : Int, alt_txt? : String, snippet_type? : String) -> Upload raise TypedError

files.getUploadURLExternal, as where to PUT the bytes.

#
Api::files_info

source
async fn Api::files_info(self : Api, file~ : String, cursor? : String, limit? : Int) -> 
File raise TypedError

files.info, as a File.

#
Api::files_list

source
async fn Api::files_list(self : Api, channel? : String, user? : String, types? : Array[String], ts_from? : String, ts_to? : String, count? : Int, page? : Int) -> Array[
File] raise TypedError

files.list, which pages by number rather than by cursor.

Hence an array and not a Page: the paging object it answers with is not the cursor scheme the rest of this file uses, and pretending otherwise would hand back a Page whose cursor was always None.

#
Api::new

source
fn Api::new(transport : &
Transport, token : String, base_url? : String, bool_style? : 
BoolStyle, extra_headers? : Map[String, String], team_id? : String) -> Api

Build the client and wrap it in one step, with Client::new's arguments.

#
Api::of

source

Wrap an existing client.

The usual entry point, because a Client is where the transport, the token and the base URL are already configured.

#
Api::pins_add

source
async fn Api::pins_add(self : Api, channel~ : String, timestamp? : String) -> Unit raise TypedError

pins.add.

#
Api::pins_remove

source
async fn Api::pins_remove(self : Api, channel~ : String, timestamp? : String) -> Unit raise TypedError

pins.remove.

#
Api::reactions_add

source
async fn Api::reactions_add(self : Api, channel~ : String, name~ : String, timestamp~ : String) -> Unit raise TypedError

reactions.add.

#
Api::reactions_remove

source
async fn Api::reactions_remove(self : Api, name~ : String, channel? : String, timestamp? : String, file? : String, file_comment? : String) -> Unit raise TypedError

reactions.remove.

#
Api::team_info

source
async fn Api::team_info(self : Api, team? : String, domain? : String) -> 
Team raise TypedError

team.info, as a Team.

#
Api::usergroups_create

source
async fn Api::usergroups_create(self : Api, name~ : String, handle? : String, description? : String, channels? : Array[String], include_count? : Bool) -> 
Usergroup raise TypedError

usergroups.create, as the group it created.

#
Api::usergroups_list

source
async fn Api::usergroups_list(self : Api, include_disabled? : Bool, include_count? : Bool, include_users? : Bool) -> Array[
Usergroup] raise TypedError

usergroups.list, which is not paginated.

#
Api::usergroups_users_list

source
async fn Api::usergroups_users_list(self : Api, usergroup~ : String, include_disabled? : Bool) -> Array[String] raise TypedError

usergroups.users.list, which is ids.

#
Api::usergroups_users_update

source
async fn Api::usergroups_users_update(self : Api, usergroup~ : String, users~ : Array[String], include_count? : Bool) -> 
Usergroup raise TypedError

usergroups.users.update, as the group with its new membership.

#
Api::users_conversations

source
async fn Api::users_conversations(self : Api, user? : String, types? : Array[String], exclude_archived? : Bool, cursor? : String, limit? : Int) -> Page[
Channel] raise TypedError

One page of users.conversations.

#
Api::users_get_presence

source
async fn Api::users_get_presence(self : Api, user? : String) -> Presence raise TypedError

users.getPresence.

#
Api::users_info

source
async fn Api::users_info(self : Api, user~ : String, include_locale? : Bool) -> 
User raise TypedError

users.info, as a User.

#
Api::users_list

source
async fn Api::users_list(self : Api, cursor? : String, limit? : Int, include_locale? : Bool) -> Page[
User] raise TypedError

One page of users.list.

The members are objects here. On conversations.members the identically named key holds ids.

#
Api::users_list_all

source
async fn Api::users_list_all(self : Api, include_locale? : Bool, page_size? : Int, max_pages? : Int) -> Array[
User] raise TypedError

Every page of users.list.

#
Api::users_lookup_by_email

source
async fn Api::users_lookup_by_email(self : Api, email~ : String) -> 
User raise TypedError

users.lookupByEmail, as a User.

#
Api::users_profile_get

source
async fn Api::users_profile_get(self : Api, user? : String, include_labels? : Bool) -> 
Profile raise TypedError

users.profile.get, as a Profile.

#
Api::users_profile_set

source
async fn Api::users_profile_set(self : Api, user? : String, profile? : Json, name? : String, value? : String) -> 
Profile raise TypedError

users.profile.set, answering the profile as stored.

#
Api::users_set_presence

source
async fn Api::users_set_presence(self : Api, presence~ : String) -> Unit raise TypedError

users.setPresence.

#
Api::views_open

source
async fn Api::views_open(self : Api, trigger_id~ : String, view~ : Json) -> 
View raise TypedError

views.open, as the view Slack stored.

#
Api::views_publish

source
async fn Api::views_publish(self : Api, user_id~ : String, view~ : Json, hash? : String) -> 
View raise TypedError

views.publish, as the App Home view Slack stored.

#
Api::views_push

source
async fn Api::views_push(self : Api, trigger_id~ : String, view~ : Json) -> 
View raise TypedError

views.push, as the view it pushed onto the stack.

#
Api::views_update

source
async fn Api::views_update(self : Api, view~ : Json, view_id? : String, external_id? : String, hash? : String) -> 
View raise TypedError

views.update, as the view after the update.

#
Identity

source
pub(all) struct Identity {
  url : String
  team : String
  user : String
  team_id : String
  user_id : String
  bot_id : String?
  is_enterprise_install : Bool?
  enterprise_id : String?
  app_id : String?
  app_name : String?
  expires_in : Int?
} derive(Eq, 
Debug)

Who a token is: auth.test, which is the first call most apps make.

The five required fields are the ones Slack answers unconditionally for any valid token. bot_id is present for a bot token and absent for a user one, which is the cheapest way to tell them apart.

#
Identity::is_bot

source
fn Identity::is_bot(self : Identity) -> Bool

Whether this token belongs to a bot.

#
Page

source
pub(all) struct Page[T] {
  items : Array[T]
  cursor : String?
  response : 
ApiResponse
}

One page of a cursor-paginated call.

Carries the whole response as well as the items, because the interesting fields of a page are not all items -- has_more on conversations.history, the warnings on a partial users.list.

#
Page::has_more

source
fn[T] Page::has_more(self : Page[T]) -> Bool

Whether another page exists.

#
Posted

source
pub(all) struct Posted {
  channel : String
  ts : String
  message : 
Message?
} derive(Eq, 
Debug)

What chat.postMessage and chat.update answer.

Not a Channel: the channel here is an id, which is the clearest case in the whole API for why extraction cannot be generic.

#
Presence

source
pub(all) struct Presence {
  presence : String
  online : Bool?
  auto_away : Bool?
  manual_away : Bool?
  connection_count : Int?
  last_activity : Int64?
} derive(Eq, 
Debug)

A user's presence: users.getPresence.

Everything but presence needs the users:read scope on your own user, so the rest is optional and usually absent for anyone else.

#
Scheduled

source
pub(all) struct Scheduled {
  scheduled_message_id : String
  channel : String
  post_at : Int64
  message : 
Message?
} derive(Eq, 
Debug)

A message queued by chat.scheduleMessage.

scheduled_message_id is what chat.deleteScheduledMessage cancels it with, and the only handle you get -- there is no ts until it is sent.

#
Upload

source
pub(all) struct Upload {
  upload_url : String
  file_id : String
} derive(Eq, 
Debug)

Where to PUT a file's bytes: files.getUploadURLExternal.

The upload itself is an ordinary HTTP request to upload_url and not a Web API call, so it is not something this library does -- see "Not included" in the library's README. file_id is what files.completeUploadExternal finishes with.

#
to_typed_error

source
fn to_typed_error(e : Error) -> TypedError

Narrow an arbitrary Error to a TypedError.

Variant patterns are the only way to match an error value and they are only in scope in the package that declares them, so a caller outside this one cannot take a TypedError apart from an Error without this. The same shape as @api.to_slack_error, which it delegates to.

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io