meta-cloud-api 0.0.1-beta.0 → 0.0.1

package/src/api/encryption.ts

@@ -0,0 +1,34 @@
+import { HttpMethodsEnum, WabaConfigEnum } from '../types/enums';
+import type { WabaConfigType } from '../types/config';
+import type { RequesterClass, RequesterResponseInterface, ResponseSuccess } from '../types/request';
+import BaseAPI from './base';
+import type { EncryptionClass, EncryptionPublicKeyResponse } from '../types/encryption';
+
+export default class EncryptionAPI extends BaseAPI implements EncryptionClass {
+    private readonly endpoint = 'whatsapp_business_encryption';
+
+    constructor(config: WabaConfigType, client: RequesterClass) {
+        super(config, client);
+    }
+
+    async getEncryptionPublicKey(): Promise<RequesterResponseInterface<EncryptionPublicKeyResponse>> {
+        return this.client.sendRequest(
+            HttpMethodsEnum.Get,
+            `${this.config[WabaConfigEnum.PhoneNumberId]}/${this.endpoint}`,
+            this.config[WabaConfigEnum.RequestTimeout],
+            null,
+        );
+    }
+
+    async setEncryptionPublicKey(businessPublicKey: string): Promise<RequesterResponseInterface<ResponseSuccess>> {
+        const formData = new FormData();
+        formData.append('business_public_key', businessPublicKey);
+
+        return this.client.sendRequest(
+            HttpMethodsEnum.Post,
+            `${this.config[WabaConfigEnum.PhoneNumberId]}/${this.endpoint}`,
+            this.config[WabaConfigEnum.RequestTimeout],
+            formData,
+        );
+    }
+}

package/src/api/flow.ts

