@purpleschool/gptbot 0.9.97 → 0.10.1

package/models/subscription.schema.ts

@@ -1,5 +1,10 @@
 import { z } from 'zod';
-import { SUBSCRIPTION_ACTION, SUBSCRIPTION_PLAN, SUBSCRIPTION_TYPE } from '../constants';
+import {
+    BILLING_SCOPE,
+    SUBSCRIPTION_ACTION,
+    SUBSCRIPTION_PLAN,
+    SUBSCRIPTION_TYPE,
+} from '../constants';
 import { SubscriptionFeatureSchema } from './subscription-feature.schema';
 
 export const SubscriptionSchema = z.object({
@@ -8,6 +13,7 @@ export const SubscriptionSchema = z.object({
     name: z.string().min(3).max(16384),
     requests: z.number(),
     price: z.number(),
+    billingScope: z.nativeEnum(BILLING_SCOPE),
     plan: z.nativeEnum(SUBSCRIPTION_PLAN),
     type: z.nativeEnum(SUBSCRIPTION_TYPE),
     discount: z.number(),

package/models/team-account/index.ts

@@ -0,0 +1,7 @@
+export * from './team-account.schema';
+export * from './team-account-member.schema';
+export * from './team-account-member-list-item.schema';
+export * from './team-account-invite.schema';
+export * from './team-account-operation.schema';
+export * from './team-to-subscription.schema';
+export * from './team-to-product.schema';

package/models/team-account/team-account-invite.schema.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+
+export const TeamAccountInviteSchema = z.object({
+    uuid: z.string().uuid(),
+    teamAccountId: z.string().uuid(),
+    email: z.string().email(),
+    invitedByUserId: z.string().uuid(),
+    acceptedByUserId: z.string().uuid().nullable(),
+    tokenHash: z.string(),
+    role: z.string(),
+    tokenLimit: z.number().int().nullable(),
+    status: z.string(),
+    expiresAt: z.date(),
+    acceptedAt: z.date().nullable(),
+    revokedAt: z.date().nullable(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});

package/models/team-account/team-account-member-list-item.schema.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import { TEAM_ACCOUNT_INVITE_STATUS, TEAM_ACCOUNT_MEMBER_ROLE } from '../../constants';
+
+export const TeamAccountMemberListItemSchema = z.object({
+    uuid: z.string().uuid(),
+    userId: z.string().uuid().nullable(),
+    name: z.string().nullable(),
+    email: z.string().email(),
+    role: z.nativeEnum(TEAM_ACCOUNT_MEMBER_ROLE),
+    inviteStatus: z.nativeEnum(TEAM_ACCOUNT_INVITE_STATUS).nullable(),
+    balance: z.object({
+        remaining: z.number().int().nullable(),
+        limit: z.number().int().nullable(),
+    }),
+});

package/models/team-account/team-account-member.schema.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+
+export const TeamAccountMemberSchema = z.object({
+    uuid: z.string().uuid(),
+    teamAccountId: z.string().uuid(),
+    userId: z.string().uuid(),
+    role: z.string(),
+    status: z.string(),
+    tokenLimit: z.number().int().nullable(),
+    spentTokens: z.number().int(),
+    joinedAt: z.date(),
+    leftAt: z.date().nullable(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});

package/models/team-account/team-account-operation.schema.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+
+export const TeamAccountOperationSchema = z.object({
+    uuid: z.string().uuid(),
+    teamAccountId: z.string().uuid(),
+    initiatorUserId: z.string().uuid().nullable(),
+    type: z.string(),
+    amount: z.number().int(),
+    createdAt: z.date(),
+});

package/models/team-account/team-account.schema.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+
+export const TeamAccountSchema = z.object({
+    uuid: z.string().uuid(),
+    ownerUserId: z.string().uuid(),
+    name: z.string(),
+    email: z.string().email(),
+    logoUrl: z.string().nullable(),
+    isActive: z.boolean(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});

package/models/team-account/team-to-product.schema.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { PRODUCT_STATUS } from '../../constants';
+import { ProductSchema } from '../product.schema';
+
+export const TeamToProductSchema = z.object({
+    uuid: z.string().uuid(),
+    teamAccountId: z.string().uuid(),
+    productId: z.string().uuid(),
+    initTokenBalance: z.number(),
+    tokenBalance: z.number(),
+    status: z.nativeEnum(PRODUCT_STATUS),
+    expiresAt: z.date().nullable(),
+    orderId: z.string().uuid().nullable(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+
+export const TeamToProductWithProductSchema = TeamToProductSchema.extend({
+    product: ProductSchema,
+});

package/models/team-account/team-to-subscription.schema.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+import { SUBSCRIPTION_STATUS, USER_TO_SUBSCRIPTION_TYPE } from '../../constants';
+import { SubscriptionSchema } from '../subscription.schema';
+
+export const TeamToSubscriptionSchema = z.object({
+    uuid: z.string().uuid(),
+    teamAccountId: z.string().uuid(),
+    subscriptionId: z.string().uuid(),
+    cloudPaymentsSubscriptionId: z.string().nullable(),
+    zenpaymentsInvoiceNumber: z.string().nullable(),
+    initTokenBalance: z.number(),
+    tokenBalance: z.number(),
+    initCarriedOverTokenBalance: z.number(),
+    carriedOverTokenBalance: z.number(),
+    startDate: z.date().nullable(),
+    endDate: z.date().nullable(),
+    status: z.nativeEnum(SUBSCRIPTION_STATUS),
+    active: z.boolean(),
+    type: z.nativeEnum(USER_TO_SUBSCRIPTION_TYPE),
+    intervalEndDate: z.date().nullable(),
+    marks: z.array(z.string()),
+    downgradedFromTeamSubscriptionId: z.string().uuid().nullable(),
+    orderId: z.string().uuid().nullable(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+
+export const TeamToSubscriptionWithSubscriptionSchema = z.intersection(
+    TeamToSubscriptionSchema,
+    z.object({
+        subscription: SubscriptionSchema,
+    }),
+);

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

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

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

@@ -8,6 +8,15 @@ 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(),
+            }),
+        )
+        .optional(),
 });
 
 export type ImageEditorModelParams = z.infer<typeof ImageEditorModelParamsSchema>;

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

@@ -5,12 +5,15 @@ import { UnlockedBySchema } from '../../unlocked-by-subscription.schema';
 export const ImageGenerationModelParamsSchema = z.object({
     aspectRatio: z.record(
         z.string(),
-        z.object({
-            width: z.number(),
-            height: z.number(),
-        }),
+        z.union([
+            z.object({
+                width: z.number(),
+                height: z.number(),
+            }),
+            z.string(),
+        ]),
     ),
-    quality: z.string().optional(),
+    quality: z.union([z.string(), z.record(z.string())]).optional(),
     resolution: z
         .object({
             options: z.array(z.nativeEnum(IMAGE_GENERATION_RESOLUTION)),

package/models/tools/index.ts

@@ -10,3 +10,6 @@ export * from './image-editor';
 export * from './video-editor';
 export * from './music';
 export * from './image-generation';
+export * from './marketplace-card';
+export * from './interior-design';
+export * from './solving-edu-task';

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

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

package/models/tools/interior-design/interior-design-config.schema.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import { InteriorDesignModelSchema } from './interior-design-model.schema';
+
+export const InteriorDesignStylesSchema = z.object({
+    uuid: z.string(),
+    title: z.string(),
+    prompt: z.string(),
+    sample: z.string(),
+    order: z.number(),
+});
+
+export type InteriorDesignStyles = z.infer<typeof InteriorDesignStylesSchema>;
+
+export const InteriorDesignRoomTypesSchema = z.object({
+    uuid: z.string(),
+    title: z.string(),
+    prompt: z.string(),
+    order: z.number(),
+});
+
+export type InteriorDesignRoomTypes = z.infer<typeof InteriorDesignRoomTypesSchema>;
+
+export const InteriorDesignConfigSchema = z.object({
+    models: z.array(InteriorDesignModelSchema),
+    styles: z.array(InteriorDesignStylesSchema),
+    roomTypes: z.array(InteriorDesignRoomTypesSchema),
+});
+
+export type InteriorDesignConfig = z.infer<typeof InteriorDesignConfigSchema>;

package/models/tools/interior-design/interior-design-job.schema.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import { USER_REACTION } from '../../../constants';
+import { ToolJobSchema } from '../../tool-job.schema';
+import { FileSchema } from '../../file.schema';
+import { AttachedToolFileSchema } from '../common';
+
+export const InteriorDesignJobParamsSchema = z.object({
+    attachedFiles: z.array(AttachedToolFileSchema),
+    styleId: z.string().optional(),
+    roomTypeId: z.string().optional(),
+});
+
+export type InteriorDesignJobParams = z.infer<typeof InteriorDesignJobParamsSchema>;
+
+export const InteriorDesignJobSchema = ToolJobSchema.extend({
+    title: z.string(),
+    prompt: z.string(),
+    reaction: z.nativeEnum(USER_REACTION).nullable(),
+    imageUrls: z.string().array(),
+    images: z
+        .array(
+            FileSchema.pick({
+                uuid: true,
+                url: true,
+            }),
+        )
+        .nullable(),
+    params: InteriorDesignJobParamsSchema,
+    modelId: z.string(),
+});
+
+export type InteriorDesignJob = z.infer<typeof InteriorDesignJobSchema>;

package/models/tools/interior-design/interior-design-model.schema.ts

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+import { IconVariantsSchema } from '../../icon-variants.schema';
+import { UnlockedBySchema } from '../../unlocked-by-subscription.schema';
+
+export const InteriorDesignModelParamsSchema = z.object({
+    imageAttachment: z.object({
+        supported: z.boolean(),
+        maxImages: z.number(),
+        acceptedTypes: z.array(z.string()),
+    }),
+});
+
+export type InteriorDesignModelParams = z.infer<typeof InteriorDesignModelParamsSchema>;
+
+export const InteriorDesignModelPricingRuleConditionSchema = z.object({
+    withoutSub: z.boolean().optional(),
+});
+export type InteriorDesignModelPricingRuleCondition = z.infer<
+    typeof InteriorDesignModelPricingRuleConditionSchema
+>;
+
+export const InteriorDesignModelPricingRulesSchema = z.array(
+    z.object({
+        condition: InteriorDesignModelPricingRuleConditionSchema,
+        value: z.number(),
+    }),
+);
+export type InteriorDesignModelPricingRules = z.infer<typeof InteriorDesignModelPricingRulesSchema>;
+
+export const InteriorDesignModelSchema = z.object({
+    uuid: z.string(),
+    title: z.string(),
+    description: z.string(),
+    price: z.number(),
+    status: z.string(),
+    order: z.number(),
+    icons: IconVariantsSchema,
+    maxPromptLength: z.number(),
+    params: InteriorDesignModelParamsSchema,
+    pricingRules: InteriorDesignModelPricingRulesSchema,
+    unlockedBy: UnlockedBySchema.nullable(),
+    canUse: z.boolean(),
+});
+
+export type InteriorDesignModel = z.infer<typeof InteriorDesignModelSchema>;

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

@@ -0,0 +1,2 @@
+export * from './marketplace-card-config.schema';
+export * from './marketplace-card-job.schema';

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

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+import { IconVariantsSchema } from '../../icon-variants.schema';
+
+export const MarketplaceCardStylePresetSchema = z.object({
+    uuid: z.string().uuid(),
+    previewImageUrl: z.string(),
+    order: z.number(),
+    isActive: z.boolean(),
+});
+export type MarketplaceCardStylePreset = z.infer<typeof MarketplaceCardStylePresetSchema>;
+
+export const MarketplaceCardModelSchema = z.object({
+    uuid: z.string().uuid(),
+    price: z.number(),
+    params: z.object({
+        imageAttachment: z.object({
+            supported: z.boolean(),
+            maxImages: z.number(),
+            acceptedTypes: z.array(z.string()),
+        }),
+    }),
+    iconVariants: IconVariantsSchema,
+    maxPromptLength: z.number(),
+    supportsImageAttachment: z.boolean(),
+    maxAttachedImages: z.number(),
+});
+export type MarketplaceCardModel = z.infer<typeof MarketplaceCardModelSchema>;
+
+export const MarketplaceCardConfigSchema = z.object({
+    styles: z.array(MarketplaceCardStylePresetSchema),
+    models: z.array(MarketplaceCardModelSchema),
+});
+export type MarketplaceCardConfigModel = z.infer<typeof MarketplaceCardConfigSchema>;

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

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+import { USER_REACTION } from '../../../constants';
+import { ToolJobSchema } from '../../tool-job.schema';
+
+export const MarketplaceCardJobSchema = ToolJobSchema.extend({
+    uuid: z.string().uuid(),
+    title: z.string(),
+    subtitle: z.string().nullable(),
+    reaction: z.nativeEnum(USER_REACTION).nullable(),
+    stylePresetId: z.string().uuid().nullable(),
+    advantages: z.array(z.string()),
+    tags: z.array(z.string()),
+    isCustom: z.boolean(),
+    customStylePrompt: z.string().nullable(),
+    inputImages: z.array(
+        z.object({
+            uuid: z.string().uuid(),
+            url: z.string(),
+        }),
+    ),
+    resultImages: z.array(z.string()).nullable(),
+    backgroundDescription: z.string().nullable(),
+    price: z.number(),
+});
+export type MarketplaceCardJob = z.infer<typeof MarketplaceCardJobSchema>;

package/models/tools/solving-edu-task/index.ts

@@ -0,0 +1,3 @@
+export * from './solving-edu-task-config.schema';
+export * from './solving-edu-task-job.schema';
+export * from './solving-edu-task-model.schema';

package/models/tools/solving-edu-task/solving-edu-task-config.schema.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { SolvingEduTaskModelSchema } from './solving-edu-task-model.schema';
+
+export const SolvingEduTaskConfigSchema = z.object({
+    models: z.array(SolvingEduTaskModelSchema),
+});
+
+export type SolvingEduTaskConfig = z.infer<typeof SolvingEduTaskConfigSchema>;

package/models/tools/solving-edu-task/solving-edu-task-job.schema.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+import { USER_REACTION } from '../../../constants';
+import { AttachedToolFileSchema } from '../common';
+import { TOOL_JOB_STATUS } from '../../../constants';
+
+export const SolvingEduTaskJobParamsSchema = z.object({
+    attachedFiles: z.array(AttachedToolFileSchema),
+});
+
+export type SolvingEduTaskJobParams = z.infer<typeof SolvingEduTaskJobParamsSchema>;
+
+export const SolvingEduTaskJobSchema = z.object({
+    uuid: z.string().uuid(),
+    prompt: z.string(),
+    aiOutput: z.string().nullable().optional(),
+    reaction: z.nativeEnum(USER_REACTION).nullable(),
+    title: z.string(),
+    status: z.nativeEnum(TOOL_JOB_STATUS),
+    modelId: z.string(),
+    price: z.number(),
+    params: SolvingEduTaskJobParamsSchema,
+    error: z.string().nullable(),
+    userId: z.string().nullable().optional(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+
+export type SolvingEduTaskJob = z.infer<typeof SolvingEduTaskJobSchema>;

package/models/tools/solving-edu-task/solving-edu-task-model.schema.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+import { TOOL_MODEL_STATUS } from '../../../constants';
+
+export const SolvingEduTaskModelParamsSchema = z.object({
+    imageAttachment: z.object({
+        supported: z.boolean(),
+        maxImages: z.number(),
+        acceptedTypes: z.array(z.string()),
+    }),
+});
+
+export type SolvingEduTaskModelParams = z.infer<typeof SolvingEduTaskModelParamsSchema>;
+
+export const SolvingEduTaskModelSchema = z.object({
+    uuid: z.string(),
+    title: z.string(),
+    description: z.string(),
+    price: z.number(),
+    order: z.number(),
+    status: z.nativeEnum(TOOL_MODEL_STATUS),
+    maxPromptLength: z.number(),
+    params: SolvingEduTaskModelParamsSchema,
+});
+
+export type SolvingEduTaskModel = z.infer<typeof SolvingEduTaskModelSchema>;

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

@@ -1,6 +1,6 @@
 import { z } from 'zod';
-import { ToolJobSchema } from '../../tool-job.schema';
 import { USER_REACTION } from '../../../constants';
+import { ToolJobSchema } from '../../tool-job.schema';
 
 export const VideoEditorJobSchema = ToolJobSchema.extend({
     title: z.string(),
@@ -9,9 +9,22 @@ export const VideoEditorJobSchema = ToolJobSchema.extend({
     inputVideoId: z.string().nullable(),
     inputVideoUrl: z.string(),
     outputVideoUrl: z.string().nullable(),
+    video: z
+        .object({
+            uuid: z.string(),
+            url: z.string(),
+        })
+        .nullable(),
+    preview: z
+        .object({
+            uuid: z.string(),
+            url: z.string(),
+        })
+        .nullable(),
     modelId: z.string(),
     isPublished: z.boolean(),
     postId: z.string().nullable(),
+    thumbnail: z.string().nullable(),
 });
 
 export type VideoEditorJob = z.infer<typeof VideoEditorJobSchema>;

package/models/user-profile.schema.ts

@@ -5,6 +5,7 @@ export const UserProfileSchema = z.object({
     name: z.string().nullable(),
     avatarUrl: z.string().url().nullable(),
     avatarKey: z.string().nullable(),
+    isPremium: z.boolean(),
     createdAt: z.date(),
     updatedAt: z.date(),
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@purpleschool/gptbot",
-  "version": "0.9.97",
+  "version": "0.10.1",
   "description": "",
   "main": "build/index.js",
   "types": "build/index.d.ts",

package/build/commands/subscription/create-custom-subscription-plan.command.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CreateCustomSubscriptionPlanCommand = void 0;
-const zod_1 = require("zod");
-const models_1 = require("../../models");
-var CreateCustomSubscriptionPlanCommand;
-(function (CreateCustomSubscriptionPlanCommand) {
-    CreateCustomSubscriptionPlanCommand.RequestSchema = zod_1.z.object({
-        tokens: zod_1.z
-            .number()
-            .refine((val) => val % 500 === 0, {
-            message: 'tokens must be a multiple of 500',
-        })
-            .refine((val) => val > 1000, {
-            message: 'tokens must be greater than 1000',
-        })
-            .refine((val) => val <= 10000, {
-            message: 'tokens must be equal or less than 10000',
-        }),
-    });
-    CreateCustomSubscriptionPlanCommand.ResponseSchema = zod_1.z.object({
-        data: zod_1.z.array(models_1.SubscriptionSchema),
-    });
-})(CreateCustomSubscriptionPlanCommand || (exports.CreateCustomSubscriptionPlanCommand = CreateCustomSubscriptionPlanCommand = {}));

package/build/constants/ai-model/enums/ai-model-content-type.enum.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AI_MODEL_CONTENT_TYPE = void 0;
-exports.AI_MODEL_CONTENT_TYPE = {
-    TEXT: 'TEXT',
-    IMAGE: 'IMAGE',
-};