@purpleschool/gptbot-tools 0.2.51 → 0.2.53

package/image-generation/commands/update-image-generation-job-title.command.ts

@@ -1,16 +0,0 @@
-import { z } from 'zod';
-import { ICommandResponseSchema } from '../../common/models/command-response.schema';
-import { ImageGenerationJobSchema } from '../models';
-
-export namespace UpdateImageGenerationJobTitleCommand {
-    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(ImageGenerationJobSchema);
-    export type Response = z.infer<typeof ResponseSchema>;
-}

package/image-generation/commands/update-published-status-image-generation-jobs.command.ts

@@ -1,26 +0,0 @@
-import { z } from 'zod';
-import { ICommandResponseSchema } from '../../common/models/command-response.schema';
-import { ImageGenerationJobSchema } from '../models';
-
-export namespace UpdatePublishedStatusImageGenerationJobsCommand {
-    export const RequestSchema = z.object({
-        criteria: z.object({
-            uuid: z.string().uuid(),
-            userId: z.string().uuid().nullable().optional(),
-            unregisteredUserId: z.string().uuid().nullable().optional(),
-        }),
-        data: z
-            .object({
-                isPublished: z.boolean(),
-                postId: z.string().nullable().optional(),
-            })
-            .refine((data) => (data.isPublished ? !!data.postId : true), {
-                message: 'Post ID is required when job is published',
-                path: ['postId'],
-            }),
-    });
-    export type Request = z.infer<typeof RequestSchema>;
-
-    export const ResponseSchema = ICommandResponseSchema(ImageGenerationJobSchema);
-    export type Response = z.infer<typeof ResponseSchema>;
-}

package/image-generation/enums/image-generation-model-strategy.enum.ts

@@ -1,31 +0,0 @@
-export enum IMAGE_GENERATION_MODEL_STRATEGY {
-    // Together AI Models
-    FLUX_IMAGE_GENERATION = 'FLUX_IMAGE_GENERATION',
-    FLUX_DEV_IMAGE_GENERATION = 'FLUX_DEV_IMAGE_GENERATION',
-    STABLE_DIFFUSION_IMAGE_GENERATION = 'STABLE_DIFFUSION_IMAGE_GENERATION',
-
-    // Grok AI
-    GROK_IMAGE_GENERATION = 'GROK_IMAGE_GENERATION',
-
-    // OpenAI
-    DALLE_IMAGE_GENERATION = 'DALLE_IMAGE_GENERATION',
-    OPENAI_IMAGE_1_GENERATION = 'OPENAI_IMAGE_1_GENERATION',
-    OPENAI_IMAGE_2_GENERATION = 'OPENAI_IMAGE_2_GENERATION',
-
-    // Google AI
-    GEMINI_IMAGE_GENERATION = 'GEMINI_IMAGE_GENERATION',
-    IMAGEN_IMAGE_GENERATION = 'IMAGEN_IMAGE_GENERATION',
-
-    // Midjourney
-    MIDJOURNEY_IMAGE_GENERATION = 'MIDJOURNEY_IMAGE_GENERATION',
-    NANO_BANANA_IMAGE_GENERATION = 'NANO_BANANA_IMAGE_GENERATION',
-
-    // Flux
-    KIE_FLUX_IMAGE_GENERATION = 'KIE_FLUX_IMAGE_GENERATION',
-
-    // Z-Image
-    KIE_Z_IMAGE_GENERATION = 'KIE_Z_IMAGE_GENERATION',
-
-    // Seedream
-    KIE_SEEDREAM_IMAGE_GENERATION = 'KIE_SEEDREAM_IMAGE_GENERATION',
-}

package/image-generation/enums/image-generation-models.enum.ts

@@ -1,4 +0,0 @@
-export enum IMAGE_GENERATION_MODELS {
-    NANO_BANANA = 'google/nano-banana',
-    NANO_BANANA_PRO = 'nano-banana-pro',
-}

package/image-generation/enums/image-generation-resolution.enum.ts

@@ -1,5 +0,0 @@
-export enum IMAGE_GENERATION_RESOLUTION {
-    LOW = '1K',
-    MEDIUM = '2K',
-    HIGH = '4K',
-}

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

@@ -1,11 +0,0 @@
-import { z } from 'zod';
-import { ImageGenerationModelSchema } from './image-generation-model.schema';
-import { ImageGenerationPresetSchema } from './image-generation-preset.schema';
-import { AiVendorSchema } from '../../ai-vendor';
-
-export const ImageGenerationConfigSchema = z.object({
-    vendors: z.array(AiVendorSchema),
-    models: z.array(ImageGenerationModelSchema),
-    presets: z.array(ImageGenerationPresetSchema),
-});
-export type ImageGenerationConfig = z.infer<typeof ImageGenerationConfigSchema>;

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

