totalum-api-sdk 2.0.6 → 2.0.8

package/dist/common/endpoints.d.ts

@@ -0,0 +1,37 @@
+export declare const endpoints: {
+    crud: {
+        getObjectById: string;
+        getObjects: string;
+        createObject: string;
+        editObjectProperties: string;
+        deleteObject: string;
+        deleteObjectAndSubElements: string;
+        updateLastUsersActions: string;
+    };
+    files: {
+        uploadFile: string;
+        getDownloadUrl: string;
+        deleteFile: string;
+        ocrOfImage: string;
+        ocrOfPdf: string;
+    };
+    filter: {
+        lookUpFilter: string;
+        customMongoFilter: string;
+        runCustomAggregationQuery: string;
+    };
+    pdfTemplate: {
+        generatePdfByTemplate: string;
+    };
+    googleIntegration: {
+        getEmails: string;
+        sendEmail: string;
+        getCalendarEvents: string;
+        createCalendarEvent: string;
+    };
+    openai: {
+        createCompletion: string;
+        createChatCompletion: string;
+        generateImage: string;
+    };
+};

package/{common/endpoints.ts → dist/common/endpoints.js}

@@ -1,5 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.endpoints = void 0;
 // ENDPOINTS
-export const endpoints = {
+exports.endpoints = {
     crud: {
         getObjectById: 'api/v1/crud/:typeId/:id',
         getObjects: 'api/v1/crud/:typeId',
@@ -35,4 +38,4 @@ export const endpoints = {
         createChatCompletion: 'api/v1/openai/chat-completion',
         generateImage: 'api/v1/openai/image',
     }
-}
+};

package/dist/common/interfaces.d.ts

@@ -0,0 +1,173 @@
+export interface GoogleCalendarI {
+    summary: string;
+    location?: string;
+    description?: string;
+    start: {
+        dateTime: string;
+        timeZone?: string;
+    };
+    end: {
+        dateTime: string;
+        timeZone?: string;
+    };
+    attendees?: {
+        email: string;
+    }[];
+    reminders?: Reminders;
+}
+interface Reminders {
+    useDefault: boolean;
+    overrides?: {
+        method: string;
+        minutes: number;
+    }[];
+}
+export interface GoogleCalendarEventsResponseI {
+    accessRole: string;
+    defaultReminders: {
+        method: string;
+        minutes: number;
+    }[];
+    etag: string;
+    items: {
+        kind: string;
+        etag: string;
+        id: string;
+        attendees?: {
+            email: string;
+            responseStatus: string;
+        }[];
+        created: string;
+        creator: {
+            email: string;
+            self?: boolean;
+        };
+        description: string;
+        end: {
+            dateTime: string;
+            timeZone: string;
+        };
+        eventType: string;
+        htmlLink: string;
+        iCalUID: string;
+        location: string;
+        organizer: {
+            email: string;
+            self?: boolean;
+        };
+        reminders: {
+            useDefault: boolean;
+        };
+        sequence: number;
+        start: {
+            dateTime: string;
+            timeZone: string;
+        };
+        status: string;
+        summary: string;
+    }[];
+}
+export interface GoogleEmailI {
+    to: string;
+    subject: string;
+    message: string;
+}
+export interface GoogleEmailResponseI {
+    id: string;
+    threadId: string;
+    labelIds: string[];
+    snippet: string;
+    payload: {
+        partId: string;
+        mimeType: string;
+        filename: string;
+        headers: {
+            name: string;
+            value: string;
+        }[];
+        body: {
+            size: number;
+            data: string;
+        };
+    };
+    sizeEstimate: number;
+    historyId: string;
+    internalDate: string;
+    fullText: string;
+}
+export interface StructureLevels {
+    id: string;
+    typeId: string;
+    propertyId?: string;
+    children: Array<StructureLevels>;
+}
+export interface FilterSearchQueryI {
+    filter?: FiltersArrayI;
+    sort?: ISearchQuerySort[];
+    pagination?: {
+        limit?: number;
+        page?: number;
+        skip?: number;
+    };
+}
+export type FilterLookupSearchQueryI = {
+    pagination: {
+        limit?: number;
+        page?: number;
+        skip?: number;
+    };
+    filters: FilterStructureLevelsI;
+};
+export interface FilterStructureLevelsI extends StructureLevels {
+    filters?: FiltersArrayI;
+    children: FilterStructureLevelsI[];
+}
+export type FiltersArrayI = Array<ISearchQueryFilterOr | ISearchQueryFilterOptions>;
+export interface ISearchQueryFilterOr {
+    or: ISearchQueryFilterOptions[];
+}
+export interface ISearchQuerySort {
+    [key: string]: 1 | -1;
+}
+export interface ISearchQueryFilterOptions {
+    [key: string]: number | Date | boolean | string | PropertyQueryOptionsI;
+}
+export interface PropertyQueryOptionsI {
+    regex?: number | string;
+    options?: 'i' | 'm' | 'x' | 's';
+    gte?: number | Date;
+    lte?: number | Date;
+    gt?: number | Date;
+    lt?: number | Date;
+}
+export type fieldValuesEnabled = string | number | boolean | Date;
+export interface DataValues {
+    typeId: string;
+    id: string;
+    _id: string;
+    properties: DataProperties;
+    updates?: string;
+    createdAt?: Date;
+    updatedAt?: Date;
+    lastUsersActions?: {
+        [key: string]: any;
+    };
+}
+export interface DataProperties {
+    [key: string]: fieldValuesEnabled | {
+        name: string;
+        previousFilename: string;
+    };
+}
+export interface AuthOptions {
+    token?: {
+        accessToken: string;
+    };
+    apiKey?: {
+        apiKey: string;
+        apiKeyName: string;
+        organizationId: string;
+    };
+    baseUrl?: string;
+}
+export {};

package/dist/common/interfaces.js

@@ -0,0 +1,3 @@
+"use strict";
+//INTERFACES
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+import { AuthOptions } from './common/interfaces';
+import { OpenaiService } from './services/OpenaiService';
+import { GoogleService } from './services/GoogleService';
+import { FilterService } from './services/FilterService';
+import { FilesService } from './services/FilesService';
+import { CrudService } from './services/CrudService';
+export declare class TotalumApiSdk {
+    private authOptions;
+    private _baseUrl;
+    private _headers;
+    openai: OpenaiService;
+    files: FilesService;
+    google: GoogleService;
+    filter: FilterService;
+    crud: CrudService;
+    constructor(authOptions: AuthOptions);
+    changeBaseUrl(newBaseUrl: string): void;
+    private setRequestData;
+}

package/dist/index.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TotalumApiSdk = void 0;
+const OpenaiService_1 = require("./services/OpenaiService");
+const GoogleService_1 = require("./services/GoogleService");
+const FilterService_1 = require("./services/FilterService");
+const FilesService_1 = require("./services/FilesService");
+const CrudService_1 = require("./services/CrudService");
+class TotalumApiSdk {
+    constructor(authOptions) {
+        var _a, _b, _c;
+        this._baseUrl = 'https://api.totalum.app/';
+        this.authOptions = authOptions;
+        if ((_a = this.authOptions.token) === null || _a === void 0 ? void 0 : _a.accessToken) {
+            this._headers = {
+                authorization: this.authOptions.token.accessToken
+            };
+        }
+        else if (((_b = this.authOptions.apiKey) === null || _b === void 0 ? void 0 : _b.apiKey) && ((_c = this.authOptions.apiKey) === null || _c === void 0 ? void 0 : _c.organizationId)) {
+            this._headers = {
+                'api-key': this.authOptions.apiKey.apiKey,
+                'organization-id': this.authOptions.apiKey.organizationId,
+                'api-key-name': this.authOptions.apiKey.apiKeyName
+            };
+        }
+        else {
+            throw new Error('Error: invalid auth options');
+        }
+        if (this.authOptions.baseUrl) {
+            this._baseUrl = this.authOptions.baseUrl;
+        }
+        this.setRequestData();
+    }
+    changeBaseUrl(newBaseUrl) {
+        this._baseUrl = newBaseUrl;
+        //update services with new implementation
+        this.setRequestData();
+    }
+    setRequestData() {
+        this.crud = new CrudService_1.CrudService(this._baseUrl, this._headers);
+        this.openai = new OpenaiService_1.OpenaiService(this._baseUrl, this._headers);
+        this.files = new FilesService_1.FilesService(this._baseUrl, this._headers);
+        this.google = new GoogleService_1.GoogleService(this._baseUrl, this._headers);
+        this.filter = new FilterService_1.FilterService(this._baseUrl, this._headers);
+    }
+}
+exports.TotalumApiSdk = TotalumApiSdk;

package/dist/services/CrudService.d.ts

@@ -0,0 +1,11 @@
+import { FilterSearchQueryI, DataProperties } from "../common/interfaces";
+export declare class CrudService {
+    private headers;
+    private baseUrl;
+    constructor(baseUrl: string, headers: any);
+    getItemById(itemType: string, id: string): Promise<import("axios").AxiosResponse<any, any>>;
+    getItems(itemType: string, query?: FilterSearchQueryI): Promise<import("axios").AxiosResponse<any, any>>;
+    deleteItemById(itemType: string, id: string): Promise<import("axios").AxiosResponse<any, any>>;
+    editItemById(itemType: string, id: string, properties: any): Promise<import("axios").AxiosResponse<any, any>>;
+    createItem(itemType: string, item: DataProperties): Promise<import("axios").AxiosResponse<any, any>>;
+}

package/dist/services/CrudService.js

@@ -0,0 +1,53 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CrudService = void 0;
+const axios_1 = __importDefault(require("axios"));
+const utils_1 = require("../utils");
+const endpoints_1 = require("../common/endpoints");
+class CrudService {
+    constructor(baseUrl, headers) {
+        this.headers = headers;
+        this.baseUrl = baseUrl;
+    }
+    getItemById(itemType, id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = utils_1.UtilsService.getUrl(this.baseUrl, endpoints_1.endpoints.crud.getObjectById, { typeId: itemType, id });
+            return axios_1.default.get(url, { headers: this.headers });
+        });
+    }
+    getItems(itemType, query) {
+        const url = utils_1.UtilsService.getUrl(this.baseUrl, endpoints_1.endpoints.crud.getObjects, { typeId: itemType });
+        return axios_1.default.get(url, { params: query, headers: this.headers });
+    }
+    deleteItemById(itemType, id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = utils_1.UtilsService.getUrl(this.baseUrl, endpoints_1.endpoints.crud.deleteObject, { typeId: itemType, id });
+            return axios_1.default.delete(url, { headers: this.headers });
+        });
+    }
+    editItemById(itemType, id, properties) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = utils_1.UtilsService.getUrl(this.baseUrl, endpoints_1.endpoints.crud.editObjectProperties, { typeId: itemType, id });
+            return axios_1.default.patch(url, properties, { headers: this.headers });
+        });
+    }
+    createItem(itemType, item) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = utils_1.UtilsService.getUrl(this.baseUrl, endpoints_1.endpoints.crud.createObject, { typeId: itemType });
+            return axios_1.default.post(url, item, { headers: this.headers });
+        });
+    }
+}
+exports.CrudService = CrudService;

