diff --git a/Example/example.ts b/Example/example.ts
index eb6fd15..33db559 100644
--- a/Example/example.ts
+++ b/Example/example.ts
@@ -3,7 +3,7 @@ import NodeCache from 'node-cache'
 import makeWASocket, { AnyMessageContent, delay, DisconnectReason, fetchLatestBaileysVersion, getAggregateVotesInPollMessage, makeCacheableSignalKeyStore, makeInMemoryStore, proto, useMultiFileAuthState, WAMessageContent, WAMessageKey } from '../src'
 import MAIN_LOGGER from '../src/Utils/logger'
 
-const logger = MAIN_LOGGER.child({ })
+const logger = MAIN_LOGGER.child({})
 logger.level = 'trace'
 
 const useStore = !process.argv.includes('--no-store')
@@ -88,6 +88,15 @@ const startSock = async() => {
 				await saveCreds()
 			}
 
+			if(events['labels.association']) {
+				console.log(events['labels.association'])
+			}
+
+
+			if(events['labels.edit']) {
+				console.log(events['labels.edit'])
+			}
+
 			if(events.call) {
 				console.log('recv call event', events.call)
 			}
diff --git a/README.md b/README.md
index c0047f7..a5a8821 100644
--- a/README.md
+++ b/README.md
@@ -240,6 +240,8 @@ export type BaileysEventMap = {
     'chats.update': Partial<Chat>[]
     /** delete chats with given ID */
     'chats.delete': string[]
+    'labels.association': LabelAssociation
+    'labels.edit': Label
     /** presence of contact in a chat updated */
     'presence.update': { id: string, presences: { [participant: string]: PresenceData } }
 
diff --git a/src/Socket/chats.ts b/src/Socket/chats.ts
index 35cb8e3..1a88161 100644
--- a/src/Socket/chats.ts
+++ b/src/Socket/chats.ts
@@ -52,7 +52,7 @@ export const makeChatsSocket = (config: SocketConfig) => {
 					type: 'get'
 				},
 				content: [
-					{ tag: 'privacy', attrs: { } }
+					{ tag: 'privacy', attrs: {} }
 				]
 			})
 			privacySettings = reduceBinaryNodeToDictionary(content?.[0] as BinaryNode, 'category')
@@ -118,7 +118,7 @@ export const makeChatsSocket = (config: SocketConfig) => {
 			content: [{
 				tag: 'disappearing_mode',
 				attrs: {
-					duration : duration.toString()
+					duration: duration.toString()
 				}
 			}]
 		})
