@purpleschool/gptbot-tools 0.2.52 → 0.2.54

package/video/models/video-job.schema.ts

@@ -1,57 +0,0 @@
-import { z } from 'zod';
-import { JOB_STATUS } from '../../tools';
-import { USER_REACTION } from '../../common';
-import { VIDEO_PUBLISH_MODERATION_STATUS } from '../enums';
-
-export const VideoJobParamsSchema = z.object({
-    imageUrls: z.string().array().optional(),
-    imageIds: z.array(z.string()).optional(),
-    referenceImages: z.string().array().optional(),
-    referenceImageIds: z.array(z.string()).optional(),
-    firstFrameUrl: z.string().optional(),
-    lastFrameUrl: z.string().optional(),
-    audioUrls: z.array(z.string().url()).optional(),
-    audioIds: z.array(z.string()).optional(),
-    firstFrameId: z.string().optional(),
-    lastFrameId: z.string().optional(),
-    duration: z.number(),
-    aspectRatio: z.string().optional(),
-    quality: z.string().optional(),
-    resolution: z.string().optional(),
-    sound: z.boolean().optional(),
-    multiShots: z.boolean().optional(),
-    batching: z.number().int().min(1).max(4).optional(),
-});
-
-export type VideoJobParams = z.infer<typeof VideoJobParamsSchema>;
-
-export const VideoJobSchema = z.object({
-    uuid: z.string(),
-    prompt: z.string(),
-    reaction: z.nativeEnum(USER_REACTION).nullable(),
-    isPublished: z.boolean(),
-    publishModerationStatus: z.nativeEnum(VIDEO_PUBLISH_MODERATION_STATUS),
-    postId: z.string().nullable(),
-    dislikeReason: z.string().nullable(),
-    externalId: z.string().nullable(),
-    title: z.string(),
-    status: z.nativeEnum(JOB_STATUS),
-    error: z.string().nullable(),
-    modelId: z.string(),
-    price: z.number(),
-    params: VideoJobParamsSchema,
-    videoUrl: z.string().nullable(),
-    previewUrl: z.string().nullable(),
-    attempts: z.array(z.any()),
-    userId: z.string().nullable().optional(),
-    unregisteredUserId: z.string().nullable().optional(),
-    tokenReservationId: z.string().nullable().optional(),
-    workspaceId: z.string().uuid().nullable().optional(),
-    isDeleted: z.boolean(),
-    isFavorite: z.boolean(),
-    createdAt: z.date(),
-    completedAt: z.date().nullable().optional(),
-    updatedAt: z.date(),
-});
-
-export type VideoJob = z.infer<typeof VideoJobSchema>;

package/video/models/video-model.schema.ts

