@purpleschool/multisite 0.0.2 → 0.0.4

package/build/queries/marketplace-card/get-marketplace-card-config.command.d.ts

@@ -0,0 +1,273 @@
+import { z } from 'zod';
+export declare namespace GetMarketplaceCardConfigCommand {
+    const ResponseSchema: z.ZodObject<{
+        data: z.ZodObject<{
+            styles: z.ZodArray<z.ZodObject<{
+                uuid: z.ZodString;
+                previewImageUrl: z.ZodString;
+                order: z.ZodNumber;
+                isActive: z.ZodBoolean;
+            }, "strip", z.ZodTypeAny, {
+                uuid: string;
+                order: number;
+                previewImageUrl: string;
+                isActive: boolean;
+            }, {
+                uuid: string;
+                order: number;
+                previewImageUrl: string;
+                isActive: boolean;
+            }>, "many">;
+            models: z.ZodArray<z.ZodObject<{
+                uuid: z.ZodString;
+                price: z.ZodNumber;
+                params: z.ZodObject<{
+                    imageAttachment: z.ZodObject<{
+                        supported: z.ZodBoolean;
+                        maxImages: z.ZodNumber;
+                        acceptedTypes: z.ZodArray<z.ZodString, "many">;
+                    }, "strip", z.ZodTypeAny, {
+                        supported: boolean;
+                        maxImages: number;
+                        acceptedTypes: string[];
+                    }, {
+                        supported: boolean;
+                        maxImages: number;
+                        acceptedTypes: string[];
+                    }>;
+                }, "strip", z.ZodTypeAny, {
+                    imageAttachment: {
+                        supported: boolean;
+                        maxImages: number;
+                        acceptedTypes: string[];
+                    };
+                }, {
+                    imageAttachment: {
+                        supported: boolean;
+                        maxImages: number;
+                        acceptedTypes: string[];
+                    };
+                }>;
+                iconVariants: z.ZodObject<{
+                    light: z.ZodObject<{
+                        png: z.ZodOptional<z.ZodString>;
+                        svg: z.ZodOptional<z.ZodString>;
+                    }, "strip", z.ZodTypeAny, {
+                        png?: string | undefined;
+                        svg?: string | undefined;
+                    }, {
+                        png?: string | undefined;
+                        svg?: string | undefined;
+                    }>;
+                    dark: z.ZodObject<{
+                        png: z.ZodOptional<z.ZodString>;
+                        svg: z.ZodOptional<z.ZodString>;
+                    }, "strip", z.ZodTypeAny, {
+                        png?: string | undefined;
+                        svg?: string | undefined;
+                    }, {
+                        png?: string | undefined;
+                        svg?: string | undefined;
+                    }>;
+                }, "strip", z.ZodTypeAny, {
+                    light: {
+                        png?: string | undefined;
+                        svg?: string | undefined;
+                    };
+                    dark: {
+                        png?: string | undefined;
+                        svg?: string | undefined;
+                    };
+                }, {
+                    light: {
+                        png?: string | undefined;
+                        svg?: string | undefined;
+                    };
+                    dark: {
+                        png?: string | undefined;
+                        svg?: string | undefined;
+                    };
+                }>;
+                maxPromptLength: z.ZodNumber;
+                supportsImageAttachment: z.ZodBoolean;
+                maxAttachedImages: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                price: number;
+                uuid: string;
+                params: {
+                    imageAttachment: {
+                        supported: boolean;
+                        maxImages: number;
+                        acceptedTypes: string[];
+                    };
+                };
+                maxPromptLength: number;
+                iconVariants: {
+                    light: {
+                        png?: string | undefined;
+                        svg?: string | undefined;
+                    };
+                    dark: {
+                        png?: string | undefined;
+                        svg?: string | undefined;
+                    };
+                };
+                supportsImageAttachment: boolean;
+                maxAttachedImages: number;
+            }, {
+                price: number;
+                uuid: string;
+                params: {
+                    imageAttachment: {
+                        supported: boolean;
+                        maxImages: number;
+                        acceptedTypes: string[];
+                    };
+                };
+                maxPromptLength: number;
+                iconVariants: {
+                    light: {
+                        png?: string | undefined;
+                        svg?: string | undefined;
+                    };
+                    dark: {
+                        png?: string | undefined;
+                        svg?: string | undefined;
+                    };
+                };
+                supportsImageAttachment: boolean;
+                maxAttachedImages: number;
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            models: {
+                price: number;
+                uuid: string;
+                params: {
+                    imageAttachment: {
+                        supported: boolean;
+                        maxImages: number;
+                        acceptedTypes: string[];
+                    };
+                };
+                maxPromptLength: number;
+                iconVariants: {
+                    light: {
+                        png?: string | undefined;
+                        svg?: string | undefined;
+                    };
+                    dark: {
+                        png?: string | undefined;
+                        svg?: string | undefined;
+                    };
+                };
+                supportsImageAttachment: boolean;
+                maxAttachedImages: number;
+            }[];
+            styles: {
+                uuid: string;
+                order: number;
+                previewImageUrl: string;
+                isActive: boolean;
+            }[];
+        }, {
+            models: {
+                price: number;
+                uuid: string;
+                params: {
+                    imageAttachment: {
+                        supported: boolean;
+                        maxImages: number;
+                        acceptedTypes: string[];
+                    };
+                };
+                maxPromptLength: number;
+                iconVariants: {
+                    light: {
+                        png?: string | undefined;
+                        svg?: string | undefined;
+                    };
+                    dark: {
+                        png?: string | undefined;
+                        svg?: string | undefined;
+                    };
+                };
+                supportsImageAttachment: boolean;
+                maxAttachedImages: number;
+            }[];
+            styles: {
+                uuid: string;
+                order: number;
+                previewImageUrl: string;
+                isActive: boolean;
+            }[];
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        data: {
+            models: {
+                price: number;
+                uuid: string;
+                params: {
+                    imageAttachment: {
+                        supported: boolean;
+                        maxImages: number;
+                        acceptedTypes: string[];
+                    };
+                };
+                maxPromptLength: number;
+                iconVariants: {
+                    light: {
+                        png?: string | undefined;
+                        svg?: string | undefined;
+                    };
+                    dark: {
+                        png?: string | undefined;
+                        svg?: string | undefined;
+                    };
+                };
+                supportsImageAttachment: boolean;
+                maxAttachedImages: number;
+            }[];
+            styles: {
+                uuid: string;
+                order: number;
+                previewImageUrl: string;
+                isActive: boolean;
+            }[];
+        };
+    }, {
+        data: {
+            models: {
+                price: number;
+                uuid: string;
+                params: {
+                    imageAttachment: {
+                        supported: boolean;
+                        maxImages: number;
+                        acceptedTypes: string[];
+                    };
+                };
+                maxPromptLength: number;
+                iconVariants: {
+                    light: {
+                        png?: string | undefined;
+                        svg?: string | undefined;
+                    };
+                    dark: {
+                        png?: string | undefined;
+                        svg?: string | undefined;
+                    };
+                };
+                supportsImageAttachment: boolean;
+                maxAttachedImages: number;
+            }[];
+            styles: {
+                uuid: string;
+                order: number;
+                previewImageUrl: string;
+                isActive: boolean;
+            }[];
+        };
+    }>;
+    type Response = z.infer<typeof ResponseSchema>;
+}
+//# sourceMappingURL=get-marketplace-card-config.command.d.ts.map

package/build/queries/marketplace-card/get-marketplace-card-config.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-marketplace-card-config.command.d.ts","sourceRoot":"","sources":["../../../queries/marketplace-card/get-marketplace-card-config.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,yBAAiB,+BAA+B,CAAC;IACtC,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAEzB,CAAC;IACH,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}

package/build/queries/marketplace-card/get-marketplace-card-config.command.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetMarketplaceCardConfigCommand = void 0;
+const zod_1 = require("zod");
+const models_1 = require("../../models");
+var GetMarketplaceCardConfigCommand;
+(function (GetMarketplaceCardConfigCommand) {
+    GetMarketplaceCardConfigCommand.ResponseSchema = zod_1.z.object({
+        data: models_1.MarketplaceCardConfigSchema,
+    });
+})(GetMarketplaceCardConfigCommand || (exports.GetMarketplaceCardConfigCommand = GetMarketplaceCardConfigCommand = {}));

package/build/queries/marketplace-card/get-marketplace-card-job.command.d.ts

@@ -0,0 +1,131 @@
+import { z } from 'zod';
+export declare namespace GetMarketplaceCardJobCommand {
+    const RequestParamSchema: z.ZodObject<{
+        uuid: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        uuid: string;
+    }, {
+        uuid: string;
+    }>;
+    type RequestParam = z.infer<typeof RequestParamSchema>;
+    const ResponseSchema: z.ZodObject<{
+        data: z.ZodObject<{
+            uuid: z.ZodString;
+            status: z.ZodNativeEnum<typeof import("../..").JOB_STATUS>;
+            error: z.ZodNullable<z.ZodString>;
+            title: z.ZodString;
+            subtitle: z.ZodNullable<z.ZodString>;
+            reaction: z.ZodNullable<z.ZodNativeEnum<typeof import("../..").USER_REACTION>>;
+            advantages: z.ZodArray<z.ZodString, "many">;
+            tags: z.ZodArray<z.ZodString, "many">;
+            stylePresetId: z.ZodNullable<z.ZodString>;
+            isCustom: z.ZodBoolean;
+            customStylePrompt: z.ZodNullable<z.ZodString>;
+            inputImages: z.ZodArray<z.ZodObject<{
+                uuid: z.ZodString;
+                url: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                uuid: string;
+                url: string;
+            }, {
+                uuid: string;
+                url: string;
+            }>, "many">;
+            resultImages: z.ZodNullable<z.ZodArray<z.ZodString, "many">>;
+            backgroundDescription: z.ZodNullable<z.ZodString>;
+            price: z.ZodNumber;
+            createdAt: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodDate]>>;
+            updatedAt: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodDate]>>;
+        }, "strip", z.ZodTypeAny, {
+            price: number;
+            uuid: string;
+            status: import("../..").JOB_STATUS;
+            title: string;
+            error: string | null;
+            reaction: import("../..").USER_REACTION | null;
+            subtitle: string | null;
+            advantages: string[];
+            tags: string[];
+            stylePresetId: string | null;
+            isCustom: boolean;
+            customStylePrompt: string | null;
+            inputImages: {
+                uuid: string;
+                url: string;
+            }[];
+            backgroundDescription: string | null;
+            resultImages: string[] | null;
+            createdAt?: string | Date | undefined;
+            updatedAt?: string | Date | undefined;
+        }, {
+            price: number;
+            uuid: string;
+            status: import("../..").JOB_STATUS;
+            title: string;
+            error: string | null;
+            reaction: import("../..").USER_REACTION | null;
+            subtitle: string | null;
+            advantages: string[];
+            tags: string[];
+            stylePresetId: string | null;
+            isCustom: boolean;
+            customStylePrompt: string | null;
+            inputImages: {
+                uuid: string;
+                url: string;
+            }[];
+            backgroundDescription: string | null;
+            resultImages: string[] | null;
+            createdAt?: string | Date | undefined;
+            updatedAt?: string | Date | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        data: {
+            price: number;
+            uuid: string;
+            status: import("../..").JOB_STATUS;
+            title: string;
+            error: string | null;
+            reaction: import("../..").USER_REACTION | null;
+            subtitle: string | null;
+            advantages: string[];
+            tags: string[];
+            stylePresetId: string | null;
+            isCustom: boolean;
+            customStylePrompt: string | null;
+            inputImages: {
+                uuid: string;
+                url: string;
+            }[];
+            backgroundDescription: string | null;
+            resultImages: string[] | null;
+            createdAt?: string | Date | undefined;
+            updatedAt?: string | Date | undefined;
+        };
+    }, {
+        data: {
+            price: number;
+            uuid: string;
+            status: import("../..").JOB_STATUS;
+            title: string;
+            error: string | null;
+            reaction: import("../..").USER_REACTION | null;
+            subtitle: string | null;
+            advantages: string[];
+            tags: string[];
+            stylePresetId: string | null;
+            isCustom: boolean;
+            customStylePrompt: string | null;
+            inputImages: {
+                uuid: string;
+                url: string;
+            }[];
+            backgroundDescription: string | null;
+            resultImages: string[] | null;
+            createdAt?: string | Date | undefined;
+            updatedAt?: string | Date | undefined;
+        };
+    }>;
+    type Response = z.infer<typeof ResponseSchema>;
+}
+//# sourceMappingURL=get-marketplace-card-job.command.d.ts.map