package/dist/services/FilesService.d.ts

@@ -0,0 +1,12 @@
+export declare class FilesService {
+    private headers;
+    private baseUrl;
+    constructor(baseUrl: string, headers: any);
+    uploadFile(fileFormData: any): Promise<import("axios").AxiosResponse<any, any>>;
+    getDownloadUrl(fileName: string): Promise<import("axios").AxiosResponse<any, any>>;
+    generatePdfByTemplate(id: string, variables: {
+        [variableName: string]: any;
+    }, name: string): Promise<import("axios").AxiosResponse<any, any>>;
+    ocrOfImage(fileName: string): Promise<import("axios").AxiosResponse<any, any>>;
+    ocrOfPdf(fileName: string): Promise<import("axios").AxiosResponse<any, any>>;
+}

package/dist/services/FilesService.js

@@ -0,0 +1,55 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilesService = void 0;
+const axios_1 = __importDefault(require("axios"));
+const utils_1 = require("../utils");
+const endpoints_1 = require("../common/endpoints");
+class FilesService {
+    constructor(baseUrl, headers) {
+        this.headers = headers;
+        this.baseUrl = baseUrl;
+    }
+    uploadFile(fileFormData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = utils_1.UtilsService.getUrl(this.baseUrl, endpoints_1.endpoints.files.uploadFile);
+            return axios_1.default.post(url, fileFormData, { headers: this.headers });
+        });
+    }
+    getDownloadUrl(fileName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = utils_1.UtilsService.getUrl(this.baseUrl, endpoints_1.endpoints.files.getDownloadUrl, { fileName });
+            return axios_1.default.get(url, { headers: this.headers });
+        });
+    }
+    generatePdfByTemplate(id, variables, name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = utils_1.UtilsService.getUrl(this.baseUrl, endpoints_1.endpoints.pdfTemplate.generatePdfByTemplate, { id });
+            return axios_1.default.post(url, { templateId: id, variables, name }, { headers: this.headers });
+        });
+    }
+    ocrOfImage(fileName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = utils_1.UtilsService.getUrl(this.baseUrl, endpoints_1.endpoints.files.ocrOfImage);
+            return axios_1.default.post(url, { fileName }, { headers: this.headers });
+        });
+    }
+    ocrOfPdf(fileName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = utils_1.UtilsService.getUrl(this.baseUrl, endpoints_1.endpoints.files.ocrOfPdf);
+            return axios_1.default.post(url, { fileName }, { headers: this.headers });
+        });
+    }
+}
+exports.FilesService = FilesService;