@@ -1,46 +0,0 @@
-import { z } from 'zod';
-import { JOB_STATUS } from '../../tools';
-import { AttachedFileSchema, USER_REACTION } from '../../common';
-import { IMAGE_GENERATION_RESOLUTION } from '../enums';
-import { STATISTICS_CALL_ORIGIN } from '@purpleschool/rugpt-lib-common';
-
-export const ImageGenerationJobParamsSchema = z.object({
-    aspectRatio: z.string(),
-    attachedFiles: z.array(AttachedFileSchema),
-    enhancePrompt: z.boolean(),
-    resolution: z.nativeEnum(IMAGE_GENERATION_RESOLUTION).optional(),
-    batching: z.number().int().min(1).max(4).optional(),
-});
-export type ImageGenerationJobParams = z.infer<typeof ImageGenerationJobParamsSchema>;
-
-export const ImageGenerationJobSchema = z.object({
-    uuid: z.string(),
-    prompt: z.string(),
-    title: z.string(),
-    status: z.nativeEnum(JOB_STATUS),
-    error: z.string().nullable(),
-    price: z.number(),
-    previewUrl: z.string().nullable(),
-    reaction: z.nativeEnum(USER_REACTION).nullable(),
-    dislikeReason: z.string().nullable(),
-    externalId: z.string().nullable(),
-    params: ImageGenerationJobParamsSchema,
-    output: z.array(z.string()),
-    presetId: z.string().nullable().optional(),
-    modelId: z.string(),
-    attempts: z.array(z.any()),
-    userId: z.string().nullable().optional(),
-    unregisteredUserId: z.string().nullable().optional(),
-    isPublished: z.boolean(),
-    origin: z.string(),
-    callOrigin: z.nativeEnum(STATISTICS_CALL_ORIGIN),
-    postId: z.string().nullable(),
-    isDeleted: z.boolean(),
-    isFavorite: z.boolean(),
-    internalError: z.string().nullable(),
-    tokenReservationId: z.string().nullable().optional(),
-    createdAt: z.date(),
-    updatedAt: z.date(),
-});
-
-export type ImageGenerationJob = z.infer<typeof ImageGenerationJobSchema>;

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

@@ -1,73 +0,0 @@
-import { z } from 'zod';
-import {
-    AttachedFileSchema,
-    IconVariantsSchema,
-    TOOL_MODEL_STATUS,
-    TOOL_MODEL_TAG,
-} from '../../common';
-import { IMAGE_GENERATION_MODEL_STRATEGY, IMAGE_GENERATION_RESOLUTION } from '../enums';
-
-export const ImageGenerationRequestParamsSchema = z.object({
-    aspectRatio: z.string(),
-    attachedFiles: z.array(AttachedFileSchema),
-    enhancePrompt: z.boolean(),
-    resolution: z.nativeEnum(IMAGE_GENERATION_RESOLUTION).optional(),
-    batching: z.number().int().min(1).max(4).optional(),
-});
-export type ImageGenerationRequestParams = z.infer<typeof ImageGenerationRequestParamsSchema>;
-
-export const ImageGenerationModelParamsSchema = z.object({
-    aspectRatio: z.record(
-        z.string(),
-        z.object({
-            width: z.number(),
-            height: z.number(),
-        }),
-    ),
-    quality: z.string().optional(),
-    resolution: z
-        .object({
-            options: z.array(z.nativeEnum(IMAGE_GENERATION_RESOLUTION)),
-        })
-        .optional(),
-});
-export type ImageGenerationModelParams = z.infer<typeof ImageGenerationModelParamsSchema>;
-
-export const ImageModelPricingRuleConditionSchema = z.object({
-    resolution: z.string().optional(),
-    withoutSub: z.boolean().optional(),
-});
-export type ImageModelPricingRuleCondition = z.infer<typeof ImageModelPricingRuleConditionSchema>;
-
-export const ImageModelPricingRulesSchema = z.array(
-    z.object({
-        condition: ImageModelPricingRuleConditionSchema,
-        value: z.number(),
-    }),
-);
-export type ImageModelPricingRules = z.infer<typeof ImageModelPricingRulesSchema>;
-
-export const ImageGenerationModelSchema = z.object({
-    uuid: z.string(),
-    title: z.string(),
-    tags: z.array(z.nativeEnum(TOOL_MODEL_TAG)),
-    hint: z.string().nullable(),
-    description: z.string(),
-    aiModel: z.string(),
-    isNew: z.boolean(),
-    price: z.number(),
-    order: z.number(),
-    params: ImageGenerationModelParamsSchema,
-    strategy: z.nativeEnum(IMAGE_GENERATION_MODEL_STRATEGY),
-    status: z.nativeEnum(TOOL_MODEL_STATUS),
-    maxPromptLength: z.number(),
-    iconVariants: IconVariantsSchema,
-    supportsImageAttachment: z.boolean(),
-    maxAttachedImages: z.number(),
-    vendorId: z.string().uuid(),
-    pricingRules: ImageModelPricingRulesSchema,
-    createdAt: z.date(),
-    updatedAt: z.date(),
-});
-
-export type ImageGenerationModel = z.infer<typeof ImageGenerationModelSchema>;

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

