@purpleschool/gptbot-tools 0.1.133 → 0.2.0-stage

package/build/writer/commands/upload-writer-source.command.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UploadWriterSourceCommand = void 0;
+const zod_1 = require("zod");
+const command_response_schema_1 = require("../../common/models/command-response.schema");
+const models_1 = require("../models");
+var UploadWriterSourceCommand;
+(function (UploadWriterSourceCommand) {
+    UploadWriterSourceCommand.RequestSchema = zod_1.z.object({
+        documentId: zod_1.z.string().uuid(),
+        fileId: zod_1.z.string().uuid(),
+        fileUrl: zod_1.z.string().url(),
+        fileMimetype: zod_1.z.string(),
+        userId: zod_1.z.string().uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.string().uuid().nullable().optional(),
+    });
+    UploadWriterSourceCommand.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(models_1.WriterSourceSchema);
+})(UploadWriterSourceCommand || (exports.UploadWriterSourceCommand = UploadWriterSourceCommand = {}));

package/build/writer/enums/index.js

@@ -20,3 +20,6 @@ __exportStar(require("./writer-ai-action-type.enum"), exports);
 __exportStar(require("./writer-document-section-type.enum"), exports);
 __exportStar(require("./writer-document-stage.enum"), exports);
 __exportStar(require("./writer-content-generation-strategy.enum"), exports);
+__exportStar(require("./writer-source-type.enum"), exports);
+__exportStar(require("./writer-source-origin.enum"), exports);
+__exportStar(require("./writer-source-status.enum"), exports);

package/build/writer/enums/writer-document-stage.enum.js