@@ -1,136 +0,0 @@
-import { z } from 'zod';
-import {
-    AttachedFileSchema,
-    TOOL_MODEL_STATUS,
-    TOOL_MODEL_TAG,
-    IconVariantsSchema,
-} from '../../common';
-import {
-    VIDEO_GENERATION_MODEL_LIMITATION,
-    VIDEO_GENERATION_STRATEGY,
-    VIDEO_PRICING_RULE_TYPE,
-} from '../enums';
-
-export const VideoModelParamsSchema = z.object({
-    imageAttachment: z.object({
-        supported: z.boolean(),
-        maxImages: z.number(),
-    }),
-    referenceImageAttachment: z
-        .object({
-            supported: z.boolean(),
-            maxImages: z.number(),
-        })
-        .optional(),
-    duration: z
-        .object({
-            options: z.array(z.number()),
-        })
-        .optional(),
-    sound: z
-        .object({
-            options: z.array(z.boolean()),
-        })
-        .optional(),
-    audioAttachment: z
-        .object({
-            supported: z.boolean(),
-            maxAudios: z.number(),
-            maxDurationSeconds: z.number(),
-            minDurationSeconds: z.number().optional(),
-            maxTotalDurationSeconds: z.number().optional(),
-            maxFileSizeMb: z.number().optional(),
-            formats: z.array(z.string()).optional(),
-            mimeTypes: z.array(z.string()).optional(),
-        })
-        .optional(),
-    aspectRatio: z
-        .object({
-            options: z.array(z.string()),
-        })
-        .optional(),
-    quality: z.string().optional(),
-    resolution: z
-        .object({
-            options: z.array(z.string()),
-        })
-        .optional(),
-    multiShots: z
-        .object({
-            options: z.array(z.boolean()),
-        })
-        .optional(),
-    frameAttachment: z
-        .object({
-            supported: z.boolean(),
-            maxImages: z.number(),
-        })
-        .optional(),
-});
-
-export type VideoModelParams = z.infer<typeof VideoModelParamsSchema>;
-
-export const VideoGenerationRequestParamsSchema = z.object({
-    attachedFiles: z.array(AttachedFileSchema).optional(),
-    imageUrls: z.string().array().optional(),
-    imageIds: z.array(z.string()).optional(),
-    referenceImages: z.string().array().optional(),
-    referenceImageIds: z.array(z.string()).optional(),
-    firstFrameUrl: z.string().optional(),
-    lastFrameUrl: z.string().optional(),
-    audioUrls: z.array(z.string().url()).optional(),
-    audioIds: z.array(z.string()).optional(),
-    firstFrameId: z.string().optional(),
-    lastFrameId: z.string().optional(),
-    duration: z.number(),
-    aspectRatio: z.string().optional(),
-    quality: z.string().optional(),
-    resolution: z.string().optional(),
-    sound: z.boolean().optional(),
-    multiShots: z.boolean().optional(),
-    batching: z.number().int().min(1).max(4).optional(),
-});
-export type VideoGenerationRequestParams = z.infer<typeof VideoGenerationRequestParamsSchema>;
-
-export const VideoModelPricingRuleConditionSchema = z.object({
-    duration: z.number().optional(),
-    aspectRatio: z.string().optional(),
-    quality: z.string().optional(),
-    resolution: z.string().optional(),
-    sound: z.boolean().optional(),
-});
-export type VideoModelPricingRuleCondition = z.infer<typeof VideoModelPricingRuleConditionSchema>;
-
-export const VideoModelPricingRulesSchema = z.array(
-    z.object({
-        type: z.nativeEnum(VIDEO_PRICING_RULE_TYPE),
-        condition: VideoModelPricingRuleConditionSchema,
-        value: z.number(),
-    }),
-);
-export type VideoModelPricingRules = z.infer<typeof VideoModelPricingRulesSchema>;
-
-export const VideoModelSchema = 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(),
-    pricePerSecond: z.number(),
-    order: z.number(),
-    isNew: z.boolean(),
-    isHidden: z.boolean(),
-    status: z.nativeEnum(TOOL_MODEL_STATUS),
-    icons: IconVariantsSchema,
-    strategy: z.nativeEnum(VIDEO_GENERATION_STRATEGY),
-    maxInputLength: z.number(),
-    params: VideoModelParamsSchema,
-    pricingRules: VideoModelPricingRulesSchema,
-    limitations: z.array(z.nativeEnum(VIDEO_GENERATION_MODEL_LIMITATION)),
-    vendorId: z.string().uuid(),
-    createdAt: z.date(),
-    updatedAt: z.date(),
-});
-
-export type VideoModel = z.infer<typeof VideoModelSchema>;

package/video/queries/find-video-job-by-id.query.ts

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

package/video/queries/find-video-jobs.query.ts

@@ -1,41 +0,0 @@
-import { z } from 'zod';
-import { JOB_SCOPE } from '../../common';
-import { ICommandResponseSchema } from '../../common/models/command-response.schema';
-import { VideoJobSchema } from '../models/video-job.schema';
-import { JOB_SORT, JOB_STATUS } from '../../tools';
-
-export namespace FindVideoJobsQuery {
-    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),
-            workspaceId: z.string().uuid().nullable().optional(),
-            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(),
-        })
-        .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(VideoJobSchema),
-            page: z.number(),
-            totalPages: z.number(),
-            total: z.number(),
-        }),
-    );
-    export type Response = z.infer<typeof ResponseSchema>;
-}

