karboai 1.0.0 → 1.2.0

package/dist/constants.d.ts

@@ -0,0 +1,6 @@
+import { UndiciHeaders } from 'undici/types/dispatcher';
+import { ErrorData } from './schemas/error';
+export declare const KARBO_API = "https://api.karboai.com";
+export declare const BASIC_HEADERS: UndiciHeaders;
+export declare const ERRORS: Record<number, ErrorData>;
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AACxD,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE5C,eAAO,MAAM,SAAS,4BAA4B,CAAC;AAEnD,eAAO,MAAM,aAAa,EAAE,aAE3B,CAAC;AAEF,eAAO,MAAM,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAyB5C,CAAC"}

package/dist/constants.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ERRORS = exports.BASIC_HEADERS = exports.KARBO_API = void 0;
+exports.KARBO_API = 'https://api.karboai.com';
+exports.BASIC_HEADERS = {
+    'Content-Type': 'application/json',
+};
+exports.ERRORS = {
+    400: {
+        name: 'KarboAI.BadRequest',
+        message: 'May empty message, content too long, too many images',
+    },
+    401: {
+        name: 'KarboAI.Unauthorized',
+        message: 'Invalid bot token',
+    },
+    403: {
+        name: 'KarboAI.Forbidden',
+        message: 'Access denied',
+    },
+    404: {
+        name: 'KarboAI.NotFound',
+        message: "Content doesn't exist",
+    },
+    413: {
+        name: 'KarboAI.FileTooLarge',
+        message: 'Please upload files smaller than XX bytes length', // TODO: rewrite to accurate length
+    },
+    429: {
+        name: 'KarboAI.TooManyRequests',
+        message: 'Rate limit exceeded',
+    },
+};

package/dist/core/httptoolkit.d.ts

@@ -0,0 +1,10 @@
+import { GetRequestConfig, MultipartRequestConfig, PostRequestConfig } from '../schemas/configs';
+export declare class HttpToolKit {
+    private readonly headers;
+    constructor(token: string);
+    private handle;
+    get: <T>(config: GetRequestConfig) => Promise<T>;
+    post: <T>(config: PostRequestConfig) => Promise<T>;
+    multipart: <T>(config: MultipartRequestConfig) => Promise<T>;
+}
+//# sourceMappingURL=httptoolkit.d.ts.map

package/dist/core/httptoolkit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"httptoolkit.d.ts","sourceRoot":"","sources":["../../src/core/httptoolkit.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,gBAAgB,EAChB,sBAAsB,EACtB,iBAAiB,EAClB,MAAM,oBAAoB,CAAC;AAI5B,qBAAa,WAAW;IACtB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAwB;gBAEpC,KAAK,EAAE,MAAM;IAOzB,OAAO,CAAC,MAAM,CAaZ;IAEK,GAAG,GAAU,CAAC,EAAE,QAAQ,gBAAgB,KAAG,OAAO,CAAC,CAAC,CAAC,CAO1D;IAEK,IAAI,GAAU,CAAC,EAAE,QAAQ,iBAAiB,KAAG,OAAO,CAAC,CAAC,CAAC,CAQ5D;IAEK,SAAS,GAAU,CAAC,EAAE,QAAQ,sBAAsB,KAAG,OAAO,CAAC,CAAC,CAAC,CAetE;CACH"}