package/dist/services/FilterService.d.ts

@@ -0,0 +1,8 @@
+import { FilterLookupSearchQueryI } from "../common/interfaces";
+export declare class FilterService {
+    private headers;
+    private baseUrl;
+    constructor(baseUrl: string, headers: any);
+    lookUpFilter(idPage: string, query: FilterLookupSearchQueryI, idsOfMultipleNodesToSearch?: string[], returnCount?: boolean): Promise<import("axios").AxiosResponse<any, any>>;
+    runCustomMongoAggregationQuery(type: string, customMongoQuery: string): Promise<import("axios").AxiosResponse<any, any>>;
+}

package/dist/services/FilterService.js

@@ -0,0 +1,49 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterService = void 0;
+const axios_1 = __importDefault(require("axios"));
+const endpoints_1 = require("../common/endpoints");
+const utils_1 = require("../utils");
+class FilterService {
+    constructor(baseUrl, headers) {
+        this.headers = headers;
+        this.baseUrl = baseUrl;
+    }
+    /*public async customMongoFilter(customMongoFilter: string, rootTypeId: string, typeIdToGet: string, options?: { variables?: any, pagination?: any, sort?: any, returnCount?: boolean }) {
+        const url = UtilsService.getUrl(this.baseUrl, endpoints.filter.customMongoFilter, {});
+        const body = { sort: options?.sort, variables: options?.variables, customMongoFilter, pagination: options?.pagination, rootTypeId, typeIdToGet };
+        const params = options?.returnCount ? { returnCount: options?.returnCount } : null;
+        return axios.post(url, body, { params: params, headers: this.headers });
+    }*/
+    lookUpFilter(idPage, query, idsOfMultipleNodesToSearch, returnCount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = utils_1.UtilsService.getUrl(this.baseUrl, endpoints_1.endpoints.filter.lookUpFilter, { idPage });
+            const params = {
+                query: encodeURIComponent(JSON.stringify(query)),
+                idsOfMultipleNodesToSearch: encodeURIComponent(JSON.stringify(idsOfMultipleNodesToSearch)),
+                returnCount: returnCount,
+            };
+            return axios_1.default.get(url, { params: params, headers: this.headers });
+        });
+    }
+    runCustomMongoAggregationQuery(type, customMongoQuery) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = utils_1.UtilsService.getUrl(this.baseUrl, endpoints_1.endpoints.filter.runCustomAggregationQuery);
+            const body = { customMongoQuery, type };
+            return axios_1.default.post(url, body, { headers: this.headers });
+        });
+    }
+}
+exports.FilterService = FilterService;

