monade-sdk 0.1.0

package/dist/src/client.d.ts

@@ -0,0 +1,231 @@
+import { CampaignServiceApiApi, ControlPlaneApi, PostgresqlDbRoutesApi } from '../generated/apis';
+import type { MonadeClientConfig } from './types';
+type Runner = <T>(fn: () => Promise<T>) => Promise<T>;
+declare class CampaignsService {
+    private readonly api;
+    private readonly run;
+    constructor(api: CampaignServiceApiApi, run: Runner);
+    list(status?: string): Promise<{
+        [key: string]: any;
+    }>;
+    listForUser(userUid: string): Promise<{
+        [key: string]: any;
+    }>;
+    get(campaignId: string): Promise<{
+        [key: string]: any;
+    }>;
+    create(data: Record<string, unknown>): Promise<{
+        [key: string]: any;
+    }>;
+    update(campaignId: string, data: Record<string, unknown>, userUid?: string): Promise<{
+        [key: string]: any;
+    }>;
+    delete(campaignId: string, userUid?: string): Promise<{
+        [key: string]: any;
+    }>;
+    start(campaignId: string, userUid?: string): Promise<{
+        [key: string]: any;
+    }>;
+    pause(campaignId: string, userUid?: string): Promise<{
+        [key: string]: any;
+    }>;
+    resume(campaignId: string, userUid?: string): Promise<{
+        [key: string]: any;
+    }>;
+    stop(campaignId: string, userUid?: string): Promise<{
+        [key: string]: any;
+    }>;
+    addContacts(campaignId: string, contactsPayload: Record<string, unknown>, userUid?: string): Promise<{
+        [key: string]: any;
+    }>;
+    listContacts(campaignId: string, userUid?: string, skip?: number, limit?: number): Promise<{
+        [key: string]: any;
+    }>;
+    clearContacts(campaignId: string, userUid?: string): Promise<{
+        [key: string]: any;
+    }>;
+    getContact(campaignId: string, contactId: string, userUid?: string): Promise<{
+        [key: string]: any;
+    }>;
+    analytics(campaignId: string, userUid?: string): Promise<{
+        [key: string]: any;
+    }>;
+    raw(): CampaignServiceApiApi;
+}
+declare class AssistantsService {
+    private readonly api;
+    private readonly run;
+    constructor(api: PostgresqlDbRoutesApi, run: Runner);
+    list(): Promise<{
+        [key: string]: any;
+    }>;
+    listByUser(userUid: string): Promise<{
+        [key: string]: any;
+    }>;
+    listByUserViaUserRoute(userUid: string): Promise<{
+        [key: string]: any;
+    }>;
+    getById(assistantId: string): Promise<{
+        [key: string]: any;
+    }>;
+    getByPhone(phoneNumber: string): Promise<{
+        [key: string]: any;
+    }>;
+    create(data: Record<string, unknown>): Promise<{
+        [key: string]: any;
+    }>;
+    update(assistantId: string, data: Record<string, unknown>): Promise<{
+        [key: string]: any;
+    }>;
+    updateAccent(assistantId: string, data: Record<string, unknown>): Promise<{
+        [key: string]: any;
+    }>;
+    delete(assistantId: string): Promise<{
+        [key: string]: any;
+    }>;
+    raw(): PostgresqlDbRoutesApi;
+}
+declare class KnowledgeBasesService {
+    private readonly api;
+    private readonly run;
+    constructor(api: PostgresqlDbRoutesApi, run: Runner);
+    list(): Promise<{
+        [key: string]: any;
+    }>;
+    listByUser(userUid: string): Promise<{
+        [key: string]: any;
+    }>;
+    getById(kbId: string): Promise<{
+        [key: string]: any;
+    }>;
+    create(data: Record<string, unknown>): Promise<{
+        [key: string]: any;
+    }>;
+    delete(kbId: string): Promise<{
+        [key: string]: any;
+    }>;
+    raw(): PostgresqlDbRoutesApi;
+}
+declare class AnalyticsService {
+    private readonly dbApi;
+    private readonly campaignApi;
+    private readonly run;
+    constructor(dbApi: PostgresqlDbRoutesApi, campaignApi: CampaignServiceApiApi, run: Runner);
+    submit(data: Record<string, unknown>): Promise<{
+        [key: string]: any;
+    }>;
+    getByCallId(callId: string): Promise<{
+        [key: string]: any;
+    }>;
+    getUserAnalytics(userUid?: string): Promise<{
+        [key: string]: any;
+    }>;
+    getUserAnalyticsByUserId(userUid: string): Promise<{
+        [key: string]: any;
+    }>;
+    getUserStats(userUid: string): Promise<{
+        [key: string]: any;
+    }>;
+    getUserCampaignAnalytics(userUid: string, campaignId: string): Promise<{
+        [key: string]: any;
+    }>;
+    getCampaignAnalytics(campaignId: string, userUid?: string): Promise<{
+        [key: string]: any;
+    }>;
+    getCampaignStats(campaignId: string, userUid?: string): Promise<{
+        [key: string]: any;
+    }>;
+    getCallRecording(callId: string): Promise<{
+        [key: string]: any;
+    }>;
+    createTranscript(data: Record<string, unknown>): Promise<{
+        [key: string]: any;
+    }>;
+    listTranscripts(userUid: string): Promise<{
+        [key: string]: any;
+    }>;
+    raw(): PostgresqlDbRoutesApi;
+}
+declare class WebhooksService {
+    private readonly api;
+    private readonly run;
+    constructor(api: PostgresqlDbRoutesApi, run: Runner);
+    create(userUid: string, data: Record<string, unknown>): Promise<{
+        [key: string]: any;
+    }>;
+    list(userUid: string): Promise<{
+        [key: string]: any;
+    }>;
+    get(userUid: string, webhookId: string): Promise<{
+        [key: string]: any;
+    }>;
+    update(userUid: string, webhookId: string, data: Record<string, unknown>): Promise<{
+        [key: string]: any;
+    }>;
+    delete(userUid: string, webhookId: string): Promise<{
+        [key: string]: any;
+    }>;
+    supportedEvents(): Promise<{
+        [key: string]: any;
+    }>;
+    lookup(userUid?: string, eventType?: string): Promise<{
+        [key: string]: any;
+    }>;
+    raw(): PostgresqlDbRoutesApi;
+}
+declare class TrunksService {
+    private readonly api;
+    private readonly run;
+    constructor(api: PostgresqlDbRoutesApi, run: Runner);
+    list(userUid: string): Promise<{
+        [key: string]: any;
+    }>;
+    get(userUid: string, trunkId: string): Promise<{
+        [key: string]: any;
+    }>;
+    create(userUid: string, data: Record<string, unknown>): Promise<{
+        [key: string]: any;
+    }>;
+    update(userUid: string, trunkId: string, data: Record<string, unknown>): Promise<{
+        [key: string]: any;
+    }>;
+    delete(userUid: string, trunkId: string): Promise<{
+        [key: string]: any;
+    }>;
+    raw(): PostgresqlDbRoutesApi;
+}
+declare class WalletService {
+    private readonly api;
+    private readonly run;
+    constructor(api: PostgresqlDbRoutesApi, run: Runner);
+    getBalance(userUid: string): Promise<{
+        [key: string]: any;
+    }>;
+    raw(): PostgresqlDbRoutesApi;
+}
+declare class OutboundCallsService {
+    private readonly api;
+    private readonly run;
+    constructor(api: ControlPlaneApi, run: Runner);
+    create(phoneNumber: string, body: Record<string, unknown>): Promise<{
+        [key: string]: any;
+    }>;
+    raw(): ControlPlaneApi;
+}
+export declare class MonadeClient {
+    readonly campaigns: CampaignsService;
+    readonly assistants: AssistantsService;
+    readonly knowledgeBases: KnowledgeBasesService;
+    readonly analytics: AnalyticsService;
+    readonly webhooks: WebhooksService;
+    readonly trunks: TrunksService;
+    readonly wallet: WalletService;
+    readonly outboundCalls: OutboundCallsService;
+    readonly generated: {
+        campaignsApi: CampaignServiceApiApi;
+        dbApi: PostgresqlDbRoutesApi;
+        controlPlaneApi: ControlPlaneApi;
+    };
+    constructor(config?: MonadeClientConfig);
+}
+export {};