package/build/queries/marketplace-card/get-marketplace-card-job.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-marketplace-card-job.command.d.ts","sourceRoot":"","sources":["../../../queries/marketplace-card/get-marketplace-card-job.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,yBAAiB,4BAA4B,CAAC;IACnC,MAAM,kBAAkB;;;;;;MAE7B,CAAC;IACH,KAAY,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;IAEvD,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAEzB,CAAC;IACH,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}

package/build/queries/marketplace-card/get-marketplace-card-job.command.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetMarketplaceCardJobCommand = void 0;
+const zod_1 = require("zod");
+const models_1 = require("../../models");
+var GetMarketplaceCardJobCommand;
+(function (GetMarketplaceCardJobCommand) {
+    GetMarketplaceCardJobCommand.RequestParamSchema = zod_1.z.object({
+        uuid: zod_1.z.string().uuid(),
+    });
+    GetMarketplaceCardJobCommand.ResponseSchema = zod_1.z.object({
+        data: models_1.MarketplaceCardJobSchema,
+    });
+})(GetMarketplaceCardJobCommand || (exports.GetMarketplaceCardJobCommand = GetMarketplaceCardJobCommand = {}));

package/build/queries/marketplace-card/get-marketplace-card-price.command.d.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+export declare namespace GetMarketplaceCardPriceCommand {
+    const RequestSchema: z.ZodObject<{
+        modelId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        modelId?: string | undefined;
+    }, {
+        modelId?: string | undefined;
+    }>;
+    type Request = z.infer<typeof RequestSchema>;
+    const ResponseSchema: z.ZodObject<{
+        data: z.ZodObject<{
+            price: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            price: number;
+        }, {
+            price: number;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        data: {
+            price: number;
+        };
+    }, {
+        data: {
+            price: number;
+        };
+    }>;
+    type Response = z.infer<typeof ResponseSchema>;
+}
+//# sourceMappingURL=get-marketplace-card-price.command.d.ts.map

package/build/queries/marketplace-card/get-marketplace-card-price.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-marketplace-card-price.command.d.ts","sourceRoot":"","sources":["../../../queries/marketplace-card/get-marketplace-card-price.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,yBAAiB,8BAA8B,CAAC;IACrC,MAAM,aAAa;;;;;;MAExB,CAAC;IACH,KAAY,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;IAE7C,MAAM,cAAc;;;;;;;;;;;;;;;;MAIzB,CAAC;IACH,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}