@@ -0,0 +1,253 @@
+import BaseAPI from './base';
+import { WabaConfigType } from '../types/config';
+import { HttpMethodsEnum, WabaConfigEnum } from '../types/enums';
+import { RequesterClass, RequesterResponseInterface, ResponseSuccess } from '../types/request';
+import {
+    FlowClass,
+    FlowsListResponse,
+    FlowCategoryEnum,
+    Flow,
+    FlowPreviewResponse,
+    FlowAssetsResponse,
+    FlowValidationError,
+    FlowMigrationResponse,
+} from '../types/flow';
+import Logger from '../utils/logger';
+
+const LIB_NAME = 'FlowAPI';
+const LOG_LOCAL = false;
+const LOGGER = new Logger(LIB_NAME, process.env.DEBUG === 'true' || LOG_LOCAL);
+
+export default class FlowAPI extends BaseAPI implements FlowClass {
+    constructor(config: WabaConfigType, client: RequesterClass) {
+        super(config, client);
+        LOGGER.log('FlowAPI initialized');
+    }
+
+    /**
+     * List Flows
+     *
+     * @param wabaId - The WABA ID
+     * @returns Promise with the list of flows
+     */
+    async listFlows(wabaId: string): Promise<RequesterResponseInterface<FlowsListResponse>> {
+        return this.client.sendRequest(
+            HttpMethodsEnum.Get,
+            `/${wabaId}/flows`,
+            this.config[WabaConfigEnum.RequestTimeout],
+            null,
+        );
+    }
+
+    /**
+     * Create Flow
+     *
+     * @param wabaId - The WABA ID
+     * @param data - The flow data including name, categories, endpoint_uri, and optional clone_flow_id
+     * @returns Promise with the created flow ID
+     */
+    async createFlow(
+        wabaId: string,
+        data: {
+            name: string;
+            categories?: FlowCategoryEnum[];
+            endpoint_uri?: string;
+            clone_flow_id?: string;
+            flow_json?: string;
+            publish?: boolean;
+        },
+    ): Promise<
+        RequesterResponseInterface<{ id: string; success: boolean; validation_errors?: FlowValidationError[] }>
+    > {
+        const formData = new FormData();
+
+        if (data.name) formData.append('name', data.name);
+        if (data.categories) formData.append('categories', JSON.stringify(data.categories));
+        if (data.endpoint_uri) formData.append('endpoint_uri', data.endpoint_uri);
+        if (data.clone_flow_id) formData.append('clone_flow_id', data.clone_flow_id);
+        if (data.flow_json) formData.append('flow_json', data.flow_json);
+        if (data.publish !== undefined) formData.append('publish', String(data.publish));
+
+        return this.client.sendRequest(
+            HttpMethodsEnum.Post,
+            `/${wabaId}/flows`,
+            this.config[WabaConfigEnum.RequestTimeout],
+            formData,
+        );
+    }
+
+    /**
+     * Get Flow
+     *
+     * @param flowId - The flow ID
+     * @param fields - Optional fields to return
+     * @param dateFormat - Optional date format
+     * @returns Promise with the flow details
+     */
+    async getFlow(
+        flowId: string,
+        fields?: string,
+        dateFormat?: string,
+    ): Promise<RequesterResponseInterface<Flow | FlowPreviewResponse>> {
+        const params = new URLSearchParams();
+        if (fields) params.append('fields', fields);
+        if (dateFormat) params.append('date_format', dateFormat);
+
+        const queryString = params.toString() ? `?${params.toString()}` : '';
+        return this.client.sendRequest(
+            HttpMethodsEnum.Get,
+            `/${flowId}${queryString}`,
+            this.config[WabaConfigEnum.RequestTimeout],
+            null,
+        );
+    }
+
+    /**
+     * Update Flow Metadata
+     *
+     * @param flowId - The flow ID
+     * @param data - The flow metadata to update
+     * @returns Promise with the success status
+     */
+    async updateFlowMetadata(
+        flowId: string,
+        data: {
+            name?: string;
+            categories?: FlowCategoryEnum[];
+            endpoint_uri?: string;
+            application_id?: string;
+        },
+    ): Promise<RequesterResponseInterface<ResponseSuccess>> {
+        const formData = new FormData();
+
+        if (data.name) formData.append('name', data.name);
+        if (data.categories) formData.append('categories', JSON.stringify(data.categories));
+        if (data.endpoint_uri) formData.append('endpoint_uri', data.endpoint_uri);
+        if (data.application_id) formData.append('application_id', data.application_id);
+
+        return this.client.sendRequest(
+            HttpMethodsEnum.Post,
+            `/${flowId}`,
+            this.config[WabaConfigEnum.RequestTimeout],
+            formData,
+        );
+    }
+
+    /**
+     * Delete Flow
+     *
+     * @param flowId - The flow ID
+     * @returns Promise with the success status
+     */
+    async deleteFlow(flowId: string): Promise<RequesterResponseInterface<ResponseSuccess>> {
+        return this.client.sendRequest(
+            HttpMethodsEnum.Delete,
+            `/${flowId}`,
+            this.config[WabaConfigEnum.RequestTimeout],
+            null,
+        );
+    }
+
+    /**
+     * List Assets (Get Flow JSON URL)
+     *
+     * @param flowId - The flow ID
+     * @returns Promise with the list of assets
+     */
+    async listAssets(flowId: string): Promise<RequesterResponseInterface<FlowAssetsResponse>> {
+        return this.client.sendRequest(
+            HttpMethodsEnum.Get,
+            `/${flowId}/assets`,
+            this.config[WabaConfigEnum.RequestTimeout],
+            null,
+        );
+    }
+
+    /**
+     * Update Flow JSON
+     *
+     * @param flowId - The flow ID
+     * @param data - The asset data including asset_type, file, and name
+     * @returns Promise with the success status and validation errors
+     */
+    async updateFlowJson(
+        flowId: string,
+        data: {
+            asset_type: 'FLOW_JSON';
+            file: Blob;
+            name: string;
+        },
+    ): Promise<RequesterResponseInterface<{ success: boolean; validation_errors?: FlowValidationError[] }>> {
+        const formData = new FormData();
+
+        formData.append('asset_type', data.asset_type);
+        formData.append('file', data.file);
+        formData.append('name', data.name);
+
+        return this.client.sendRequest(
+            HttpMethodsEnum.Post,
+            `/${flowId}/assets`,
+            this.config[WabaConfigEnum.RequestTimeout],
+            formData,
+        );
+    }
+
+    /**
+     * Publish Flow
+     *
+     * @param flowId - The flow ID
+     * @returns Promise with the success status
+     */
+    async publishFlow(flowId: string): Promise<RequesterResponseInterface<ResponseSuccess>> {
+        return this.client.sendRequest(
+            HttpMethodsEnum.Post,
+            `/${flowId}/publish`,
+            this.config[WabaConfigEnum.RequestTimeout],
+            JSON.stringify({}),
+        );
+    }
+
+    /**
+     * Deprecate Flow
+     *
+     * @param flowId - The flow ID
+     * @returns Promise with the success status
+     */
+    async deprecateFlow(flowId: string): Promise<RequesterResponseInterface<ResponseSuccess>> {
+        return this.client.sendRequest(
+            HttpMethodsEnum.Post,
+            `/${flowId}/deprecate`,
+            this.config[WabaConfigEnum.RequestTimeout],
+            JSON.stringify({}),
+        );
+    }
+
+    /**
+     * Migrate Flows
+     *
+     * @param wabaId - The destination WABA ID
+     * @param data - The migration data including source_waba_id and optional source_flow_names
+     * @returns Promise with migration results
+     */
+    async migrateFlows(
+        wabaId: string,
+        data: {
+            source_waba_id: string;
+            source_flow_names?: string[];
+        },
+    ): Promise<RequesterResponseInterface<FlowMigrationResponse>> {
+        const formData = new FormData();
+
+        formData.append('source_waba_id', data.source_waba_id);
+        if (data.source_flow_names) {
+            formData.append('source_flow_names', JSON.stringify(data.source_flow_names));
+        }
+
+        return this.client.sendRequest(
+            HttpMethodsEnum.Post,
+            `/${wabaId}/migrate_flows`,
+            this.config[WabaConfigEnum.RequestTimeout],
+            formData,
+        );
+    }
+}