package/dist/src/client.js

@@ -0,0 +1,356 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MonadeClient = void 0;
+const runtime_1 = require("../generated/runtime");
+const apis_1 = require("../generated/apis");
+const errors_1 = require("./errors");
+const DEFAULT_BASE_URL = 'http://35.200.254.189';
+const DEFAULT_TIMEOUT_MS = 30000;
+function createFetchWithTimeout(baseFetch, timeoutMs) {
+    return async (input, init) => {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+            return await baseFetch(input, {
+                ...init,
+                signal: init?.signal ?? controller.signal,
+            });
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    };
+}
+async function parseErrorPayload(response) {
+    const contentType = response.headers.get('content-type') || '';
+    if (contentType.includes('application/json')) {
+        const json = await response.clone().json().catch(() => undefined);
+        const message = (json && (json.detail || json.message || json.error)) || response.statusText || 'Request failed';
+        return { message, payload: json };
+    }
+    const text = await response.clone().text().catch(() => '');
+    return { message: text || response.statusText || 'Request failed', payload: text || undefined };
+}
+async function mapSdkError(error) {
+    if (error instanceof runtime_1.ResponseError) {
+        const status = error.response.status;
+        const { message, payload } = await parseErrorPayload(error.response);
+        if (status === 401 || status === 403) {
+            throw new errors_1.AuthError(message, status, payload);
+        }
+        if (status === 400 || status === 422) {
+            throw new errors_1.ValidationError(message, status, payload);
+        }
+        throw new errors_1.ApiError(message, status, payload);
+    }
+    if (error instanceof runtime_1.FetchError) {
+        throw new errors_1.ApiError(error.message || 'Network request failed');
+    }
+    if (error instanceof Error) {
+        throw new errors_1.ApiError(error.message);
+    }
+    throw new errors_1.ApiError('Unknown SDK error');
+}
+class CampaignsService {
+    constructor(api, run) {
+        this.api = api;
+        this.run = run;
+    }
+    list(status) {
+        return this.run(() => this.api.listCampaigns(status ? { status } : {}));
+    }
+    listForUser(userUid) {
+        return this.run(() => this.api.getAllCampaignsForUser({ userUid }));
+    }
+    get(campaignId) {
+        return this.run(() => this.api.getCampaignDetails({ campaignId }));
+    }
+    create(data) {
+        return this.run(() => this.api.createCampaign({ createCampaignRequest: data }));
+    }
+    update(campaignId, data, userUid) {
+        return this.run(() => this.api.updateCampaign({ campaignId, updateCampaignRequest: data, userUid }));
+    }
+    delete(campaignId, userUid) {
+        return this.run(() => this.api.deleteCampaign({ campaignId, userUid }));
+    }
+    start(campaignId, userUid) {
+        return this.run(() => this.api.startCampaign({ campaignId, userUid }));
+    }
+    pause(campaignId, userUid) {
+        return this.run(() => this.api.pauseCampaign({ campaignId, userUid }));
+    }
+    resume(campaignId, userUid) {
+        return this.run(() => this.api.resumeCampaign({ campaignId, userUid }));
+    }
+    stop(campaignId, userUid) {
+        return this.run(() => this.api.stopCampaign({ campaignId, userUid }));
+    }
+    addContacts(campaignId, contactsPayload, userUid) {
+        return this.run(() => this.api.addContactsToCampaign({
+            campaignId,
+            addContactsToCampaignRequest: contactsPayload,
+            userUid,
+        }));
+    }
+    listContacts(campaignId, userUid, skip, limit) {
+        return this.run(() => this.api.listCampaignContacts({
+            campaignId,
+            userUid,
+            skip: skip?.toString(),
+            limit: limit?.toString(),
+        }));
+    }
+    clearContacts(campaignId, userUid) {
+        return this.run(() => this.api.clearCampaignContacts({ campaignId, userUid }));
+    }
+    getContact(campaignId, contactId, userUid) {
+        return this.run(() => this.api.getContactDetails({ campaignId, contactId, userUid }));
+    }
+    analytics(campaignId, userUid) {
+        return this.run(() => this.api.getCampaignAnalytics({ campaignId, userUid }));
+    }
+    raw() {
+        return this.api;
+    }
+}
+class AssistantsService {
+    constructor(api, run) {
+        this.api = api;
+        this.run = run;
+    }
+    list() {
+        return this.run(() => this.api.getAllAssistants());
+    }
+    listByUser(userUid) {
+        return this.run(() => this.api.getAssistantsByUserId({ userUid }));
+    }
+    listByUserViaUserRoute(userUid) {
+        return this.run(() => this.api.getUserSAssistants({ userUid }));
+    }
+    getById(assistantId) {
+        return this.run(() => this.api.getAssistantById({ assistantId }));
+    }
+    getByPhone(phoneNumber) {
+        return this.run(() => this.api.getAssistantByPhoneNumber({ phoneNumber }));
+    }
+    create(data) {
+        return this.run(() => this.api.createAssistant({ createAssistantRequest: data }));
+    }
+    update(assistantId, data) {
+        return this.run(() => this.api.updateAssistant({ assistantId, updateAssistantRequest: data }));
+    }
+    updateAccent(assistantId, data) {
+        return this.run(() => this.api.updateAssistantSpeakingAccent({
+            assistantId,
+            updateAssistantSpeakingAccentRequest: data,
+        }));
+    }
+    delete(assistantId) {
+        return this.run(() => this.api.deleteAssistant({ assistantId }));
+    }
+    raw() {
+        return this.api;
+    }
+}
+class KnowledgeBasesService {
+    constructor(api, run) {
+        this.api = api;
+        this.run = run;
+    }
+    list() {
+        return this.run(() => this.api.getAllKnowledgeBases());
+    }
+    listByUser(userUid) {
+        return this.run(() => this.api.getUserSKnowledgeBases({ userUid }));
+    }
+    getById(kbId) {
+        return this.run(() => this.api.getKnowledgeBaseById({ kbId }));
+    }
+    create(data) {
+        return this.run(() => this.api.createKnowledgeBase({ createKnowledgeBaseRequest: data }));
+    }
+    delete(kbId) {
+        return this.run(() => this.api.deleteKnowledgeBase({ kbId }));
+    }
+    raw() {
+        return this.api;
+    }
+}
+class AnalyticsService {
+    constructor(dbApi, campaignApi, run) {
+        this.dbApi = dbApi;
+        this.campaignApi = campaignApi;
+        this.run = run;
+    }
+    submit(data) {
+        return this.run(() => this.dbApi.submitAnalyticsData({ submitAnalyticsDataRequest: data }));
+    }
+    getByCallId(callId) {
+        return this.run(() => this.dbApi.getAnalyticsByCallId({ callId }));
+    }
+    getUserAnalytics(userUid) {
+        return this.run(() => this.dbApi.getUserAnalytics(userUid ? { userUid } : {}));
+    }
+    getUserAnalyticsByUserId(userUid) {
+        return this.run(() => this.dbApi.getUserAnalyticsByUserId({ userUid }));
+    }
+    getUserStats(userUid) {
+        return this.run(() => this.dbApi.getUserAnalyticsStatistics({ userUid }));
+    }
+    getUserCampaignAnalytics(userUid, campaignId) {
+        return this.run(() => this.dbApi.getUserCampaignAnalytics({ userUid, campaignId }));
+    }
+    getCampaignAnalytics(campaignId, userUid) {
+        return this.run(() => this.campaignApi.getCampaignAnalytics({ campaignId, userUid }));
+    }
+    getCampaignStats(campaignId, userUid) {
+        return this.run(() => this.dbApi.getCampaignStatisticsDup({ campaignId, userUid }));
+    }
+    getCallRecording(callId) {
+        return this.run(() => this.dbApi.getCallRecording({ callId }));
+    }
+    createTranscript(data) {
+        return this.run(() => this.dbApi.createTranscriptRecord({ createTranscriptRecordRequest: data }));
+    }
+    listTranscripts(userUid) {
+        return this.run(() => this.dbApi.getUserSTranscripts({ userUid }));
+    }
+    raw() {
+        return this.dbApi;
+    }
+}
+class WebhooksService {
+    constructor(api, run) {
+        this.api = api;
+        this.run = run;
+    }
+    create(userUid, data) {
+        return this.run(() => this.api.createWebhookEndpoint({
+            userUid,
+            createWebhookEndpointRequest: data,
+        }));
+    }
+    list(userUid) {
+        return this.run(() => this.api.listUserWebhookEndpoints({ userUid }));
+    }
+    get(userUid, webhookId) {
+        return this.run(() => this.api.getWebhookEndpointById({ userUid, webhookId }));
+    }
+    update(userUid, webhookId, data) {
+        return this.run(() => this.api.updateWebhookEndpoint({
+            userUid,
+            webhookId,
+            updateWebhookEndpointRequest: data,
+        }));
+    }
+    delete(userUid, webhookId) {
+        return this.run(() => this.api.deleteWebhookEndpoint({ userUid, webhookId }));
+    }
+    supportedEvents() {
+        return this.run(() => this.api.getSupportedEventTypes());
+    }
+    lookup(userUid, eventType) {
+        return this.run(() => this.api.lookupActiveEndpointsInternal({ userUid, eventType }));
+    }
+    raw() {
+        return this.api;
+    }
+}
+class TrunksService {
+    constructor(api, run) {
+        this.api = api;
+        this.run = run;
+    }
+    list(userUid) {
+        return this.run(() => this.api.listUserTrunks({ userUid }));
+    }
+    get(userUid, trunkId) {
+        return this.run(() => this.api.getSpecificUserTrunk({ userUid, trunkId }));
+    }
+    create(userUid, data) {
+        return this.run(() => this.api.createUserTrunk({ userUid, createUserTrunkRequest: data }));
+    }
+    update(userUid, trunkId, data) {
+        return this.run(() => this.api.updateUserTrunk({
+            userUid,
+            trunkId,
+            updateUserTrunkRequest: data,
+        }));
+    }
+    delete(userUid, trunkId) {
+        return this.run(() => this.api.deleteTrunkGloballyWarning({ userUid, trunkId }));
+    }
+    raw() {
+        return this.api;
+    }
+}
+class WalletService {
+    constructor(api, run) {
+        this.api = api;
+        this.run = run;
+    }
+    getBalance(userUid) {
+        return this.run(() => this.api.getUserCredits({ userUid }));
+    }
+    raw() {
+        return this.api;
+    }
+}
+class OutboundCallsService {
+    constructor(api, run) {
+        this.api = api;
+        this.run = run;
+    }
+    create(phoneNumber, body) {
+        return this.run(() => this.api.postOutboundCallByPhoneNumber({ phoneNumber, requestBody: body }));
+    }
+    raw() {
+        return this.api;
+    }
+}
+class MonadeClient {
+    constructor(config = {}) {
+        const timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        const fetchApi = createFetchWithTimeout((config.fetch ?? fetch), timeoutMs);
+        const headers = {
+            ...(config.headers ?? {}),
+        };
+        if (config.apiKey) {
+            headers.Authorization = headers.Authorization ?? `Bearer ${config.apiKey}`;
+            headers['X-API-Key'] = headers['X-API-Key'] ?? config.apiKey;
+        }
+        const runtimeConfig = new runtime_1.Configuration({
+            basePath: config.baseUrl ?? DEFAULT_BASE_URL,
+            headers,
+            fetchApi,
+            accessToken: config.apiKey,
+            apiKey: config.apiKey,
+        });
+        const campaignsApi = new apis_1.CampaignServiceApiApi(runtimeConfig);
+        const dbApi = new apis_1.PostgresqlDbRoutesApi(runtimeConfig);
+        const controlPlaneApi = new apis_1.ControlPlaneApi(runtimeConfig);
+        const run = async (fn) => {
+            try {
+                return await fn();
+            }
+            catch (error) {
+                return await mapSdkError(error);
+            }
+        };
+        this.campaigns = new CampaignsService(campaignsApi, run);
+        this.assistants = new AssistantsService(dbApi, run);
+        this.knowledgeBases = new KnowledgeBasesService(dbApi, run);
+        this.analytics = new AnalyticsService(dbApi, campaignsApi, run);
+        this.webhooks = new WebhooksService(dbApi, run);
+        this.trunks = new TrunksService(dbApi, run);
+        this.wallet = new WalletService(dbApi, run);
+        this.outboundCalls = new OutboundCallsService(controlPlaneApi, run);
+        this.generated = {
+            campaignsApi,
+            dbApi,
+            controlPlaneApi,
+        };
+    }
+}
+exports.MonadeClient = MonadeClient;