package/build/queries/marketplace-card/get-marketplace-card-price.command.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetMarketplaceCardPriceCommand = void 0;
+const zod_1 = require("zod");
+var GetMarketplaceCardPriceCommand;
+(function (GetMarketplaceCardPriceCommand) {
+    GetMarketplaceCardPriceCommand.RequestSchema = zod_1.z.object({
+        modelId: zod_1.z.string().uuid().optional(),
+    });
+    GetMarketplaceCardPriceCommand.ResponseSchema = zod_1.z.object({
+        data: zod_1.z.object({
+            price: zod_1.z.number().int().nonnegative(),
+        }),
+    });
+})(GetMarketplaceCardPriceCommand || (exports.GetMarketplaceCardPriceCommand = GetMarketplaceCardPriceCommand = {}));

package/build/queries/marketplace-card/index.d.ts

@@ -0,0 +1,5 @@
+export * from './get-marketplace-card-config.command';
+export * from './get-marketplace-card-price.command';
+export * from './get-marketplace-card-job.command';
+export * from './find-marketplace-card-jobs.command';
+//# sourceMappingURL=index.d.ts.map

package/build/queries/marketplace-card/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../queries/marketplace-card/index.ts"],"names":[],"mappings":"AAAA,cAAc,uCAAuC,CAAC;AACtD,cAAc,sCAAsC,CAAC;AACrD,cAAc,oCAAoC,CAAC;AACnD,cAAc,sCAAsC,CAAC"}