package/dist/core/httptoolkit.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpToolKit = void 0;
+const undici_1 = require("undici");
+const lodash_1 = __importDefault(require("lodash"));
+const constants_1 = require("../constants");
+const logger_1 = require("../utils/logger");
+const errors_1 = require("../utils/errors");
+class HttpToolKit {
+    headers = { ...constants_1.BASIC_HEADERS };
+    constructor(token) {
+        this.headers = {
+            ...this.headers,
+            'Bot-Token': token,
+        };
+    }
+    handle = async (response, path, schema) => {
+        if (!response.ok) {
+            logger_1.LOGGER.child({ path }).error(response.status);
+            errors_1.KarboException.throw(response.status);
+        }
+        logger_1.LOGGER.child({ path }).info(response.status);
+        return schema.parse(await response.json());
+    };
+    get = async (config) => {
+        const response = await (0, undici_1.fetch)(`${constants_1.KARBO_API}${config.path}`, {
+            method: 'GET',
+            headers: this.headers,
+        });
+        return (await this.handle(response, config.path, config.schema));
+    };
+    post = async (config) => {
+        const response = await (0, undici_1.fetch)(`${constants_1.KARBO_API}${config.path}`, {
+            method: 'GET',
+            body: config.body,
+            headers: this.headers,
+        });
+        return (await this.handle(response, config.path, config.schema));
+    };
+    multipart = async (config) => {
+        const blob = new Blob([config.buffer], {
+            type: `image/${config.fileName.split('.').pop()}`,
+        });
+        const form = new undici_1.FormData();
+        form.append('file', blob, config.fileName);
+        const response = await (0, undici_1.fetch)(`${constants_1.KARBO_API}${config.path}`, {
+            method: 'POST',
+            body: form,
+            headers: lodash_1.default.omit(this.headers, ['Content-Type']),
+        });
+        return (await this.handle(response, config.path, config.schema));
+    };
+}
+exports.HttpToolKit = HttpToolKit;

package/dist/core/karboai.d.ts

@@ -0,0 +1,19 @@
+import { KarboConfig } from '../schemas/configs';
+import { MeResponse } from '../schemas/responses';
+export declare class KarboAI {
+    private readonly config;
+    private readonly httptoolkit;
+    constructor(config: KarboConfig);
+    private sendMessage;
+    me: () => Promise<MeResponse>;
+    text: (chatId: string, content: string, replyMessageId?: string) => Promise<{
+        messageId: string;
+        createdAt: number;
+    }>;
+    image: (chatId: string, images: string[], replyMessageId?: string) => Promise<{
+        messageId: string;
+        createdAt: number;
+    }>;
+    upload: (path: string) => Promise<string>;
+}
+//# sourceMappingURL=karboai.d.ts.map

package/dist/core/karboai.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"karboai.d.ts","sourceRoot":"","sources":["../../src/core/karboai.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAqB,MAAM,oBAAoB,CAAC;AACpE,OAAO,EACL,UAAU,EAMX,MAAM,sBAAsB,CAAC;AAK9B,qBAAa,OAAO;IAClB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAc;IACrC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAc;gBAE9B,MAAM,EAAE,WAAW;IAO/B,OAAO,CAAC,WAAW,CAcd;IAEE,EAAE,QAAa,OAAO,CAAC,UAAU,CAAC,CAIpC;IAEE,IAAI,GACT,QAAQ,MAAM,EACd,SAAS,MAAM,EACf,iBAAiB,MAAM;;;OAMpB;IAEE,KAAK,GACV,QAAQ,MAAM,EACd,QAAQ,MAAM,EAAE,EAChB,iBAAiB,MAAM;;;OAMpB;IAEE,MAAM,GAAU,MAAM,MAAM,KAAG,OAAO,CAAC,MAAM,CAAC,CAWnD;CACH"}

package/dist/core/karboai.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KarboAI = void 0;
+const promises_1 = require("fs/promises");
+const responses_1 = require("../schemas/responses");
+const logger_1 = __importDefault(require("../utils/logger"));
+const utils_1 = require("../utils/utils");
+const httptoolkit_1 = require("./httptoolkit");
+class KarboAI {
+    config;
+    httptoolkit;
+    constructor(config) {
+        this.config = config;
+        this.httptoolkit = new httptoolkit_1.HttpToolKit(config.token);
+        (0, logger_1.default)(!!config.enableLogging);
+    }
+    sendMessage = async (config) => await this.httptoolkit.post({
+        path: '/bot/send-message',
+        body: JSON.stringify((0, utils_1.clean)({
+            chat_id: config.chatId,
+            content: config.content,
+            reply_message_id: config.replyMessageId,
+            images: config.images,
+        })),
+        schema: responses_1.MessageResponseSchema,
+    });
+    me = async () => await this.httptoolkit.get({
+        path: '/bot/me',
+        schema: responses_1.MeResponseSchema,
+    });
+    text = async (chatId, content, replyMessageId) => await this.sendMessage({
+        chatId,
+        content,
+        replyMessageId,
+    });
+    image = async (chatId, images, replyMessageId) => await this.sendMessage({
+        chatId,
+        images,
+        replyMessageId,
+    });
+    upload = async (path) => {
+        const file = await (0, promises_1.readFile)(path);
+        return (await this.httptoolkit.multipart({
+            path: '/bot/upload/image',
+            buffer: file,
+            fileName: path.split('/').pop(),
+            schema: responses_1.UploadResponseSchema,
+        })).url;
+    };
+}
+exports.KarboAI = KarboAI;

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-export {};
+export { KarboAI } from './core/karboai';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/index.js