package/video/queries/get-video-config.query.ts

@@ -1,13 +0,0 @@
-import { z } from 'zod';
-import { ICommandResponseSchema, LocaleRequestSchema } from '../../common';
-import { VideoConfigSchema } from '../models';
-
-export namespace GetVideoConfigQuery {
-    export const RequestSchema = LocaleRequestSchema.extend({
-        includeHidden: z.boolean().optional(),
-    });
-    export type Request = z.infer<typeof RequestSchema>;
-
-    export const ResponseSchema = ICommandResponseSchema(VideoConfigSchema);
-    export type Response = z.infer<typeof ResponseSchema>;
-}

package/video/routes/video-model.amqp.routes.ts

@@ -1,3 +0,0 @@
-export const VIDEO_MODEL_AMQP_ROUTES = {
-    GET_MODEL_BY_UUID: 'tools.video.model.get-by-uuid.rpc',
-} as const;

package/video/routes/video.amqp.routes.ts

@@ -1,15 +0,0 @@
-export const VIDEO_AMQP_ROUTES = {
-    EXECUTE: 'tools.video.execute.rpc',
-    GET_PRICE: 'tools.video.get-price.rpc',
-    CONFIG: 'tools.video.config.rpc',
-    GET_JOB: 'tools.video.jobs.get.rpc',
-    LIST_JOBS: 'tools.video.jobs.list.rpc',
-    SET_REACTION: 'tools.video.jobs.set-reaction.rpc',
-    UPDATE_TITLE: 'tools.video.jobs.update-title.rpc',
-    UPDATE_FAVORITE: 'tools.video.jobs.update-favorite.rpc',
-    SOFT_DELETE: 'tools.video.jobs.soft-delete.rpc',
-    SOFT_DELETE_ALL: 'tools.video.jobs.soft-delete-all.rpc',
-    RETRY: 'tools.video.jobs.retry.rpc',
-    UPDATE_JOB: 'tools.video.jobs.update.rpc',
-    MODERATE_BEFORE_POST: 'tools.video.jobs.moderate-before-post.rpc',
-} as const;

package/video/routes/video.http.routes.ts

@@ -1,9 +0,0 @@
-export const VIDEO_GENERATION_CONTROLLER = 'video-generation';
-
-export const VIDEO_GENERATION_ROUTES = {
-    KIE_VEO_CALLBACK: 'kie/veo/callback',
-    KIE_RUNWAY_CALLBACK: 'kie/runway/callback',
-    KIE_SORA_2_CALLBACK: 'kie/sora-2/callback',
-    KIE_SEEDANCE_CALLBACK: 'kie/seedance/callback',
-    KIE_KLING_CALLBACK: 'kie/kling/callback',
-};

package/video/utils/calculate-video-generation-price.util.ts

@@ -1,56 +0,0 @@
-import { VIDEO_PRICING_RULE_TYPE } from '../enums';
-import {
-    VideoGenerationRequestParams,
-    VideoModelPricingRuleCondition,
-    VideoModelPricingRules,
-} from '../models';
-
-function matchesCondition(
-    condition: VideoModelPricingRuleCondition,
-    params: VideoGenerationRequestParams,
-): boolean {
-    const keys = Object.keys(condition) as (keyof VideoModelPricingRuleCondition)[];
-
-    return keys.every((key) => {
-        const expected = condition[key];
-
-        if (expected === undefined || expected === null || expected === '') {
-            return true;
-        }
-
-        const value = params[key];
-        if (value === undefined || value === null) {
-            return false;
-        }
-
-        return value === expected;
-    });
-}
-
-export function calculateVideoGenerationPrice({
-    pricePerSecond,
-    params,
-    rules,
-}: {
-    pricePerSecond: number;
-    params: VideoGenerationRequestParams;
-    rules: VideoModelPricingRules;
-}) {
-    const perSecondRule = rules
-        .filter((r) => r.type === VIDEO_PRICING_RULE_TYPE.PER_SECOND)
-        .find((r) => matchesCondition(r.condition, params));
-
-    const effectivePricePerSecond = perSecondRule ? perSecondRule.value : pricePerSecond;
-
-    const base = effectivePricePerSecond * params.duration;
-
-    const flatMarkup = rules.reduce((sum, r) => {
-        if (r.type !== VIDEO_PRICING_RULE_TYPE.FLAT) {
-            return sum;
-        }
-
-        return matchesCondition(r.condition, params) ? sum + r.value : sum;
-    }, 0);
-
-    return Math.ceil(base + flatMarkup);
-}

