@purpleschool/gptbot 0.13.23 → 0.14.2-stage-2

package/commands/model-page/common.schemas.ts

@@ -0,0 +1,64 @@
+import { z } from 'zod';
+import { MODEL_PAGE_TYPE } from '../../constants';
+
+export const ModelPageUuidParamSchema = z.object({
+    uuid: z.string().uuid(),
+});
+
+export const ModelPageTranslationParamSchema = ModelPageUuidParamSchema.extend({
+    translationUuid: z.string().uuid(),
+});
+
+export const ModelPageDeleteResponseSchema = z.object({
+    isDeleted: z.boolean(),
+});
+
+export const OptionalQueryArraySchema = <T extends z.ZodTypeAny>(schema: T) =>
+    z
+        .preprocess((value) => {
+            if (value === undefined || value === null || value === '') {
+                return undefined;
+            }
+            return Array.isArray(value) ? value : [value];
+        }, z.array(schema))
+        .optional();
+
+export const ModelPageSourceCreateSchema = z
+    .object({
+        slug: z.string().min(1),
+        type: z.nativeEnum(MODEL_PAGE_TYPE),
+        vendorId: z.string().uuid(),
+        aiModelId: z.string().uuid().nullable().optional(),
+        toolModelId: z.string().uuid().nullable().optional(),
+    })
+    .superRefine((value, context) => {
+        const isText = value.type === MODEL_PAGE_TYPE.TEXT;
+        if (isText && !value.aiModelId) {
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: 'aiModelId is required for TEXT',
+                path: ['aiModelId'],
+            });
+        }
+        if (isText && value.toolModelId) {
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: 'toolModelId cannot be set for TEXT',
+                path: ['toolModelId'],
+            });
+        }
+        if (!isText && value.aiModelId) {
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: 'aiModelId cannot be set for a non-text model page',
+                path: ['aiModelId'],
+            });
+        }
+        if (!isText && !value.toolModelId) {
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: 'toolModelId is required for a non-text model page',
+                path: ['toolModelId'],
+            });
+        }
+    });

package/commands/model-page/index.ts

@@ -0,0 +1,5 @@
+export * from './base';
+export * from './public';
+export * from './question';
+export * from './question-translation';
+export * from './translation';