package/dist/services/GoogleService.d.ts

@@ -0,0 +1,15 @@
+import { GoogleCalendarI } from "../common/interfaces";
+export declare class GoogleService {
+    private headers;
+    private baseUrl;
+    constructor(baseUrl: string, headers: any);
+    getGoogleAccountEmails(accountEmail: string): Promise<import("axios").AxiosResponse<any, any>>;
+    googleAccountSendEmail(accountEmail: string, body: {
+        to: string;
+        subject: string;
+        message?: string;
+        html?: string;
+    }): Promise<import("axios").AxiosResponse<any, any>>;
+    getGoogleCalendarEvents(accountEmail: string): Promise<import("axios").AxiosResponse<any, any>>;
+    createCalendarEvent(accountEmail: string, body: GoogleCalendarI): Promise<import("axios").AxiosResponse<any, any>>;
+}

package/dist/services/GoogleService.js

@@ -0,0 +1,53 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleService = void 0;
+const axios_1 = __importDefault(require("axios"));
+const endpoints_1 = require("../common/endpoints");
+const utils_1 = require("../utils");
+class GoogleService {
+    constructor(baseUrl, headers) {
+        this.headers = headers;
+        this.baseUrl = baseUrl;
+    }
+    getGoogleAccountEmails(accountEmail) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = utils_1.UtilsService.getUrl(this.baseUrl, endpoints_1.endpoints.googleIntegration.getEmails, {});
+            const params = { userEmail: accountEmail };
+            return axios_1.default.get(url, { params: params, headers: this.headers });
+        });
+    }
+    googleAccountSendEmail(accountEmail, body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = utils_1.UtilsService.getUrl(this.baseUrl, endpoints_1.endpoints.googleIntegration.sendEmail, {});
+            const params = { userEmail: accountEmail };
+            return axios_1.default.post(url, body, { params: params, headers: this.headers });
+        });
+    }
+    getGoogleCalendarEvents(accountEmail) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = utils_1.UtilsService.getUrl(this.baseUrl, endpoints_1.endpoints.googleIntegration.getCalendarEvents, {});
+            const params = { userEmail: accountEmail };
+            return axios_1.default.get(url, { params: params, headers: this.headers });
+        });
+    }
+    createCalendarEvent(accountEmail, body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = utils_1.UtilsService.getUrl(this.baseUrl, endpoints_1.endpoints.googleIntegration.createCalendarEvent, {});
+            const params = { userEmail: accountEmail };
+            return axios_1.default.post(url, body, { params: params, headers: this.headers });
+        });
+    }
+}
+exports.GoogleService = GoogleService;