package/video-editor/commands/delete-all-video-editor-jobs.command.ts

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

package/video-editor/commands/delete-video-editor-job-by-uuid.command.ts

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

package/video-editor/commands/edit-video.command.ts

@@ -1,24 +0,0 @@
-import { z } from 'zod';
-import { JOB_SCOPE } from '../../common';
-import { ICommandResponseSchema } from '../../common/models/command-response.schema';
-import { VideoEditorJobSchema, VideoEditorJobParamsSchema } from '../models';
-
-export namespace EditVideoCommand {
-    export const RequestSchema = z.object({
-        userId: z.string().uuid().nullable().optional(),
-        unregisteredUserId: z.string().uuid().nullable().optional(),
-        scope: z.nativeEnum(JOB_SCOPE).optional().default(JOB_SCOPE.TOOL),
-        prompt: z.string(),
-        inputVideoId: z.string().uuid(),
-        inputVideoUrl: z.string(),
-        duration: z.number(),
-        modelId: z.string().uuid(),
-        tokenReservationId: z.string().uuid(),
-        precalculatedPrice: z.number(),
-        params: VideoEditorJobParamsSchema.optional(),
-    });
-    export type Request = z.infer<typeof RequestSchema>;
-
-    export const ResponseSchema = ICommandResponseSchema(VideoEditorJobSchema);
-    export type Response = z.infer<typeof ResponseSchema>;
-}

package/video-editor/commands/get-video-editor-price.command.ts

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

package/video-editor/commands/retry-video-editor-job.command.ts

@@ -1,26 +0,0 @@
-import { z } from 'zod';
-import { ICommandResponseSchema } from '../../common/models/command-response.schema';
-import {
-    VideoEditorJobParamsSchema,
-    VideoEditorJobSchema,
-} from '../models/video-editor-job.schema';
-
-export namespace RetryVideoEditorJobCommand {
-    export const RequestSchema = z.object({
-        uuid: z.string().uuid(),
-        userId: z.string().uuid().nullable().optional(),
-        unregisteredUserId: z.string().uuid().nullable().optional(),
-        prompt: z.string().optional(),
-        inputVideoId: z.string().uuid().optional(),
-        inputVideoUrl: z.string().optional(),
-        duration: z.number().optional(),
-        modelId: z.string().uuid().optional(),
-        tokenReservationId: z.string().uuid(),
-        precalculatedPrice: z.number(),
-        params: VideoEditorJobParamsSchema.optional(),
-    });
-    export type Request = z.infer<typeof RequestSchema>;
-
-    export const ResponseSchema = ICommandResponseSchema(VideoEditorJobSchema);
-    export type Response = z.infer<typeof ResponseSchema>;
-}

package/video-editor/commands/set-reaction-to-video-editor-job.command.ts

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

package/video-editor/commands/update-published-status-video-editor-jobs.command.ts

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

package/video-editor/commands/update-video-editor-job-favorite.command.ts

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

package/video-editor/commands/update-video-editor-job-title.command.ts

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

package/video-editor/commands/video-editor-model/get-video-editor-model.command.ts

@@ -1,14 +0,0 @@
-import { z } from 'zod';
-import { ICommandResponseSchema, LocaleSchema } from '../../../common';
-import { VideoEditorModelSchema } from '../../models';
-
-export namespace GetVideoEditorModelByUuidCommand {
-    export const RequestSchema = z.object({
-        uuid: z.string().uuid(),
-        locale: LocaleSchema,
-    });
-    export type Request = z.infer<typeof RequestSchema>;
-
-    export const ResponseSchema = ICommandResponseSchema(VideoEditorModelSchema);
-    export type Response = z.infer<typeof ResponseSchema>;
-}