@@ -4,9 +4,15 @@ exports.WRITER_DOCUMENT_STAGE = void 0;
 var WRITER_DOCUMENT_STAGE;
 (function (WRITER_DOCUMENT_STAGE) {
     WRITER_DOCUMENT_STAGE["CREATED"] = "CREATED";
+    WRITER_DOCUMENT_STAGE["ANALYZING_TOPIC"] = "ANALYZING_TOPIC";
+    WRITER_DOCUMENT_STAGE["TOPIC_ANALYZED"] = "TOPIC_ANALYZED";
+    WRITER_DOCUMENT_STAGE["TOPIC_ANALYSIS_FAILED"] = "TOPIC_ANALYSIS_FAILED";
     WRITER_DOCUMENT_STAGE["GENERATING_OUTLINE"] = "GENERATING_OUTLINE";
     WRITER_DOCUMENT_STAGE["OUTLINE_GENERATED"] = "OUTLINE_GENERATED";
     WRITER_DOCUMENT_STAGE["OUTLINE_GENERATION_FAILED"] = "OUTLINE_GENERATION_FAILED";
+    WRITER_DOCUMENT_STAGE["COLLECTING_SOURCES"] = "COLLECTING_SOURCES";
+    WRITER_DOCUMENT_STAGE["SOURCES_COLLECTED"] = "SOURCES_COLLECTED";
+    WRITER_DOCUMENT_STAGE["SOURCES_COLLECTION_FAILED"] = "SOURCES_COLLECTION_FAILED";
     WRITER_DOCUMENT_STAGE["GENERATING_CONTENT"] = "GENERATING_CONTENT";
     WRITER_DOCUMENT_STAGE["CONTENT_GENERATED"] = "CONTENT_GENERATED";
     WRITER_DOCUMENT_STAGE["CONTENT_GENERATION_FAILED"] = "CONTENT_GENERATION_FAILED";

package/build/writer/enums/writer-source-origin.enum.js

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

package/build/writer/enums/writer-source-status.enum.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WRITER_SOURCE_STATUS = void 0;
+var WRITER_SOURCE_STATUS;
+(function (WRITER_SOURCE_STATUS) {
+    WRITER_SOURCE_STATUS["READY"] = "READY";
+    WRITER_SOURCE_STATUS["REQUIRES_CITATION_METADATA_CONFIRMATION"] = "REQUIRES_CITATION_METADATA_CONFIRMATION";
+    WRITER_SOURCE_STATUS["DISCARDED"] = "DISCARDED";
+})(WRITER_SOURCE_STATUS || (exports.WRITER_SOURCE_STATUS = WRITER_SOURCE_STATUS = {}));

package/build/writer/enums/writer-source-type.enum.js

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

package/build/writer/models/index.js

@@ -21,3 +21,5 @@ __exportStar(require("./writer-document-outline.schema"), exports);
 __exportStar(require("./writer-document-title-page.schema"), exports);
 __exportStar(require("./writer-document.schema"), exports);
 __exportStar(require("./writer-document-type.schema"), exports);
+__exportStar(require("./writer-source.schema"), exports);
+__exportStar(require("./writer-source-bibliographic-metadata.schema"), exports);

package/build/writer/models/writer-document-type.schema.js

@@ -10,9 +10,9 @@ exports.WriterDocumentTypeSchema = zod_1.z.object({
     order: zod_1.z.number(),
     minPages: zod_1.z.number(),
     maxPages: zod_1.z.number(),
+    skipSources: zod_1.z.boolean(),
     pageRange: zod_1.z.array(zod_1.z.number()),
     needsTableOfContents: zod_1.z.boolean(),
-    needsCitations: zod_1.z.boolean(),
     createdAt: zod_1.z.date(),
     updatedAt: zod_1.z.date(),
 });

package/build/writer/models/writer-document.schema.js

@@ -22,6 +22,9 @@ exports.WriterDocumentSchema = zod_1.z.object({
     modelId: zod_1.z.string().nullable(),
     reaction: zod_1.z.nativeEnum(common_1.USER_REACTION).nullable(),
     dislikeReason: zod_1.z.string().nullable(),
+    description: zod_1.z.string().nullable(),
+    internalError: zod_1.z.string().nullable(),
+    skipSources: zod_1.z.boolean(),
     pages: zod_1.z.number(),
     isDeleted: zod_1.z.boolean(),
     tokenReservationId: zod_1.z.string().nullable().optional(),

package/build/writer/models/writer-source-bibliographic-metadata.schema.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WriterSourceBibliographicMetadataSchema = exports.JournalArticleBibliographicMetadataSchema = exports.BookBibliographicMetadataSchema = void 0;
+const zod_1 = require("zod");
+const enums_1 = require("../enums");
+exports.BookBibliographicMetadataSchema = zod_1.z.object({
+    type: zod_1.z.literal(enums_1.WRITER_SOURCE_TYPE.BOOK),
+    title: zod_1.z.string(),
+    authors: zod_1.z.string(),
+    year: zod_1.z.number(),
+    publicationCity: zod_1.z.string(),
+    publisher: zod_1.z.string(),
+    pageCount: zod_1.z.number().nullable(),
+});
+exports.JournalArticleBibliographicMetadataSchema = zod_1.z.object({
+    type: zod_1.z.literal(enums_1.WRITER_SOURCE_TYPE.JOURNAL_ARTICLE),
+    title: zod_1.z.string(),
+    authors: zod_1.z.string(),
+    year: zod_1.z.number(),
+    journalName: zod_1.z.string(),
+    issueNumber: zod_1.z.string(),
+    pageRange: zod_1.z.string(),
+});
+exports.WriterSourceBibliographicMetadataSchema = zod_1.z.discriminatedUnion('type', [
+    exports.BookBibliographicMetadataSchema,
+    exports.JournalArticleBibliographicMetadataSchema,
+]);

package/build/writer/models/writer-source.schema.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WriterSourceSchema = void 0;
+const zod_1 = require("zod");
+const enums_1 = require("../enums");
+const writer_source_bibliographic_metadata_schema_1 = require("./writer-source-bibliographic-metadata.schema");
+exports.WriterSourceSchema = zod_1.z.object({
+    uuid: zod_1.z.string().uuid(),
+    query: zod_1.z.string().nullable(),
+    url: zod_1.z.string(),
+    snippet: zod_1.z.string().nullable(),
+    inclusionReason: zod_1.z.string().nullable(),
+    sourceOrigin: zod_1.z.nativeEnum(enums_1.WRITER_SOURCE_ORIGIN),
+    content: zod_1.z.string().nullable(),
+    documentId: zod_1.z.string().uuid(),
+    fileId: zod_1.z.string().nullable(),
+    citation: zod_1.z.string().nullable(),
+    status: zod_1.z.nativeEnum(enums_1.WRITER_SOURCE_STATUS),
+    bibliographicMetadata: writer_source_bibliographic_metadata_schema_1.WriterSourceBibliographicMetadataSchema.nullable(),
+    createdAt: zod_1.z.date(),
+    updatedAt: zod_1.z.date(),
+});

package/build/writer/queries/get-writer-document-sources.query.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetWriterDocumentSourcesQueryContract = void 0;
+const zod_1 = require("zod");
+const command_response_schema_1 = require("../../common/models/command-response.schema");
+const models_1 = require("../models");
+var GetWriterDocumentSourcesQueryContract;
+(function (GetWriterDocumentSourcesQueryContract) {
+    GetWriterDocumentSourcesQueryContract.RequestSchema = zod_1.z.object({
+        uuid: zod_1.z.string().uuid(),
+        userId: zod_1.z.string().uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.string().uuid().nullable().optional(),
+    });
+    GetWriterDocumentSourcesQueryContract.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(zod_1.z.array(models_1.WriterSourceSchema));
+})(GetWriterDocumentSourcesQueryContract || (exports.GetWriterDocumentSourcesQueryContract = GetWriterDocumentSourcesQueryContract = {}));

package/build/writer/queries/index.js

@@ -17,3 +17,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./find-writer-documents.query"), exports);
 __exportStar(require("./get-writer-config.query"), exports);
 __exportStar(require("./find-writer-document-by-uuid.query"), exports);
+__exportStar(require("./get-writer-document-sources.query"), exports);

package/build/writer/routes/writer.routes.js

@@ -13,6 +13,12 @@ exports.WRITER_AMQP_ROUTES = {
     TOGGLE_DOCUMENT_TITLE_PAGE: 'tools.writer.toggle-document-title-page.rpc',
     UPDATE_DOCUMENT_CONTENTS: 'tools.writer.update-document-contents.rpc',
     GENERATE_DOCUMENT_CONTENTS: 'tools.writer.generate-document-contents.rpc',
+    GENERATE_DOCUMENT_OUTLINE: 'tools.writer.generate-document-outline.rpc',
+    COLLECT_SOURCES: 'tools.writer.collect-sources.rpc',
+    GET_DOCUMENT_SOURCES: 'tools.writer.get-document-sources.rpc',
+    UPLOAD_SOURCE: 'tools.writer.upload-source.rpc',
+    CONFIRM_SOURCE_CITATION_METADATA: 'tools.writer.confirm-source-citation-metadata.rpc',
+    DISCARD_SOURCE: 'tools.writer.discard-source.rpc',
     GET_CONTENT_GENERATION_PRICE: 'tools.writer.content-generation.get-price.rpc',
     PARAPHRASE: 'tools.writer.actions.paraphrase.rpc',
     EXTEND_TEXT: 'tools.writer.actions.extend-text.rpc',

package/common/enums/file-type.enum.ts

@@ -0,0 +1,4 @@
+export enum FILE_TYPE {
+    PDF = 'PDF',
+    DOCX = 'DOCX',
+}

package/common/enums/index.ts

@@ -1,3 +1,4 @@
 export * from './reasoning-effort.enum';
 export * from './user-reaction.enum';
 export * from './tool-model-status.enum';
+export * from './file-type.enum';

package/common/enums/reasoning-effort.enum.ts

@@ -3,3 +3,8 @@ export enum REASONING_EFFORT {
     MEDIUM = 'medium',
     HIGH = 'high',
 }
+
+export enum IMAGE_DETAIL {
+    LOW = 'low',
+    HIGH = 'high',
+}

package/image-editor/commands/image-editor.command.ts

@@ -12,6 +12,7 @@ export namespace ImageEditorCommand {
         params: z.object({
             attachedFiles: z.array(AttachedFileSchema),
             systemPromptId: z.string().optional(),
+            aspectRatio: z.string().optional(),
         }),
         userHasActiveSubscriptionOrProduct: z.boolean(),
         tokenReservationId: z.string().uuid(),

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

@@ -6,6 +6,8 @@ export const ImageEditorJobParamsSchema = z.object({
     attachedFiles: z.array(AttachedFileSchema).optional(),
     imageUrls: z.array(z.string()).optional(),
     systemPromptId: z.string().optional(),
+    aspectRatio: z.string().optional(),
+    userHasActiveSubscriptionOrProduct: z.boolean().optional(),
 });
 
 export type ImageEditorJobParams = z.infer<typeof ImageEditorJobParamsSchema>;

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

@@ -8,6 +8,13 @@ export const ImageEditorModelParamsSchema = z.object({
         maxImages: z.number(),
         acceptedTypes: z.array(z.string()),
     }),
+    aspectRatio: z.record(
+        z.string(),
+        z.object({
+            width: z.number(),
+            height: z.number(),
+        }),
+    ),
 });
 
 export type ImageEditorModelParams = z.infer<typeof ImageEditorModelParamsSchema>;
@@ -32,6 +39,8 @@ export const ImageEditorModelSchema = z.object({
     title: z.string(),
     description: z.string(),
     aiModel: z.string(),
+    isNew: z.boolean(),
+    tierLabel: z.string(),
     pricePerImage: z.number(),
     order: z.number(),
     status: z.nativeEnum(TOOL_MODEL_STATUS),

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

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { JOB_STATUS } from '../../tools';
+import { JOB_REQUEST_ORIGIN, JOB_STATUS } from '../../tools';
 import { AttachedFileSchema, USER_REACTION } from '../../common';
 import { IMAGE_GENERATION_RESOLUTION } from '../enums';
 
@@ -29,6 +29,7 @@ export const ImageGenerationJobSchema = z.object({
     userId: z.string().nullable().optional(),
     unregisteredUserId: z.string().nullable().optional(),
     isPublished: z.boolean(),
+    origin: z.nativeEnum(JOB_REQUEST_ORIGIN),
     postId: z.string().nullable(),
     isDeleted: z.boolean(),
     internalError: z.string().nullable(),

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

@@ -46,6 +46,7 @@ export const ImageGenerationModelSchema = z.object({
     title: z.string(),
     description: z.string(),
     aiModel: z.string(),
+    isNew: z.boolean(),
     price: z.number(),
     order: z.number(),
     params: ImageGenerationModelParamsSchema,

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

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { ICommandResponseSchema } from '../../common/models/command-response.schema';
 import { ImageGenerationJobSchema } from '../models';
+import { JOB_REQUEST_ORIGIN } from '../../tools/enums/job-request-origin.enum';
 
 export namespace FindImageGenerationJobsQuery {
     export const RequestSchema = z
@@ -10,6 +11,7 @@ export namespace FindImageGenerationJobsQuery {
             title: z.string().optional(),
             limit: z.coerce.number().min(1).optional(),
             offset: z.coerce.number().min(0).default(0).optional(),
+            origin: z.nativeEnum(JOB_REQUEST_ORIGIN).optional(),
         })
         .refine(
             (data) => {

package/index.ts

@@ -1,4 +1,5 @@
 export * from './common';
+export * from './account-merge';
 export * from './paraphrase';
 export * from './tools';
 export * from './stt';
@@ -13,6 +14,11 @@ export * from './video-editor';
 export * from './music';
 export * from './ai-proxy';
 export * from './ai-vendor';
+export * from './marketplace-card';
+export * from './analytics';
+export * from './solving-edu-task';
+export * from './spell-corrector';
+export * from './tool-workspace';
 
 import * as common from './common';
 import * as paraphrase from './paraphrase';
@@ -29,6 +35,12 @@ import * as videoEditor from './video-editor';
 import * as music from './music';
 import * as aiVendor from './ai-vendor';
 import * as interiorDesign from './interior-design';
+import * as marketplaceCard from './marketplace-card';
+import * as analytics from './analytics';
+import * as solvingEduTask from './solving-edu-task';
+import * as spellCorrector from './spell-corrector';
+import * as accountMerge from './account-merge';
+import * as toolWorkspace from './tool-workspace';
 
 export namespace ToolService {
     export import Common = common;
@@ -46,4 +58,10 @@ export namespace ToolService {
     export import Music = music;
     export import AiVendor = aiVendor;
     export import InteriorDesign = interiorDesign;
+    export import MarketplaceCard = marketplaceCard;
+    export import Analytics = analytics;
+    export import SolvingEduTask = solvingEduTask;
+    export import SpellCorrector = spellCorrector;
+    export import AccountMerge = accountMerge;
+    export import ToolWorkspace = toolWorkspace;
 }

package/marketplace-card/commands/execute-marketplace-card.command.ts

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { MarketplaceCardJobSchema } from '../models';
+import { TOOL_CONTENT_TYPE } from '../../tools';
+import { TOOL_WORKSPACE_ITEM_SLOT } from '../../tool-workspace';
+
+export namespace ExecuteMarketplaceCardCommand {
+    export const RequestSchema = z.object({
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+        workspaceId: z.string().uuid().nullable().optional(),
+        workspaceItemId: z.string().uuid().nullable().optional(),
+        workspaceToolType: z.nativeEnum(TOOL_CONTENT_TYPE).nullable().optional(),
+        workspaceSlot: z.nativeEnum(TOOL_WORKSPACE_ITEM_SLOT).optional(),
+        workspaceOrder: z.number().int().min(0).optional(),
+        params: z.object({
+            title: z.string(),
+            subtitle: z.string().nullable().optional(),
+            advantages: z.array(z.string()),
+            tags: z.array(z.string()),
+            stylePresetId: z.string().uuid().nullable().optional(),
+            isCustom: z.boolean(),
+            customStylePrompt: z.string().nullable().optional(),
+            inputImages: z.array(z.string()),
+            backgroundDescription: z.string().nullable().optional(),
+        }),
+        precalculatedPrice: z.number(),
+        tokenReservationId: z.string().uuid(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(MarketplaceCardJobSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/marketplace-card/commands/get-marketplace-card-price.command.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+
+export namespace GetMarketplaceCardPriceCommand {
+    export const RequestSchema = z.object({});
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseDataSchema = z.object({
+        price: z.number(),
+    });
+    export type ResponseData = z.infer<typeof ResponseDataSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(ResponseDataSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/marketplace-card/commands/index.ts

@@ -0,0 +1,7 @@
+export * from './execute-marketplace-card.command';
+export * from './set-reaction-to-marketplace-card-job.command';
+export * from './soft-delete-marketplace-card-job-by-uuid.command';
+export * from './retry-marketplace-card-job.command';
+export * from './get-marketplace-card-price.command';
+export * from './soft-delete-all-marketplace-card-jobs.command';
+export * from './update-title-marketplace-card-job.command';

package/marketplace-card/commands/retry-marketplace-card-job.command.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { MarketplaceCardJobSchema } from '../models';
+
+export namespace RetryMarketplaceCardJobCommand {
+    export const RequestSchema = z.object({
+        uuid: z.string().uuid(),
+        tokenReservationId: z.string().uuid(),
+        precalculatedPrice: z.number(),
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+        title: z.string().optional(),
+        subtitle: z.string().nullable().optional(),
+        advantages: z.array(z.string()).optional(),
+        tags: z.array(z.string()).optional(),
+        stylePresetId: z.string().uuid().nullable().optional(),
+        isCustom: z.boolean().optional(),
+        customStylePrompt: z.string().nullable().optional(),
+        inputImages: z.array(z.string()).optional(),
+        backgroundDescription: z.string().nullable().optional(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(MarketplaceCardJobSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/marketplace-card/commands/set-reaction-to-marketplace-card-job.command.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+import { USER_REACTION } from '../../common';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { MarketplaceCardJobSchema } from '../models';
+
+export namespace SetReactionToMarketplaceCardJobCommand {
+    export const RequestSchema = z
+        .object({
+            userId: z.string().uuid().nullable().optional(),
+            unregisteredUserId: z.string().uuid().nullable().optional(),
+            uuid: z.string().uuid(),
+            reaction: z.nativeEnum(USER_REACTION).nullable(),
+            dislikeReason: z.string().nullable().default(null),
+        })
+        .refine(
+            (data) => {
+                if (data.reaction !== USER_REACTION.DISLIKED && data.dislikeReason) {
+                    return false;
+                }
+                return true;
+            },
+            {
+                message: 'Dislike reason is not allowed when reaction is not disliked',
+            },
+        );
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(MarketplaceCardJobSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/marketplace-card/commands/soft-delete-all-marketplace-card-jobs.command.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+
+export namespace SoftDeleteAllMarketplaceCardJobsCommand {
+    export const RequestSchema = z.object({
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(z.boolean());
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/marketplace-card/commands/soft-delete-marketplace-card-job-by-uuid.command.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+
+export namespace SoftDeleteMarketplaceCardJobByUuidCommand {
+    export const RequestSchema = z.object({
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+        uuid: z.string().uuid(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(z.boolean());
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/marketplace-card/commands/update-title-marketplace-card-job.command.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { MarketplaceCardJobSchema } from '../models';
+import { ICommandResponseSchema } from '../../common';
+
+export namespace UpdateTitleMarketplaceCardJobCommand {
+    export const RequestSchema = z.object({
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+        uuid: z.string(),
+        title: z.string(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(MarketplaceCardJobSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/marketplace-card/enums/index.ts

@@ -0,0 +1 @@
+export * from './marketplace-card-strategy.enum';

package/marketplace-card/enums/marketplace-card-strategy.enum.ts

@@ -0,0 +1,6 @@
+export enum MARKETPLACE_CARD_STRATEGY {
+    NANO_BANANA_POLLING = 'NANO_BANANA_POLLING',
+    NANO_BANANA_CALLBACK = 'NANO_BANANA_CALLBACK',
+    NANO_BANANA_PRO_CALLBACK = 'NANO_BANANA_PRO_CALLBACK',
+    NANO_BANANA_PRO_POLLING = 'NANO_BANANA_PRO_POLLING',
+}

package/marketplace-card/index.ts

@@ -0,0 +1,5 @@
+export * from './commands';
+export * from './enums';
+export * from './models';
+export * from './queries';
+export * from './routes';

package/marketplace-card/models/index.ts

@@ -0,0 +1,4 @@
+export * from './marketplace-card-job.schema';
+export * from './marketplace-card-config.schema';
+export * from './marketplace-card-style-preset.schema';
+export * from './marketplace-card-model.schema';

package/marketplace-card/models/marketplace-card-config.schema.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { MarketplaceCardStylePresetSchema } from './marketplace-card-style-preset.schema';
+import { MarketplaceCardModelSchema } from './marketplace-card-model.schema';
+
+export const MarketplaceCardConfigSchema = z.object({
+    styles: z.array(MarketplaceCardStylePresetSchema),
+    models: z.array(MarketplaceCardModelSchema),
+});
+export type MarketplaceCardConfigModel = z.infer<typeof MarketplaceCardConfigSchema>;

package/marketplace-card/models/marketplace-card-job.schema.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+import { USER_REACTION } from '../../common';
+import { JOB_STATUS } from '../../tools';
+
+export const MarketplaceCardJobSchema = z.object({
+    uuid: z.string().uuid(),
+    status: z.nativeEnum(JOB_STATUS),
+    error: z.string().nullable(),
+    internalError: z.string().nullable(),
+    externalId: z.string().nullable(),
+    tokenReservationId: z.string().nullable().optional(),
+    title: z.string(),
+    subtitle: z.string().nullable(),
+    reaction: z.nativeEnum(USER_REACTION).nullable(),
+    dislikeReason: z.string().nullable(),
+    advantages: z.array(z.string()),
+    tags: z.array(z.string()),
+    stylePresetId: z.string().uuid().nullable(),
+    isCustom: z.boolean(),
+    customStylePrompt: z.string().nullable(),
+    inputImages: z.array(z.string()),
+    resultImages: z.array(z.string()),
+    backgroundDescription: z.string().nullable(),
+    price: z.number(),
+    modelId: z.string().uuid(),
+    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 MarketplaceCardJob = z.infer<typeof MarketplaceCardJobSchema>;

package/marketplace-card/models/marketplace-card-model.schema.ts

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+import { IconVariantsSchema, TOOL_MODEL_STATUS } from '../../common';
+import { MARKETPLACE_CARD_STRATEGY } from '../enums';
+
+export const MarketplaceCardModelParamsSchema = z.object({
+    imageAttachment: z.object({
+        supported: z.boolean(),
+        maxImages: z.number(),
+        acceptedTypes: z.array(z.string()),
+    }),
+});
+
+export type MarketplaceCardModelParams = z.infer<typeof MarketplaceCardModelParamsSchema>;
+
+export const MarketplaceCardModelSchema = z.object({
+    uuid: z.string().uuid(),
+    title: z.string(),
+    description: z.string(),
+    aiModel: z.string(),
+    price: z.number(),
+    order: z.number(),
+    statusCheckEndpoint: z.string().nullable(),
+    params: MarketplaceCardModelParamsSchema,
+    strategy: z.nativeEnum(MARKETPLACE_CARD_STRATEGY),
+    status: z.nativeEnum(TOOL_MODEL_STATUS),
+    iconVariants: IconVariantsSchema,
+    maxPromptLength: z.number(),
+    supportsImageAttachment: z.boolean(),
+    maxAttachedImages: z.number(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+
+export type MarketplaceCardModel = z.infer<typeof MarketplaceCardModelSchema>;

package/marketplace-card/models/marketplace-card-style-preset.schema.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+
+export const MarketplaceCardStylePresetSchema = z.object({
+    uuid: z.string().uuid(),
+    title: z.string(),
+    description: z.string(),
+    previewImageUrl: z.string(),
+    systemPrompt: z.string(),
+    order: z.number(),
+    isActive: z.boolean(),
+});
+export type CardStyleModel = z.infer<typeof MarketplaceCardStylePresetSchema>;