meta-cloud-api 0.0.3 → 0.0.4

package/src/api/messages.ts

@@ -1,160 +0,0 @@
-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

@@ -1,59 +0,0 @@
-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

@@ -1,64 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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,
-        );
-    }
-}

package/src/api/template.ts

@@ -1,70 +0,0 @@
-import { objectToQueryString } from 'src/utils/objectToQueryString';
-import type { WabaConfigType } from '../types/config';
-import { HttpMethodsEnum, WabaConfigEnum } from '../types/enums';
-import type { RequesterClass, RequesterResponseInterface, ResponsePagination, ResponseSuccess } from '../types/request';
-import type {
-    TemplateClass,
-    TemplateDeleteParams,
-    TemplateGetParams,
-    TemplateRequestBody,
-    TemplateResponse,
-} from '../types/template';
-import BaseAPI from './base';
-
-export default class TemplateApi extends BaseAPI implements TemplateClass {
-    private readonly endpoint = 'message_templates';
-
-    constructor(config: WabaConfigType, client: RequesterClass) {
-        super(config, client);
-    }
-
-    async getTemplate(templateId: string): Promise<RequesterResponseInterface<TemplateResponse>> {
-        return this.client.sendRequest(
-            HttpMethodsEnum.Get,
-            `${templateId}`,
-            this.config[WabaConfigEnum.RequestTimeout],
-            null,
-        );
-    }
-
-    async updateTemplate(
-        templateId: string,
-        template: Partial<TemplateRequestBody>,
-    ): Promise<RequesterResponseInterface<ResponseSuccess>> {
-        return this.client.sendRequest(
-            HttpMethodsEnum.Post,
-            `${templateId}`,
-            this.config[WabaConfigEnum.RequestTimeout],
-            JSON.stringify(template),
-        );
-    }
-
-    async getTemplates(
-        params: TemplateGetParams,
-    ): Promise<RequesterResponseInterface<ResponsePagination<TemplateResponse>>> {
-        return this.client.sendRequest(
-            HttpMethodsEnum.Get,
-            `${this.config[WabaConfigEnum.BusinessAcctId]}/${this.endpoint}${objectToQueryString(params)}`,
-            this.config[WabaConfigEnum.RequestTimeout],
-            null,
-        );
-    }
-
-    async createTemplate(template: TemplateRequestBody): Promise<RequesterResponseInterface<TemplateResponse>> {
-        return this.client.sendRequest(
-            HttpMethodsEnum.Post,
-            `${this.config[WabaConfigEnum.BusinessAcctId]}/${this.endpoint}`,
-            this.config[WabaConfigEnum.RequestTimeout],
-            JSON.stringify(template),
-        );
-    }
-
-    async deleteTemplate(params: TemplateDeleteParams): Promise<RequesterResponseInterface<ResponseSuccess>> {
-        return this.client.sendRequest(
-            HttpMethodsEnum.Delete,
-            `${this.config[WabaConfigEnum.BusinessAcctId]}/${this.endpoint}${objectToQueryString(params)}`,
-            this.config[WabaConfigEnum.RequestTimeout],
-            null,
-        );
-    }
-}

package/src/api/twoStepVerification.ts

@@ -1,24 +0,0 @@
-import { TwoStepVerificationClass } from '../types/twoStepVerification';
-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 TwoStepVerificationAPI extends BaseAPI implements TwoStepVerificationClass {
-    constructor(config: WabaConfigType, client: RequesterClass) {
-        super(config, client);
-    }
-
-    async setTwoStepVerificationCode(pin: string): Promise<RequesterResponseInterface<ResponseSuccess>> {
-        const body = {
-            pin,
-        };
-
-        return this.client.sendRequest(
-            HttpMethodsEnum.Post,
-            `${this.config[WabaConfigEnum.PhoneNumberId]}`,
-            this.config[WabaConfigEnum.RequestTimeout],
-            JSON.stringify(body),
-        );
-    }
-}

package/src/api/waba.ts