package/dist/services/OpenaiService.d.ts

@@ -0,0 +1,38 @@
+import { AxiosResponse } from "axios";
+import { Completion } from "openai/resources";
+import { ChatCompletionCreateParamsBase } from "openai/resources/chat/completions";
+import { CompletionCreateParamsBase } from "openai/resources/completions";
+export declare class OpenaiService {
+    private headers;
+    private baseUrl;
+    constructor(baseUrl: string, headers: any);
+    /**
+     *
+     * @param body the openai completion body, more info here: https://platform.openai.com/docs/api-reference/completions/create
+     * @returns the completion provided by openai api
+     * @deprecated use createChatCompletion instead
+     */
+    createCompletion(body: CompletionCreateParamsBase): Promise<AxiosResponse<{
+        data: Completion;
+    }>>;
+    /**
+     *
+     * @param body the openai chat completion body, more info here:  https://platform.openai.com/docs/api-reference/chat/create
+     * @returns the chat completion provided by openai api
+     */
+    createChatCompletion(body: ChatCompletionCreateParamsBase): Promise<AxiosResponse<{
+        data: Completion;
+    }>>;
+    /**
+ *
+ * @param body the openai chat completion body, more info here:  https://platform.openai.com/docs/api-reference/chat/create
+ * @returns the chat completion provided by openai api
+ */
+    generateImage(body: {
+        prompt: string;
+        size: '256x256' | '512x512' | '1024x1024';
+        fileName: string;
+    }): Promise<AxiosResponse<{
+        data: Completion;
+    }>>;
+}

package/dist/services/OpenaiService.js

@@ -0,0 +1,62 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenaiService = void 0;
+const axios_1 = __importDefault(require("axios"));
+const utils_1 = require("../utils");
+const endpoints_1 = require("../common/endpoints");
+class OpenaiService {
+    constructor(baseUrl, headers) {
+        this.headers = headers;
+        this.baseUrl = baseUrl;
+    }
+    /**
+     *
+     * @param body the openai completion body, more info here: https://platform.openai.com/docs/api-reference/completions/create
+     * @returns the completion provided by openai api
+     * @deprecated use createChatCompletion instead
+     */
+    createCompletion(body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = utils_1.UtilsService.getUrl(this.baseUrl, endpoints_1.endpoints.openai.createCompletion);
+            const b = body;
+            return axios_1.default.post(url, b, { headers: this.headers });
+        });
+    }
+    /**
+     *
+     * @param body the openai chat completion body, more info here:  https://platform.openai.com/docs/api-reference/chat/create
+     * @returns the chat completion provided by openai api
+     */
+    createChatCompletion(body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = utils_1.UtilsService.getUrl(this.baseUrl, endpoints_1.endpoints.openai.createChatCompletion);
+            const b = body;
+            return axios_1.default.post(url, b, { headers: this.headers });
+        });
+    }
+    /**
+ *
+ * @param body the openai chat completion body, more info here:  https://platform.openai.com/docs/api-reference/chat/create
+ * @returns the chat completion provided by openai api
+ */
+    generateImage(body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = utils_1.UtilsService.getUrl(this.baseUrl, endpoints_1.endpoints.openai.generateImage);
+            const b = body;
+            return axios_1.default.post(url, b, { headers: this.headers });
+        });
+    }
+}
+exports.OpenaiService = OpenaiService;

package/dist/utils.d.ts

@@ -0,0 +1,3 @@
+export declare class UtilsService {
+    static getUrl(baseUrl: string, pattern: string, params?: any): string;
+}