@purpleschool/gptbot 0.15.74 → 0.15.75-paraphrase-special

package/build/api/controllers/http/paraphrase.d.ts

@@ -2,6 +2,7 @@ export declare const PARAPHRASE_CONTROLLER_PRIVATE: 'private/tools/paraphrase';
 export declare const PARAPHRASE_CONTROLLER_PUBLIC: 'public/tools/paraphrase';
 export declare const PARAPHRASE_ROUTES: {
     readonly CONFIG: 'config';
+    readonly PRICE: 'price';
     readonly EXECUTE: 'execute';
     readonly GET_JOBS: 'jobs';
     readonly GET_JOB: (uuid: string) => string;

package/build/api/controllers/http/paraphrase.js

@@ -5,6 +5,7 @@ exports.PARAPHRASE_CONTROLLER_PRIVATE = 'private/tools/paraphrase';
 exports.PARAPHRASE_CONTROLLER_PUBLIC = 'public/tools/paraphrase';
 exports.PARAPHRASE_ROUTES = {
     CONFIG: 'config',
+    PRICE: 'price',
     EXECUTE: 'execute',
     GET_JOBS: 'jobs',
     GET_JOB: (uuid) => `jobs/${uuid}`,

package/build/api/routes.d.ts

@@ -687,6 +687,7 @@ export declare const REST_API: {
     };
     readonly PARAPHRASE_PUBLIC: {
         readonly CONFIG: "/api/public/tools/paraphrase/config";
+        readonly PRICE: "/api/public/tools/paraphrase/price";
         readonly EXECUTE: "/api/public/tools/paraphrase/execute";
         readonly GET_JOBS: "/api/public/tools/paraphrase/jobs";
         readonly GET_JOB: (uuid: string) => string;
@@ -699,6 +700,7 @@ export declare const REST_API: {
     };
     readonly PARAPHRASE_PRIVATE: {
         readonly CONFIG: "/api/private/tools/paraphrase/config";
+        readonly PRICE: "/api/private/tools/paraphrase/price";
         readonly EXECUTE: "/api/private/tools/paraphrase/execute";
         readonly GET_JOBS: "/api/private/tools/paraphrase/jobs";
         readonly GET_JOB: (uuid: string) => string;

package/build/api/routes.js

@@ -725,6 +725,7 @@ exports.REST_API = {
     },
     PARAPHRASE_PUBLIC: {
         CONFIG: `${exports.ROOT}/${CONTROLLERS.PARAPHRASE_CONTROLLER_PUBLIC}/${CONTROLLERS.PARAPHRASE_ROUTES.CONFIG}`,
+        PRICE: `${exports.ROOT}/${CONTROLLERS.PARAPHRASE_CONTROLLER_PUBLIC}/${CONTROLLERS.PARAPHRASE_ROUTES.PRICE}`,
         EXECUTE: `${exports.ROOT}/${CONTROLLERS.PARAPHRASE_CONTROLLER_PUBLIC}/${CONTROLLERS.PARAPHRASE_ROUTES.EXECUTE}`,
         GET_JOBS: `${exports.ROOT}/${CONTROLLERS.PARAPHRASE_CONTROLLER_PUBLIC}/${CONTROLLERS.PARAPHRASE_ROUTES.GET_JOBS}`,
         GET_JOB: (uuid) => `${exports.ROOT}/${CONTROLLERS.PARAPHRASE_CONTROLLER_PUBLIC}/${CONTROLLERS.PARAPHRASE_ROUTES.GET_JOB(uuid)}`,
@@ -737,6 +738,7 @@ exports.REST_API = {
     },
     PARAPHRASE_PRIVATE: {
         CONFIG: `${exports.ROOT}/${CONTROLLERS.PARAPHRASE_CONTROLLER_PRIVATE}/${CONTROLLERS.PARAPHRASE_ROUTES.CONFIG}`,
+        PRICE: `${exports.ROOT}/${CONTROLLERS.PARAPHRASE_CONTROLLER_PRIVATE}/${CONTROLLERS.PARAPHRASE_ROUTES.PRICE}`,
         EXECUTE: `${exports.ROOT}/${CONTROLLERS.PARAPHRASE_CONTROLLER_PRIVATE}/${CONTROLLERS.PARAPHRASE_ROUTES.EXECUTE}`,
         GET_JOBS: `${exports.ROOT}/${CONTROLLERS.PARAPHRASE_CONTROLLER_PRIVATE}/${CONTROLLERS.PARAPHRASE_ROUTES.GET_JOBS}`,
         GET_JOB: (uuid) => `${exports.ROOT}/${CONTROLLERS.PARAPHRASE_CONTROLLER_PRIVATE}/${CONTROLLERS.PARAPHRASE_ROUTES.GET_JOB(uuid)}`,

package/build/commands/tools/paraphrase/find-paraphrase-job-by-uuid.command.d.ts

@@ -20,6 +20,26 @@ export declare namespace FindParaphraseJobByUUIDCommand {
             intensity: z.ZodEnum<typeof import("../../..").PARAPHRASING_INTENSITY>;
             reaction: z.ZodNullable<z.ZodEnum<typeof import("../../..").USER_REACTION>>;
             aiOutput: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            inputKind: z.ZodDefault<z.ZodNullable<z.ZodEnum<typeof import("../../..").PARAPHRASE_INPUT_KIND>>>;
+            sourceDocument: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                uuid: z.ZodString;
+                url: z.ZodString;
+                name: z.ZodString;
+                mimeType: z.ZodString;
+                type: z.ZodString;
+                size: z.ZodNumber;
+                extension: z.ZodString;
+            }, z.core.$strip>>>;
+            outputDocument: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                uuid: z.ZodString;
+                url: z.ZodString;
+                name: z.ZodString;
+                mimeType: z.ZodString;
+                type: z.ZodString;
+                size: z.ZodNumber;
+                extension: z.ZodString;
+            }, z.core.$strip>>>;
+            uniquenessPercentage: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
         }, z.core.$strip>;
     }, z.core.$strip>;
     type Response = z.infer<typeof ResponseSchema>;

package/build/commands/tools/paraphrase/find-paraphrase-jobs.command.d.ts

@@ -26,6 +26,26 @@ export declare namespace FindParaphraseJobsCommand {
             intensity: z.ZodEnum<typeof import("../../..").PARAPHRASING_INTENSITY>;
             reaction: z.ZodNullable<z.ZodEnum<typeof import("../../..").USER_REACTION>>;
             aiOutput: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            inputKind: z.ZodDefault<z.ZodNullable<z.ZodEnum<typeof import("../../..").PARAPHRASE_INPUT_KIND>>>;
+            sourceDocument: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                uuid: z.ZodString;
+                url: z.ZodString;
+                name: z.ZodString;
+                mimeType: z.ZodString;
+                type: z.ZodString;
+                size: z.ZodNumber;
+                extension: z.ZodString;
+            }, z.core.$strip>>>;
+            outputDocument: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                uuid: z.ZodString;
+                url: z.ZodString;
+                name: z.ZodString;
+                mimeType: z.ZodString;
+                type: z.ZodString;
+                size: z.ZodNumber;
+                extension: z.ZodString;
+            }, z.core.$strip>>>;
+            uniquenessPercentage: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
         }, z.core.$strip>>;
         totalPages: z.ZodNumber;
         total: z.ZodNumber;

package/build/commands/tools/paraphrase/get-paraphrase-price.command.d.ts

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import { PARAPHRASING_INTENSITY } from '../../../constants';
+export declare namespace GetParaphrasePriceCommand {
+    const PrivateRequestSchema: z.ZodObject<{
+        typeId: z.ZodString;
+        styleId: z.ZodString;
+        intensity: z.ZodEnum<typeof PARAPHRASING_INTENSITY>;
+        prompt: z.ZodOptional<z.ZodString>;
+        fileId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    const PublicRequestSchema: z.ZodObject<{
+        typeId: z.ZodString;
+        styleId: z.ZodString;
+        intensity: z.ZodEnum<typeof PARAPHRASING_INTENSITY>;
+        prompt: z.ZodString;
+    }, z.core.$strict>;
+    const RequestSchema: z.ZodObject<{
+        typeId: z.ZodString;
+        styleId: z.ZodString;
+        intensity: z.ZodEnum<typeof PARAPHRASING_INTENSITY>;
+        prompt: z.ZodOptional<z.ZodString>;
+        fileId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    type Request = z.infer<typeof RequestSchema>;
+    const ResponseSchema: z.ZodObject<{
+        price: z.ZodNumber;
+        charsUntilNextPriceIncrease: z.ZodNullable<z.ZodNumber>;
+        charsUntilNextPriceDecrease: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>;
+    type Response = z.infer<typeof ResponseSchema>;
+}

package/build/commands/tools/paraphrase/get-paraphrase-price.command.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetParaphrasePriceCommand = void 0;
+const zod_1 = require("zod");
+const constants_1 = require("../../../constants");
+const chat_1 = require("../../chat");
+var GetParaphrasePriceCommand;
+(function (GetParaphrasePriceCommand) {
+    GetParaphrasePriceCommand.PrivateRequestSchema = zod_1.z
+        .object({
+        typeId: zod_1.z.string().uuid(),
+        styleId: zod_1.z.string().uuid(),
+        intensity: zod_1.z.nativeEnum(constants_1.PARAPHRASING_INTENSITY),
+        prompt: zod_1.z.string().min(1).max(100000).optional(),
+        fileId: zod_1.z.string().uuid().optional(),
+    })
+        .refine((request) => (request.prompt !== undefined) !== (request.fileId !== undefined), {
+        message: 'Требуется ровно один из prompt или fileId',
+    });
+    GetParaphrasePriceCommand.PublicRequestSchema = zod_1.z
+        .object({
+        typeId: zod_1.z.string().uuid(),
+        styleId: zod_1.z.string().uuid(),
+        intensity: zod_1.z.nativeEnum(constants_1.PARAPHRASING_INTENSITY),
+        prompt: zod_1.z.string().min(1).max(100000),
+    })
+        .strict();
+    GetParaphrasePriceCommand.RequestSchema = GetParaphrasePriceCommand.PrivateRequestSchema;
+    GetParaphrasePriceCommand.ResponseSchema = chat_1.CalculateChatPriceCommand.ResponseSchema;
+})(GetParaphrasePriceCommand || (exports.GetParaphrasePriceCommand = GetParaphrasePriceCommand = {}));

package/build/commands/tools/paraphrase/get-paraphrase-tool-config.command.d.ts

@@ -3,6 +3,7 @@ export declare namespace GetParaphraseToolConfigCommand {
     const ResponseSchema: z.ZodObject<{
         data: z.ZodObject<{
             maxSymbols: z.ZodNumber;
+            freeMaxSymbols: z.ZodNumber;
             styles: z.ZodArray<z.ZodObject<{
                 uuid: z.ZodString;
                 title: z.ZodString;
@@ -19,6 +20,8 @@ export declare namespace GetParaphraseToolConfigCommand {
                 title: z.ZodString;
                 icon: z.ZodString;
                 price: z.ZodNumber;
+                freeMaxPromptLength: z.ZodNumber;
+                maxPromptLength: z.ZodNumber;
                 order: z.ZodNumber;
                 status: z.ZodEnum<typeof import("../../..").TOOL_MODEL_STATUS>;
                 canUse: z.ZodBoolean;

package/build/commands/tools/paraphrase/index.d.ts

@@ -8,3 +8,4 @@ export * from './find-paraphrase-job-by-uuid.command';
 export * from './find-paraphrase-jobs.command';
 export * from './get-paraphrase-tool-config.command';
 export * from './update-paraphrase-job-favorite.command';
+export * from './get-paraphrase-price.command';

package/build/commands/tools/paraphrase/index.js

@@ -24,3 +24,4 @@ __exportStar(require("./find-paraphrase-job-by-uuid.command"), exports);
 __exportStar(require("./find-paraphrase-jobs.command"), exports);
 __exportStar(require("./get-paraphrase-tool-config.command"), exports);
 __exportStar(require("./update-paraphrase-job-favorite.command"), exports);
+__exportStar(require("./get-paraphrase-price.command"), exports);

package/build/commands/tools/paraphrase/paraphrase.command.d.ts

@@ -4,9 +4,16 @@ export declare namespace ParaphraseCommand {
     const RequestSchema: z.ZodObject<{
         styleId: z.ZodString;
         typeId: z.ZodString;
-        prompt: z.ZodString;
+        prompt: z.ZodOptional<z.ZodString>;
+        fileId: z.ZodOptional<z.ZodString>;
         intensity: z.ZodEnum<typeof PARAPHRASING_INTENSITY>;
     }, z.core.$strip>;
+    const PublicRequestSchema: z.ZodObject<{
+        styleId: z.ZodString;
+        typeId: z.ZodString;
+        prompt: z.ZodString;
+        intensity: z.ZodEnum<typeof PARAPHRASING_INTENSITY>;
+    }, z.core.$strict>;
     type Request = z.infer<typeof RequestSchema>;
     const ResponseSchema: z.ZodObject<{
         data: z.ZodObject<{
@@ -16,6 +23,34 @@ export declare namespace ParaphraseCommand {
             isFavorite: z.ZodBoolean;
             createdAt: z.ZodDate;
             updatedAt: z.ZodDate;
+            styleId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            modelId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            userInput: z.ZodString;
+            title: z.ZodString;
+            typeId: z.ZodString;
+            intensity: z.ZodEnum<typeof PARAPHRASING_INTENSITY>;
+            reaction: z.ZodNullable<z.ZodEnum<typeof import("../../..").USER_REACTION>>;
+            aiOutput: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            inputKind: z.ZodDefault<z.ZodNullable<z.ZodEnum<typeof import("../../..").PARAPHRASE_INPUT_KIND>>>;
+            sourceDocument: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                uuid: z.ZodString;
+                url: z.ZodString;
+                name: z.ZodString;
+                mimeType: z.ZodString;
+                type: z.ZodString;
+                size: z.ZodNumber;
+                extension: z.ZodString;
+            }, z.core.$strip>>>;
+            outputDocument: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                uuid: z.ZodString;
+                url: z.ZodString;
+                name: z.ZodString;
+                mimeType: z.ZodString;
+                type: z.ZodString;
+                size: z.ZodNumber;
+                extension: z.ZodString;
+            }, z.core.$strip>>>;
+            uniquenessPercentage: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
         }, z.core.$strip>;
     }, z.core.$strip>;
     type Response = z.infer<typeof ResponseSchema>;

package/build/commands/tools/paraphrase/paraphrase.command.js

@@ -6,13 +6,26 @@ const constants_1 = require("../../../constants");
 const models_1 = require("../../../models");
 var ParaphraseCommand;
 (function (ParaphraseCommand) {
-    ParaphraseCommand.RequestSchema = zod_1.z.object({
+    ParaphraseCommand.RequestSchema = zod_1.z
+        .object({
         styleId: zod_1.z.string().uuid(),
         typeId: zod_1.z.string().uuid(),
-        prompt: zod_1.z.string().min(1).max(100000),
+        prompt: zod_1.z.string().min(1).max(100000).optional(),
+        fileId: zod_1.z.string().uuid().optional(),
         intensity: zod_1.z.nativeEnum(constants_1.PARAPHRASING_INTENSITY),
+    })
+        .refine((request) => (request.prompt !== undefined) !== (request.fileId !== undefined), {
+        message: 'Требуется ровно один из prompt или fileId',
     });
+    ParaphraseCommand.PublicRequestSchema = zod_1.z
+        .object({
+        styleId: zod_1.z.string().uuid(),
+        typeId: zod_1.z.string().uuid(),
+        prompt: zod_1.z.string().min(1).max(100000),
+        intensity: zod_1.z.nativeEnum(constants_1.PARAPHRASING_INTENSITY),
+    })
+        .strict();
     ParaphraseCommand.ResponseSchema = zod_1.z.object({
-        data: models_1.ToolJobSchema,
+        data: models_1.ParaphraseToolJobSchema,
     });
 })(ParaphraseCommand || (exports.ParaphraseCommand = ParaphraseCommand = {}));

package/build/commands/tools/paraphrase/retry-paraphrase-job.command.d.ts

@@ -20,6 +20,26 @@ export declare namespace RetryParaphraseJobCommand {
             intensity: z.ZodEnum<typeof import("../../..").PARAPHRASING_INTENSITY>;
             reaction: z.ZodNullable<z.ZodEnum<typeof import("../../..").USER_REACTION>>;
             aiOutput: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            inputKind: z.ZodDefault<z.ZodNullable<z.ZodEnum<typeof import("../../..").PARAPHRASE_INPUT_KIND>>>;
+            sourceDocument: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                uuid: z.ZodString;
+                url: z.ZodString;
+                name: z.ZodString;
+                mimeType: z.ZodString;
+                type: z.ZodString;
+                size: z.ZodNumber;
+                extension: z.ZodString;
+            }, z.core.$strip>>>;
+            outputDocument: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                uuid: z.ZodString;
+                url: z.ZodString;
+                name: z.ZodString;
+                mimeType: z.ZodString;
+                type: z.ZodString;
+                size: z.ZodNumber;
+                extension: z.ZodString;
+            }, z.core.$strip>>>;
+            uniquenessPercentage: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
         }, z.core.$strip>;
     }, z.core.$strip>;
     type Response = z.infer<typeof ResponseSchema>;

package/build/commands/tools/paraphrase/set-reaction-to-paraphrase-job.command.d.ts

@@ -26,6 +26,26 @@ export declare namespace SetReactionToParaphraseJobCommand {
             intensity: z.ZodEnum<typeof import("../../..").PARAPHRASING_INTENSITY>;
             reaction: z.ZodNullable<z.ZodEnum<typeof USER_REACTION>>;
             aiOutput: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            inputKind: z.ZodDefault<z.ZodNullable<z.ZodEnum<typeof import("../../..").PARAPHRASE_INPUT_KIND>>>;
+            sourceDocument: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                uuid: z.ZodString;
+                url: z.ZodString;
+                name: z.ZodString;
+                mimeType: z.ZodString;
+                type: z.ZodString;
+                size: z.ZodNumber;
+                extension: z.ZodString;
+            }, z.core.$strip>>>;
+            outputDocument: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                uuid: z.ZodString;
+                url: z.ZodString;
+                name: z.ZodString;
+                mimeType: z.ZodString;
+                type: z.ZodString;
+                size: z.ZodNumber;
+                extension: z.ZodString;
+            }, z.core.$strip>>>;
+            uniquenessPercentage: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
         }, z.core.$strip>;
     }, z.core.$strip>;
     type Response = z.infer<typeof ResponseSchema>;

package/build/commands/tools/paraphrase/update-paraphrase-job-favorite.command.d.ts

@@ -24,6 +24,26 @@ export declare namespace UpdateParaphraseJobFavoriteCommand {
             intensity: z.ZodEnum<typeof import("../../..").PARAPHRASING_INTENSITY>;
             reaction: z.ZodNullable<z.ZodEnum<typeof import("../../..").USER_REACTION>>;
             aiOutput: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            inputKind: z.ZodDefault<z.ZodNullable<z.ZodEnum<typeof import("../../..").PARAPHRASE_INPUT_KIND>>>;
+            sourceDocument: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                uuid: z.ZodString;
+                url: z.ZodString;
+                name: z.ZodString;
+                mimeType: z.ZodString;
+                type: z.ZodString;
+                size: z.ZodNumber;
+                extension: z.ZodString;
+            }, z.core.$strip>>>;
+            outputDocument: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                uuid: z.ZodString;
+                url: z.ZodString;
+                name: z.ZodString;
+                mimeType: z.ZodString;
+                type: z.ZodString;
+                size: z.ZodNumber;
+                extension: z.ZodString;
+            }, z.core.$strip>>>;
+            uniquenessPercentage: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
         }, z.core.$strip>;
     }, z.core.$strip>;
     type Response = z.infer<typeof ResponseSchema>;

package/build/commands/tools/paraphrase/update-paraphrase-job-title.command.d.ts

@@ -24,6 +24,26 @@ export declare namespace UpdateParaphraseJobTitleCommand {
             intensity: z.ZodEnum<typeof import("../../..").PARAPHRASING_INTENSITY>;
             reaction: z.ZodNullable<z.ZodEnum<typeof import("../../..").USER_REACTION>>;
             aiOutput: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            inputKind: z.ZodDefault<z.ZodNullable<z.ZodEnum<typeof import("../../..").PARAPHRASE_INPUT_KIND>>>;
+            sourceDocument: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                uuid: z.ZodString;
+                url: z.ZodString;
+                name: z.ZodString;
+                mimeType: z.ZodString;
+                type: z.ZodString;
+                size: z.ZodNumber;
+                extension: z.ZodString;
+            }, z.core.$strip>>>;
+            outputDocument: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                uuid: z.ZodString;
+                url: z.ZodString;
+                name: z.ZodString;
+                mimeType: z.ZodString;
+                type: z.ZodString;
+                size: z.ZodNumber;
+                extension: z.ZodString;
+            }, z.core.$strip>>>;
+            uniquenessPercentage: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
         }, z.core.$strip>;
     }, z.core.$strip>;
     type Response = z.infer<typeof ResponseSchema>;

