State Layer

try await chat.loadMessages(with: MessagesPagination(pageSize: pageSize))
let allMessages = chat.state.messages

var connectedUser = try await chatClient.connectUser(
    userInfo: UserInfo(id: "<# Your User ID Here #>"),
    token: "<# Your User Token Here#>"
)
// Or while being logged in
connectedUser = try chatClient.makeConnectedUser()
// Register for push notifications
try await connectedUser.addDevice(
    .apn(
        token: apnTokenData,
        providerName: "<# Your Stream's Push Configuration Name>"
    )
)
// Mute a user
try await connectedUser.muteUser("user-id")
// Block a user
try await connectedUser.blockUser("another-user-id")
// Mark all the channels as read
try await connectedUser.markAllChannelsRead()
// Read user data
let unreadCounts = connectedUser.state.user.unreadCount
let numberOfUnreadChannels = unreadCounts.channels
let numberOfUnreadMessages = unreadCounts.messages
// React to user data changes
connectedUser.state.$user
  .sink { changedUser in
      let changedUnreadCount = changedUser.unreadCount
  }
  .store(in: &cancellables)

let query = ChannelListQuery(
    filter: .and([
        .equal(.type, to: .messaging),
        .containMembers(userIds: ["thierry"])
    ]),
    sort: [Sorting(key: .lastMessageAt, isAscending: false)],
    pageSize: 10
)
let channelList = chatClient.makeChannelList(with: query)
// Local state of the channel list (state from previous sessions)
var channels = channelList.state.channels
// Load the first page of channels from the Stream API
try await channelList.get()
// Load more channels
try await channelList.loadMoreChannels()
// Access all the loaded channels
channels = channelList.state.channels

let cancellable = channelList.state
    .$channels
    .sink { channels in
        // Do something with channels
    }

let channelId = ChannelId(type: .messaging, id: "general")
let chat = chatClient.makeChat(for: channelId)
// Local state of the channel (state from previous sessions)
var messages = chat.state.messages
var members = chat.state.members
// Load the latest state from the Stream API and subscribe to data changes
try await chat.get(watch: true)
// Access all the loaded messages and members
messages = chat.state.messages
members = chat.state.members
// Load more messages
try await chat.loadOlderMessages()
// Access all the loaded messages
messages = chat.state.messages

let fileURL = URL(filePath: "<file url>")
let attachment = try AnyAttachmentPayload(
    localFileURL: fileURL,
    attachmentType: .file
)
try await chat.sendMessage(
    with: "Hello",
    attachments: [attachment],
    quote: "other-message-id",
    pinning: .noExpiration,
    extraData: [
      "my-custom-key": .string("and string value")
    ]
)

try await chat.reply(
    to: "parent-message-id",
    text: "Hi!",
    showReplyInChannel: true
)

try await chat.sendReaction(
    to: "message-id",
    with: "like",
    score: 1,
    enforceUnique: true,
    extraData: [
        "has-xyz-enabled": .bool(true)
    ]
)
try await chat.deleteReaction(
    from: "message-id",
    with: "like"
)

let messageState = try await chat.messageState(for: "message-id")
try await chat.loadMoreReplies(for: messageId)
// Access all the loaded replies
let replies = messageState.replies
// Load reactions
let reactionsBatch25 = try await chat.loadReactions(
    for: "message-id",
    pagination: Pagination(pageSize: 25)
)
// Paginate reactions by loading 10 more
let reactionsBatch10 = try await chat.loadMoreReactions(
    for: "message-id",
    limit: 10
)
// Access all the currently loaded reactions
let allLoadedReactions35 = messageState.reactions

let query = ChannelMemberListQuery(
        cid: ChannelId(type: .messaging, id: "general"),
        sort: [Sorting(key: .createdAt, isAscending: true)]
    )
let memberList = chatClient.makeMemberList(with: query)
// Local state of the member list (state from previous sessions)
var members = memberList.state.members
// Load the first page of members from the Stream API
try await memberList.get()
// Load more members
try await memberList.loadMoreMembers()
// Access all the loaded members
members = memberList.state.members

let messageSearch = chatClient.makeMessageSearch()
// Searching for messages containing "Stream"
try await messageSearch.search(text: "Stream")
// Or searching for messages in the specified channel containing "Stream"
try await messageSearch.search(query:
    MessageSearchQuery(
        channelFilter: .containMembers(userIds: ["john"]),
        messageFilter: .autocomplete(.text, text: "Stream")
    )
)
// Load more results
try await messageSearch.loadMoreMessages()
// All the loaded results
let matches = messageSearch.state.messages

let query = ReactionListQuery(
    messageId: messageId,
    filter: .equal(.reactionType, to: "like")
)
let reactionList = chatClient.makeReactionList(with: query)
// Load reactions for the query
try await reactionList.get()
// Load more reactions
try await reactionList.loadMoreReactions()
// All the loaded reactions
let users = reactionList.state.reactions

let query = UserListQuery(
    filter: .in(.id, values: ["john", "jack", "jessie"]),
    sort: [Sorting(key: .lastActivityAt, isAscending: false)]
)
let userList = chatClient.makeUserList(with: query)
// Load users for the query
try await userList.get()
// Load more users
try await userList.loadMoreUsers()
// All the loaded users
let users = userList.state.users

let userSearch = chatClient.makeUserSearch()
try await userSearch.search(term: "thi")
// Load more results
try await userSearch.loadMoreUsers()
// All the loaded results for "thi"
var users = userSearch.state.users
// Change the search term
try await userSearch.search(term: "thie")
// All the loaded results for "thie"
users = userSearch.state.users

// Every single event
chatClient.subscribe { event in
    // …
}
.store(in: &cancellables)

// A specific event
chatClient.subscribe(toEvent: ConnectionStatusUpdated.self) { event in
    // …
}
.store(in: &cancellables)

// Channel specific event
let channelId = ChannelId(type: .messaging, id: "general")
let chat = chatClient.makeChat(for: channelId)
chat.subscribe { event in
    // All the events only for this particular channel id
}
.store(in: &cancellables)

// Channel specific events filtered down to a single type
chat.subscribe(toEvent: ChannelHiddenEvent.self) { event in
    // …
}
.store(in: &cancellables)