slidge-whatsapp 0.2.2__cp311-cp311-manylinux_2_36_aarch64.whl → 0.2.5__cp311-cp311-manylinux_2_36_aarch64.whl

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/store/sqlstore/upgrade.go

@@ -0,0 +1,296 @@
+// Copyright (c) 2021 Tulir Asokan
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package sqlstore
+
+import (
+	"database/sql"
+	"fmt"
+	"strings"
+)
+
+type upgradeFunc func(*sql.Tx, *Container) error
+
+// Upgrades is a list of functions that will upgrade a database to the latest version.
+//
+// This may be of use if you want to manage the database fully manually, but in most cases you
+// should just call Container.Upgrade to let the library handle everything.
+var Upgrades = [...]upgradeFunc{upgradeV1, upgradeV2, upgradeV3, upgradeV4, upgradeV5, upgradeV6}
+
+func (c *Container) getVersion() (int, error) {
+	_, err := c.db.Exec("CREATE TABLE IF NOT EXISTS whatsmeow_version (version INTEGER)")
+	if err != nil {
+		return -1, err
+	}
+
+	version := 0
+	row := c.db.QueryRow("SELECT version FROM whatsmeow_version LIMIT 1")
+	if row != nil {
+		_ = row.Scan(&version)
+	}
+	return version, nil
+}
+
+func (c *Container) setVersion(tx *sql.Tx, version int) error {
+	_, err := tx.Exec("DELETE FROM whatsmeow_version")
+	if err != nil {
+		return err
+	}
+	_, err = tx.Exec("INSERT INTO whatsmeow_version (version) VALUES ($1)", version)
+	return err
+}
+
+// Upgrade upgrades the database from the current to the latest version available.
+func (c *Container) Upgrade() error {
+	if c.dialect == "sqlite" {
+		var foreignKeysEnabled bool
+		err := c.db.QueryRow("PRAGMA foreign_keys").Scan(&foreignKeysEnabled)
+		if err != nil {
+			return fmt.Errorf("failed to check if foreign keys are enabled: %w", err)
+		} else if !foreignKeysEnabled {
+			return fmt.Errorf("foreign keys are not enabled")
+		}
+	}
+
+	version, err := c.getVersion()
+	if err != nil {
+		return err
+	}
+
+	for ; version < len(Upgrades); version++ {
+		var tx *sql.Tx
+		tx, err = c.db.Begin()
+		if err != nil {
+			return err
+		}
+
+		migrateFunc := Upgrades[version]
+		c.log.Infof("Upgrading database to v%d", version+1)
+		err = migrateFunc(tx, c)
+		if err != nil {
+			_ = tx.Rollback()
+			return err
+		}
+
+		if err = c.setVersion(tx, version+1); err != nil {
+			return err
+		}
+
+		if err = tx.Commit(); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func upgradeV1(tx *sql.Tx, _ *Container) error {
+	_, err := tx.Exec(`CREATE TABLE whatsmeow_device (
+		jid TEXT PRIMARY KEY,
+
+		registration_id BIGINT NOT NULL CHECK ( registration_id >= 0 AND registration_id < 4294967296 ),
+
+		noise_key    bytea NOT NULL CHECK ( length(noise_key) = 32 ),
+		identity_key bytea NOT NULL CHECK ( length(identity_key) = 32 ),
+
+		signed_pre_key     bytea   NOT NULL CHECK ( length(signed_pre_key) = 32 ),
+		signed_pre_key_id  INTEGER NOT NULL CHECK ( signed_pre_key_id >= 0 AND signed_pre_key_id < 16777216 ),
+		signed_pre_key_sig bytea   NOT NULL CHECK ( length(signed_pre_key_sig) = 64 ),
+
+		adv_key         bytea NOT NULL,
+		adv_details     bytea NOT NULL,
+		adv_account_sig bytea NOT NULL CHECK ( length(adv_account_sig) = 64 ),
+		adv_device_sig  bytea NOT NULL CHECK ( length(adv_device_sig) = 64 ),
+
+		platform      TEXT NOT NULL DEFAULT '',
+		business_name TEXT NOT NULL DEFAULT '',
+		push_name     TEXT NOT NULL DEFAULT ''
+	)`)
+	if err != nil {
+		return err
+	}
+	_, err = tx.Exec(`CREATE TABLE whatsmeow_identity_keys (
+		our_jid  TEXT,
+		their_id TEXT,
+		identity bytea NOT NULL CHECK ( length(identity) = 32 ),
+
+		PRIMARY KEY (our_jid, their_id),
+		FOREIGN KEY (our_jid) REFERENCES whatsmeow_device(jid) ON DELETE CASCADE ON UPDATE CASCADE
+	)`)
+	if err != nil {
+		return err
+	}
+	_, err = tx.Exec(`CREATE TABLE whatsmeow_pre_keys (
+		jid      TEXT,
+		key_id   INTEGER          CHECK ( key_id >= 0 AND key_id < 16777216 ),
+		key      bytea   NOT NULL CHECK ( length(key) = 32 ),
+		uploaded BOOLEAN NOT NULL,
+
+		PRIMARY KEY (jid, key_id),
+		FOREIGN KEY (jid) REFERENCES whatsmeow_device(jid) ON DELETE CASCADE ON UPDATE CASCADE
+	)`)
+	if err != nil {
+		return err
+	}
+	_, err = tx.Exec(`CREATE TABLE whatsmeow_sessions (
+		our_jid  TEXT,
+		their_id TEXT,
+		session  bytea,
+
+		PRIMARY KEY (our_jid, their_id),
+		FOREIGN KEY (our_jid) REFERENCES whatsmeow_device(jid) ON DELETE CASCADE ON UPDATE CASCADE
+	)`)
+	if err != nil {
+		return err
+	}
+	_, err = tx.Exec(`CREATE TABLE whatsmeow_sender_keys (
+		our_jid    TEXT,
+		chat_id    TEXT,
+		sender_id  TEXT,
+		sender_key bytea NOT NULL,
+
+		PRIMARY KEY (our_jid, chat_id, sender_id),
+		FOREIGN KEY (our_jid) REFERENCES whatsmeow_device(jid) ON DELETE CASCADE ON UPDATE CASCADE
+	)`)
+	if err != nil {
+		return err
+	}
+	_, err = tx.Exec(`CREATE TABLE whatsmeow_app_state_sync_keys (
+		jid         TEXT,
+		key_id      bytea,
+		key_data    bytea  NOT NULL,
+		timestamp   BIGINT NOT NULL,
+		fingerprint bytea  NOT NULL,
+
+		PRIMARY KEY (jid, key_id),
+		FOREIGN KEY (jid) REFERENCES whatsmeow_device(jid) ON DELETE CASCADE ON UPDATE CASCADE
+	)`)
+	if err != nil {
+		return err
+	}
+	_, err = tx.Exec(`CREATE TABLE whatsmeow_app_state_version (
+		jid     TEXT,
+		name    TEXT,
+		version BIGINT NOT NULL,
+		hash    bytea  NOT NULL CHECK ( length(hash) = 128 ),
+
+		PRIMARY KEY (jid, name),
+		FOREIGN KEY (jid) REFERENCES whatsmeow_device(jid) ON DELETE CASCADE ON UPDATE CASCADE
+	)`)
+	if err != nil {
+		return err
+	}
+	_, err = tx.Exec(`CREATE TABLE whatsmeow_app_state_mutation_macs (
+		jid       TEXT,
+		name      TEXT,
+		version   BIGINT,
+		index_mac bytea          CHECK ( length(index_mac) = 32 ),
+		value_mac bytea NOT NULL CHECK ( length(value_mac) = 32 ),
+
+		PRIMARY KEY (jid, name, version, index_mac),
+		FOREIGN KEY (jid, name) REFERENCES whatsmeow_app_state_version(jid, name) ON DELETE CASCADE ON UPDATE CASCADE
+	)`)
+	if err != nil {
+		return err
+	}
+	_, err = tx.Exec(`CREATE TABLE whatsmeow_contacts (
+		our_jid       TEXT,
+		their_jid     TEXT,
+		first_name    TEXT,
+		full_name     TEXT,
+		push_name     TEXT,
+		business_name TEXT,
+
+		PRIMARY KEY (our_jid, their_jid),
+		FOREIGN KEY (our_jid) REFERENCES whatsmeow_device(jid) ON DELETE CASCADE ON UPDATE CASCADE
+	)`)
+	if err != nil {
+		return err
+	}
+	_, err = tx.Exec(`CREATE TABLE whatsmeow_chat_settings (
+		our_jid       TEXT,
+		chat_jid      TEXT,
+		muted_until   BIGINT  NOT NULL DEFAULT 0,
+		pinned        BOOLEAN NOT NULL DEFAULT false,
+		archived      BOOLEAN NOT NULL DEFAULT false,
+
+		PRIMARY KEY (our_jid, chat_jid),
+		FOREIGN KEY (our_jid) REFERENCES whatsmeow_device(jid) ON DELETE CASCADE ON UPDATE CASCADE
+	)`)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+const fillSigKeyPostgres = `
+UPDATE whatsmeow_device SET adv_account_sig_key=(
+	SELECT identity
+	FROM whatsmeow_identity_keys
+	WHERE our_jid=whatsmeow_device.jid
+	  AND their_id=concat(split_part(whatsmeow_device.jid, '.', 1), ':0')
+);
+DELETE FROM whatsmeow_device WHERE adv_account_sig_key IS NULL;
+ALTER TABLE whatsmeow_device ALTER COLUMN adv_account_sig_key SET NOT NULL;
+`
+
+const fillSigKeySQLite = `
+UPDATE whatsmeow_device SET adv_account_sig_key=(
+	SELECT identity
+	FROM whatsmeow_identity_keys
+	WHERE our_jid=whatsmeow_device.jid
+	  AND their_id=substr(whatsmeow_device.jid, 0, instr(whatsmeow_device.jid, '.')) || ':0'
+)
+`
+
+func upgradeV2(tx *sql.Tx, container *Container) error {
+	_, err := tx.Exec("ALTER TABLE whatsmeow_device ADD COLUMN adv_account_sig_key bytea CHECK ( length(adv_account_sig_key) = 32 )")
+	if err != nil {
+		return err
+	}
+
+	if strings.Contains(container.dialect, "postgres") || container.dialect == "pgx" {
+		_, err = tx.Exec(fillSigKeyPostgres)
+	} else {
+		_, err = tx.Exec(fillSigKeySQLite)
+	}
+	return err
+}
+
+func upgradeV3(tx *sql.Tx, container *Container) error {
+	_, err := tx.Exec(`CREATE TABLE whatsmeow_message_secrets (
+		our_jid    TEXT,
+		chat_jid   TEXT,
+		sender_jid TEXT,
+		message_id TEXT,
+		key        bytea NOT NULL,
+
+		PRIMARY KEY (our_jid, chat_jid, sender_jid, message_id),
+		FOREIGN KEY (our_jid) REFERENCES whatsmeow_device(jid) ON DELETE CASCADE ON UPDATE CASCADE
+	)`)
+	return err
+}
+
+func upgradeV4(tx *sql.Tx, container *Container) error {
+	_, err := tx.Exec(`CREATE TABLE whatsmeow_privacy_tokens (
+		our_jid   TEXT,
+		their_jid TEXT,
+		token     bytea  NOT NULL,
+		timestamp BIGINT NOT NULL,
+		PRIMARY KEY (our_jid, their_jid)
+	)`)
+	return err
+}
+
+func upgradeV5(tx *sql.Tx, container *Container) error {
+	_, err := tx.Exec("UPDATE whatsmeow_device SET jid=REPLACE(jid, '.0', '')")
+	return err
+}
+
+func upgradeV6(tx *sql.Tx, container *Container) error {
+	_, err := tx.Exec("ALTER TABLE whatsmeow_device ADD COLUMN facebook_uuid uuid")
+	return err
+}

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/store/store.go

@@ -0,0 +1,194 @@
+// Copyright (c) 2022 Tulir Asokan
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+// Package store contains interfaces for storing data needed for WhatsApp multidevice.
+package store
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/google/uuid"
+
+	"go.mau.fi/whatsmeow/proto/waAdv"
+	"go.mau.fi/whatsmeow/types"
+	"go.mau.fi/whatsmeow/util/keys"
+	waLog "go.mau.fi/whatsmeow/util/log"
+)
+
+type IdentityStore interface {
+	PutIdentity(address string, key [32]byte) error
+	DeleteAllIdentities(phone string) error
+	DeleteIdentity(address string) error
+	IsTrustedIdentity(address string, key [32]byte) (bool, error)
+}
+
+type SessionStore interface {
+	GetSession(address string) ([]byte, error)
+	HasSession(address string) (bool, error)
+	PutSession(address string, session []byte) error
+	DeleteAllSessions(phone string) error
+	DeleteSession(address string) error
+}
+
+type PreKeyStore interface {
+	GetOrGenPreKeys(count uint32) ([]*keys.PreKey, error)
+	GenOnePreKey() (*keys.PreKey, error)
+	GetPreKey(id uint32) (*keys.PreKey, error)
+	RemovePreKey(id uint32) error
+	MarkPreKeysAsUploaded(upToID uint32) error
+	UploadedPreKeyCount() (int, error)
+}
+
+type SenderKeyStore interface {
+	PutSenderKey(group, user string, session []byte) error
+	GetSenderKey(group, user string) ([]byte, error)
+}
+
+type AppStateSyncKey struct {
+	Data        []byte
+	Fingerprint []byte
+	Timestamp   int64
+}
+
+type AppStateSyncKeyStore interface {
+	PutAppStateSyncKey(id []byte, key AppStateSyncKey) error
+	GetAppStateSyncKey(id []byte) (*AppStateSyncKey, error)
+	GetLatestAppStateSyncKeyID() ([]byte, error)
+}
+
+type AppStateMutationMAC struct {
+	IndexMAC []byte
+	ValueMAC []byte
+}
+
+type AppStateStore interface {
+	PutAppStateVersion(name string, version uint64, hash [128]byte) error
+	GetAppStateVersion(name string) (uint64, [128]byte, error)
+	DeleteAppStateVersion(name string) error
+
+	PutAppStateMutationMACs(name string, version uint64, mutations []AppStateMutationMAC) error
+	DeleteAppStateMutationMACs(name string, indexMACs [][]byte) error
+	GetAppStateMutationMAC(name string, indexMAC []byte) (valueMAC []byte, err error)
+}
+
+type ContactEntry struct {
+	JID       types.JID
+	FirstName string
+	FullName  string
+}
+
+type ContactStore interface {
+	PutPushName(user types.JID, pushName string) (bool, string, error)
+	PutBusinessName(user types.JID, businessName string) (bool, string, error)
+	PutContactName(user types.JID, fullName, firstName string) error
+	PutAllContactNames(contacts []ContactEntry) error
+	GetContact(user types.JID) (types.ContactInfo, error)
+	GetAllContacts() (map[types.JID]types.ContactInfo, error)
+}
+
+type ChatSettingsStore interface {
+	PutMutedUntil(chat types.JID, mutedUntil time.Time) error
+	PutPinned(chat types.JID, pinned bool) error
+	PutArchived(chat types.JID, archived bool) error
+	GetChatSettings(chat types.JID) (types.LocalChatSettings, error)
+}
+
+type DeviceContainer interface {
+	PutDevice(store *Device) error
+	DeleteDevice(store *Device) error
+}
+
+type MessageSecretInsert struct {
+	Chat   types.JID
+	Sender types.JID
+	ID     types.MessageID
+	Secret []byte
+}
+
+type MsgSecretStore interface {
+	PutMessageSecrets([]MessageSecretInsert) error
+	PutMessageSecret(chat, sender types.JID, id types.MessageID, secret []byte) error
+	GetMessageSecret(chat, sender types.JID, id types.MessageID) ([]byte, error)
+}
+
+type PrivacyToken struct {
+	User      types.JID
+	Token     []byte
+	Timestamp time.Time
+}
+
+type PrivacyTokenStore interface {
+	PutPrivacyTokens(tokens ...PrivacyToken) error
+	GetPrivacyToken(user types.JID) (*PrivacyToken, error)
+}
+
+type AllStores interface {
+	IdentityStore
+	SessionStore
+	PreKeyStore
+	SenderKeyStore
+	AppStateSyncKeyStore
+	AppStateStore
+	ContactStore
+	ChatSettingsStore
+	MsgSecretStore
+	PrivacyTokenStore
+}
+
+type Device struct {
+	Log waLog.Logger
+
+	NoiseKey       *keys.KeyPair
+	IdentityKey    *keys.KeyPair
+	SignedPreKey   *keys.PreKey
+	RegistrationID uint32
+	AdvSecretKey   []byte
+
+	ID           *types.JID
+	Account      *waAdv.ADVSignedDeviceIdentity
+	Platform     string
+	BusinessName string
+	PushName     string
+
+	FacebookUUID uuid.UUID
+
+	Initialized   bool
+	Identities    IdentityStore
+	Sessions      SessionStore
+	PreKeys       PreKeyStore
+	SenderKeys    SenderKeyStore
+	AppStateKeys  AppStateSyncKeyStore
+	AppState      AppStateStore
+	Contacts      ContactStore
+	ChatSettings  ChatSettingsStore
+	MsgSecrets    MsgSecretStore
+	PrivacyTokens PrivacyTokenStore
+	Container     DeviceContainer
+
+	DatabaseErrorHandler func(device *Device, action string, attemptIndex int, err error) (retry bool)
+}
+
+func (device *Device) handleDatabaseError(attemptIndex int, err error, action string, args ...interface{}) bool {
+	if device.DatabaseErrorHandler != nil {
+		return device.DatabaseErrorHandler(device, fmt.Sprintf(action, args...), attemptIndex, err)
+	}
+	device.Log.Errorf("Failed to %s: %v", fmt.Sprintf(action, args...), err)
+	return false
+}
+
+func (device *Device) Save() error {
+	return device.Container.PutDevice(device)
+}
+
+func (device *Device) Delete() error {
+	err := device.Container.DeleteDevice(device)
+	if err != nil {
+		return err
+	}
+	device.ID = nil
+	return nil
+}

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/types/call.go

@@ -0,0 +1,21 @@
+// Copyright (c) 2021 Tulir Asokan
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package types
+
+import "time"
+
+type BasicCallMeta struct {
+	From        JID
+	Timestamp   time.Time
+	CallCreator JID
+	CallID      string
+}
+
+type CallRemoteMeta struct {
+	RemotePlatform string // The platform of the caller's WhatsApp client
+	RemoteVersion  string // Version of the caller's WhatsApp client
+}

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/types/events/appstate.go

@@ -0,0 +1,185 @@
+// Copyright (c) 2021 Tulir Asokan
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package events
+
+import (
+	"time"
+
+	"go.mau.fi/whatsmeow/appstate"
+	"go.mau.fi/whatsmeow/proto/waSyncAction"
+	"go.mau.fi/whatsmeow/types"
+)
+
+// Contact is emitted when an entry in the user's contact list is modified from another device.
+type Contact struct {
+	JID       types.JID // The contact who was modified.
+	Timestamp time.Time // The time when the modification happened.'
+
+	Action       *waSyncAction.ContactAction // The new contact info.
+	FromFullSync bool                        // Whether the action is emitted because of a fullSync
+}
+
+// PushName is emitted when a message is received with a different push name than the previous value cached for the same user.
+type PushName struct {
+	JID         types.JID          // The user whose push name changed.
+	Message     *types.MessageInfo // The message where this change was first noticed.
+	OldPushName string             // The previous push name from the local cache.
+	NewPushName string             // The new push name that was included in the message.
+}
+
+// BusinessName is emitted when a message is received with a different verified business name than the previous value cached for the same user.
+type BusinessName struct {
+	JID             types.JID
+	Message         *types.MessageInfo // This is only present if the change was detected in a message.
+	OldBusinessName string
+	NewBusinessName string
+}
+
+// Pin is emitted when a chat is pinned or unpinned from another device.
+type Pin struct {
+	JID       types.JID // The chat which was pinned or unpinned.
+	Timestamp time.Time // The time when the (un)pinning happened.
+
+	Action       *waSyncAction.PinAction // Whether the chat is now pinned or not.
+	FromFullSync bool                    // Whether the action is emitted because of a fullSync
+}
+
+// Star is emitted when a message is starred or unstarred from another device.
+type Star struct {
+	ChatJID   types.JID // The chat where the message was pinned.
+	SenderJID types.JID // In group chats, the user who sent the message (except if the message was sent by the user).
+	IsFromMe  bool      // Whether the message was sent by the user.
+	MessageID string    // The message which was starred or unstarred.
+	Timestamp time.Time // The time when the (un)starring happened.
+
+	Action       *waSyncAction.StarAction // Whether the message is now starred or not.
+	FromFullSync bool                     // Whether the action is emitted because of a fullSync
+}
+
+// DeleteForMe is emitted when a message is deleted (for the current user only) from another device.
+type DeleteForMe struct {
+	ChatJID   types.JID // The chat where the message was deleted.
+	SenderJID types.JID // In group chats, the user who sent the message (except if the message was sent by the user).
+	IsFromMe  bool      // Whether the message was sent by the user.
+	MessageID string    // The message which was deleted.
+	Timestamp time.Time // The time when the deletion happened.
+
+	Action       *waSyncAction.DeleteMessageForMeAction // Additional information for the deletion.
+	FromFullSync bool                                   // Whether the action is emitted because of a fullSync
+}
+
+// Mute is emitted when a chat is muted or unmuted from another device.
+type Mute struct {
+	JID       types.JID // The chat which was muted or unmuted.
+	Timestamp time.Time // The time when the (un)muting happened.
+
+	Action       *waSyncAction.MuteAction // The current mute status of the chat.
+	FromFullSync bool                     // Whether the action is emitted because of a fullSync
+}
+
+// Archive is emitted when a chat is archived or unarchived from another device.
+type Archive struct {
+	JID       types.JID // The chat which was archived or unarchived.
+	Timestamp time.Time // The time when the (un)archiving happened.
+
+	Action       *waSyncAction.ArchiveChatAction // The current archival status of the chat.
+	FromFullSync bool                            // Whether the action is emitted because of a fullSync
+}
+
+// MarkChatAsRead is emitted when a whole chat is marked as read or unread from another device.
+type MarkChatAsRead struct {
+	JID       types.JID // The chat which was marked as read or unread.
+	Timestamp time.Time // The time when the marking happened.
+
+	Action       *waSyncAction.MarkChatAsReadAction // Whether the chat was marked as read or unread, and info about the most recent messages.
+	FromFullSync bool                               // Whether the action is emitted because of a fullSync
+}
+
+// ClearChat is emitted when a chat is cleared on another device. This is different from DeleteChat.
+type ClearChat struct {
+	JID       types.JID // The chat which was cleared.
+	Timestamp time.Time // The time when the clear happened.
+
+	Action       *waSyncAction.ClearChatAction // Information about the clear.
+	FromFullSync bool                          // Whether the action is emitted because of a fullSync
+}
+
+// DeleteChat is emitted when a chat is deleted on another device.
+type DeleteChat struct {
+	JID       types.JID // The chat which was deleted.
+	Timestamp time.Time // The time when the deletion happened.
+
+	Action       *waSyncAction.DeleteChatAction // Information about the deletion.
+	FromFullSync bool                           // Whether the action is emitted because of a fullSync
+}
+
+// PushNameSetting is emitted when the user's push name is changed from another device.
+type PushNameSetting struct {
+	Timestamp time.Time // The time when the push name was changed.
+
+	Action       *waSyncAction.PushNameSetting // The new push name for the user.
+	FromFullSync bool                          // Whether the action is emitted because of a fullSync
+}
+
+// UnarchiveChatsSetting is emitted when the user changes the "Keep chats archived" setting from another device.
+type UnarchiveChatsSetting struct {
+	Timestamp time.Time // The time when the setting was changed.
+
+	Action       *waSyncAction.UnarchiveChatsSetting // The new settings.
+	FromFullSync bool                                // Whether the action is emitted because of a fullSync
+}
+
+// UserStatusMute is emitted when the user mutes or unmutes another user's status updates.
+type UserStatusMute struct {
+	JID       types.JID // The user who was muted or unmuted
+	Timestamp time.Time // The timestamp when the action happened
+
+	Action       *waSyncAction.UserStatusMuteAction // The new mute status
+	FromFullSync bool                               // Whether the action is emitted because of a fullSync
+}
+
+// LabelEdit is emitted when a label is edited from any device.
+type LabelEdit struct {
+	Timestamp time.Time // The time when the label was edited.
+	LabelID   string    // The label id which was edited.
+
+	Action       *waSyncAction.LabelEditAction // The new label info.
+	FromFullSync bool                          // Whether the action is emitted because of a fullSync
+}
+
+// LabelAssociationChat is emitted when a chat is labeled or unlabeled from any device.
+type LabelAssociationChat struct {
+	JID       types.JID // The chat which was labeled or unlabeled.
+	Timestamp time.Time // The time when the (un)labeling happened.
+	LabelID   string    // The label id which was added or removed.
+
+	Action       *waSyncAction.LabelAssociationAction // The current label status of the chat.
+	FromFullSync bool                                 // Whether the action is emitted because of a fullSync
+}
+
+// LabelAssociationMessage is emitted when a message is labeled or unlabeled from any device.
+type LabelAssociationMessage struct {
+	JID       types.JID // The chat which was labeled or unlabeled.
+	Timestamp time.Time // The time when the (un)labeling happened.
+	LabelID   string    // The label id which was added or removed.
+	MessageID string    // The message id which was labeled or unlabeled.
+
+	Action       *waSyncAction.LabelAssociationAction // The current label status of the message.
+	FromFullSync bool                                 // Whether the action is emitted because of a fullSync
+}
+
+// AppState is emitted directly for new data received from app state syncing.
+// You should generally use the higher-level events like events.Contact and events.Mute.
+type AppState struct {
+	Index []string
+	*waSyncAction.SyncActionValue
+}
+
+// AppStateSyncComplete is emitted when app state is resynced.
+type AppStateSyncComplete struct {
+	Name appstate.WAPatchName
+}