@@ -1,55 +0,0 @@
-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 { WABAClass, WabaSubscriptions } from '../types/waba';
-
-export default class WabaAPI extends BaseAPI implements WABAClass {
-    constructor(config: WabaConfigType, client: RequesterClass) {
-        super(config, client);
-    }
-
-    async getAllWabaSubscriptions(): Promise<RequesterResponseInterface<WabaSubscriptions>> {
-        return this.client.sendRequest(
-            HttpMethodsEnum.Get,
-            `${this.config[WabaConfigEnum.BusinessAcctId]}/subscribed_apps`,
-            this.config[WabaConfigEnum.RequestTimeout],
-            null,
-        );
-    }
-
-    async subscribeToWaba(): Promise<RequesterResponseInterface<ResponseSuccess>> {
-        return this.client.sendRequest(
-            HttpMethodsEnum.Post,
-            `${this.config[WabaConfigEnum.BusinessAcctId]}/subscribed_apps`,
-            this.config[WabaConfigEnum.RequestTimeout],
-            null,
-        );
-    }
-
-    async unsubscribeFromWaba(): Promise<RequesterResponseInterface<ResponseSuccess>> {
-        return this.client.sendRequest(
-            HttpMethodsEnum.Delete,
-            `${this.config[WabaConfigEnum.BusinessAcctId]}/subscribed_apps`,
-            this.config[WabaConfigEnum.RequestTimeout],
-            null,
-        );
-    }
-
-    async overrideWabaWebhook(
-        webhookUrl: string,
-        verifyToken: string,
-    ): Promise<RequesterResponseInterface<ResponseSuccess>> {
-        const body = {
-            url: webhookUrl,
-            verify_token: verifyToken,
-        };
-
-        return this.client.sendRequest(
-            HttpMethodsEnum.Post,
-            `${this.config[WabaConfigEnum.BusinessAcctId]}/webhooks`,
-            this.config[WabaConfigEnum.RequestTimeout],
-            JSON.stringify(body),
-        );
-    }
-}

package/src/httpsClient.ts

@@ -1,83 +0,0 @@
-import { Agent } from 'https';
-
-import Logger from './utils/logger';
-import { HttpMethodsEnum } from './types/enums';
-import { HttpsClientClass, HttpsClientResponseClass, ResponseHeaders, ResponseJSONBody } from './types/httpsClient';
-
-const LIB_NAME = 'HttpsClient';
-const LOG_LOCAL = false;
-const LOGGER = new Logger(LIB_NAME, process.env.DEBUG === 'true' || LOG_LOCAL);
-
-export default class HttpsClient implements HttpsClientClass {
-    agent: Agent;
-
-    constructor() {
-        this.agent = new Agent({ keepAlive: true });
-    }
-
-    clearSockets(): boolean {
-        this.agent.destroy();
-        return true;
-    }
-
-    async sendRequest(
-        hostname: string,
-        path: string,
-        method: HttpMethodsEnum,
-        headers: HeadersInit,
-        timeout: number,
-        body?: BodyInit | null,
-    ): Promise<HttpsClientResponseClass> {
-        const url = `https://${hostname}/${path}`;
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), timeout);
-
-        try {
-            const response = await fetch(url, {
-                method,
-                headers,
-                body,
-                signal: controller.signal,
-            });
-            LOGGER.log(`${method} : ${url} - ${JSON.stringify(response)}`);
-
-            clearTimeout(timeoutId);
-            return new HttpsClientResponse(response);
-        } catch (error) {
-            throw error;
-        }
-    }
-}
-
-export class HttpsClientResponse implements HttpsClientResponseClass {
-    res: Response;
-    respStatusCode: number;
-    respHeaders: ResponseHeaders;
-
-    constructor(resp: Response) {
-        this.res = resp;
-        this.respStatusCode = resp.status;
-        this.respHeaders = Object.fromEntries(resp.headers.entries());
-    }
-
-    statusCode(): number {
-        return this.respStatusCode;
-    }
-
-    headers(): ResponseHeaders {
-        return this.respHeaders;
-    }
-
-    rawResponse(): Response {
-        return this.res;
-    }
-
-    async json(): Promise<ResponseJSONBody> {
-        try {
-            return (await this.res.json()) as ResponseJSONBody;
-        } catch (err) {
-            // TODO Error Handling
-            throw new Error('Failed to parse response body to JSON: ' + (err as Error).message);
-        }
-    }
-}