package/src/api/index.ts

@@ -0,0 +1,24 @@
+import MessagesAPI from './messages';
+import BaseAPI from './base';
+import PhoneNumberAPI from './phoneNumber';
+import TemplateAPI from './template';
+import RegistrationAPI from './registration';
+import TwoStepVerificationAPI from './twoStepVerification';
+import QrCodeAPI from './qrCode';
+import EncryptionAPI from './encryption';
+import WabaAPI from './waba';
+import MediaAPI from './media';
+import FlowAPI from './flow';
+export {
+    MessagesAPI,
+    BaseAPI,
+    PhoneNumberAPI,
+    TemplateAPI,
+    RegistrationAPI,
+    TwoStepVerificationAPI,
+    QrCodeAPI,
+    EncryptionAPI,
+    WabaAPI,
+    MediaAPI,
+    FlowAPI,
+};

package/src/api/media.ts

@@ -0,0 +1,52 @@
+import { HttpMethodsEnum, WabaConfigEnum } from '../types/enums';
+import type { RequesterClass, RequesterResponseInterface, ResponseSuccess } from '../types/request';
+import type { WabaConfigType } from '../types/config';
+import type { MediaClass, MediaResponse, MediasResponse, UploadMediaResponse } from '../types/media';
+import BaseAPI from './base';
+
+export default class MediaAPI extends BaseAPI implements MediaClass {
+    private readonly endpoint = 'media';
+
+    constructor(config: WabaConfigType, client: RequesterClass) {
+        super(config, client);
+    }
+
+    async getMediaById(mediaId: string): Promise<RequesterResponseInterface<MediaResponse>> {
+        return this.client.sendRequest(
+            HttpMethodsEnum.Get,
+            `${mediaId}`,
+            this.config[WabaConfigEnum.RequestTimeout],
+            null,
+        );
+    }
+
+    async uploadMedia(
+        file: File,
+        messagingProduct: string = 'whatsapp',
+    ): Promise<RequesterResponseInterface<UploadMediaResponse>> {
+        const formData = new FormData();
+        formData.append('file', file);
+        formData.append('messaging_product', messagingProduct);
+        formData.append('type', file.type);
+
+        return this.client.sendRequest(
+            HttpMethodsEnum.Post,
+            `${this.config[WabaConfigEnum.PhoneNumberId]}/${this.endpoint}`,
+            this.config[WabaConfigEnum.RequestTimeout],
+            formData,
+        );
+    }
+
+    async deleteMedia(mediaId: string): Promise<RequesterResponseInterface<ResponseSuccess>> {
+        return this.client.sendRequest(
+            HttpMethodsEnum.Delete,
+            `${mediaId}`,
+            this.config[WabaConfigEnum.RequestTimeout],
+            null,
+        );
+    }
+
+    async downloadMedia(mediaUrl: string): Promise<RequesterResponseInterface<Blob>> {
+        return this.client.sendRequest(HttpMethodsEnum.Get, mediaUrl, this.config[WabaConfigEnum.RequestTimeout], null);
+    }
+}

package/src/api/messages.ts