package/video-editor/enums/video-editor-model-limitation.enum.ts

@@ -1,4 +0,0 @@
-export enum VIDEO_EDITOR_MODEL_LIMITATION {
-    OUTPUT_VIDEO_LENGTH_CAPPED_TO_5_SECONDS = 'OUTPUT_VIDEO_LENGTH_CAPPED_TO_5_SECONDS',
-    DOES_NOT_AFFECT_AUDIO = 'DOES_NOT_AFFECT_AUDIO',
-}

package/video-editor/enums/video-editor-model-strategy.enum.ts

@@ -1,8 +0,0 @@
-export enum VIDEO_EDITOR_MODEL_STRATEGY {
-    LUMA_MODIFY_POLLING = 'LUMA_MODIFY_POLLING',
-    ALEPH_EDITING_POLLING = 'ALEPH_EDITING_POLLING',
-    LUMA_MODIFY_CALLBACK = 'LUMA_MODIFY_CALLBACK',
-    ALEPH_EDITING_CALLBACK = 'ALEPH_EDITING_CALLBACK',
-    WAN_2_6_VIDEO_TO_VIDEO_CALLBACK = 'WAN_2_6_VIDEO_TO_VIDEO_CALLBACK',
-    WAN_2_7_VIDEO_TO_VIDEO_CALLBACK = 'WAN_2_7_VIDEO_TO_VIDEO_CALLBACK',
-}

package/video-editor/enums/video-editor-pricing-rule-type.enum.ts

@@ -1,4 +0,0 @@
-export enum VIDEO_EDITOR_PRICING_RULE_TYPE {
-    FLAT = 'flat',
-    PER_SECOND = 'per_second',
-}

package/video-editor/models/video-editor-config.schema.ts

@@ -1,7 +0,0 @@
-import z from 'zod';
-import { VideoEditorModelSchema } from './video-editor-model.schema';
-
-export const VideoEditorConfigSchema = z.object({
-    models: z.array(VideoEditorModelSchema),
-});
-export type VideoEditorConfig = z.infer<typeof VideoEditorConfigSchema>;

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

@@ -1,43 +0,0 @@
-import { z } from 'zod';
-import { JOB_STATUS } from '../../tools';
-import { USER_REACTION } from '../../common';
-
-export const VideoEditorJobParamsSchema = z.object({
-    duration: z.number().optional(),
-    resolution: z.string().optional(),
-});
-
-export type VideoEditorJobParams = z.infer<typeof VideoEditorJobParamsSchema>;
-
-export const VideoEditorJobSchema = z.object({
-    uuid: z.string(),
-    prompt: z.string(),
-    title: z.string(),
-    status: z.nativeEnum(JOB_STATUS),
-    error: z.string().nullable(),
-    price: z.number(),
-    reaction: z.nativeEnum(USER_REACTION).nullable(),
-    dislikeReason: z.string().nullable(),
-    externalId: z.string().nullable(),
-    modelId: z.string(),
-    inputVideoUrl: z.string(),
-    inputVideoId: z.string().nullable(),
-    outputVideoUrl: z.string().nullable(),
-    outputVideoId: z.string().nullable(),
-    previewUrl: z.string().nullable(),
-    params: VideoEditorJobParamsSchema.optional(),
-    duration: z.number(),
-    attempts: z.array(z.any()),
-    userId: z.string().nullable().optional(),
-    unregisteredUserId: z.string().nullable().optional(),
-    tokenReservationId: z.string().nullable().optional(),
-    isPublished: z.boolean(),
-    postId: z.string().nullable(),
-    isDeleted: z.boolean(),
-    isFavorite: z.boolean(),
-    createdAt: z.date(),
-    completedAt: z.date().nullable().optional(),
-    updatedAt: z.date(),
-});
-
-export type VideoEditorJob = z.infer<typeof VideoEditorJobSchema>;