package/build/queries/marketplace-card/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./get-marketplace-card-config.command"), exports);
+__exportStar(require("./get-marketplace-card-price.command"), exports);
+__exportStar(require("./get-marketplace-card-job.command"), exports);
+__exportStar(require("./find-marketplace-card-jobs.command"), exports);

package/commands/auth/create-user.command.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { UserSchema } from '../../models';
+
+export namespace CreateUserCommand {
+    export const RequestSchema = UserSchema.pick({
+        email: true,
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.object({
+            uuid: z.string().uuid(),
+        }),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/auth/index.ts

@@ -0,0 +1,9 @@
+export * from './login.command';
+export * from './register.command';
+export * from './create-user.command';
+export * from './restore-password.command';
+export * from './reset-password.command';
+export * from './verify-email.command';
+export * from './verify-email-retry.command';
+export * from './vk-login.command';
+export * from './yandex-login.command';

package/commands/auth/login.command.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { UserSchema } from '../../models';
+
+export namespace LoginCommand {
+    export const RequestSchema = UserSchema.pick({
+        email: true,
+        password: true,
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.object({
+            accessToken: z.string(),
+        }),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/auth/register.command.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { UserSchema } from '../../models';
+
+export namespace RegisterCommand {
+    export const RequestSchema = UserSchema.pick({
+        email: true,
+        password: true,
+    }).extend({
+        partnerId: z.string().uuid().optional(),
+        marketingConsent: z.boolean().default(false),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.object({
+            accessToken: z.string(),
+        }),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/auth/reset-password.command.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+
+export namespace ResetPasswordCommand {
+    export const RequestSchema = z.object({
+        userId: z.string().uuid(),
+        restoreToken: z.string().min(6),
+        newPassword: z.string().min(6).max(128),
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.object({
+            accessToken: z.string(),
+        }),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/auth/restore-password.command.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { UserSchema } from '../../models';
+
+export namespace RestorePasswordCommand {
+    export const RequestSchema = UserSchema.pick({
+        email: true,
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.object({
+            message: z.string(),
+        }),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/auth/verify-email-retry.command.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+
+export namespace VerifyEmailRetryCommand {
+    export const RequestSchema = z.object({
+        userId: z.string().uuid(),
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.object({
+            isSuccess: z.boolean(),
+        }),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/auth/verify-email.command.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+
+export namespace VerifyEmailCommand {
+    export const RequestSchema = z.object({
+        verifyTokenHash: z.string().min(6),
+        email: z.string().email(),
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.object({
+            isSuccess: z.boolean(),
+        }),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}