@@ -0,0 +1,160 @@
+import type { WabaConfigType } from '../types/config';
+import { ComponentTypesEnum, HttpMethodsEnum, MessageTypesEnum, WabaConfigEnum } from '../types/enums';
+
+import * as m from '../types/messages';
+import type { RequesterClass, RequesterResponseInterface } from '../types/request';
+import BaseAPI from './base';
+
+export default class MessagesApi extends BaseAPI implements m.MessagesClass {
+    private readonly commonMethod = HttpMethodsEnum.Post;
+    private readonly commonEndpoint = 'messages';
+
+    constructor(config: WabaConfigType, client: RequesterClass) {
+        super(config, client);
+    }
+
+    bodyBuilder<T extends MessageTypesEnum, C extends ComponentTypesEnum>(
+        type: T,
+        payload:
+            | m.AudioMediaObject
+            | [m.ContactObject]
+            | m.DocumentMediaObject
+            | m.ImageMediaObject
+            | m.InteractiveObject
+            | m.LocationObject
+            | m.MessageTemplateObject<C>
+            | m.StickerMediaObject
+            | m.TextObject
+            | m.VideoMediaObject,
+        toNumber: string,
+        replyMessageId?: string,
+    ) {
+        const body: m.MessageRequestBody<T> = {
+            messaging_product: 'whatsapp',
+            recipient_type: 'individual',
+            to: toNumber,
+            type: type,
+            [type]: payload,
+        };
+
+        if (replyMessageId) body['context'] = { message_id: replyMessageId };
+
+        return body;
+    }
+
+    private send(body: BodyInit | null): Promise<RequesterResponseInterface<m.MessagesResponse>> {
+        return this.client.sendRequest(
+            this.commonMethod,
+            `${this.config[WabaConfigEnum.PhoneNumberId]}/${this.commonEndpoint}`,
+            this.config[WabaConfigEnum.RequestTimeout],
+            body,
+        );
+    }
+
+    async audio(
+        body: m.AudioMediaObject,
+        recipient: number,
+        replyMessageId?: string,
+    ): Promise<RequesterResponseInterface<m.MessagesResponse>> {
+        return this.send(
+            JSON.stringify(this.bodyBuilder(MessageTypesEnum.Audio, body, recipient.toString(), replyMessageId)),
+        );
+    }
+
+    async contacts(
+        body: [m.ContactObject],
+        recipient: number,
+        replyMessageId?: string,
+    ): Promise<RequesterResponseInterface<m.MessagesResponse>> {
+        return this.send(
+            JSON.stringify(this.bodyBuilder(MessageTypesEnum.Contacts, body, recipient.toString(), replyMessageId)),
+        );
+    }
+
+    async document(
+        body: m.DocumentMediaObject,
+        recipient: number,
+        replyMessageId?: string,
+    ): Promise<RequesterResponseInterface<m.MessagesResponse>> {
+        return this.send(
+            JSON.stringify(this.bodyBuilder(MessageTypesEnum.Document, body, recipient.toString(), replyMessageId)),
+        );
+    }
+
+    async image(
+        body: m.ImageMediaObject,
+        recipient: number,
+        replyMessageId?: string,
+    ): Promise<RequesterResponseInterface<m.MessagesResponse>> {
+        return this.send(
+            JSON.stringify(this.bodyBuilder(MessageTypesEnum.Image, body, recipient.toString(), replyMessageId)),
+        );
+    }
+
+    async interactive(
+        body: m.InteractiveObject,
+        recipient: number,
+        replyMessageId?: string,
+    ): Promise<RequesterResponseInterface<m.MessagesResponse>> {
+        return this.send(
+            JSON.stringify(this.bodyBuilder(MessageTypesEnum.Interactive, body, recipient.toString(), replyMessageId)),
+        );
+    }
+
+    async location(
+        body: m.LocationObject,
+        recipient: number,
+        replyMessageId?: string,
+    ): Promise<RequesterResponseInterface<m.MessagesResponse>> {
+        return this.send(
+            JSON.stringify(this.bodyBuilder(MessageTypesEnum.Location, body, recipient.toString(), replyMessageId)),
+        );
+    }
+
+    async sticker(
+        body: m.StickerMediaObject,
+        recipient: number,
+        replyMessageId?: string,
+    ): Promise<RequesterResponseInterface<m.MessagesResponse>> {
+        return this.send(
+            JSON.stringify(this.bodyBuilder(MessageTypesEnum.Sticker, body, recipient.toString(), replyMessageId)),
+        );
+    }
+
+    async template(
+        body: m.MessageTemplateObject<ComponentTypesEnum>,
+        recipient: number,
+        replyMessageId?: string,
+    ): Promise<RequesterResponseInterface<m.MessagesResponse>> {
+        return this.send(
+            JSON.stringify(this.bodyBuilder(MessageTypesEnum.Template, body, recipient.toString(), replyMessageId)),
+        );
+    }
+
+    async text(
+        body: m.TextObject,
+        recipient: number,
+        replyMessageId?: string,
+    ): Promise<RequesterResponseInterface<m.MessagesResponse>> {
+        return this.send(
+            JSON.stringify(this.bodyBuilder(MessageTypesEnum.Text, body, recipient.toString(), replyMessageId)),
+        );
+    }
+
+    async video(
+        body: m.VideoMediaObject,
+        recipient: number,
+        replyMessageId?: string,
+    ): Promise<RequesterResponseInterface<m.MessagesResponse>> {
+        return this.send(
+            JSON.stringify(this.bodyBuilder(MessageTypesEnum.Video, body, recipient.toString(), replyMessageId)),
+        );
+    }
+
+    async status(body: m.StatusObject): Promise<RequesterResponseInterface<m.MessagesResponse>> {
+        const mp: m.GeneralMessageBody = { messaging_product: 'whatsapp' };
+        const bodyToSend: m.StatusRequestBody = Object.assign(mp, body);
+
+        return this.send(JSON.stringify(bodyToSend));
+    }
+}

