@purpleschool/gptbot-tools 0.0.36 → 0.0.37-texteditor

package/image-editor/models/image-editor-job.schema.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+import { JOB_STATUS } from '../../tools';
+import { USER_REACTION } from '../../common';
+
+export const ImageEditorJobParamsSchema = z.object({
+    imageUrls: z.array(z.string()).optional(),
+    systemPromptId: z.string().optional(),
+});
+
+export type ImageEditorJobParams = z.infer<typeof ImageEditorJobParamsSchema>;
+
+export const ImageEditorJobSchema = z.object({
+    uuid: z.string(),
+    prompt: z.string(),
+    reaction: z.nativeEnum(USER_REACTION).nullable(),
+    externalId: z.string().nullable(),
+    title: z.string(),
+    status: z.nativeEnum(JOB_STATUS),
+    error: z.string().nullable(),
+    modelId: z.string(),
+    price: z.number(),
+    params: ImageEditorJobParamsSchema,
+    imageUrls: z.array(z.string()).nullable(),
+    attempts: z.array(z.any()),
+    userId: z.string().nullable().optional(),
+    unregisteredUserId: z.string().nullable().optional(),
+    isDeleted: z.boolean(),
+    createdAt: z.date(),
+    completedAt: z.date().nullable().optional(),
+    updatedAt: z.date(),
+});
+
+export type ImageEditorJob = z.infer<typeof ImageEditorJobSchema>;