package/dist/src/errors.d.ts

@@ -0,0 +1,11 @@
+export declare class ApiError extends Error {
+    readonly status?: number;
+    readonly data?: unknown;
+    constructor(message: string, status?: number, data?: unknown);
+}
+export declare class AuthError extends ApiError {
+    constructor(message?: string, status?: number, data?: unknown);
+}
+export declare class ValidationError extends ApiError {
+    constructor(message?: string, status?: number, data?: unknown);
+}

package/dist/src/errors.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationError = exports.AuthError = exports.ApiError = void 0;
+class ApiError extends Error {
+    constructor(message, status, data) {
+        super(message);
+        this.name = 'ApiError';
+        this.status = status;
+        this.data = data;
+    }
+}
+exports.ApiError = ApiError;
+class AuthError extends ApiError {
+    constructor(message = 'Authentication failed', status = 401, data) {
+        super(message, status, data);
+        this.name = 'AuthError';
+    }
+}
+exports.AuthError = AuthError;
+class ValidationError extends ApiError {
+    constructor(message = 'Validation failed', status = 422, data) {
+        super(message, status, data);
+        this.name = 'ValidationError';
+    }
+}
+exports.ValidationError = ValidationError;

package/dist/src/index.d.ts

@@ -0,0 +1,5 @@
+export { MonadeClient } from './client';
+export type { MonadeClientConfig, OperationManifestEntry } from './types';
+export { ApiError, AuthError, ValidationError } from './errors';
+export { supportedOperations, supportedOperationIds, operationsByGroup } from './operations';
+export * from '../generated/models';

package/dist/src/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.operationsByGroup = exports.supportedOperationIds = exports.supportedOperations = exports.ValidationError = exports.AuthError = exports.ApiError = exports.MonadeClient = void 0;
+var client_1 = require("./client");
+Object.defineProperty(exports, "MonadeClient", { enumerable: true, get: function () { return client_1.MonadeClient; } });
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "ApiError", { enumerable: true, get: function () { return errors_1.ApiError; } });
+Object.defineProperty(exports, "AuthError", { enumerable: true, get: function () { return errors_1.AuthError; } });
+Object.defineProperty(exports, "ValidationError", { enumerable: true, get: function () { return errors_1.ValidationError; } });
+var operations_1 = require("./operations");
+Object.defineProperty(exports, "supportedOperations", { enumerable: true, get: function () { return operations_1.supportedOperations; } });
+Object.defineProperty(exports, "supportedOperationIds", { enumerable: true, get: function () { return operations_1.supportedOperationIds; } });
+Object.defineProperty(exports, "operationsByGroup", { enumerable: true, get: function () { return operations_1.operationsByGroup; } });
+__exportStar(require("../generated/models"), exports);