package/src/index.ts

@@ -1,3 +0,0 @@
-import WhatsApp from './whatsapp';
-
-export default WhatsApp;

package/src/request.ts

@@ -1,104 +0,0 @@
-import HttpsClient from './httpsClient';
-import Logger from './utils/logger';
-import type { HttpMethodsEnum } from './types/enums';
-import type { RequesterClass } from './types/request';
-import { MetaError } from './utils/isMetaError';
-import { isMetaError } from './utils/isMetaError';
-
-const LIB_NAME = 'REQUESTER';
-const LOG_LOCAL = false;
-const LOGGER = new Logger(LIB_NAME, process.env.DEBUG === 'true' || LOG_LOCAL);
-
-export default class Requester implements RequesterClass {
-    client: Readonly<HttpsClient>;
-    accessToken: Readonly<string>;
-    phoneNumberId: Readonly<number>;
-    businessAcctId: Readonly<string>;
-    apiVersion: Readonly<string>;
-    userAgent: Readonly<string>;
-    host: Readonly<string>;
-    protocol: Readonly<string> = 'https:';
-
-    constructor(
-        host: string,
-        apiVersion: string,
-        phoneNumberId: number,
-        accessToken: string,
-        businessAcctId: string,
-        userAgent: string,
-    ) {
-        this.client = new HttpsClient();
-        this.host = host;
-        this.apiVersion = apiVersion;
-        this.phoneNumberId = phoneNumberId;
-        this.accessToken = accessToken;
-        this.businessAcctId = businessAcctId;
-        this.userAgent = userAgent;
-    }
-
-    buildHeader(contentType: string): HeadersInit {
-        const headers: HeadersInit = {
-            'Content-Type': contentType,
-            Authorization: `Bearer ${this.accessToken}`,
-            'User-Agent': this.userAgent,
-        };
-        return headers;
-    }
-
-    buildCAPIPath(endpoint: string): string {
-        return `v${this.apiVersion}.0/${endpoint}`;
-    }
-
-    async sendRequest(method: HttpMethodsEnum, endpoint: string, timeout: number, body?: any) {
-        const contentType = 'application/json';
-        const path = `${this.protocol.toLowerCase()}//${this.host}/${this.buildCAPIPath(endpoint)}`;
-
-        LOGGER.log(`${method} : ${path}`);
-
-        try {
-            const response = await this.client.sendRequest(
-                this.host,
-                this.buildCAPIPath(endpoint),
-                method,
-                this.buildHeader(contentType),
-                timeout,
-                method === 'POST' || method === 'PUT' ? body : undefined,
-            );
-
-            if (!response.rawResponse().ok) {
-                const errorData = await response.json();
-                if (isMetaError(errorData)) {
-                    throw errorData;
-                }
-                // If the error doesn't match Meta's format, create a generic MetaError
-                throw {
-                    name: 'MetaError',
-                    message: 'Unknown error occurred',
-                    error: {
-                        message: errorData.message || 'Unknown error occurred',
-                        type: 'UnknownError',
-                        code: response.statusCode(),
-                        fbtrace_id: '',
-                    },
-                } as MetaError;
-            }
-
-            return response;
-        } catch (error) {
-            if (isMetaError(error)) {
-                throw error;
-            }
-            // Handle network errors or other unexpected errors
-            throw {
-                name: 'MetaError',
-                message: error instanceof Error ? error.message : 'Network error occurred',
-                error: {
-                    message: error instanceof Error ? error.message : 'Network error occurred',
-                    type: 'NetworkError',
-                    code: 500,
-                    fbtrace_id: '',
-                },
-            } as MetaError;
-        }
-    }
-}

package/src/types/base.ts

@@ -1,5 +0,0 @@
-import type { WabaConfigType } from './config';
-
-export declare class BaseClass {
-    constructor(config: WabaConfigType);
-}