package/src/api/phoneNumber.ts

@@ -0,0 +1,59 @@
+import {
+    PhoneNumberClass,
+    PhoneNumberResponse,
+    PhoneNumbersResponse,
+    RequestVerificationCodeRequest,
+    VerifyCodeRequest,
+} from 'src/types/phoneNumber';
+import { objectToQueryString } from 'src/utils/objectToQueryString';
+import type { WabaConfigType } from '../types/config';
+import { HttpMethodsEnum, WabaConfigEnum } from '../types/enums';
+import type { RequesterClass, RequesterResponseInterface, ResponseSuccess } from '../types/request';
+import BaseAPI from './base';
+
+export default class PhoneNumberApi extends BaseAPI implements PhoneNumberClass {
+    private readonly endpoint = 'phone_numbers';
+
+    constructor(config: WabaConfigType, client: RequesterClass) {
+        super(config, client);
+    }
+
+    async getPhoneNumberById(fields?: string): Promise<RequesterResponseInterface<PhoneNumberResponse>> {
+        const queryParams = fields ? objectToQueryString({ fields }) : '';
+        return this.client.sendRequest(
+            HttpMethodsEnum.Get,
+            `${this.config[WabaConfigEnum.PhoneNumberId]}${queryParams}`,
+            this.config[WabaConfigEnum.RequestTimeout],
+            null,
+        );
+    }
+
+    async getPhoneNumbers(): Promise<RequesterResponseInterface<PhoneNumbersResponse>> {
+        return this.client.sendRequest(
+            HttpMethodsEnum.Get,
+            `${this.config[WabaConfigEnum.BusinessAcctId]}/${this.endpoint}`,
+            this.config[WabaConfigEnum.RequestTimeout],
+            null,
+        );
+    }
+
+    async requestVerificationCode(
+        requestVerificationCodeRequest: RequestVerificationCodeRequest,
+    ): Promise<RequesterResponseInterface<ResponseSuccess>> {
+        return this.client.sendRequest(
+            HttpMethodsEnum.Post,
+            `${this.config[WabaConfigEnum.PhoneNumberId]}/request_code`,
+            this.config[WabaConfigEnum.RequestTimeout],
+            JSON.stringify(requestVerificationCodeRequest),
+        );
+    }
+
+    async verifyCode(verifyCodeRequest: VerifyCodeRequest): Promise<RequesterResponseInterface<ResponseSuccess>> {
+        return this.client.sendRequest(
+            HttpMethodsEnum.Post,
+            `${this.config[WabaConfigEnum.PhoneNumberId]}/verify_code`,
+            this.config[WabaConfigEnum.RequestTimeout],
+            JSON.stringify(verifyCodeRequest),
+        );
+    }
+}

package/src/api/qrCode.ts