@@ -1,2 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.KarboAI = void 0;
+var karboai_1 = require("./core/karboai");
+Object.defineProperty(exports, "KarboAI", { enumerable: true, get: function () { return karboai_1.KarboAI; } });

package/dist/schemas/configs.d.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+export declare const GetRequestConfigSchema: z.ZodObject<{
+    path: z.ZodString;
+    schema: z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+}, z.core.$strip>;
+export declare const PostRequestConfigSchema: z.ZodObject<{
+    body: z.ZodString;
+    path: z.ZodString;
+    schema: z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+}, z.core.$strip>;
+export declare const MultipartRequestConfigSchema: z.ZodObject<{
+    buffer: z.ZodCustom<Buffer<ArrayBufferLike>, Buffer<ArrayBufferLike>>;
+    fileName: z.ZodString;
+    path: z.ZodString;
+    schema: z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+}, z.core.$strip>;
+export declare const KarboConfigSchema: z.ZodObject<{
+    token: z.ZodString;
+    id: z.ZodString;
+    enableLogging: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const SendMessageConfigSchema: z.ZodObject<{
+    chatId: z.ZodString;
+    content: z.ZodOptional<z.ZodString>;
+    replyMessageId: z.ZodOptional<z.ZodString>;
+    images: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type GetRequestConfig = z.Infer<typeof GetRequestConfigSchema>;
+export type PostRequestConfig = z.Infer<typeof PostRequestConfigSchema>;
+export type MultipartRequestConfig = z.Infer<typeof MultipartRequestConfigSchema>;
+export type KarboConfig = z.Infer<typeof KarboConfigSchema>;
+export type SendMessageConfig = z.Infer<typeof SendMessageConfigSchema>;
+//# sourceMappingURL=configs.d.ts.map

package/dist/schemas/configs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"configs.d.ts","sourceRoot":"","sources":["../../src/schemas/configs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAW,MAAM,KAAK,CAAC;AAEjC,eAAO,MAAM,sBAAsB;;;iBAGjC,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;;iBAGlC,CAAC;AAEH,eAAO,MAAM,4BAA4B;;;;;iBAIvC,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;;iBAI5B,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;;;iBAKlC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACxE,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAC1C,OAAO,4BAA4B,CACpC,CAAC;AACF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAC5D,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC"}

package/dist/schemas/configs.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SendMessageConfigSchema = exports.KarboConfigSchema = exports.MultipartRequestConfigSchema = exports.PostRequestConfigSchema = exports.GetRequestConfigSchema = void 0;
+const zod_1 = require("zod");
+exports.GetRequestConfigSchema = zod_1.z.object({
+    path: zod_1.z.string(),
+    schema: zod_1.z.instanceof(zod_1.ZodType),
+});
+exports.PostRequestConfigSchema = zod_1.z.object({
+    ...exports.GetRequestConfigSchema.shape,
+    body: zod_1.z.string(),
+});
+exports.MultipartRequestConfigSchema = zod_1.z.object({
+    ...exports.GetRequestConfigSchema.shape,
+    buffer: zod_1.z.instanceof(Buffer),
+    fileName: zod_1.z.string(),
+});
+exports.KarboConfigSchema = zod_1.z.object({
+    token: zod_1.z.string(),
+    id: zod_1.z.string(),
+    enableLogging: zod_1.z.boolean().optional(),
+});
+exports.SendMessageConfigSchema = zod_1.z.object({
+    chatId: zod_1.z.string(),
+    content: zod_1.z.string().optional(),
+    replyMessageId: zod_1.z.string().optional(),
+    images: zod_1.z.array(zod_1.z.string()).optional(),
+});

package/dist/schemas/enums.d.ts

@@ -0,0 +1,7 @@
+import z from 'zod';
+export declare const BotStatusEnum: z.ZodPipe<z.ZodEnum<{
+    not_official: "not_official";
+    official: "official";
+    banned: "banned";
+}>, z.ZodTransform<string, "not_official" | "official" | "banned">>;
+//# sourceMappingURL=enums.d.ts.map

package/dist/schemas/enums.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enums.d.ts","sourceRoot":"","sources":["../../src/schemas/enums.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAEpB,eAAO,MAAM,aAAa;;;;mEAEgB,CAAC"}

package/dist/schemas/enums.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BotStatusEnum = void 0;
+const zod_1 = __importDefault(require("zod"));
+exports.BotStatusEnum = zod_1.default
+    .enum(['not_official', 'official', 'banned'])
+    .transform((data) => data.toUpperCase());

package/dist/schemas/error.d.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+export declare const ErrorDataSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    message: z.ZodString;
+}, z.core.$strip>;
+export type ErrorData = z.infer<typeof ErrorDataSchema>;
+//# sourceMappingURL=error.d.ts.map

package/dist/schemas/error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../../src/schemas/error.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,eAAe;;;iBAG1B,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC"}

package/dist/schemas/error.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorDataSchema = void 0;
+const zod_1 = require("zod");
+exports.ErrorDataSchema = zod_1.z.object({
+    name: zod_1.z.string().optional(),
+    message: zod_1.z.string(),
+});

package/dist/schemas/karboai/message.d.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+export declare const MessageSchema: z.ZodObject<{
+    message_id: z.ZodString;
+    chat_id: z.ZodString;
+    user_id: z.ZodString;
+    content: z.ZodString;
+    created_time: z.ZodString;
+    type: z.ZodNumber;
+    reply_message_id: z.ZodNullable<z.ZodString>;
+    audio: z.ZodNullable<z.ZodString>;
+    sticker: z.ZodNullable<z.ZodString>;
+    images: z.ZodArray<z.ZodString>;
+    author: z.ZodPipe<z.ZodObject<{
+        user_id: z.ZodString;
+        nickname: z.ZodString;
+        avatar: z.ZodString;
+        role: z.ZodNumber;
+        short_info: z.ZodString;
+    }, z.core.$strip>, z.ZodTransform<{
+        userId: string;
+        nickname: string;
+        avatar: string;
+    }, {
+        user_id: string;
+        nickname: string;
+        avatar: string;
+        role: number;
+        short_info: string;
+    }>>;
+}, z.core.$strip>;
+export type Message = z.infer<typeof MessageSchema>;
+//# sourceMappingURL=message.d.ts.map

package/dist/schemas/karboai/message.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message.d.ts","sourceRoot":"","sources":["../../../src/schemas/karboai/message.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAYxB,CAAC;AAEH,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC"}

package/dist/schemas/karboai/message.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageSchema = void 0;
+const zod_1 = require("zod");
+const users_1 = require("./users");
+exports.MessageSchema = zod_1.z.object({
+    message_id: zod_1.z.string(),
+    chat_id: zod_1.z.string(),
+    user_id: zod_1.z.string(),
+    content: zod_1.z.string(),
+    created_time: zod_1.z.string(),
+    type: zod_1.z.number(),
+    reply_message_id: zod_1.z.string().nullable(),
+    audio: zod_1.z.string().nullable(),
+    sticker: zod_1.z.string().nullable(),
+    images: zod_1.z.array(zod_1.z.string()),
+    author: users_1.AuthorSchema,
+});

package/dist/schemas/karboai/users.d.ts

@@ -0,0 +1,59 @@
+import { z } from 'zod';
+export declare const UserSchema: z.ZodPipe<z.ZodObject<{
+    user_id: z.ZodString;
+    nickname: z.ZodString;
+    avatar: z.ZodString;
+    role: z.ZodNumber;
+    short_info: z.ZodString;
+}, z.core.$strip>, z.ZodTransform<{
+    userId: string;
+    nickname: string;
+    avatar: string;
+    role: number;
+    shortInfo: string;
+}, {
+    user_id: string;
+    nickname: string;
+    avatar: string;
+    role: number;
+    short_info: string;
+}>>;
+export declare const MemberSchema: z.ZodPipe<z.ZodObject<{
+    user_id: z.ZodString;
+    nickname: z.ZodString;
+    avatar: z.ZodString;
+    role: z.ZodNumber;
+    short_info: z.ZodString;
+}, z.core.$strip>, z.ZodTransform<{
+    userId: string;
+    nickname: string;
+    avatar: string;
+    role: number;
+}, {
+    user_id: string;
+    nickname: string;
+    avatar: string;
+    role: number;
+    short_info: string;
+}>>;
+export declare const AuthorSchema: z.ZodPipe<z.ZodObject<{
+    user_id: z.ZodString;
+    nickname: z.ZodString;
+    avatar: z.ZodString;
+    role: z.ZodNumber;
+    short_info: z.ZodString;
+}, z.core.$strip>, z.ZodTransform<{
+    userId: string;
+    nickname: string;
+    avatar: string;
+}, {
+    user_id: string;
+    nickname: string;
+    avatar: string;
+    role: number;
+    short_info: string;
+}>>;
+export type User = z.infer<typeof UserSchema>;
+export type Member = z.infer<typeof MemberSchema>;
+export type Author = z.infer<typeof AuthorSchema>;
+//# sourceMappingURL=users.d.ts.map

package/dist/schemas/karboai/users.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"users.d.ts","sourceRoot":"","sources":["../../../src/schemas/karboai/users.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAUxB,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;GAQrB,CAAC;AAEH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;GAOvB,CAAC;AAEH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;GAMvB,CAAC;AAEH,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAC9C,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAClD,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC"}

package/dist/schemas/karboai/users.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthorSchema = exports.MemberSchema = exports.UserSchema = void 0;
+const zod_1 = require("zod");
+const BasicUserSchema = zod_1.z.object({
+    user_id: zod_1.z.string(),
+    nickname: zod_1.z.string(),
+    avatar: zod_1.z.string(),
+    role: zod_1.z.number(),
+    short_info: zod_1.z.string(),
+});
+exports.UserSchema = BasicUserSchema.transform((data) => {
+    return {
+        userId: data.user_id,
+        nickname: data.nickname,
+        avatar: data.avatar,
+        role: data.role,
+        shortInfo: data.short_info,
+    };
+});
+exports.MemberSchema = BasicUserSchema.transform((data) => {
+    return {
+        userId: data.user_id,
+        nickname: data.nickname,
+        avatar: data.avatar,
+        role: data.role,
+    };
+});
+exports.AuthorSchema = BasicUserSchema.transform((data) => {
+    return {
+        userId: data.user_id,
+        nickname: data.nickname,
+        avatar: data.avatar,
+    };
+});

package/dist/schemas/responses.d.ts

@@ -0,0 +1,35 @@
+import z from 'zod';
+export declare const MeResponseSchema: z.ZodPipe<z.ZodObject<{
+    bot_id: z.ZodString;
+    name: z.ZodString;
+    status: z.ZodPipe<z.ZodEnum<{
+        not_official: "not_official";
+        official: "official";
+        banned: "banned";
+    }>, z.ZodTransform<string, "not_official" | "official" | "banned">>;
+}, z.core.$strip>, z.ZodTransform<{
+    botId: string;
+    name: string;
+    status: string;
+}, {
+    bot_id: string;
+    name: string;
+    status: string;
+}>>;
+export declare const MessageResponseSchema: z.ZodPipe<z.ZodObject<{
+    message_id: z.ZodString;
+    created_time: z.ZodNumber;
+}, z.core.$strip>, z.ZodTransform<{
+    messageId: string;
+    createdAt: number;
+}, {
+    message_id: string;
+    created_time: number;
+}>>;
+export declare const UploadResponseSchema: z.ZodObject<{
+    url: z.ZodString;
+}, z.core.$strip>;
+export type MeResponse = z.Infer<typeof MeResponseSchema>;
+export type MessageResponse = z.Infer<typeof MessageResponseSchema>;
+export type UploadResponse = z.Infer<typeof UploadResponseSchema>;
+//# sourceMappingURL=responses.d.ts.map

package/dist/schemas/responses.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"responses.d.ts","sourceRoot":"","sources":["../../src/schemas/responses.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAIpB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;GAYzB,CAAC;AAEL,eAAO,MAAM,qBAAqB;;;;;;;;;GAU9B,CAAC;AAEL,eAAO,MAAM,oBAAoB;;iBAE/B,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC1D,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

package/dist/schemas/responses.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UploadResponseSchema = exports.MessageResponseSchema = exports.MeResponseSchema = void 0;
+const zod_1 = __importDefault(require("zod"));
+const enums_1 = require("./enums");
+exports.MeResponseSchema = zod_1.default
+    .object({
+    bot_id: zod_1.default.string(),
+    name: zod_1.default.string(),
+    status: enums_1.BotStatusEnum,
+})
+    .transform((data) => {
+    return {
+        botId: data.bot_id,
+        name: data.name,
+        status: data.status,
+    };
+});
+exports.MessageResponseSchema = zod_1.default
+    .object({
+    message_id: zod_1.default.string(),
+    created_time: zod_1.default.number(),
+})
+    .transform((data) => {
+    return {
+        messageId: data.message_id,
+        createdAt: data.created_time,
+    };
+});
+exports.UploadResponseSchema = zod_1.default.object({
+    url: zod_1.default.string(),
+});

package/dist/utils/errors.d.ts

@@ -0,0 +1,8 @@
+import { ErrorData } from '../schemas/error';
+export declare class KarboException extends Error {
+    readonly code: number;
+    constructor(code: number, data: ErrorData);
+    static get(code: number): KarboException;
+    static throw(code: number): void;
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/utils/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/utils/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAG7C,qBAAa,cAAe,SAAQ,KAAK;IACvC,SAAgB,IAAI,EAAE,MAAM,CAAC;gBAEjB,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS;IAWzC,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc;IAWxC,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;CAGjC"}

package/dist/utils/errors.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KarboException = void 0;
+const constants_1 = require("../constants");
+class KarboException extends Error {
+    code;
+    constructor(code, data) {
+        super(data.message);
+        this.code = code;
+        this.name = data.name || `KarboAI.${code}`;
+        this.code = code;
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, KarboException);
+        }
+    }
+    static get(code) {
+        const errorData = constants_1.ERRORS[code];
+        return errorData
+            ? new KarboException(code, errorData)
+            : new KarboException(code, {
+                name: 'UnknownError',
+                message: 'Unknown error',
+            });
+    }
+    static throw(code) {
+        throw this.get(code);
+    }
+}
+exports.KarboException = KarboException;

package/dist/utils/logger.d.ts

@@ -0,0 +1,5 @@
+import { Logger } from 'pino';
+export declare let LOGGER: Logger;
+declare const initLogger: (enableLogging: boolean) => Logger;
+export default initLogger;
+//# sourceMappingURL=logger.d.ts.map

package/dist/utils/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/utils/logger.ts"],"names":[],"mappings":"AAAA,OAAa,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAGpC,eAAO,IAAI,MAAM,EAAE,MAAM,CAAC;AAE1B,QAAA,MAAM,UAAU,GAAI,eAAe,OAAO,KAAG,MAY5C,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/utils/logger.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LOGGER = void 0;
+const pino_1 = __importDefault(require("pino"));
+const pino_pretty_1 = __importDefault(require("pino-pretty"));
+const initLogger = (enableLogging) => {
+    if (exports.LOGGER)
+        return exports.LOGGER;
+    return (exports.LOGGER = (0, pino_1.default)({
+        enabled: enableLogging,
+    }, (0, pino_pretty_1.default)({
+        colorize: true,
+        sync: true,
+    })));
+};
+exports.default = initLogger;

package/dist/utils/utils.d.ts

@@ -0,0 +1,2 @@
+export declare const clean: (body: Record<string, any>) => Record<string, any>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/utils/utils.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,KAAK,GAAI,MAAM,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,KAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAGjE,CAAC"}

package/dist/utils/utils.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clean = void 0;
+const clean = (body) => Object.fromEntries(Object.entries(body).filter(([_, value]) => value !== undefined));
+exports.clean = clean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "karboai",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "A powerful lib for https://karboai.com",
   "keywords": [
     "karbo",
@@ -28,6 +28,19 @@
   "author": "celt_is_god",
   "type": "commonjs",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "tsc && node dist/tests/main.js",
+    "start": "tsc && node dist/index.js"
+  },
+  "dependencies": {
+    "@types/node": "^25.5.2",
+    "lodash": "^4.18.1",
+    "pino": "^10.3.1",
+    "pino-pretty": "^13.1.3",
+    "socket.io-client": "^4.8.3",
+    "undici": "^8.0.2",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/lodash": "^4.17.24"
   }
 }