@@ -146,12 +146,12 @@ export const makeChatsSocket = (config: SocketConfig) => {
 					content: [
 						{
 							tag: 'query',
-							attrs: { },
-							content: [ queryNode ]
+							attrs: {},
+							content: [queryNode]
 						},
 						{
 							tag: 'list',
-							attrs: { },
+							attrs: {},
 							content: userNodes
 						}
 					]
@@ -171,17 +171,17 @@ export const makeChatsSocket = (config: SocketConfig) => {
 			[
 				{
 					tag: 'user',
-					attrs: { },
+					attrs: {},
 					content: jids.map(
 						jid => ({
 							tag: 'contact',
-							attrs: { },
+							attrs: {},
 							content: `+${jid}`
 						})
 					)
 				}
 			],
-			{ tag: 'contact', attrs: { } }
+			{ tag: 'contact', attrs: {} }
 		)
 
 		return results.map(user => {
@@ -193,7 +193,7 @@ export const makeChatsSocket = (config: SocketConfig) => {
 	const fetchStatus = async(jid: string) => {
 		const [result] = await interactiveQuery(
 			[{ tag: 'user', attrs: { jid } }],
-			{ tag: 'status', attrs: { } }
+			{ tag: 'status', attrs: {} }
 		)
 		if(result) {
 			const status = getBinaryNodeChild(result, 'status')
@@ -248,7 +248,7 @@ export const makeChatsSocket = (config: SocketConfig) => {
 			content: [
 				{
 					tag: 'status',
-					attrs: { },
+					attrs: {},
 					content: Buffer.from(status, 'utf-8')
 				}
 			]
@@ -379,19 +379,19 @@ export const makeChatsSocket = (config: SocketConfig) => {
 	const resyncAppState = ev.createBufferedFunction(async(collections: readonly WAPatchName[], isInitialSync: boolean) => {
 		// we use this to determine which events to fire
 		// otherwise when we resync from scratch -- all notifications will fire
-		const initialVersionMap: { [T in WAPatchName]?: number } = { }
-		const globalMutationMap: ChatMutationMap = { }
+		const initialVersionMap: { [T in WAPatchName]?: number } = {}
+		const globalMutationMap: ChatMutationMap = {}
 
 		await authState.keys.transaction(
 			async() => {
 				const collectionsToHandle = new Set<string>(collections)
 				// in case something goes wrong -- ensure we don't enter a loop that cannot be exited from
-				const attemptsMap: { [T in WAPatchName]?: number } = { }
+				const attemptsMap: { [T in WAPatchName]?: number } = {}
 				// keep executing till all collections are done
 				// sometimes a single patch request will not return all the patches (God knows why)
 				// so we fetch till they're all done (this is determined by the "has_more_patches" flag)
 				while(collectionsToHandle.size) {
-					const states = { } as { [T in WAPatchName]: LTHashState }
+					const states = {} as { [T in WAPatchName]: LTHashState }
 					const nodes: BinaryNode[] = []
 
 					for(const name of collectionsToHandle) {
@@ -412,7 +412,7 @@ export const makeChatsSocket = (config: SocketConfig) => {
 
 						nodes.push({
 							tag: 'collection',
-							attrs:  {
+							attrs: {
 								name,
 								version: state.version.toString(),
 								// return snapshot if being synced from scratch
@@ -431,7 +431,7 @@ export const makeChatsSocket = (config: SocketConfig) => {
 						content: [
 							{
 								tag: 'sync',
-								attrs: { },
+								attrs: {},
 								content: nodes
 							}
 						]
@@ -516,10 +516,10 @@ export const makeChatsSocket = (config: SocketConfig) => {
 	})
 
 	/**
-     * fetch the profile picture of a user/group
-     * type = "preview" for a low res picture
-     * type = "image for the high res picture"
-     */
+	 * fetch the profile picture of a user/group
+	 * type = "preview" for a low res picture
+	 * type = "image for the high res picture"
+	 */
 	const profilePictureUrl = async(jid: string, type: 'preview' | 'image' = 'preview', timeoutMs?: number) => {
 		jid = jidNormalizedUser(jid)
 		const result = await query({
@@ -564,7 +564,7 @@ export const makeChatsSocket = (config: SocketConfig) => {
 				content: [
 					{
 						tag: type === 'recording' ? 'composing' : type,
-						attrs: type === 'recording' ? { media : 'audio' } : {}
+						attrs: type === 'recording' ? { media: 'audio' } : {}
 					}
 				]
 			})
@@ -587,7 +587,7 @@ export const makeChatsSocket = (config: SocketConfig) => {
 				? [
 					{
 						tag: 'tctoken',
-						attrs: { },
+						attrs: {},
 						content: tcToken
 					}
 				]
@@ -669,7 +669,7 @@ export const makeChatsSocket = (config: SocketConfig) => {
 							content: [
 								{
 									tag: 'sync',
-									attrs: { },
+									attrs: {},
 									content: [
 										{
 											tag: 'collection',
@@ -681,7 +681,7 @@ export const makeChatsSocket = (config: SocketConfig) => {
 											content: [
 												{
 													tag: 'patch',
-													attrs: { },
+													attrs: {},
 													content: proto.SyncdPatch.encode(patch).finish()
 												}
 											]
@@ -731,7 +731,7 @@ export const makeChatsSocket = (config: SocketConfig) => {
 
 		const propsNode = getBinaryNodeChild(abtNode, 'props')
 
-		let props: { [_: string]: string } = { }
+		let props: { [_: string]: string } = {}
 		if(propsNode) {
 			props = reduceBinaryNodeToDictionary(propsNode, 'prop')
 		}
@@ -751,13 +751,13 @@ export const makeChatsSocket = (config: SocketConfig) => {
 				type: 'get',
 			},
 			content: [
-				{ tag: 'props', attrs: { } }
+				{ tag: 'props', attrs: {} }
 			]
 		})
 
 		const propsNode = getBinaryNodeChild(resultNode, 'props')
 
-		let props: { [_: string]: string } = { }
+		let props: { [_: string]: string } = {}
 		if(propsNode) {
 			props = reduceBinaryNodeToDictionary(propsNode, 'prop')
 		}
@@ -768,15 +768,61 @@ export const makeChatsSocket = (config: SocketConfig) => {
 	}
 
 	/**
-     * modify a chat -- mark unread, read etc.
-     * lastMessages must be sorted in reverse chronologically
-     * requires the last messages till the last message received; required for archive & unread
-    */
+	 * modify a chat -- mark unread, read etc.
+	 * lastMessages must be sorted in reverse chronologically
+	 * requires the last messages till the last message received; required for archive & unread
+	*/
 	const chatModify = (mod: ChatModification, jid: string) => {
 		const patch = chatModificationToAppPatch(mod, jid)
 		return appPatch(patch)
 	}
 
+	/**
+	 * Adds label for the chats
+	 */
+	const addChatLabel = (jid: string, labelId: string) => {
+		return chatModify({
+			addChatLabel: {
+				labelId
+			}
+		}, jid)
+	}
+
+	/**
+	 * Removes label for the chat
+	 */
+	const removeChatLabel = (jid: string, labelId: string) => {
+		return chatModify({
+			removeChatLabel: {
+				labelId
+			}
+		}, jid)
+	}
+
+	/**
+	 * Adds label for the message
+	 */
+	const addMessageLabel = (jid: string, messageId: string, labelId: string) => {
+		return chatModify({
+			addMessageLabel: {
+				messageId,
+				labelId
+			}
+		}, jid)
+	}
+
+	/**
+	 * Removes label for the message
+	 */
+	const removeMessageLabel = (jid: string, messageId: string, labelId: string) => {
+		return chatModify({
+			removeMessageLabel: {
+				messageId,
+				labelId
+			}
+		}, jid)
+	}
+
 	/**
 	 * queries need to be fired on connection open
 	 * help ensure parity with WA Web
@@ -945,6 +991,10 @@ export const makeChatsSocket = (config: SocketConfig) => {
 		updateDefaultDisappearingMode,
 		getBusinessProfile,
 		resyncAppState,
-		chatModify
+		chatModify,
+		addChatLabel,
+		removeChatLabel,
+		addMessageLabel,
+		removeMessageLabel
 	}
 }
diff --git a/src/Store/make-in-memory-store.ts b/src/Store/make-in-memory-store.ts
index 477be1d..8830911 100644
--- a/src/Store/make-in-memory-store.ts
+++ b/src/Store/make-in-memory-store.ts
@@ -1,43 +1,94 @@
-import type KeyedDB from '@adiwajshing/keyed-db'
+import KeyedDB from '@adiwajshing/keyed-db'
 import type { Comparable } from '@adiwajshing/keyed-db/lib/Types'
 import type { Logger } from 'pino'
 import { proto } from '../../WAProto'
 import { DEFAULT_CONNECTION_CONFIG } from '../Defaults'
 import type makeMDSocket from '../Socket'
 import type { BaileysEventEmitter, Chat, ConnectionState, Contact, GroupMetadata, PresenceData, WAMessage, WAMessageCursor, WAMessageKey } from '../Types'
+import { Label } from '../Types/Label'
+import { LabelAssociation, LabelAssociationType, MessageLabelAssociation } from '../Types/LabelAssociation'
 import { toNumber, updateMessageWithReaction, updateMessageWithReceipt } from '../Utils'
 import { jidNormalizedUser } from '../WABinary'
 import makeOrderedDictionary from './make-ordered-dictionary'
+import { ObjectRepository } from './object-repository'
 
 type WASocket = ReturnType<typeof makeMDSocket>
 
 export const waChatKey = (pin: boolean) => ({
 	key: (c: Chat) => (pin ? (c.pinned ? '1' : '0') : '') + (c.archived ? '0' : '1') + (c.conversationTimestamp ? c.conversationTimestamp.toString(16).padStart(8, '0') : '') + c.id,
-	compare: (k1: string, k2: string) => k2.localeCompare (k1)
+	compare: (k1: string, k2: string) => k2.localeCompare(k1)
 })
 
 export const waMessageID = (m: WAMessage) => m.key.id || ''
 
+export const waLabelAssociationKey: Comparable<LabelAssociation, string> = {
+	key: (la: LabelAssociation) => (la.type === LabelAssociationType.Chat ? la.chatId + la.labelId : la.chatId + la.messageId + la.labelId),
+	compare: (k1: string, k2: string) => k2.localeCompare(k1)
+}
+
 export type BaileysInMemoryStoreConfig = {
 	chatKey?: Comparable<Chat, string>
+	labelAssociationKey?: Comparable<LabelAssociation, string>
 	logger?: Logger
 }
 
 const makeMessagesDictionary = () => makeOrderedDictionary(waMessageID)
 
-export default (
-	{ logger: _logger, chatKey }: BaileysInMemoryStoreConfig
-) => {
-	const logger = _logger || DEFAULT_CONNECTION_CONFIG.logger.child({ stream: 'in-mem-store' })
-	chatKey = chatKey || waChatKey(true)
-	const KeyedDB = require('@adiwajshing/keyed-db').default as new (...args: any[]) => KeyedDB<Chat, string>
+const predefinedLabels = Object.freeze<Record<string, Label>>({
+	'0': {
+		id: '0',
+		name: 'New customer',
+		predefinedId: '0',
+		color: 0,
+		deleted: false
+	},
+	'1': {
+		id: '1',
+		name: 'New order',
+		predefinedId: '1',
+		color: 1,
+		deleted: false
+	},
+	'2': {
+		id: '2',
+		name: 'Pending payment',
+		predefinedId: '2',
+		color: 2,
+		deleted: false
+	},
+	'3': {
+		id: '3',
+		name: 'Paid',
+		predefinedId: '3',
+		color: 3,
+		deleted: false
+	},
+	'4': {
+		id: '4',
+		name: 'Order completed',
+		predefinedId: '4',
+		color: 4,
+		deleted: false
+	}
+})
 
-	const chats = new KeyedDB(chatKey, c => c.id)
-	const messages: { [_: string]: ReturnType<typeof makeMessagesDictionary> } = { }
-	const contacts: { [_: string]: Contact } = { }
-	const groupMetadata: { [_: string]: GroupMetadata } = { }
-	const presences: { [id: string]: { [participant: string]: PresenceData } } = { }
+export default (
+	{ logger: _logger, chatKey, labelAssociationKey }: BaileysInMemoryStoreConfig
+) => {
+	// const logger = _logger || DEFAULT_CONNECTION_CONFIG.logger.child({ stream: 'in-mem-store' })
+	chatKey = chatKey || waChatKey(true)
+	labelAssociationKey = labelAssociationKey || waLabelAssociationKey
+	const logger = _logger || DEFAULT_CONNECTION_CONFIG.logger.child({ stream: 'in-mem-store' })
+	// const KeyedDB = require('@adiwajshing/keyed-db').default as new (...args: any[]) => KeyedDB<Chat, string>
+
+	const chats = new KeyedDB<Chat, string>(chatKey, c => c.id)
+	const messages: { [_: string]: ReturnType<typeof makeMessagesDictionary> } = {}
+	const contacts: { [_: string]: Contact } = {}
+	const groupMetadata: { [_: string]: GroupMetadata } = {}
+	const presences: { [id: string]: { [participant: string]: PresenceData } } = {}
 	const state: ConnectionState = { connection: 'close' }
+	const labels = new ObjectRepository<Label>(predefinedLabels)
+	const labelAssociations = new KeyedDB<LabelAssociation, string>(labelAssociationKey, labelAssociationKey.key)
 
 	const assertMessageList = (jid: string) => {
 		if(!messages[jid]) {
@@ -60,6 +111,12 @@ export default (
 		return oldContacts
 	}
 
+	const labelsUpsert = (newLabels: Label[]) => {
+		for(const label of newLabels) {
+			labels.upsertById(label.id, label)
+		}
+	}
+
 	/**
 	 * binds to a BaileysEventEmitter.
 	 * It listens to all events and constructs a state that you can query accurate data from.
@@ -131,6 +188,33 @@ export default (
 				}
 			}
 		})
+
+		ev.on('labels.edit', (label: Label) => {
+			if(label.deleted) {
+				return labels.deleteById(label.id)
+			}
+
+			// WhatsApp can store only up to 20 labels
+			if(labels.count() < 20) {
+				return labels.upsertById(label.id, label)
+			}
+
+			logger.error('Labels count exceed')
+		})
+
+		ev.on('labels.association', ({ type, association }) => {
+			switch (type) {
+			case 'add':
+				labelAssociations.upsert(association)
+				break
+			case 'remove':
+				labelAssociations.delete(association)
+				break
+			default:
+				console.error(`unknown operation type [${type}]`)
+			}
+		})
+
 		ev.on('presence.update', ({ id, presences: update }) => {
 			presences[id] = presences[id] || {}
 			Object.assign(presences[id], update)
@@ -255,12 +339,16 @@ export default (
 	const toJSON = () => ({
 		chats,
 		contacts,
-		messages
+		messages,
+		labels,
+		labelAssociations
 	})
 
-	const fromJSON = (json: { chats: Chat[], contacts: { [id: string]: Contact }, messages: { [id: string]: WAMessage[] } }) => {
+	const fromJSON = (json: {chats: Chat[], contacts: { [id: string]: Contact }, messages: { [id: string]: WAMessage[] }, labels: { [labelId: string]: Label }, labelAssociations: LabelAssociation[]}) => {
 		chats.upsert(...json.chats)
+		labelAssociations.upsert(...json.labelAssociations || [])
 		contactsUpsert(Object.values(json.contacts))
+		labelsUpsert(Object.values(json.labels || {}))
 		for(const jid in json.messages) {
 			const list = assertMessageList(jid)
 			for(const msg of json.messages[jid]) {
@@ -277,6 +365,8 @@ export default (
 		groupMetadata,
 		state,
 		presences,
+		labels,
+		labelAssociations,
 		bind,
 		/** loads messages from the store, if not found -- uses the legacy connection */
 		loadMessages: async(jid: string, count: number, cursor: WAMessageCursor) => {
@@ -304,6 +394,38 @@ export default (
 
 			return messages
 		},
+		/**
+		 * Get all available labels for profile
+		 *
+		 * Keep in mind that the list is formed from predefined tags and tags
+		 * that were "caught" during their editing.
+		 */
+		getLabels: () => {
+			return labels
+		},
+
+		/**
+		 * Get labels for chat
+		 *
+		 * @returns Label IDs
+		 **/
+		getChatLabels: (chatId: string) => {
+			return labelAssociations.filter((la) => la.chatId === chatId).all()
+		},
+
+		/**
+		 * Get labels for message
+		 *
+		 * @returns Label IDs
+		 **/
+		getMessageLabels: (messageId: string) => {
+			const associations = labelAssociations
+				.filter((la: MessageLabelAssociation) => la.messageId === messageId)
+				.all()
+
+			return associations.map(({ labelId }) => labelId)
+
+		},
 		loadMessage: async(jid: string, id: string) => messages[jid]?.get(id),
 		mostRecentMessage: async(jid: string) => {
 			const message: WAMessage | undefined = messages[jid]?.array.slice(-1)[0]
diff --git a/src/Store/object-repository.ts b/src/Store/object-repository.ts
new file mode 100644
index 0000000..adf2924
--- /dev/null
+++ b/src/Store/object-repository.ts
@@ -0,0 +1,32 @@
+export class ObjectRepository<T extends object> {
+	readonly entityMap: Map<string, T>
+
+	constructor(entities: Record<string, T> = {}) {
+		this.entityMap = new Map(Object.entries(entities))
+	}
+
+	findById(id: string) {
+		return this.entityMap.get(id)
+	}
+
+	findAll() {
+		return Array.from(this.entityMap.values())
+	}
+
+	upsertById(id: string, entity: T) {
+		return this.entityMap.set(id, { ...entity })
+	}
+
+	deleteById(id: string) {
+		return this.entityMap.delete(id)
+	}
+
+	count() {
+		return this.entityMap.size
+	}
+
+	toJSON() {
+		return this.findAll()
+	}
+
+}
\ No newline at end of file
diff --git a/src/Types/Chat.ts b/src/Types/Chat.ts
index a89a9cd..4077da8 100644
--- a/src/Types/Chat.ts
+++ b/src/Types/Chat.ts
@@ -1,6 +1,8 @@
 import type { proto } from '../../WAProto'
 import type { AccountSettings } from './Auth'
 import type { BufferedEventData } from './Events'
+import type { ChatLabelAssociationActionBody } from './LabelAssociation'
+import type { MessageLabelAssociationActionBody } from './LabelAssociation'
 import type { MinimalMessage } from './Message'
 
 /** privacy settings in WhatsApp Web */
@@ -13,13 +15,7 @@ export type WAReadReceiptsValue = 'all' | 'none'
 /** set of statuses visible to other people; see updatePresence() in WhatsAppWeb.Send */
 export type WAPresence = 'unavailable' | 'available' | 'composing' | 'recording' | 'paused'
 
-export const ALL_WA_PATCH_NAMES = [
-	'critical_block',
-	'critical_unblock_low',
-	'regular_high',
-	'regular_low',
-	'regular'
-] as const
+export const ALL_WA_PATCH_NAMES = ['critical_block', 'critical_unblock_low', 'regular_high', 'regular_low', 'regular'] as const
 
 export type WAPatchName = typeof ALL_WA_PATCH_NAMES[number]
 
@@ -77,7 +73,7 @@ export type ChatModification =
         mute: number | null
     }
     | {
-        clear: 'all' | { messages: {id: string, fromMe?: boolean, timestamp: number}[] }
+        clear: 'all' | { messages: { id: string, fromMe?: boolean, timestamp: number }[] }
     }
     | {
         star: {
@@ -90,6 +86,11 @@ export type ChatModification =
         lastMessages: LastMessageList
     }
     | { delete: true, lastMessages: LastMessageList }
+    // Label assosiation
+    | { addChatLabel: ChatLabelAssociationActionBody }
+    | { removeChatLabel: ChatLabelAssociationActionBody }
+    | { addMessageLabel: MessageLabelAssociationActionBody }
+    | { removeMessageLabel: MessageLabelAssociationActionBody }
 
 export type InitialReceivedChatsState = {
     [jid: string]: {
diff --git a/src/Types/Events.ts b/src/Types/Events.ts
index e4fc942..f37a6d2 100644
--- a/src/Types/Events.ts
+++ b/src/Types/Events.ts
@@ -5,6 +5,8 @@ import { WACallEvent } from './Call'
 import { Chat, ChatUpdate, PresenceData } from './Chat'
 import { Contact } from './Contact'
 import { GroupMetadata, ParticipantAction } from './GroupMetadata'
+import { Label } from './Label'
+import { LabelAssociation } from './LabelAssociation'
 import { MessageUpsertType, MessageUserReceiptUpdate, WAMessage, WAMessageKey, WAMessageUpdate } from './Message'
 import { ConnectionState } from './State'
 
@@ -54,6 +56,8 @@ export type BaileysEventMap = {
     'blocklist.update': { blocklist: string[], type: 'add' | 'remove' }
     /** Receive an update on a call, including when the call was received, rejected, accepted */
     'call': WACallEvent[]
+    'labels.edit': Label
+    'labels.association': { association: LabelAssociation, type: 'add' | 'remove' }
 }
 
 export type BufferedEventData = {
diff --git a/src/Types/Label.ts b/src/Types/Label.ts
new file mode 100644
index 0000000..6319b00
--- /dev/null
+++ b/src/Types/Label.ts
@@ -0,0 +1,36 @@
+export interface Label {
+    /** Label uniq ID */
+    id: string
+    /** Label name */
+    name: string
+    /** Label color ID */
+    color: number
+    /** Is label has been deleted */
+    deleted: boolean
+    /** WhatsApp has 5 predefined labels (New customer, New order & etc) */
+    predefinedId?: string
+}
+
+/** WhatsApp has 20 predefined colors */
+export enum LabelColor {
+    Color1 = 0,
+    Color2,
+    Color3,
+    Color4,
+    Color5,
+    Color6,
+    Color7,
+    Color8,
+    Color9,
+    Color10,
+    Color11,
+    Color12,
+    Color13,
+    Color14,
+    Color15,
+    Color16,
+    Color17,
+    Color18,
+    Color19,
+    Color20,
+}
\ No newline at end of file
diff --git a/src/Types/LabelAssociation.ts b/src/Types/LabelAssociation.ts
new file mode 100644
index 0000000..8c17cf5
--- /dev/null
+++ b/src/Types/LabelAssociation.ts
@@ -0,0 +1,35 @@
+/** Association type */
+export enum LabelAssociationType {
+  Chat = 'label_jid',
+  Message = 'label_message'
+}
+
+export type LabelAssociationTypes = `${LabelAssociationType}`
+
+/** Association for chat */
+export interface ChatLabelAssociation {
+  type: LabelAssociationType.Chat
+  chatId: string
+  labelId: string
+}
+
+/** Association for message */
+export interface MessageLabelAssociation {
+  type: LabelAssociationType.Message
+  chatId: string
+  messageId: string
+  labelId: string
+}
+
+export type LabelAssociation = ChatLabelAssociation | MessageLabelAssociation
+
+/** Body for add/remove chat label association action */
+export interface ChatLabelAssociationActionBody {
+  labelId: string
+}
+
+/** body for add/remove message label association action */
+export interface MessageLabelAssociationActionBody {
+  labelId: string
+  messageId: string
+}
\ No newline at end of file
diff --git a/src/Utils/chat-utils.ts b/src/Utils/chat-utils.ts
index 2ce6695..99765e2 100644
--- a/src/Utils/chat-utils.ts
+++ b/src/Utils/chat-utils.ts
@@ -3,6 +3,7 @@ import { AxiosRequestConfig } from 'axios'
 import type { Logger } from 'pino'
 import { proto } from '../../WAProto'
 import { BaileysEventEmitter, Chat, ChatModification, ChatMutation, ChatUpdate, Contact, InitialAppStateSyncOptions, LastMessageList, LTHashState, WAPatchCreate, WAPatchName } from '../Types'
+import { ChatLabelAssociation, LabelAssociationType, MessageLabelAssociation } from '../Types/LabelAssociation'
 import { BinaryNode, getBinaryNodeChild, getBinaryNodeChildren, isJidGroup, jidNormalizedUser } from '../WABinary'
 import { aesDecrypt, aesEncrypt, hkdf, hmacSign } from './crypto'
 import { toNumber } from './generics'
@@ -37,15 +38,15 @@ const generateMac = (operation: proto.SyncdMutation.SyncdOperation, data: Buffer
 		}
 
 		const buff = Buffer.from([r])
-		return Buffer.concat([ buff, Buffer.from(keyId as any, 'base64') ])
+		return Buffer.concat([buff, Buffer.from(keyId as any, 'base64')])
 	}
 
 	const keyData = getKeyData()
 
 	const last = Buffer.alloc(8) // 8 bytes
-	last.set([ keyData.length ], last.length - 1)
+	last.set([keyData.length], last.length - 1)
 
-	const total = Buffer.concat([ keyData, data, last ])
+	const total = Buffer.concat([keyData, data, last])
 	const hmac = hmacSign(total, key, 'sha512')
 
 	return hmac.slice(0, 32)
@@ -170,7 +171,7 @@ export const encodeSyncdPatch = async(
 						blob: indexMac
 					},
 					value: {
-						blob: Buffer.concat([ encValue, valueMac ])
+						blob: Buffer.concat([encValue, valueMac])
 					},
 					keyId: { id: encKeyId }
 				}
@@ -280,7 +281,7 @@ export const extractSyncdPatches = async(
 	const syncNode = getBinaryNodeChild(result, 'sync')
 	const collectionNodes = getBinaryNodeChildren(syncNode, 'collection')
 
-	const final = { } as { [T in WAPatchName]: { patches: proto.ISyncdPatch[], hasMorePatches: boolean, snapshot?: proto.ISyncdSnapshot } }
+	const final = {} as { [T in WAPatchName]: { patches: proto.ISyncdPatch[], hasMorePatches: boolean, snapshot?: proto.ISyncdSnapshot } }
 	await Promise.all(
 		collectionNodes.map(
 			async collectionNode => {
@@ -301,7 +302,7 @@ export const extractSyncdPatches = async(
 					}
 
 					const blobRef = proto.ExternalBlobReference.decode(
-                        snapshotNode.content! as Buffer
+						snapshotNode.content! as Buffer
 					)
 					const data = await downloadExternalBlob(blobRef, options)
 					snapshot = proto.SyncdSnapshot.decode(data)
@@ -417,9 +418,9 @@ export const decodePatches = async(
 		indexValueMap: { ...initial.indexValueMap }
 	}
 
-	const mutationMap: ChatMutationMap = { }
+	const mutationMap: ChatMutationMap = {}
 
-	for(let i = 0;i < syncds.length;i++) {
+	for(let i = 0; i < syncds.length; i++) {
 		const syncd = syncds[i]
 		const { version, keyId, snapshotMac } = syncd
 		if(syncd.externalMutations) {
@@ -606,6 +607,68 @@ export const chatModificationToAppPatch = (
 			apiVersion: 1,
 			operation: OP.SET,
 		}
+	} else if('addChatLabel' in mod) {
+		patch = {
+			syncAction: {
+				labelAssociationAction: {
+					labeled: true,
+				}
+			},
+			index: [LabelAssociationType.Chat, mod.addChatLabel.labelId, jid],
+			type: 'regular',
+			apiVersion: 3,
+			operation: OP.SET,
+		}
+	} else if('removeChatLabel' in mod) {
+		patch = {
+			syncAction: {
+				labelAssociationAction: {
+					labeled: false,
+				}
+			},
+			index: [LabelAssociationType.Chat, mod.removeChatLabel.labelId, jid],
+			type: 'regular',
+			apiVersion: 3,
+			operation: OP.SET,
+		}
+	} else if('addMessageLabel' in mod) {
+		patch = {
+			syncAction: {
+				labelAssociationAction: {
+					labeled: true,
+				}
+			},
+			index: [
+				LabelAssociationType.Message,
+				mod.addMessageLabel.labelId,
+				jid,
+				mod.addMessageLabel.messageId,
+				'0',
+				'0'
+			],
+			type: 'regular',
+			apiVersion: 3,
+			operation: OP.SET,
+		}
+	} else if('removeMessageLabel' in mod) {
+		patch = {
+			syncAction: {
+				labelAssociationAction: {
+					labeled: false,
+				}
+			},
+			index: [
+				LabelAssociationType.Message,
+				mod.removeMessageLabel.labelId,
+				jid,
+				mod.removeMessageLabel.messageId,
+				'0',
+				'0'
+			],
+			type: 'regular',
+			apiVersion: 3,
+			operation: OP.SET,
+		}
 	} else {
 		throw new Boom('not supported')
 	}
@@ -659,7 +722,7 @@ export const processSyncAction = (
 		const archiveAction = action?.archiveChatAction
 		const isArchived = archiveAction
 			? archiveAction.archived
-		 	: type === 'archive'
+			: type === 'archive'
 		// // basically we don't need to fire an "archive" update if the chat is being marked unarchvied
 		// // this only applies for the initial sync
 		// if(isInitialSync && !isArchived) {
@@ -687,13 +750,15 @@ export const processSyncAction = (
 			conditional: getChatUpdateConditional(id, markReadAction?.messageRange)
 		}])
 	} else if(action?.deleteMessageForMeAction || type === 'deleteMessageForMe') {
-		ev.emit('messages.delete', { keys: [
-			{
-				remoteJid: id,
-				id: msgId,
-				fromMe: fromMe === '1'
-			}
-		] })
+		ev.emit('messages.delete', {
+			keys: [
+				{
+					remoteJid: id,
+					id: msgId,
+					fromMe: fromMe === '1'
+				}
+			]
+		})
 	} else if(action?.contactAction) {
 		ev.emit('contacts.upsert', [{ id, name: action.contactAction!.fullName! }])
 	} else if(action?.pushNameSetting) {
@@ -731,6 +796,34 @@ export const processSyncAction = (
 		if(!isInitialSync) {
 			ev.emit('chats.delete', [id])
 		}
+	} else if(action?.labelEditAction) {
+		const { name, color, deleted, predefinedId } = action.labelEditAction!
+
+		ev.emit('labels.edit', {
+			id,
+			name: name!,
+			color: color!,
+			deleted: deleted!,
+			predefinedId: predefinedId ? String(predefinedId) : undefined
+		})
+	} else if(action?.labelAssociationAction) {
+		ev.emit('labels.association', {
+			type: action.labelAssociationAction.labeled
+				? 'add'
+				: 'remove',
+			association: type === LabelAssociationType.Chat
+				? {
+					type: LabelAssociationType.Chat,
+					chatId: syncAction.index[2],
+					labelId: syncAction.index[1]
+				} as ChatLabelAssociation
+				: {
+					type: LabelAssociationType.Message,
+					chatId: syncAction.index[2],
+					messageId: syncAction.index[3],
+					labelId: syncAction.index[1]
+				} as MessageLabelAssociation
+		})
 	} else {
 		logger?.debug({ syncAction, id }, 'unprocessable update')
 	}