package/image-editor/models/image-editor-model.schema.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+import { IconVariantsSchema } from '../../common';
+import { IMAGE_EDITING_STRATEGY } from '../enums';
+
+export const ImageEditorModelParamsSchema = z.object({
+    imageAttachment: z.object({
+        supported: z.boolean(),
+        maxImages: z.number(),
+        acceptedTypes: z.array(z.string()),
+    }),
+});
+
+export type ImageEditorModelParams = z.infer<typeof ImageEditorModelParamsSchema>;
+
+export const ImageEditorModelSchema = z.object({
+    uuid: z.string(),
+    title: z.string(),
+    description: z.string(),
+    aiModel: z.string(),
+    pricePerImage: z.number(),
+    order: z.number(),
+    icons: IconVariantsSchema,
+    strategy: z.nativeEnum(IMAGE_EDITING_STRATEGY),
+    maxInputLength: z.number(),
+    params: ImageEditorModelParamsSchema,
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+
+export type ImageEditorModel = z.infer<typeof ImageEditorModelSchema>;

package/image-editor/models/index.ts

@@ -0,0 +1,3 @@
+export * from './image-editor-config.schema';
+export * from './image-editor-job.schema';
+export * from './image-editor-model.schema';

package/image-editor/queries/find-image-editor-job-by-id.query.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { ImageEditorJobSchema } from '../models';
+
+export namespace FindImageEditorJobByIdQuery {
+    export const RequestSchema = ImageEditorJobSchema.pick({ uuid: true });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(ImageEditorJobSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/image-editor/queries/find-image-editor-jobs.query.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { ImageEditorJobSchema } from '../models';
+
+export namespace FindImageEditorJobsQuery {
+    export const RequestSchema = z.object({
+        userId: z.string().uuid().optional(),
+        unregisteredUserId: z.string().uuid().optional(),
+        title: z.string().optional(),
+        limit: z.coerce.number().min(1).optional(),
+        offset: z.coerce.number().min(0).default(0).optional(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(
+        z.object({
+            data: z.array(ImageEditorJobSchema),
+            page: z.number(),
+            totalPages: z.number(),
+        }),
+    );
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/image-editor/queries/find-image-jobs.query.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { ImageEditorJobSchema } from '../models';
+
+export namespace FindImageJobsQuery {
+    export const RequestSchema = z.object({
+        userId: z.string().uuid().optional(),
+        unregisteredUserId: z.string().uuid().optional(),
+        title: z.string().optional(),
+        limit: z.coerce.number().min(1).optional(),
+        offset: z.coerce.number().min(0).default(0).optional(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(
+        z.object({
+            data: z.array(ImageEditorJobSchema),
+            page: z.number(),
+            totalPages: z.number(),
+        }),
+    );
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/image-editor/queries/get-image-editor-config.query.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { ImageEditorConfigSchema } from '../models';
+
+export namespace GetImageEditorConfigQuery {
+    export const ResponseSchema = ICommandResponseSchema(ImageEditorConfigSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/image-editor/queries/index.ts

@@ -0,0 +1,3 @@
+export * from './find-image-editor-job-by-id.query';
+export * from './find-image-editor-jobs.query';
+export * from './get-image-editor-config.query';

package/image-editor/routes/image-editor.amqp.routes.ts

@@ -0,0 +1,11 @@
+export const IMAGE_EDITOR_AMQP_ROUTES = {
+    EXECUTE: 'tools.image.execute.rpc',
+    CONFIG: 'tools.image.config.rpc',
+    GET_JOB: 'tools.image.jobs.get.rpc',
+    LIST_JOBS: 'tools.image.jobs.list.rpc',
+    SET_REACTION: 'tools.image.jobs.set-reaction.rpc',
+    UPDATE_TITLE: 'tools.image.jobs.update-title.rpc',
+    SOFT_DELETE: 'tools.image.jobs.soft-delete.rpc',
+    SOFT_DELETE_ALL: 'tools.image.jobs.soft-delete-all.rpc',
+    RETRY: 'tools.image.jobs.retry.rpc',
+} as const;

package/image-editor/routes/image-editor.http.routes.ts

@@ -0,0 +1,5 @@
+export const IMAGE_EDITOR_CONTROLLER = 'image-editor';
+
+export const IMAGE_EDITOR_ROUTES = {
+    KIE_NANO_BANANA_CALLBACK: 'kie/nano-banana/callback',
+};

package/image-editor/routes/index.ts

@@ -0,0 +1,2 @@
+export * from './image-editor.amqp.routes';
+export * from './image-editor.http.routes';

package/index.ts

@@ -6,6 +6,7 @@ export * from './tts';
 export * from './language';
 export * from './video';
 export * from './writer';
+export * from './image-editor';
 
 import * as common from './common';
 import * as paraphrase from './paraphrase';
@@ -16,6 +17,7 @@ import * as presentation from './presentation';
 import * as language from './language';
 import * as video from './video';
 import * as writer from './writer';
+import * as imageEditor from './image-editor';
 
 export namespace ToolService {
     export import Common = common;
@@ -27,4 +29,5 @@ export namespace ToolService {
     export import Language = language;
     export import Video = video;
     export import Writer = writer;
+    export import ImageEditor = imageEditor;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@purpleschool/gptbot-tools",
-  "version": "0.0.36",
+  "version": "0.0.37-texteditor+01",
   "main": "build/index.js",
   "types": "build/index.d.ts",
   "scripts": {

package/writer/commands/create-writer-document.command.ts

@@ -6,7 +6,7 @@ export namespace CreateWriterDocumentCommand {
     export const RequestSchema = z.object({
         userId: z.string().uuid().nullable().optional(),
         unregisteredUserId: z.string().uuid().nullable().optional(),
-        topic: z.string(),
+        prompt: z.string(),
         numPages: z.number(),
         documentTypeId: z.string().uuid(),
     });

package/writer/commands/generate-document-contents.command.ts

@@ -7,6 +7,7 @@ export namespace GenerateWriterDocumentContentsCommand {
         documentId: z.string().uuid(),
         userId: z.string().uuid().nullable().optional(),
         unregisteredUserId: z.string().uuid().nullable().optional(),
+        userBalance: z.number(),
     });
     export type Request = z.infer<typeof RequestSchema>;
 

package/writer/commands/index.ts

@@ -3,3 +3,9 @@ export * from './delete-writer-document.command';
 export * from './delete-all-user-writer-documents.command';
 export * from './update-writer-document-outline.command';
 export * from './generate-document-contents.command';
+export * from './writer-paraphrase.command';
+export * from './writer-extend-text.command';
+export * from './writer-shorten-text.command';
+export * from './writer-fix-errors.command';
+export * from './writer-generate-text.command';
+export * from './update-writer-document-contents.command';

package/writer/commands/update-writer-document-contents.command.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common';
+
+export namespace UpdateWriterDocumentContentsCommand {
+    export const RequestSchema = z.object({
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+        documentId: z.string().uuid(),
+        contents: z.string(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(
+        z.object({
+            success: z.boolean(),
+        }),
+    );
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/writer/commands/update-writer-document-final-md.command.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common';
+
+export namespace UpdateWriterDocumentContentsCommand {
+    export const RequestSchema = z.object({
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+        documentId: z.string().uuid(),
+        contents: z.string(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(
+        z.object({
+            success: z.boolean(),
+        }),
+    );
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/writer/commands/writer-extend-text.command.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common';
+
+export namespace WriterExtendTextCommand {
+    export const RequestSchema = z.object({
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+        documentId: z.string().uuid(),
+        selectionText: z.string(),
+        userBalance: z.number(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(
+        z.object({
+            output: z.string(),
+        }),
+    );
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/writer/commands/writer-fix-errors.command.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common';
+
+export namespace WriterFixErrorsCommand {
+    export const RequestSchema = z.object({
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+        documentId: z.string().uuid(),
+        selectionText: z.string(),
+        userBalance: z.number(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(
+        z.object({
+            output: z.string(),
+        }),
+    );
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/writer/commands/writer-generate-text.command.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common';
+
+export namespace WriterGenerateTextCommand {
+    export const RequestSchema = z.object({
+        documentId: z.string().uuid(),
+        prompt: z.string().min(1).max(500),
+        selectionText: z.string(),
+        contextBefore: z.string().optional(),
+        contextAfter: z.string().optional(),
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+        userBalance: z.number(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(
+        z.object({
+            output: z.string(),
+        }),
+    );
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/writer/commands/writer-paraphrase.command.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common';
+
+export namespace WriterParaphraseCommand {
+    export const RequestSchema = z.object({
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+        documentId: z.string().uuid(),
+        selectionText: z.string(),
+        userBalance: z.number(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(
+        z.object({
+            output: z.string(),
+        }),
+    );
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/writer/commands/writer-shorten-text.command.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common';
+
+export namespace WriterShortenTextCommand {
+    export const RequestSchema = z.object({
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+        documentId: z.string().uuid(),
+        selectionText: z.string(),
+        userBalance: z.number(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(
+        z.object({
+            output: z.string(),
+        }),
+    );
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/writer/enums/index.ts

@@ -1,4 +1,5 @@
-export * from './writer-ai-operation-pricing-type.enum';
-export * from './writer-ai-operation-type.enum';
+export * from './writer-ai-action-call.enum';
+export * from './writer-ai-action-pricing-type.enum';
+export * from './writer-ai-action-type.enum';
 export * from './writer-document-section-type.enum';
 export * from './writer-document-stage.enum';

package/writer/enums/writer-ai-action-call.enum.ts

@@ -0,0 +1,5 @@
+export enum WRITER_AI_ACTION_CALL_STATUS {
+    PROCESSING = 'processing',
+    COMPLETED = 'completed',
+    FAILED = 'failed',
+}

package/writer/enums/{writer-ai-operation-pricing-type.enum.ts → writer-ai-action-pricing-type.enum.ts}

@@ -1,4 +1,4 @@
-export enum WRITER_AI_OPERATION_PRICING_TYPE {
+export enum WRITER_AI_ACTION_PRICING_TYPE {
     PER_CHARACTER = 'PER_CHARACTER',
     FLAT = 'FLAT',
 }

package/writer/enums/{writer-ai-operation-type.enum.ts → writer-ai-action-type.enum.ts}

@@ -1,5 +1,7 @@
-export enum WRITER_AI_OPERATION_TYPE {
+export enum WRITER_AI_ACTION_TYPE {
     PARAPHRASE = 'PARAPHRASE',
     EXTEND_TEXT = 'EXTEND_TEXT',
+    SHORTEN_TEXT = 'SHORTEN_TEXT',
     GENERATE_TEXT = 'GENERATE_TEXT',
+    FIX_ERRORS = 'FIX_ERRORS',
 }

package/writer/index.ts

@@ -3,3 +3,4 @@ export * from './models';
 export * from './queries';
 export * from './enums';
 export * from './routes';
+export * from './utils';

package/writer/models/index.ts

@@ -1,5 +1,5 @@
 export * from './writer-config.schema';
-export * from './writer-ai-operation.schema';
+export * from './writer-ai-action.schema';
 export * from './writer-document-outline.schema';
 export * from './writer-document.schema';
 export * from './writer-document-type.schema';

package/writer/models/writer-ai-action.schema.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+import { WRITER_AI_ACTION_PRICING_TYPE, WRITER_AI_ACTION_TYPE } from '../enums';
+
+export const WriterAiActionPricingRulesSchema = z.discriminatedUnion('type', [
+    z.object({
+        type: z.literal(WRITER_AI_ACTION_PRICING_TYPE.PER_CHARACTER),
+        price: z.number(),
+    }),
+    z.object({
+        type: z.literal(WRITER_AI_ACTION_PRICING_TYPE.FLAT),
+        price: z.number(),
+    }),
+]);
+export type WriterAiActionPricingRules = z.infer<typeof WriterAiActionPricingRulesSchema>;
+
+export const WriterAiActionSchema = z.object({
+    uuid: z.string(),
+    type: z.nativeEnum(WRITER_AI_ACTION_TYPE),
+    pricingRules: WriterAiActionPricingRulesSchema,
+    maxPromptLength: z.number(),
+    title: z.string(),
+    icon: z.string(),
+    order: z.number(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+export type WriterAiAction = z.infer<typeof WriterAiActionSchema>;

package/writer/models/writer-config.schema.ts

@@ -1,12 +1,12 @@
 import { z } from 'zod';
 import { WriterDocumentTypeSchema } from './writer-document-type.schema';
-import { WriterAiOperationSchema } from './writer-ai-operation.schema';
+import { WriterAiActionSchema } from './writer-ai-action.schema';
 
 export const WriterConfigSchema = z.object({
     minPages: z.number(),
     maxPages: z.number(),
-    maxTopicLength: z.number(),
+    maxPromptLength: z.number(),
     documentTypes: z.array(WriterDocumentTypeSchema),
-    aiOperations: z.array(WriterAiOperationSchema),
+    aiActions: z.array(WriterAiActionSchema),
 });
-export type PresentationConfig = z.infer<typeof WriterConfigSchema>;
+export type WriterConfig = z.infer<typeof WriterConfigSchema>;

package/writer/routes/writer.routes.ts

@@ -6,5 +6,11 @@ export const WRITER_AMQP_ROUTES = {
     DELETE_DOCUMENT: 'tools.writer.delete-document.rpc',
     DELETE_ALL_USER_DOCUMENTS: 'tools.writer.delete-all-user-documents.rpc',
     UPDATE_DOCUMENT_OUTLINE: 'tools.writer.update-document-outline.rpc',
+    UPDATE_DOCUMENT_CONTENTS: 'tools.writer.update-document-contents.rpc',
     GENERATE_DOCUMENT_CONTENTS: 'tools.writer.generate-document-contents.rpc',
+    PARAPHRASE: 'tools.writer.actions.paraphrase.rpc',
+    EXTEND_TEXT: 'tools.writer.actions.extend-text.rpc',
+    SHORTEN_TEXT: 'tools.writer.actions.shorten-text.rpc',
+    FIX_ERRORS: 'tools.writer.actions.fix-errors.rpc',
+    GENERATE_TEXT: 'tools.writer.actions.generate-text.rpc',
 } as const;

package/writer/utils/calculate-writer-ai-action-price.util.ts

@@ -0,0 +1,20 @@
+import { WRITER_AI_ACTION_PRICING_TYPE } from '../enums';
+import { WriterAiActionPricingRules } from '../models';
+
+export function calculateWriterAiActionPrice(
+    pricingRules: WriterAiActionPricingRules,
+    selectionText: string,
+): number {
+    switch (pricingRules.type) {
+        case WRITER_AI_ACTION_PRICING_TYPE.PER_CHARACTER:
+            const characterCount = selectionText.length;
+            const price = characterCount * pricingRules.price;
+            return Math.max(1, Math.ceil(price));
+
+        case WRITER_AI_ACTION_PRICING_TYPE.FLAT:
+            return Math.max(1, Math.ceil(pricingRules.price));
+
+        default:
+            throw new Error(`Unknown pricing type`);
+    }
+}

package/writer/utils/calculate-writer-content-generation-price.util.ts

@@ -0,0 +1,3 @@
+export function calculateWriterContentGenerationPrice(pages: number): number {
+    return Math.max(1, pages);
+}

package/writer/utils/index.ts

@@ -0,0 +1,2 @@
+export * from './calculate-writer-ai-action-price.util';
+export * from './calculate-writer-content-generation-price.util';

package/build/writer/enums/writer-ai-operation-pricing-type.enum.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WRITER_AI_OPERATION_PRICING_TYPE = void 0;
-var WRITER_AI_OPERATION_PRICING_TYPE;
-(function (WRITER_AI_OPERATION_PRICING_TYPE) {
-    WRITER_AI_OPERATION_PRICING_TYPE["PER_CHARACTER"] = "PER_CHARACTER";
-    WRITER_AI_OPERATION_PRICING_TYPE["FLAT"] = "FLAT";
-})(WRITER_AI_OPERATION_PRICING_TYPE || (exports.WRITER_AI_OPERATION_PRICING_TYPE = WRITER_AI_OPERATION_PRICING_TYPE = {}));

package/build/writer/enums/writer-ai-operation-type.enum.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WRITER_AI_OPERATION_TYPE = void 0;
-var WRITER_AI_OPERATION_TYPE;
-(function (WRITER_AI_OPERATION_TYPE) {
-    WRITER_AI_OPERATION_TYPE["PARAPHRASE"] = "PARAPHRASE";
-    WRITER_AI_OPERATION_TYPE["EXTEND_TEXT"] = "EXTEND_TEXT";
-    WRITER_AI_OPERATION_TYPE["GENERATE_TEXT"] = "GENERATE_TEXT";
-})(WRITER_AI_OPERATION_TYPE || (exports.WRITER_AI_OPERATION_TYPE = WRITER_AI_OPERATION_TYPE = {}));

package/build/writer/models/writer-ai-operation.schema.js

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WriterAiOperationSchema = exports.WriterAiOperationPricingRulesSchema = void 0;
-const zod_1 = require("zod");
-const enums_1 = require("../enums");
-exports.WriterAiOperationPricingRulesSchema = zod_1.z.discriminatedUnion('type', [
-    zod_1.z.object({
-        type: zod_1.z.literal(enums_1.WRITER_AI_OPERATION_PRICING_TYPE.PER_CHARACTER),
-        price: zod_1.z.number(),
-    }),
-    zod_1.z.object({
-        type: zod_1.z.literal(enums_1.WRITER_AI_OPERATION_PRICING_TYPE.FLAT),
-        price: zod_1.z.number(),
-    }),
-]);
-exports.WriterAiOperationSchema = zod_1.z.object({
-    uuid: zod_1.z.string(),
-    type: zod_1.z.nativeEnum(enums_1.WRITER_AI_OPERATION_TYPE),
-    pricingRules: exports.WriterAiOperationPricingRulesSchema,
-    maxPromptLength: zod_1.z.number(),
-    title: zod_1.z.string(),
-    icon: zod_1.z.string(),
-    order: zod_1.z.number(),
-    createdAt: zod_1.z.date(),
-    updatedAt: zod_1.z.date(),
-});

package/writer/models/writer-ai-operation.schema.ts

@@ -1,27 +0,0 @@
-import { z } from 'zod';
-import { WRITER_AI_OPERATION_PRICING_TYPE, WRITER_AI_OPERATION_TYPE } from '../enums';
-
-export const WriterAiOperationPricingRulesSchema = z.discriminatedUnion('type', [
-    z.object({
-        type: z.literal(WRITER_AI_OPERATION_PRICING_TYPE.PER_CHARACTER),
-        price: z.number(),
-    }),
-    z.object({
-        type: z.literal(WRITER_AI_OPERATION_PRICING_TYPE.FLAT),
-        price: z.number(),
-    }),
-]);
-
-export const WriterAiOperationSchema = z.object({
-    uuid: z.string(),
-    type: z.nativeEnum(WRITER_AI_OPERATION_TYPE),
-    pricingRules: WriterAiOperationPricingRulesSchema,
-    maxPromptLength: z.number(),
-    title: z.string(),
-    icon: z.string(),
-    order: z.number(),
-    createdAt: z.date(),
-    updatedAt: z.date(),
-});
-
-export type WriterAiOperation = z.infer<typeof WriterAiOperationSchema>;