package/commands/model-page/public/find-model-page-answer-detail.command.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import { MODEL_PAGE_QUESTION_TYPE } from '../../../constants';
+import { ModelPageAnswerDetailSchema } from '../../../models';
+
+export namespace FindModelPageAnswerDetailCommand {
+    export const RequestParamSchema = z.object({
+        questionType: z.nativeEnum(MODEL_PAGE_QUESTION_TYPE),
+        slug: z.string(),
+    });
+
+    export type RequestParam = z.infer<typeof RequestParamSchema>;
+
+    export const ResponseSchema = ModelPageAnswerDetailSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/model-page/public/find-model-page-detail.command.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import { ModelPageDetailSchema } from '../../../models';
+
+export namespace FindModelPageDetailCommand {
+    export const RequestParamSchema = z.object({
+        slug: z.string(),
+    });
+
+    export type RequestParam = z.infer<typeof RequestParamSchema>;
+
+    export const ResponseSchema = ModelPageDetailSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/model-page/public/find-model-page-hub.command.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { MODEL_PAGE_SORT_BY, MODEL_PAGE_TYPE, SORT_ORDER } from '../../../constants';
+import { ModelPageHubSchema } from '../../../models';
+import { OptionalQueryArraySchema } from '../common.schemas';
+
+export namespace FindModelPageHubCommand {
+    export const RequestQuerySchema = z.object({
+        vendorIds: OptionalQueryArraySchema(z.string().uuid()),
+        types: OptionalQueryArraySchema(z.nativeEnum(MODEL_PAGE_TYPE)),
+        sortBy: z.nativeEnum(MODEL_PAGE_SORT_BY).optional().default(MODEL_PAGE_SORT_BY.ORDER),
+        sortDir: z.nativeEnum(SORT_ORDER).optional().default(SORT_ORDER.ASC),
+        page: z.coerce.number().int().min(1).optional().default(1),
+        limit: z.coerce.number().int().min(1).max(100).optional().default(20),
+    });
+
+    export type RequestQuery = z.infer<typeof RequestQuerySchema>;
+
+    export const ResponseSchema = ModelPageHubSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/model-page/public/find-model-page-question-type.command.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { MODEL_PAGE_QUESTION_TYPE } from '../../../constants';
+import { ModelPageQuestionTypeListSchema } from '../../../models';
+
+export namespace FindModelPageQuestionTypeCommand {
+    export const RequestParamSchema = z.object({
+        questionType: z.nativeEnum(MODEL_PAGE_QUESTION_TYPE),
+    });
+
+    export type RequestParam = z.infer<typeof RequestParamSchema>;
+
+    export const ResponseSchema = ModelPageQuestionTypeListSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/model-page/public/index.ts

@@ -0,0 +1,4 @@
+export * from './find-model-page-answer-detail.command';
+export * from './find-model-page-detail.command';
+export * from './find-model-page-hub.command';
+export * from './find-model-page-question-type.command';

package/commands/model-page/question/create-model-page-question.command.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { ModelPageQuestionSchema } from '../../../models';
+
+export namespace CreateModelPageQuestionCommand {
+    export const RequestSchema = ModelPageQuestionSchema.pick({
+        modelPageId: true,
+        questionType: true,
+        slug: true,
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: ModelPageQuestionSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/model-page/question/delete-model-page-question.command.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { ModelPageDeleteResponseSchema, ModelPageUuidParamSchema } from '../common.schemas';
+
+export namespace DeleteModelPageQuestionCommand {
+    export const RequestParamSchema = ModelPageUuidParamSchema;
+    export type RequestParam = z.infer<typeof RequestParamSchema>;
+
+    export const ResponseSchema = ModelPageDeleteResponseSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/model-page/question/find-model-page-question-admin.command.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { ModelPageQuestionSchema } from '../../../models';
+import { ModelPageUuidParamSchema } from '../common.schemas';
+
+export namespace FindModelPageQuestionAdminCommand {
+    export const RequestParamSchema = ModelPageUuidParamSchema;
+    export type RequestParam = z.infer<typeof RequestParamSchema>;
+
+    export const ResponseSchema = z.object({
+        data: ModelPageQuestionSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/model-page/question/find-model-page-questions-admin.command.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { MODEL_PAGE_QUESTION_TYPE } from '../../../constants';
+import { ModelPageQuestionSchema } from '../../../models';
+
+export namespace FindModelPageQuestionsAdminCommand {
+    export const RequestQuerySchema = z.object({
+        modelPageId: z.string().uuid().optional(),
+        questionType: z.nativeEnum(MODEL_PAGE_QUESTION_TYPE).optional(),
+        slug: z.string().optional(),
+        limit: z.coerce.number().int().min(1).max(100).optional().default(20),
+        offset: z.coerce.number().int().min(0).optional().default(0),
+    });
+
+    export type RequestQuery = z.infer<typeof RequestQuerySchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.array(ModelPageQuestionSchema),
+        page: z.number(),
+        totalPages: z.number(),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/model-page/question/index.ts

@@ -0,0 +1,5 @@
+export * from './create-model-page-question.command';
+export * from './delete-model-page-question.command';
+export * from './find-model-page-question-admin.command';
+export * from './find-model-page-questions-admin.command';
+export * from './update-model-page-question.command';

package/commands/model-page/question/update-model-page-question.command.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { ModelPageQuestionSchema } from '../../../models';
+import { ModelPageUuidParamSchema } from '../common.schemas';
+
+export namespace UpdateModelPageQuestionCommand {
+    export const RequestParamSchema = ModelPageUuidParamSchema;
+    export type RequestParam = z.infer<typeof RequestParamSchema>;
+
+    export const RequestSchema = ModelPageQuestionSchema.pick({
+        modelPageId: true,
+        questionType: true,
+        slug: true,
+    }).partial();
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: ModelPageQuestionSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/model-page/question-translation/create-model-page-question-translation.command.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { ModelPageQuestionTranslationSchema } from '../../../models';
+import { ModelPageUuidParamSchema } from '../common.schemas';
+
+export namespace CreateModelPageQuestionTranslationCommand {
+    export const RequestParamSchema = ModelPageUuidParamSchema;
+    export type RequestParam = z.infer<typeof RequestParamSchema>;
+
+    export const RequestSchema = ModelPageQuestionTranslationSchema.pick({
+        locale: true,
+        answer: true,
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: ModelPageQuestionTranslationSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/model-page/question-translation/delete-model-page-question-translation.command.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { ModelPageDeleteResponseSchema, ModelPageTranslationParamSchema } from '../common.schemas';
+
+export namespace DeleteModelPageQuestionTranslationCommand {
+    export const RequestParamSchema = ModelPageTranslationParamSchema;
+    export type RequestParam = z.infer<typeof RequestParamSchema>;
+
+    export const ResponseSchema = ModelPageDeleteResponseSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/model-page/question-translation/find-model-page-question-translation.command.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { ModelPageQuestionTranslationSchema } from '../../../models';
+import { ModelPageTranslationParamSchema } from '../common.schemas';
+
+export namespace FindModelPageQuestionTranslationCommand {
+    export const RequestParamSchema = ModelPageTranslationParamSchema;
+    export type RequestParam = z.infer<typeof RequestParamSchema>;
+
+    export const ResponseSchema = z.object({
+        data: ModelPageQuestionTranslationSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/model-page/question-translation/find-model-page-question-translations.command.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { ModelPageQuestionTranslationSchema } from '../../../models';
+import { ModelPageUuidParamSchema } from '../common.schemas';
+
+export namespace FindModelPageQuestionTranslationsCommand {
+    export const RequestParamSchema = ModelPageUuidParamSchema;
+    export type RequestParam = z.infer<typeof RequestParamSchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.array(ModelPageQuestionTranslationSchema),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/model-page/question-translation/index.ts

@@ -0,0 +1,5 @@
+export * from './create-model-page-question-translation.command';
+export * from './delete-model-page-question-translation.command';
+export * from './find-model-page-question-translation.command';
+export * from './find-model-page-question-translations.command';
+export * from './update-model-page-question-translation.command';

package/commands/model-page/question-translation/update-model-page-question-translation.command.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { ModelPageQuestionTranslationSchema } from '../../../models';
+import { ModelPageTranslationParamSchema } from '../common.schemas';
+
+export namespace UpdateModelPageQuestionTranslationCommand {
+    export const RequestParamSchema = ModelPageTranslationParamSchema;
+    export type RequestParam = z.infer<typeof RequestParamSchema>;
+
+    export const RequestSchema = ModelPageQuestionTranslationSchema.pick({
+        answer: true,
+    }).partial();
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: ModelPageQuestionTranslationSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/model-page/translation/create-model-page-translation.command.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { ModelPageTranslationSchema } from '../../../models';
+import { ModelPageUuidParamSchema } from '../common.schemas';
+
+export namespace CreateModelPageTranslationCommand {
+    export const RequestParamSchema = ModelPageUuidParamSchema;
+    export type RequestParam = z.infer<typeof RequestParamSchema>;
+
+    export const RequestSchema = ModelPageTranslationSchema.pick({
+        locale: true,
+        description: true,
+        documentation: true,
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: ModelPageTranslationSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/model-page/translation/delete-model-page-translation.command.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { ModelPageDeleteResponseSchema, ModelPageTranslationParamSchema } from '../common.schemas';
+
+export namespace DeleteModelPageTranslationCommand {
+    export const RequestParamSchema = ModelPageTranslationParamSchema;
+    export type RequestParam = z.infer<typeof RequestParamSchema>;
+
+    export const ResponseSchema = ModelPageDeleteResponseSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/model-page/translation/find-model-page-translation.command.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { ModelPageTranslationSchema } from '../../../models';
+import { ModelPageTranslationParamSchema } from '../common.schemas';
+
+export namespace FindModelPageTranslationCommand {
+    export const RequestParamSchema = ModelPageTranslationParamSchema;
+    export type RequestParam = z.infer<typeof RequestParamSchema>;
+
+    export const ResponseSchema = z.object({
+        data: ModelPageTranslationSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/model-page/translation/find-model-page-translations.command.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { ModelPageTranslationSchema } from '../../../models';
+import { ModelPageUuidParamSchema } from '../common.schemas';
+
+export namespace FindModelPageTranslationsCommand {
+    export const RequestParamSchema = ModelPageUuidParamSchema;
+    export type RequestParam = z.infer<typeof RequestParamSchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.array(ModelPageTranslationSchema),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/model-page/translation/index.ts

@@ -0,0 +1,5 @@
+export * from './create-model-page-translation.command';
+export * from './delete-model-page-translation.command';
+export * from './find-model-page-translation.command';
+export * from './find-model-page-translations.command';
+export * from './update-model-page-translation.command';

package/commands/model-page/translation/update-model-page-translation.command.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { ModelPageTranslationSchema } from '../../../models';
+import { ModelPageTranslationParamSchema } from '../common.schemas';
+
+export namespace UpdateModelPageTranslationCommand {
+    export const RequestParamSchema = ModelPageTranslationParamSchema;
+    export type RequestParam = z.infer<typeof RequestParamSchema>;
+
+    export const RequestSchema = ModelPageTranslationSchema.pick({
+        description: true,
+        documentation: true,
+    }).partial();
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: ModelPageTranslationSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/question/create-question.command.ts

@@ -1,10 +1,24 @@
 import { z } from 'zod';
 import { QuestionSchema } from '../../models';
 
+const hasParent = (value?: string | null): boolean => value !== undefined && value !== null;
+
+export const QuestionParentBaseSchema = z.object({
+    pageId: QuestionSchema.shape.pageId.optional(),
+    modelPageId: QuestionSchema.shape.modelPageId.optional(),
+});
+
+export const QuestionParentSchema = QuestionParentBaseSchema.superRefine((value, ctx) => {
+    if (Number(hasParent(value.pageId)) + Number(hasParent(value.modelPageId)) !== 1) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: 'Укажите ровно одного родителя вопроса: pageId или modelPageId',
+        });
+    }
+});
+
 export namespace CreateQuestionCommand {
-    export const RequestSchema = QuestionSchema.pick({
-        pageId: true,
-    });
+    export const RequestSchema = QuestionParentSchema;
 
     export type Request = z.infer<typeof RequestSchema>;
 

package/commands/question/update-question.command.ts

@@ -1,14 +1,21 @@
 import { z } from 'zod';
 import { QuestionSchema } from '../../models';
+import { QuestionParentBaseSchema } from './create-question.command';
 
 export namespace UpdateQuestionCommand {
-    export const RequestSchema = QuestionSchema.omit({
-        createdAt: true,
-        updatedAt: true,
-        uuid: true,
-        question: true,
-        answer: true,
-    }).partial();
+    export const RequestSchema = QuestionParentBaseSchema.partial().superRefine((value, ctx) => {
+        if (
+            value.pageId !== undefined &&
+            value.modelPageId !== undefined &&
+            ((value.pageId !== null && value.modelPageId !== null) ||
+                (value.pageId === null && value.modelPageId === null))
+        ) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: 'Вопрос должен иметь ровно одного родителя: pageId или modelPageId',
+            });
+        }
+    });
 
     export type Request = z.infer<typeof RequestSchema>;
 

package/commands/tools/diagrams/find-diagrams-jobs.command.ts

@@ -1,6 +1,4 @@
 import { z } from 'zod';
-import { QueryBooleanSchema } from '../../../helpers';
-import { JOB_SORT, TOOL_JOB_STATUS } from '../../../constants';
 import { DiagramsJobSchemaResponse } from '../../../models';
 
 export namespace FindDiagramsJobsCommand {
@@ -8,9 +6,6 @@ export namespace FindDiagramsJobsCommand {
         limit: z.coerce.number().min(1).optional(),
         offset: z.coerce.number().min(0).default(0).optional(),
         title: z.string().optional(),
-        isFavorite: QueryBooleanSchema.optional(),
-        createdAtSortOrder: z.nativeEnum(JOB_SORT).optional().default(JOB_SORT.DESC),
-        status: z.nativeEnum(TOOL_JOB_STATUS).optional(),
     });
     export type RequestQuery = z.infer<typeof RequestQuerySchema>;
 

package/commands/tools/diagrams/index.ts

@@ -9,4 +9,3 @@ export * from './delete-all-diagrams-jobs.command';
 export * from './find-diagrams-job-by-uuid.command';
 export * from './find-diagrams-jobs.command';
 export * from './get-diagrams-tool-config.command';
-export * from './update-diagrams-job-favorite.command';

package/commands/tools/html-page-builder/find-html-page-builder-sessions.command.ts

@@ -1,6 +1,4 @@
 import { z } from 'zod';
-import { QueryBooleanSchema } from '../../../helpers';
-import { JOB_SORT, TOOL_JOB_STATUS } from '../../../constants';
 import { HtmlPageBuilderSessionSchema } from '../../../models';
 
 export namespace FindHtmlPageBuilderSessionsCommand {
@@ -8,9 +6,6 @@ export namespace FindHtmlPageBuilderSessionsCommand {
         limit: z.coerce.number().min(1).optional(),
         offset: z.coerce.number().min(0).default(0).optional(),
         title: z.string().optional(),
-        isFavorite: QueryBooleanSchema.optional(),
-        createdAtSortOrder: z.nativeEnum(JOB_SORT).optional().default(JOB_SORT.DESC),
-        status: z.nativeEnum(TOOL_JOB_STATUS).optional(),
     });
     export type RequestQuery = z.infer<typeof RequestQuerySchema>;
 

package/commands/tools/html-page-builder/index.ts

@@ -6,4 +6,3 @@ export * from './find-html-page-builder-sessions.command';
 export * from './update-html-page-builder-session-title.command';
 export * from './delete-html-page-builder-session-by-uuid.command';
 export * from './delete-all-html-page-builder-sessions.command';
-export * from './update-html-page-builder-session-favorite.command';

package/commands/tools/image-editor/find-image-editor-jobs.command.ts

@@ -1,6 +1,4 @@
 import { z } from 'zod';
-import { QueryBooleanSchema } from '../../../helpers';
-import { JOB_SORT, TOOL_JOB_STATUS } from '../../../constants';
 import { ImageEditorJobSchema } from '../../../models';
 
 export namespace FindImageEditorJobsCommand {
@@ -8,9 +6,6 @@ export namespace FindImageEditorJobsCommand {
         limit: z.coerce.number().min(1).optional(),
         offset: z.coerce.number().min(0).default(0).optional(),
         title: z.string().optional(),
-        isFavorite: QueryBooleanSchema.optional(),
-        createdAtSortOrder: z.nativeEnum(JOB_SORT).optional().default(JOB_SORT.DESC),
-        status: z.nativeEnum(TOOL_JOB_STATUS).optional(),
     });
     export type RequestQuery = z.infer<typeof RequestQuerySchema>;
 

package/commands/tools/image-editor/index.ts

@@ -7,4 +7,3 @@ export * from './update-image-editor-job-title.command';
 export * from './find-image-editor-job-by-uuid.command';
 export * from './find-image-editor-jobs.command';
 export * from './get-image-editor-tool-config.command';
-export * from './update-image-editor-job-favorite.command';

package/commands/tools/image-generation/find-image-generation-jobs.command.ts

@@ -1,6 +1,4 @@
 import { z } from 'zod';
-import { QueryBooleanSchema } from '../../../helpers';
-import { JOB_SORT, TOOL_JOB_STATUS } from '../../../constants';
 import { ImageGenerationJobSchema } from '../../../models';
 
 export namespace FindImageGenerationJobsCommand {
@@ -8,9 +6,6 @@ export namespace FindImageGenerationJobsCommand {
         limit: z.coerce.number().min(1).optional(),
         offset: z.coerce.number().min(0).default(0).optional(),
         title: z.string().optional(),
-        isFavorite: QueryBooleanSchema.optional(),
-        createdAtSortOrder: z.nativeEnum(JOB_SORT).optional().default(JOB_SORT.DESC),
-        status: z.nativeEnum(TOOL_JOB_STATUS).optional(),
     });
     export type RequestQuery = z.infer<typeof RequestQuerySchema>;
 

package/commands/tools/image-generation/index.ts

@@ -7,4 +7,3 @@ export * from './delete-image-generation-job-by-uuid.command';
 export * from './delete-all-image-generation-jobs.command';
 export * from './get-image-generation-config.command';
 export * from './retry-image-generation-job.command';
-export * from './update-image-generation-job-favorite.command';

package/commands/tools/interior-design/find-interior-design-jobs.command.ts

@@ -1,6 +1,4 @@
 import { z } from 'zod';
-import { QueryBooleanSchema } from '../../../helpers';
-import { JOB_SORT, TOOL_JOB_STATUS } from '../../../constants';
 import { InteriorDesignJobSchema } from '../../../models';
 
 export namespace FindInteriorDesignJobsCommand {
@@ -8,9 +6,6 @@ export namespace FindInteriorDesignJobsCommand {
         limit: z.coerce.number().min(1).optional(),
         offset: z.coerce.number().min(0).default(0).optional(),
         title: z.string().optional(),
-        isFavorite: QueryBooleanSchema.optional(),
-        createdAtSortOrder: z.nativeEnum(JOB_SORT).optional().default(JOB_SORT.DESC),
-        status: z.nativeEnum(TOOL_JOB_STATUS).optional(),
     });
     export type RequestQuery = z.infer<typeof RequestQuerySchema>;
 

package/commands/tools/interior-design/index.ts

@@ -7,4 +7,3 @@ export * from './update-interior-design-job-title.command';
 export * from './find-interior-design-job-by-uuid.command';
 export * from './find-interior-design-jobs.command';
 export * from './get-interior-design-tool-config.command';
-export * from './update-interior-design-job-favorite.command';

package/commands/tools/marketplace-card/find-marketplace-card-jobs.command.ts

@@ -1,6 +1,4 @@
 import { z } from 'zod';
-import { QueryBooleanSchema } from '../../../helpers';
-import { JOB_SORT, TOOL_JOB_STATUS } from '../../../constants';
 import { MarketplaceCardJobSchema } from '../../../models';
 
 export namespace FindMarketplaceCardJobsCommand {
@@ -8,9 +6,6 @@ export namespace FindMarketplaceCardJobsCommand {
         limit: z.coerce.number().min(1).optional(),
         offset: z.coerce.number().min(0).default(0).optional(),
         title: z.string().optional(),
-        isFavorite: QueryBooleanSchema.optional(),
-        createdAtSortOrder: z.nativeEnum(JOB_SORT).optional().default(JOB_SORT.DESC),
-        status: z.nativeEnum(TOOL_JOB_STATUS).optional(),
     });
     export type RequestQuery = z.infer<typeof RequestQuerySchema>;
 

package/commands/tools/marketplace-card/index.ts

@@ -8,4 +8,3 @@ export * from './set-reaction-to-marketplace-card.command';
 export * from './delete-marketplace-card-by-uuid.command';
 export * from './delete-all-marketplace-card-jobs.command';
 export * from './update-marketplace-card-job-title.command';
-export * from './update-marketplace-card-job-favorite.command';