@@ -1,13 +0,0 @@
-import { z } from 'zod';
-
-export const ImageGenerationPresetSchema = z.object({
-    uuid: z.string().uuid(),
-    title: z.string(),
-    prompt: z.string(),
-    sample: z.string(),
-    order: z.number(),
-    createdAt: z.date(),
-    updatedAt: z.date(),
-});
-
-export type ImageGenerationPreset = z.infer<typeof ImageGenerationPresetSchema>;

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

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

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

@@ -1,42 +0,0 @@
-import { z } from 'zod';
-import { JOB_SCOPE } from '../../common';
-import { ICommandResponseSchema } from '../../common/models/command-response.schema';
-import { ImageGenerationJobSchema } from '../models';
-import { STATISTICS_CALL_ORIGIN } from '@purpleschool/rugpt-lib-common';
-import { JOB_SORT, JOB_STATUS } from '../../tools';
-
-export namespace FindImageGenerationJobsQuery {
-    export const RequestSchema = z
-        .object({
-            userId: z.string().uuid().optional(),
-            unregisteredUserId: z.string().uuid().optional(),
-            scope: z.nativeEnum(JOB_SCOPE).optional().default(JOB_SCOPE.TOOL),
-            title: z.string().optional(),
-            isFavorite: z.coerce.boolean().optional(),
-            createdAtSortOrder: z.nativeEnum(JOB_SORT).optional().default(JOB_SORT.DESC),
-            status: z.nativeEnum(JOB_STATUS).optional(),
-            limit: z.coerce.number().min(1).optional(),
-            offset: z.coerce.number().min(0).default(0).optional(),
-            callOrigin: z.nativeEnum(STATISTICS_CALL_ORIGIN).optional(),
-        })
-        .refine(
-            (data) => {
-                return Boolean(data.userId) !== Boolean(data.unregisteredUserId);
-            },
-            {
-                message: 'At least userId or unregisteredUserId must be present',
-                path: ['userId', 'unregisteredUserId'],
-            },
-        );
-    export type Request = z.infer<typeof RequestSchema>;
-
-    export const ResponseSchema = ICommandResponseSchema(
-        z.object({
-            data: z.array(ImageGenerationJobSchema),
-            page: z.number(),
-            totalPages: z.number(),
-            total: z.number(),
-        }),
-    );
-    export type Response = z.infer<typeof ResponseSchema>;
-}

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

@@ -1,11 +0,0 @@
-import { z } from 'zod';
-import { ICommandResponseSchema, LocaleRequestSchema } from '../../common';
-import { ImageGenerationConfigSchema } from '../models';
-
-export namespace GetImageGenerationConfigQuery {
-    export const RequestSchema = LocaleRequestSchema;
-    export type Request = z.infer<typeof RequestSchema>;
-
-    export const ResponseSchema = ICommandResponseSchema(ImageGenerationConfigSchema);
-    export type Response = z.infer<typeof ResponseSchema>;
-}

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

@@ -1,16 +0,0 @@
-export const IMAGE_GENERATION_AMQP_ROUTES = {
-    EXECUTE: 'tools.image-generation.execute.rpc',
-    GET_PRICE: 'tools.image-generation.get-price.rpc',
-    CONFIG: 'tools.image-generation.config.rpc',
-    FORWARD_JOB: 'tools.image-generation.jobs.forward.rpc',
-    GET_JOB: 'tools.image-generation.jobs.get.rpc',
-    LIST_JOBS: 'tools.image-generation.jobs.list.rpc',
-    SET_REACTION: 'tools.image-generation.jobs.set-reaction.rpc',
-    UPDATE_TITLE: 'tools.image-generation.jobs.update-title.rpc',
-    UPDATE_FAVORITE: 'tools.image-generation.jobs.update-favorite.rpc',
-    UPDATE_JOB: 'tools.image-generation.jobs.update.rpc',
-    SOFT_DELETE: 'tools.image-generation.jobs.soft-delete.rpc',
-    SOFT_DELETE_ALL: 'tools.image-generation.jobs.soft-delete-all.rpc',
-    GET_MODEL_BY_UUID: 'tools.image-generation.model.get-by-uuid.rpc',
-    RETRY: 'tools.image-generation.jobs.retry.rpc',
-} as const;

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