@@ -0,0 +1,64 @@
+import { HttpMethodsEnum, WabaConfigEnum } from '../types/enums';
+import type { WabaConfigType } from '../types/config';
+import type { RequesterClass, RequesterResponseInterface, ResponseSuccess } from '../types/request';
+import BaseAPI from './base';
+import {
+    CreateQrCodeRequest,
+    QrCodeClass,
+    QrCodeResponse,
+    QrCodesResponse,
+    UpdateQrCodeRequest,
+} from '../types/qrCode';
+
+export default class QrCodeAPI extends BaseAPI implements QrCodeClass {
+    private readonly endpoint = 'message_qrdls';
+
+    constructor(config: WabaConfigType, client: RequesterClass) {
+        super(config, client);
+    }
+
+    async createQrCode(request: CreateQrCodeRequest): Promise<RequesterResponseInterface<QrCodeResponse>> {
+        return this.client.sendRequest(
+            HttpMethodsEnum.Post,
+            `${this.config[WabaConfigEnum.PhoneNumberId]}/${this.endpoint}`,
+            this.config[WabaConfigEnum.RequestTimeout],
+            JSON.stringify(request),
+        );
+    }
+
+    async getQrCodes(): Promise<RequesterResponseInterface<QrCodesResponse>> {
+        return this.client.sendRequest(
+            HttpMethodsEnum.Get,
+            `${this.config[WabaConfigEnum.PhoneNumberId]}/${this.endpoint}`,
+            this.config[WabaConfigEnum.RequestTimeout],
+            null,
+        );
+    }
+
+    async getQrCode(qrCodeId: string): Promise<RequesterResponseInterface<QrCodeResponse>> {
+        return this.client.sendRequest(
+            HttpMethodsEnum.Get,
+            `${this.config[WabaConfigEnum.PhoneNumberId]}/${this.endpoint}/${qrCodeId}`,
+            this.config[WabaConfigEnum.RequestTimeout],
+            null,
+        );
+    }
+
+    async updateQrCode(request: UpdateQrCodeRequest): Promise<RequesterResponseInterface<QrCodeResponse>> {
+        return this.client.sendRequest(
+            HttpMethodsEnum.Post,
+            `${this.config[WabaConfigEnum.PhoneNumberId]}/${this.endpoint}`,
+            this.config[WabaConfigEnum.RequestTimeout],
+            JSON.stringify(request),
+        );
+    }
+
+    async deleteQrCode(qrCodeId: string): Promise<RequesterResponseInterface<ResponseSuccess>> {
+        return this.client.sendRequest(
+            HttpMethodsEnum.Delete,
+            `${this.config[WabaConfigEnum.PhoneNumberId]}/${this.endpoint}/${qrCodeId}`,
+            this.config[WabaConfigEnum.RequestTimeout],
+            null,
+        );
+    }
+}

package/src/api/registration.ts

@@ -0,0 +1,38 @@
+import { RegistrationClass } from '../types/registration';
+import type { WabaConfigType } from '../types/config';
+import { HttpMethodsEnum, WabaConfigEnum, DataLocalizationRegionEnum } from '../types/enums';
+import type { RequesterClass, RequesterResponseInterface, ResponseSuccess } from '../types/request';
+import BaseAPI from './base';
+
+export default class RegistrationAPI extends BaseAPI implements RegistrationClass {
+    constructor(config: WabaConfigType, client: RequesterClass) {
+        super(config, client);
+    }
+
+    async register(
+        pin: string,
+        dataLocalizationRegion?: DataLocalizationRegionEnum,
+    ): Promise<RequesterResponseInterface<ResponseSuccess>> {
+        const body = {
+            messaging_product: 'whatsapp',
+            pin,
+            ...(dataLocalizationRegion && { data_localization_region: dataLocalizationRegion }),
+        };
+
+        return this.client.sendRequest(
+            HttpMethodsEnum.Post,
+            `${this.config[WabaConfigEnum.PhoneNumberId]}/register`,
+            this.config[WabaConfigEnum.RequestTimeout],
+            JSON.stringify(body),
+        );
+    }
+
+    async deregister(): Promise<RequesterResponseInterface<ResponseSuccess>> {
+        return this.client.sendRequest(
+            HttpMethodsEnum.Post,
+            `${this.config[WabaConfigEnum.PhoneNumberId]}/deregister`,
+            this.config[WabaConfigEnum.RequestTimeout],
+            null,
+        );
+    }
+}