package/build/commands/user-profile/update-profile.command.js

@@ -3,10 +3,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.UpdateProfileCommand = void 0;
 const zod_1 = require("zod");
 const models_1 = require("../../models");
+const helpers_1 = require("../../helpers");
 var UpdateProfileCommand;
 (function (UpdateProfileCommand) {
     UpdateProfileCommand.RequestSchema = zod_1.z.object({
-        name: zod_1.z.string().min(1).max(100).optional(),
+        name: zod_1.z
+            .string()
+            .min(1)
+            .max(100)
+            .refine((value) => !(0, helpers_1.containsLink)(value), {
+            message: 'Nickname cannot contain links',
+        })
+            .optional(),
     });
     UpdateProfileCommand.ResponseSchema = zod_1.z.object({
         data: models_1.UserProfileResponseSchema,

package/build/constants/tool-paraphrase/enums/index.d.ts

@@ -1 +1,2 @@
 export * from './paraphrasing-intesity.enum';
+export * from './paraphrase-input-kind.enum';

package/build/constants/tool-paraphrase/enums/index.js

@@ -15,3 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./paraphrasing-intesity.enum"), exports);
+__exportStar(require("./paraphrase-input-kind.enum"), exports);

package/build/constants/tool-paraphrase/enums/paraphrase-input-kind.enum.d.ts

@@ -0,0 +1,4 @@
+export declare enum PARAPHRASE_INPUT_KIND {
+    TEXT = "text",
+    DOCUMENT = "document"
+}

package/build/constants/tool-paraphrase/enums/paraphrase-input-kind.enum.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PARAPHRASE_INPUT_KIND = void 0;
+var PARAPHRASE_INPUT_KIND;
+(function (PARAPHRASE_INPUT_KIND) {
+    PARAPHRASE_INPUT_KIND["TEXT"] = "text";
+    PARAPHRASE_INPUT_KIND["DOCUMENT"] = "document";
+})(PARAPHRASE_INPUT_KIND || (exports.PARAPHRASE_INPUT_KIND = PARAPHRASE_INPUT_KIND = {}));

package/build/helpers/contains-link.helper.d.ts

@@ -0,0 +1 @@
+export declare const containsLink: (value: string) => boolean;

package/build/helpers/contains-link.helper.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.containsLink = void 0;
+const LINK_PATTERN = /(?:https?:\/\/|ftp:\/\/|www\.)[^\s]+|(?:^|[\s(])(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z]{2,}(?::\d+)?(?:[/?#][^\s]*)?/iu;
+const containsLink = (value) => LINK_PATTERN.test(value);
+exports.containsLink = containsLink;

package/build/helpers/index.d.ts

@@ -13,3 +13,4 @@ export * from './music';
 export * from './interior-design';
 export * from './query-boolean.schema';
 export * from './localized-text.schema';
+export * from './contains-link.helper';

package/build/helpers/index.js

@@ -29,3 +29,4 @@ __exportStar(require("./music"), exports);
 __exportStar(require("./interior-design"), exports);
 __exportStar(require("./query-boolean.schema"), exports);
 __exportStar(require("./localized-text.schema"), exports);
+__exportStar(require("./contains-link.helper"), exports);

package/build/models/tools/paraphrase/index.d.ts

@@ -2,3 +2,4 @@ export * from './paraphrase-config.schema';
 export * from './paraphrase-job.schema';
 export * from './paraphrase-model.schema';
 export * from './paraphrase-style.schema';
+export * from './paraphrase-document.schema';

package/build/models/tools/paraphrase/index.js

@@ -18,3 +18,4 @@ __exportStar(require("./paraphrase-config.schema"), exports);
 __exportStar(require("./paraphrase-job.schema"), exports);
 __exportStar(require("./paraphrase-model.schema"), exports);
 __exportStar(require("./paraphrase-style.schema"), exports);
+__exportStar(require("./paraphrase-document.schema"), exports);

package/build/models/tools/paraphrase/paraphrase-config.schema.d.ts

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 export declare const ParaphraseToolConfigSchema: z.ZodObject<{
     maxSymbols: z.ZodNumber;
+    freeMaxSymbols: z.ZodNumber;
     styles: z.ZodArray<z.ZodObject<{
         uuid: z.ZodString;
         title: z.ZodString;
@@ -17,6 +18,8 @@ export declare const ParaphraseToolConfigSchema: z.ZodObject<{
         title: z.ZodString;
         icon: z.ZodString;
         price: z.ZodNumber;
+        freeMaxPromptLength: z.ZodNumber;
+        maxPromptLength: z.ZodNumber;
         order: z.ZodNumber;
         status: z.ZodEnum<typeof import("../../..").TOOL_MODEL_STATUS>;
         canUse: z.ZodBoolean;

package/build/models/tools/paraphrase/paraphrase-config.schema.js

@@ -6,6 +6,7 @@ const paraphrase_style_schema_1 = require("./paraphrase-style.schema");
 const paraphrase_model_schema_1 = require("./paraphrase-model.schema");
 exports.ParaphraseToolConfigSchema = zod_1.z.object({
     maxSymbols: zod_1.z.number(),
+    freeMaxSymbols: zod_1.z.number(),
     styles: zod_1.z.array(paraphrase_style_schema_1.ParaphraseStyleSchema),
     types: zod_1.z.array(paraphrase_model_schema_1.ParaphraseModelSchema),
 });

package/build/models/tools/paraphrase/paraphrase-document.schema.d.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+export declare const ParaphraseDocumentMetadataSchema: z.ZodObject<{
+    uuid: z.ZodString;
+    url: z.ZodString;
+    name: z.ZodString;
+    mimeType: z.ZodString;
+    type: z.ZodString;
+    size: z.ZodNumber;
+    extension: z.ZodString;
+}, z.core.$strip>;

package/build/models/tools/paraphrase/paraphrase-document.schema.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParaphraseDocumentMetadataSchema = void 0;
+const zod_1 = require("zod");
+exports.ParaphraseDocumentMetadataSchema = zod_1.z.object({
+    uuid: zod_1.z.string().uuid(),
+    url: zod_1.z.string(),
+    name: zod_1.z.string(),
+    mimeType: zod_1.z.string(),
+    type: zod_1.z.string(),
+    size: zod_1.z.number().nonnegative(),
+    extension: zod_1.z.string(),
+});

package/build/models/tools/paraphrase/paraphrase-job.schema.d.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { PARAPHRASING_INTENSITY, USER_REACTION } from '../../../constants';
+import { PARAPHRASE_INPUT_KIND, PARAPHRASING_INTENSITY, USER_REACTION } from '../../../constants';
 export declare const ParaphraseToolJobSchema: z.ZodObject<{
     uuid: z.ZodString;
     status: z.ZodEnum<typeof import("../../..").TOOL_JOB_STATUS>;
@@ -15,4 +15,24 @@ export declare const ParaphraseToolJobSchema: z.ZodObject<{
     intensity: z.ZodEnum<typeof PARAPHRASING_INTENSITY>;
     reaction: z.ZodNullable<z.ZodEnum<typeof USER_REACTION>>;
     aiOutput: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    inputKind: z.ZodDefault<z.ZodNullable<z.ZodEnum<typeof PARAPHRASE_INPUT_KIND>>>;
+    sourceDocument: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        uuid: z.ZodString;
+        url: z.ZodString;
+        name: z.ZodString;
+        mimeType: z.ZodString;
+        type: z.ZodString;
+        size: z.ZodNumber;
+        extension: z.ZodString;
+    }, z.core.$strip>>>;
+    outputDocument: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        uuid: z.ZodString;
+        url: z.ZodString;
+        name: z.ZodString;
+        mimeType: z.ZodString;
+        type: z.ZodString;
+        size: z.ZodNumber;
+        extension: z.ZodString;
+    }, z.core.$strip>>>;
+    uniquenessPercentage: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
 }, z.core.$strip>;

package/build/models/tools/paraphrase/paraphrase-job.schema.js

@@ -4,6 +4,7 @@ exports.ParaphraseToolJobSchema = void 0;
 const zod_1 = require("zod");
 const tool_job_schema_1 = require("../../tool-job.schema");
 const constants_1 = require("../../../constants");
+const paraphrase_document_schema_1 = require("./paraphrase-document.schema");
 exports.ParaphraseToolJobSchema = tool_job_schema_1.ToolJobSchema.extend({
     styleId: zod_1.z.string().uuid().nullable().optional(),
     modelId: zod_1.z.string().uuid().nullable().optional(),
@@ -13,4 +14,8 @@ exports.ParaphraseToolJobSchema = tool_job_schema_1.ToolJobSchema.extend({
     intensity: zod_1.z.nativeEnum(constants_1.PARAPHRASING_INTENSITY),
     reaction: zod_1.z.nativeEnum(constants_1.USER_REACTION).nullable(),
     aiOutput: zod_1.z.string().nullable().optional(),
+    inputKind: zod_1.z.nativeEnum(constants_1.PARAPHRASE_INPUT_KIND).nullable().default(null),
+    sourceDocument: paraphrase_document_schema_1.ParaphraseDocumentMetadataSchema.nullable().default(null),
+    outputDocument: paraphrase_document_schema_1.ParaphraseDocumentMetadataSchema.nullable().default(null),
+    uniquenessPercentage: zod_1.z.number().int().min(0).max(100).nullable().default(null),
 });

package/build/models/tools/paraphrase/paraphrase-model.schema.d.ts

@@ -5,6 +5,8 @@ export declare const ParaphraseModelSchema: z.ZodObject<{
     title: z.ZodString;
     icon: z.ZodString;
     price: z.ZodNumber;
+    freeMaxPromptLength: z.ZodNumber;
+    maxPromptLength: z.ZodNumber;
     order: z.ZodNumber;
     status: z.ZodEnum<typeof TOOL_MODEL_STATUS>;
     canUse: z.ZodBoolean;

package/build/models/tools/paraphrase/paraphrase-model.schema.js

@@ -9,6 +9,8 @@ exports.ParaphraseModelSchema = zod_1.z.object({
     title: zod_1.z.string(),
     icon: zod_1.z.string(),
     price: zod_1.z.number(),
+    freeMaxPromptLength: zod_1.z.number(),
+    maxPromptLength: zod_1.z.number(),
     order: zod_1.z.number(),
     status: zod_1.z.nativeEnum(constants_1.TOOL_MODEL_STATUS),
     canUse: zod_1.z.boolean(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@purpleschool/gptbot",
-  "version": "0.15.74",
+  "version": "0.15.75-paraphrase-special",
   "description": "",
   "main": "build/index.js",
   "types": "build/index.d.ts",