@@ -1,9 +0,0 @@
-export const IMAGE_GENERATION_CONTROLLER = 'image-generation';
-
-export const IMAGE_GENERATION_ROUTES = {
-    KIE_MIDJOURNEY_CALLBACK: 'kie/midjourney/callback',
-    KIE_NANO_BANANA_CALLBACK: 'kie/nano-banana/callback',
-    KIE_FLUX_CALLBACK: 'kie/flux/callback',
-    KIE_Z_CALLBACK: 'kie/z-image/callback',
-    KIE_SEEDREAM_CALLBACK: 'kie/seedream/callback',
-} as const;

package/image-recognition/commands/delete-all-image-recognition-jobs.command.ts

@@ -1,13 +0,0 @@
-import { z } from 'zod';
-import { ICommandResponseSchema } from '../../common/models/command-response.schema';
-
-export namespace DeleteAllImageRecognitionJobsCommand {
-    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/image-recognition/commands/delete-image-recognition-job-by-uuid.command.ts

@@ -1,14 +0,0 @@
-import { z } from 'zod';
-import { ICommandResponseSchema } from '../../common/models/command-response.schema';
-
-export namespace DeleteImageRecognitionJobByUuidCommand {
-    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/image-recognition/commands/get-image-recognition-price.command.ts

@@ -1,17 +0,0 @@
-import { z } from 'zod';
-import { ICommandResponseSchema } from '../../common/models/command-response.schema';
-
-export namespace GetImageRecognitionPriceCommand {
-    export const RequestSchema = z.object({
-        modelId: z.string().uuid(),
-    });
-    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/image-recognition/commands/image-recognition.command.ts

@@ -1,24 +0,0 @@
-import { z } from 'zod';
-import { ICommandResponseSchema } from '../../common/models/command-response.schema';
-import { ImageRecognitionJobSchema } from '../models';
-import { AttachedFileSchema, LocaleSchema } from '../../common';
-
-export namespace ImageRecognitionCommand {
-    export const RequestSchema = z.object({
-        locale: LocaleSchema,
-        userId: z.string().uuid().nullable().optional(),
-        unregisteredUserId: z.string().uuid().nullable().optional(),
-        prompt: z.string().optional(),
-        categoryId: z.string().uuid(),
-        modelId: z.string().uuid(),
-        params: z.object({
-            attachedFiles: z.array(AttachedFileSchema),
-        }),
-        tokenReservationId: z.string().uuid().optional(),
-        precalculatedPrice: z.number().optional(),
-    });
-    export type Request = z.infer<typeof RequestSchema>;
-
-    export const ResponseSchema = ICommandResponseSchema(ImageRecognitionJobSchema);
-    export type Response = z.infer<typeof ResponseSchema>;
-}

package/image-recognition/commands/retry-image-recognition-job.command.ts

@@ -1,28 +0,0 @@
-import { z } from 'zod';
-import { ICommandResponseSchema } from '../../common/models/command-response.schema';
-import { LocaleSchema } from '../../common/models/locale.schema';
-import { ImageRecognitionJobSchema } from '../models';
-import { AttachedFileSchema } from '../../common';
-
-export namespace RetryImageRecognitionJobCommand {
-    export const RequestSchema = z.object({
-        locale: LocaleSchema,
-        uuid: z.string().uuid(),
-        tokenReservationId: z.string().uuid().optional(),
-        precalculatedPrice: z.number().optional(),
-        userId: z.string().uuid().nullable().optional(),
-        unregisteredUserId: z.string().uuid().nullable().optional(),
-        prompt: z.string().optional(),
-        categoryId: z.string().uuid().optional(),
-        modelId: z.string().uuid().optional(),
-        params: z
-            .object({
-                attachedFiles: z.array(AttachedFileSchema),
-            })
-            .optional(),
-    });
-    export type Request = z.infer<typeof RequestSchema>;
-
-    export const ResponseSchema = ICommandResponseSchema(ImageRecognitionJobSchema);
-    export type Response = z.infer<typeof ResponseSchema>;
-}

package/image-recognition/commands/set-reaction-to-image-recognition-job.command.ts

@@ -1,31 +0,0 @@
-import { z } from 'zod';
-import { USER_REACTION } from '../../common';
-import { ICommandResponseSchema } from '../../common/models/command-response.schema';
-import { ImageRecognitionJobSchema } from '../models';
-
-export namespace SetReactionToImageRecognitionJobCommand {
-    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(ImageRecognitionJobSchema);
-    export type Response = z.infer<typeof ResponseSchema>;
-}

package/image-recognition/commands/update-image-recognition-job-favorite.command.ts

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

package/image-recognition/commands/update-image-recognition-job-title.command.ts

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

package/image-recognition/models/image-recognition-category.schema.ts

@@ -1,16 +0,0 @@
-import { z } from 'zod';
-import { IconVariantsSchema, TOOL_MODEL_STATUS } from '../../common';
-
-export const ImageRecognitionCategorySchema = z.object({
-    uuid: z.string(),
-    parentId: z.string().nullable(),
-    title: z.string(),
-    systemPrompt: z.string(),
-    order: z.number(),
-    status: z.nativeEnum(TOOL_MODEL_STATUS),
-    icons: IconVariantsSchema.nullable(),
-    createdAt: z.date(),
-    updatedAt: z.date(),
-});
-
-export type ImageRecognitionCategory = z.infer<typeof ImageRecognitionCategorySchema>;

package/image-recognition/models/image-recognition-config.schema.ts

@@ -1,10 +0,0 @@
-import { z } from 'zod';
-import { ImageRecognitionModelSchema } from './image-recognition-model.schema';
-import { ImageRecognitionCategorySchema } from './image-recognition-category.schema';
-
-export const ImageRecognitionConfigSchema = z.object({
-    models: z.array(ImageRecognitionModelSchema),
-    categories: z.array(ImageRecognitionCategorySchema),
-});
-
-export type ImageRecognitionConfig = z.infer<typeof ImageRecognitionConfigSchema>;

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

@@ -1,37 +0,0 @@
-import { z } from 'zod';
-import { JOB_STATUS } from '../../tools';
-import { AttachedFileSchema, USER_REACTION } from '../../common';
-
-export const ImageRecognitionJobParamsSchema = z.object({
-    attachedFiles: z.array(AttachedFileSchema),
-});
-
-export type ImageRecognitionJobParams = z.infer<typeof ImageRecognitionJobParamsSchema>;
-
-export const ImageRecognitionJobSchema = z.object({
-    uuid: z.string(),
-    prompt: z.string().nullable(),
-    categoryId: z.string(),
-    aiOutput: z.string().nullable().optional(),
-    reaction: z.nativeEnum(USER_REACTION).nullable(),
-    dislikeReason: z.string().nullable(),
-    externalId: z.string().nullable(),
-    title: z.string(),
-    status: z.nativeEnum(JOB_STATUS),
-    error: z.string().nullable(),
-    internalError: z.string().nullable().optional(),
-    modelId: z.string(),
-    price: z.number(),
-    params: ImageRecognitionJobParamsSchema,
-    attempts: z.array(z.any()),
-    userId: z.string().nullable().optional(),
-    unregisteredUserId: z.string().nullable().optional(),
-    tokenReservationId: z.string().nullable().optional(),
-    isDeleted: z.boolean(),
-    isFavorite: z.boolean(),
-    createdAt: z.date(),
-    completedAt: z.date().nullable().optional(),
-    updatedAt: z.date(),
-});
-
-export type ImageRecognitionJob = z.infer<typeof ImageRecognitionJobSchema>;

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

@@ -1,29 +0,0 @@
-import { z } from 'zod';
-import { IconVariantsSchema, TOOL_MODEL_STATUS } from '../../common';
-
-export const ImageRecognitionModelParamsSchema = z.object({
-    imageAttachment: z.object({
-        supported: z.boolean(),
-        maxImages: z.number(),
-        acceptedTypes: z.array(z.string()),
-    }),
-});
-
-export type ImageRecognitionModelParams = z.infer<typeof ImageRecognitionModelParamsSchema>;
-
-export const ImageRecognitionModelSchema = z.object({
-    uuid: z.string(),
-    title: z.string(),
-    description: z.string(),
-    aiModel: z.string(),
-    price: z.number(),
-    order: z.number(),
-    status: z.nativeEnum(TOOL_MODEL_STATUS),
-    icons: IconVariantsSchema,
-    maxPromptLength: z.number(),
-    params: ImageRecognitionModelParamsSchema,
-    createdAt: z.date(),
-    updatedAt: z.date(),
-});
-
-export type ImageRecognitionModel = z.infer<typeof ImageRecognitionModelSchema>;

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

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